Program Manager

Overview

The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.

Kind: global class

ProgramManager

Constructor

ProgramManager

Create a new instance of the ProgramManager

ProgramManager(host, keyProvider, recordProvider)

Parameters	Type	Description
host	`string`	A host uri running the official Aleo API
keyProvider	`FunctionKeyProvider`	A key provider that implements FunctionKeyProvider interface
recordProvider	`RecordProvider`	A record provider that implements RecordProvider interface

Methods

checkFee

Check if the fee is sufficient to pay for the transaction

programManager.checkFee()

setAccount

Set the account to use for transaction submission to the Aleo network

programManager.setAccount(account)

Parameters	Type	Description
account	Account	Account to use for transaction submission

setKeyProvider

Set the key provider that provides the proving and verifying keys for programs

setKeyProvider(keyProvider)

Parameters	Type	Description
keyProvider	`FunctionKeyProvider`	**

setHost

Set the host peer to use for transaction submission to the Aleo network

setHost(host)

Parameters	Type	Description
host	`string`	Peer url to use for transaction submission

setRecordProvider

Set the record provider that provides records for transactions

setRecordProvider(recordProvider)

Parameters	Type	Description
recordProvider	`RecordProvider`	**

setHeader

Set a header in the AleoNetworkClient header map

setHeader(headerName, value)

Parameters	Type	Description
headerName	`string`	The name of the header to set
value	`string`	The header value

Examples

import { ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a ProgramManager
const programManager = new ProgramManager("https://api.explorer.provable.com/v1");

// Set the value of the `Accept-Language` header to `en-US`
programManager.setHeader('Accept-Language', 'en-US');

removeHeader

Remove a header from the AleoNetworkClient header map

removeHeader(headerName)

Parameters	Type	Description
headerName	`string`	The name of the header to be removed

Examples

import { ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a ProgramManager
const programManager = new ProgramManager("https://api.explorer.provable.com/v1");

// Remove the default `X-Aleo-SDK-Version` header
programManager.removeHeader('X-Aleo-SDK-Version');

buildDeploymentTransaction

Builds a deployment transaction for submission to the Aleo network.

buildDeploymentTransaction(program, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey) ► string

Parameters	Type	Description
program	`string`	Program source code
priorityFee	`number`	The optional priority fee to be paid for that transaction.
privateFee	`boolean`	Use a private record to pay the fee. If false this will use the account public credit balance
recordSearchParams	`RecordSearchParams`	Optional parameters for searching for a record to use pay the deployment fee
feeRecord	`string`	Optional Fee record to use for the transaction
privateKey	`PrivateKey`	Optional private key to use for the transaction
*return*	`string`	The transaction id of the deployed program or a failure message from the network

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for deployments
const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
programManager.setAccount(Account);

// Define a fee in credits
const priorityFee = 0.0;

// Create the deployment transaction.
const tx = await programManager.buildDeploymentTransaction(program, fee, false);
await programManager.networkClient.submitTransaction(tx);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 20000);

deploy

Deploy an Aleo program to the Aleo network

deploy(program, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey) ► string

Parameters	Type	Description
program	`string`	Program source code
priorityFee	`number`	The optional fee to be paid for the transaction
privateFee	`boolean`	Use a private record to pay the fee. If false this will use the account public credit balance
recordSearchParams	`RecordSearchParams`	Optional parameters for searching for a record to used pay the deployment fee
feeRecord	`string`	Optional Fee record to use for the transaction
privateKey	`PrivateKey`	Optional private key to use for the transaction
*return*	`string`	The transaction id of the deployed program or a failure message from the network

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for deployments
const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Define a fee in credits
const priorityFee = 0.0;

// Deploy the program
const tx_id = await programManager.deploy(program, fee, false);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 20000);

buildExecutionTransaction

Builds an execution transaction for submission to the Aleo network.

buildExecutionTransaction(options) ► Promise.<Transaction>

Parameters	Type	Description
options	`ExecuteOptions`	The options for the execution transaction.
*return*	`Promise.<Transaction>`	- A promise that resolves to the transaction or an error.

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build and execute the transaction
const tx = await programManager.buildExecutionTransaction({
  programName: "hello_hello.aleo",
  functionName: "hello_hello",
  priorityFee: 0.0,
  privateFee: false,
  inputs: ["5u32", "5u32"],
  keySearchParams: { "cacheKey": "hello_hello:hello" }
});

// Submit the transaction to the network
await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

buildAuthorization

Builds a SnarkVM Authorization for a specific function.

buildAuthorization(options) ► Promise.<Authorization>

Parameters	Type	Description
options	`AuthorizationOptions`	The options for building the Authorization
*return*	`Promise.<Authorization>`	A promise that resolves to an Authorization or throws an Error.

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a ProgramManager with the key and record providers.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build the `Authorization`.
const authorization = await programManager.buildAuthorization({
  programName: "credits.aleo",
  functionName: "transfer_public",
  inputs: [
    "aleo1vwls2ete8dk8uu2kmkmzumd7q38fvshrht8hlc0a5362uq8ftgyqnm3w08",
    "10000000u64",
  ],
});

buildAuthorizationUnchecked

Builds a SnarkVM Authorization for a specific function without building a circuit first. This should be used when fast authorization generation is needed and the invoker is confident inputs are coorect.

buildAuthorizationUnchecked(options) ► Promise.<Authorization>

Parameters	Type	Description
options	`AuthorizationOptions`	The options for building the Authorization
*return*	`Promise.<Authorization>`	- A promise that resolves to an Authorization or throws an Error.

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a ProgramManager with the key and record providers.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build the unchecked `Authorization`.
const authorization = await programManager.buildAuthorizationUnchecked({
  programName: "credits.aleo",
  functionName: "transfer_public",
  inputs: [
    "aleo1vwls2ete8dk8uu2kmkmzumd7q38fvshrht8hlc0a5362uq8ftgyqnm3w08",
    "10000000u64",
  ],
});

provingRequest

Builds a ProvingRequest for submission to a prover for execution.

provingRequest(options) ► Promise.<ProvingRequest>

Parameters	Type	Description
options	`ProvingRequestOptions`	The options for building the proving request
*return*	`Promise.<ProvingRequest>`	- A promise that resolves to the transaction or an error.

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a ProgramManager with the key and record providers.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build the proving request.
const provingRequest = await programManager.provingRequest({
  programName: "credits.aleo",
  functionName: "transfer_public",
  baseFee: 100000,
  priorityFee: 0,
  privateFee: false,
  inputs: [
    "aleo1vwls2ete8dk8uu2kmkmzumd7q38fvshrht8hlc0a5362uq8ftgyqnm3w08",
    "10000000u64",
  ],
  broadcast: false,
});

buildFeeAuthorization

Builds a SnarkVM fee Authorization for credits.aleo/fee_private or credits.aleo/fee_public. If a record is provided fee_private will be executed, otherwise fee_public will be executed.

buildFeeAuthorization(options) ► Promise.<Authorization>

Parameters	Type	Description
options	`FeeAuthorizationOptions`	The options for building the Authorization.
*return*	`Promise.<Authorization>`	- A promise that resolves to an Authorization or throws an Error.

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider.
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a ProgramManager with the key and record providers.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build a credits.aleo/fee_public `Authorization`.
const feePublicAuthorization = await programManager.authorizeFee({
  deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
  baseFeeCredits: 0.1,
});

// Build a credits.aleo/fee_private `Authorization`.
const record = "{ owner: aleo1j7qxyunfldj2lp8hsvy7mw5k8zaqgjfyr72x2gh3x4ewgae8v5gscf5jh3.private, microcredits: 1500000000000000u64.private, _nonce: 3077450429259593211617823051143573281856129402760267155982965992208217472983group.public }";
const feePrivateAuthorization = await programManager.authorizeFee({
  deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
  baseFeeCredits: 0.1,
  feeRecord: record,
});

execute

Builds an execution transaction for submission to the Aleo network.

execute(options) ► Promise.<string>

Parameters	Type	Description
options	`ExecuteOptions`	The options for the execution transaction.
*return*	`Promise.<string>`	- The transaction id

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);

// Build and execute the transaction
const tx_id = await programManager.execute({
  programName: "hello_hello.aleo",
  functionName: "hello_hello",
  priorityFee: 0.0,
  privateFee: false,
  inputs: ["5u32", "5u32"],
  keySearchParams: { "cacheKey": "hello_hello:hello" }
});

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

run

Run an Aleo program in offline mode

run(program, function_name, inputs, proveExecution, imports, keySearchParams, provingKey, verifyingKey, privateKey, offlineQuery) ► Promise.<ExecutionResponse>

Parameters	Type	Description
program	`string`	Program source code containing the function to be executed
function_name	`string`	Function name to execute
inputs	`Array.<string>`	Inputs to the function
proveExecution	`number`	Whether to prove the execution of the function and return an execution transcript that contains the proof.
imports	`Array.<string>`	Optional imports to the program
keySearchParams	`KeySearchParams`	Optional parameters for finding the matching proving & verifying keys for the function
provingKey	`ProvingKey`	Optional proving key to use for the transaction
verifyingKey	`VerifyingKey`	Optional verifying key to use for the transaction
privateKey	`PrivateKey`	Optional private key to use for the transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<ExecutionResponse>`	The execution response containing the outputs of the function and the proof if the program is proved.

Examples

/// Import the mainnet version of the sdk used to build executions.
import { Account, ProgramManager } from "@provablehq/sdk/mainnet.js";

/// Create the source for the "helloworld" program
const program = "program helloworld.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
const programManager = new ProgramManager(undefined, undefined, undefined);

/// Create a temporary account for the execution of the program
const account = new Account();
programManager.setAccount(account);

/// Get the response and ensure that the program executed correctly
const executionResponse = await programManager.run(program, "hello", ["5u32", "5u32"]);
const result = executionResponse.getOutputs();
assert(result === ["10u32"]);

join

Join two credits records into a single credits record

join(recordOne, recordTwo, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey, offlineQuery) ► Promise.<string>

Parameters	Type	Description
recordOne	`RecordPlaintext`	First credits record to join
recordTwo	`RecordPlaintext`	Second credits record to join
priorityFee	`number`	The optional priority fee to be paid for the transaction
privateFee	`boolean`	Use a private record to pay the fee. If false this will use the account public credit balance
recordSearchParams	`RecordSearchParams`	Optional parameters for finding the fee record to use to pay the fee for the join transaction
feeRecord	`RecordPlaintext`	Fee record to use for the join transaction
privateKey	`PrivateKey`	Private key to use for the join transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<string>`	The transaction id

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const record_1 = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
const record_2 = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 1540945439182663264862696551825005342995406165131907382295858612069623286213group.public}"
const tx_id = await programManager.join(record_1, record_2, 0.05, false);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

split

Split credits into two new credits records

split(splitAmount, amountRecord, privateKey, offlineQuery) ► Promise.<string>

Parameters	Type	Description
splitAmount	`number`	Amount in microcredits to split from the original credits record
amountRecord	`RecordPlaintext`	Amount record to use for the split transaction
privateKey	`PrivateKey`	Optional private key to use for the split transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<string>`	The transaction id

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const record = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
const tx_id = await programManager.split(25000000, record);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

synthesizeKeys

Pre-synthesize proving and verifying keys for a program

synthesizeKeys(program, function_id, inputs, privateKey) ► Promise.<FunctionKeyPair>

Parameters	Type	Description
program	`string`	The program source code to synthesize keys for
function_id	`string`	The function id to synthesize keys for
inputs	`Array.<string>`	Sample inputs to the function
privateKey	`PrivateKey`	Optional private key to use for the key synthesis
*return*	`Promise.<FunctionKeyPair>`	**

buildTransferTransaction

Build a transaction to transfer credits to another account for later submission to the Aleo network

buildTransferTransaction(amount, recipient, transferType, priorityFee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) ► Promise.<Transaction>

Parameters	Type	Description
amount	`number`	The amount of credits to transfer
recipient	`string`	The recipient of the transfer
transferType	`string`	The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
priorityFee	`number`	The optional priority fee to be paid for the transaction
privateFee	`boolean`	Use a private record to pay the fee. If false this will use the account public credit balance
recordSearchParams	`RecordSearchParams`	Optional parameters for finding the amount and fee records for the transfer transaction
amountRecord	`RecordPlaintext`	Optional amount record to use for the transfer
feeRecord	`RecordPlaintext`	Optional fee record to use for the transfer
privateKey	`PrivateKey`	Optional private key to use for the transfer transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<Transaction>`	The transaction object

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const tx = await programManager.buildTransferTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "public", 0.2, false);
await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

buildTransferPublicTransaction

Build a transfer_public transaction to transfer credits to another account for later submission to the Aleo network

buildTransferPublicTransaction(amount, recipient, priorityFee, privateKey, offlineQuery) ► Promise.<Transaction>

Parameters	Type	Description
amount	`number`	The amount of credits to transfer
recipient	`string`	The recipient of the transfer
priorityFee	`number`	The optional priority fee to be paid for the transfer
privateKey	`PrivateKey`	Optional private key to use for the transfer transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<Transaction>`	The transaction object

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const tx = await programManager.buildTransferPublicTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", 0.2);
await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

buildTransferPublicAsSignerTransaction

Build a transfer_public_as_signer transaction to transfer credits to another account for later submission to the Aleo network

buildTransferPublicAsSignerTransaction(amount, recipient, priorityFee, privateKey, offlineQuery) ► Promise.<Transaction>

Parameters	Type	Description
amount	`number`	The amount of credits to transfer
recipient	`string`	The recipient of the transfer
priorityFee	`number`	The optional priority fee to be paid for the transfer
privateKey	`PrivateKey`	Optional private key to use for the transfer transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<Transaction>`	The transaction object

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const tx = await programManager.buildTransferPublicAsSignerTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", 0.2);
await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

transfer

Transfer credits to another account

transfer(amount, recipient, transferType, priorityFee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) ► Promise.<string>

Parameters	Type	Description
amount	`number`	The amount of credits to transfer
recipient	`string`	The recipient of the transfer
transferType	`string`	The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
priorityFee	`number`	The optional priority fee to be paid for the transfer
privateFee	`boolean`	Use a private record to pay the fee. If false this will use the account public credit balance
recordSearchParams	`RecordSearchParams`	Optional parameters for finding the amount and fee records for the transfer transaction
amountRecord	`RecordPlaintext`	Optional amount record to use for the transfer
feeRecord	`RecordPlaintext`	Optional fee record to use for the transfer
privateKey	`PrivateKey`	Optional private key to use for the transfer transaction
offlineQuery	`OfflineQuery`	Optional offline query if creating transactions in an offline environment
*return*	`Promise.<string>`	The transaction id

Examples

/// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";

// Create a new NetworkClient, KeyProvider, and RecordProvider
const keyProvider = new AleoKeyProvider();
const recordProvider = new NetworkRecordProvider(account, networkClient);
keyProvider.useCache(true);

// Initialize a program manager with the key provider to automatically fetch keys for executions
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "public", 0.2, false);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

buildBondPublicTransaction

Build transaction to bond credits to a validator for later submission to the Aleo Network

buildBondPublicTransaction(validator_address, withdrawal_address, amount, options) ► Promise.<Transaction>

Parameters	Type	Description
validator_address	`string`	Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 10,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
withdrawal_address	`string`	Address to withdraw the staked credits to when unbond_public is called.
amount	`number`	The amount of credits to bond
options	`Partial.<ExecuteOptions>`	Override default execution options.
*return*	`Promise.<Transaction>`	The transaction object

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
programManager.setAccount(new Account("YourPrivateKey"));

// Create the bonding transaction object for later submission
const tx = await programManager.buildBondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);

// The transaction can be later submitted to the network using the network client.
await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

bondPublic

Bond credits to validator.

bondPublic(validator_address, withdrawal_address, amount, options) ► Promise.<string>

Parameters	Type	Description
validator_address	`string`	Address of the validator to bond to, if this address is the same as the signer (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 1,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
withdrawal_address	`string`	Address to withdraw the staked credits to when unbond_public is called.
amount	`number`	The amount of credits to bond
options	`Options`	Options for the execution
*return*	`Promise.<string>`	The transaction id

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);

// Create the bonding transaction
tx_id = await programManager.bondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

buildBondValidatorTransaction

Build a bond_validator transaction for later submission to the Aleo Network.

buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options) ► Promise.<Transaction>

Parameters	Type	Description
validator_address	`string`	Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator staking committee as a delegator.
withdrawal_address	`string`	Address to withdraw the staked credits to when unbond_public is called.
amount	`number`	The amount of credits to bond. A minimum of 10000 credits is required to bond as a delegator.
commission	`number`	The commission rate for the validator (must be between 0 and 100 - an error will be thrown if it is not)
options	`Partial.<ExecuteOptions>`	Override default execution options.
*return*	`Promise.<Transaction>`	The transaction object

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
programManager.setAccount(new Account("YourPrivateKey"));

// Create the bond validator transaction object for later use.
const tx = await programManager.buildBondValidatorTransaction("aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);

// The transaction can later be submitted to the network using the network client.
const tx_id = await programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

bondValidator

Build transaction to bond a validator.

bondValidator(validator_address, withdrawal_address, amount, commission, options) ► Promise.<string>

Parameters	Type	Description
validator_address	`string`	Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 10,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
withdrawal_address	`string`	Address to withdraw the staked credits to when unbond_public is called.
amount	`number`	The amount of credits to bond
commission	`number`	The commission rate for the validator (must be between 0 and 100 - an error will be thrown if it is not)
options	`Partial.<ExecuteOptions>`	Override default execution options.
*return*	`Promise.<string>`	The transaction id

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
programManager.setAccount(new Account("YourPrivateKey"));

// Create the bonding transaction
const tx_id = await programManager.bondValidator("aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

buildUnbondPublicTransaction

Build an unbond_public execution transaction to unbond credits from a validator in the Aleo network.

buildUnbondPublicTransaction(staker_address, amount, options) ► Promise.<Transaction>

Parameters	Type	Description
staker_address	`string`	The address of the staker who is unbonding the credits.
amount	`number`	The amount of credits to unbond (scaled by 1,000,000).
options	`Partial.<ExecuteOptions>`	Override default execution options.
*return*	`Promise.<Transaction>`	- A promise that resolves to the transaction or an error message.

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management.
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to unbond credits.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
const tx = await programManager.buildUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 2000000);

// The transaction can be submitted later to the network using the network client.
programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

unbondPublic

Unbond a specified amount of staked credits. If the address of the executor of this function is an existing validator, it will subtract this amount of credits from the validator staked credits. If there are less than 1,000,000 credits staked pool after the unbond, the validator will be removed from the validator set. If the address of the executor of this function is not a validator and has credits bonded as a delegator, it will subtract this amount of credits from the delegator staked credits. If there are less than 10 credits bonded after the unbond operation, the delegator will be removed from the validator staking pool.

unbondPublic(staker_address, amount, options) ► Promise.<string>

Parameters	Type	Description
staker_address	`string`	Address of the staker who is unbonding the credits
amount	`number`	Amount of credits to unbond.
options	`ExecuteOptions`	Options for the execution
*return*	`Promise.<string>`	The transaction id

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
programManager.setAccount(new Account("YourPrivateKey"));

// Create the unbond_public transaction and send it to the network
const tx_id = await programManager.unbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 10);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

buildClaimUnbondPublicTransaction

Build a transaction to claim unbonded public credits in the Aleo network.

buildClaimUnbondPublicTransaction(staker_address, options) ► Promise.<Transaction>

Parameters	Type	Description
staker_address	`string`	The address of the staker who is claiming the credits.
options	`Partial.<ExecuteOptions>`	Override default execution options.
*return*	`Promise.<Transaction>`	- A promise that resolves to the transaction or an error message.

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to claim unbonded credits.
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);

// Create the claim_unbond_public transaction object for later use.
const tx = await programManager.buildClaimUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");

// The transaction can be submitted later to the network using the network client.
programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

claimUnbondPublic

Claim unbonded credits. If credits have been unbonded by the account executing this function, this method will claim them and add them to the public balance of the account.

claimUnbondPublic(staker_address, options) ► Promise.<string>

Parameters	Type	Description
staker_address	`string`	Address of the staker who is claiming the credits
options	`ExecuteOptions`	**
*return*	`Promise.<string>`	The transaction id

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
programManager.setAccount(new Account("YourPrivateKey"));

// Create the claim_unbond_public transaction
const tx_id = await programManager.claimUnbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

buildSetValidatorStateTransaction

Build a set_validator_state transaction for later usage.

This function allows a validator to set their state to be either opened or closed to new stakers. When the validator is open to new stakers, any staker (including the validator) can bond or unbond from the validator. When the validator is closed to new stakers, existing stakers can still bond or unbond from the validator, but new stakers cannot bond.

This function serves two primary purposes:

Allow a validator to leave the committee, by closing themselves to stakers and then unbonding all of their stakers.
Allow a validator to maintain their % of stake, by closing themselves to allowing more stakers to bond to them.

buildSetValidatorStateTransaction(validator_state, options) ► Promise.<Transaction>

Parameters	Type	Description
validator_state	`boolean`	**
options	`Partial.<ExecuteOptions>`	Override default execution options
*return*	`Promise.<Transaction>`	The transaction object

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);

// Create the set_validator_state transaction
const tx = await programManager.buildSetValidatorStateTransaction(true);

// The transaction can be submitted later to the network using the network client.
programManager.networkClient.submitTransaction(tx.toString());

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx.id());
 assert(transaction.id() === tx.id());
}, 10000);

setValidatorState

Submit a set_validator_state transaction to the Aleo Network.

This function serves two primary purposes:

Allow a validator to leave the committee, by closing themselves to stakers and then unbonding all of their stakers.
Allow a validator to maintain their % of stake, by closing themselves to allowing more stakers to bond to them.

setValidatorState(validator_state, options) ► Promise.<string>

Parameters	Type	Description
validator_state	`boolean`	**
options	`Partial.<ExecuteOptions>`	Override default execution options
*return*	`Promise.<string>`	The transaction id

Examples

// Import the mainnet version of the sdk.
import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";

// Create a keyProvider to handle key management
const keyProvider = new AleoKeyProvider();
keyProvider.useCache(true);

// Create a new ProgramManager with the key that will be used to bond credits
const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);

// Create the set_validator_state transaction
const tx_id = await programManager.setValidatorState(true);

// Verify the transaction was successful
setTimeout(async () => {
 const transaction = await programManager.networkClient.getTransaction(tx_id);
 assert(transaction.id() === tx_id);
}, 10000);

verifyExecution

Verify a proof from an offline execution. This is useful when it is desired to do offchain proving and verification.

verifyExecution(executionResponse, blockHeight, imports, importedVerifyingKeys) ► boolean

Parameters	Type	Description
executionResponse	`executionResponse`	The response from an offline function execution (via the ;programManager.run; method)
blockHeight	`blockHeight`	The ledger height when the execution was generated.
imports	`ImportedPrograms`	The imported programs used in the execution. Specified as { programName: programSourceCode, ... }
importedVerifyingKeys	`ImportedVerifyingKeys`	The verifying keys in the execution. Specified as { programName: [[functionName, verifyingKey], ...], ... }
*return*	`boolean`	True if the proof is valid, false otherwise

Examples

/// Import the mainnet version of the sdk used to build executions.
import { Account, ProgramManager } from "@provablehq/sdk/mainnet.js";

/// Create the source for two programs.
const program = "import add_it_up.aleo; \n\n program mul_add.aleo;\n\nfunction mul_and_add:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    mul r0 r1 into r2;\n call add_it_up.aleo/add_it r1 r2 into r3;  output r3 as u32.private;\n";
const program_import = "program add_it_up.aleo;\n\nfunction add_it:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
const programManager = new ProgramManager(undefined, undefined, undefined);

/// Create a temporary account for the execution of the program
const account = Account.fromCipherText(process.env.ciphertext, process.env.password);
programManager.setAccount(account);

/// Get the response and ensure that the program executed correctly
const executionResponse = await programManager.run(program, "mul_and_add", ["5u32", "5u32"], true);

/// Construct the imports and verifying keys
const imports = { "add_it_up.aleo": program_import };
const importedVerifyingKeys = { "add_it_up.aleo": [["add_it", "verifyingKey1..."]] };

/// Verify the execution.
const blockHeight = 9000000;
const isValid = programManager.verifyExecution(executionResponse, blockHeight, imports, importedVerifyingKeys);
assert(isValid);

createProgramFromSource

Create a program object from a program source code

createProgramFromSource(program) ► Program

Parameters	Type	Description
program	`string`	Program source code
*return*	Program	The program object

creditsProgram

Get the credits program object

creditsProgram() ► Program

Parameters	Type	Description
*return*	Program	The credits program object

verifyProgram

Verify a program is valid

verifyProgram(program)

Parameters	Type	Description
program	`string`	The program source code

Overview​

Constructor​

ProgramManager​

Methods​

checkFee​

setAccount​

setKeyProvider​

setHost​

setRecordProvider​

setHeader​

Examples​

removeHeader​

Examples​

buildDeploymentTransaction​

Examples​

deploy​

Examples​

buildExecutionTransaction​

Examples​

buildAuthorization​

Examples​

buildAuthorizationUnchecked​

Examples​

provingRequest​

Examples​

buildFeeAuthorization​

Examples​

execute​

Examples​

run​

Examples​

join​

Examples​

split​

Examples​

synthesizeKeys​

buildTransferTransaction​

Examples​

buildTransferPublicTransaction​

Examples​

buildTransferPublicAsSignerTransaction​

Examples​

transfer​

Examples​

buildBondPublicTransaction​

Examples​

bondPublic​

Examples​

buildBondValidatorTransaction​

Examples​

bondValidator​

Examples​

buildUnbondPublicTransaction​

Examples​

unbondPublic​

Examples​

buildClaimUnbondPublicTransaction​

Examples​

claimUnbondPublic​

Examples​

buildSetValidatorStateTransaction​

Examples​

setValidatorState​

Examples​

verifyExecution​

Examples​

createProgramFromSource​

creditsProgram​

verifyProgram​

Overview

Constructor

ProgramManager

Methods

checkFee

setAccount

setKeyProvider

setHost

setRecordProvider

setHeader

Examples

removeHeader

Examples

buildDeploymentTransaction

Examples

deploy

Examples

buildExecutionTransaction

Examples

buildAuthorization

Examples

buildAuthorizationUnchecked

Examples

provingRequest

Examples

buildFeeAuthorization

Examples

execute

Examples

run

Examples

join

Examples

split

Examples

synthesizeKeys

buildTransferTransaction

Examples

buildTransferPublicTransaction

Examples

buildTransferPublicAsSignerTransaction

Examples

transfer

Examples

buildBondPublicTransaction

Examples

bondPublic

Examples

buildBondValidatorTransaction

Examples

bondValidator

Examples

buildUnbondPublicTransaction

Examples

unbondPublic

Examples

buildClaimUnbondPublicTransaction

Examples

claimUnbondPublic

Examples

buildSetValidatorStateTransaction

Examples

setValidatorState

Examples

verifyExecution

Examples

createProgramFromSource

creditsProgram

verifyProgram