Struct Process 

pub struct Process<N>
where
    N: Network,
{ /* private fields */ }

Implementations

impl<N> Process<N>

where N: Network,

pub fn authorize<A, R>( &self, private_key: &PrivateKey<N>, program_id: impl TryInto<ProgramID<N>>, function_name: impl TryInto<Identifier<N>>, inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>, rng: &mut R, ) -> Result<Authorization<N>, ProcessAuthError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Authorizes a call to the program function for the given inputs.

pub fn authorize_unchecked<A, R>( &self, private_key: &PrivateKey<N>, program_id: impl TryInto<ProgramID<N>>, function_name: impl TryInto<Identifier<N>>, inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>, rng: &mut R, ) -> Result<Authorization<N>, ProcessAuthError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Authorizes a call to the program function for the given inputs. Compared to authorize, this method does not check for circuit satisfiability of the request.

pub fn authorize_request<A, R>( &self, request: Request<N>, rng: &mut R, ) -> Result<Authorization<N>, ProcessAuthError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Authorizes a call to the program function for the given inputs. Compared to authorize, no private key is needed, but this only works for single public requests.

pub fn authorize_fee_private<A, R>( &self, private_key: &PrivateKey<N>, credits: Record<N, Plaintext<N>>, base_fee_in_microcredits: u64, priority_fee_in_microcredits: u64, deployment_or_execution_id: Field<N>, rng: &mut R, ) -> Result<Authorization<N>, ProcessAuthError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Authorizes the fee given the credits record, the fee amount (in microcredits), and the deployment or execution ID.

pub fn authorize_fee_public<A, R>( &self, private_key: &PrivateKey<N>, base_fee_in_microcredits: u64, priority_fee_in_microcredits: u64, deployment_or_execution_id: Field<N>, rng: &mut R, ) -> Result<Authorization<N>, ProcessAuthError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Authorizes the fee given the the fee amount (in microcredits) and the deployment or execution ID.

impl<N> Process<N>

where N: Network,

pub fn deploy<A, R>( &self, program: &ProgramCore<N>, rng: &mut R, ) -> Result<Deployment<N>, ProcessDeployError>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Deploys the given program ID, if it does not exist.

pub fn load_deployment( &mut self, deployment: &Deployment<N>, ) -> Result<(), Error>

Adds the newly-deployed program. This method assumes the given deployment is valid.

impl<N> Process<N>

where N: Network,

pub fn evaluate<A>( &self, authorization: Authorization<N>, ) -> Result<Response<N>, ProcessEvalError>

where A: Aleo<Network = N>,

Evaluates a program function on the given request.

impl<N> Process<N>

where N: Network,

pub fn execute<A, R>( &self, authorization: Authorization<N>, rng: &mut R, ) -> Result<(Response<N>, Trace<N>), ProcessExecError>

where A: Aleo<Network = N>, R: CryptoRng + Rng,

Executes the given authorization.

impl<N> Process<N>

where N: Network,

pub fn finalize_deployment<P>( &self, state: FinalizeGlobalState, store: &FinalizeStore<N, P>, deployment: &Deployment<N>, fee: &Fee<N>, ) -> Result<(Stack<N>, Vec<FinalizeOperation<N>>), Error>

where P: FinalizeStorage<N>,

Finalizes the deployment and fee. This method assumes the given deployment is valid. This method should only be called by VM::finalize().

pub fn finalize_execution<P>( &self, state: FinalizeGlobalState, store: &FinalizeStore<N, P>, execution: &Execution<N>, fee: Option<&Fee<N>>, ) -> Result<Vec<FinalizeOperation<N>>, Error>

where P: FinalizeStorage<N>,

Finalizes the execution and fee. This method assumes the given execution is valid. This method should only be called by VM::finalize().

pub fn finalize_fee<P>( &self, state: FinalizeGlobalState, store: &FinalizeStore<N, P>, fee: &Fee<N>, ) -> Result<Vec<FinalizeOperation<N>>, Error>

where P: FinalizeStorage<N>,

Finalizes the fee. This method assumes the given fee is valid. This method should only be called by VM::finalize().

impl<N> Process<N>

where N: Network,

pub fn verify_deployment<A, R>( &self, consensus_version: ConsensusVersion, deployment: &Deployment<N>, rng: &mut R, ) -> Result<(), Error>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Verifies the given deployment is ordered.

impl<N> Process<N>

where N: Network,

pub fn verify_execution( &self, consensus_version: ConsensusVersion, varuna_version: VarunaVersion, inclusion_version: InclusionVersion, execution: &Execution<N>, ) -> Result<(), Error>

Verifies the given execution is valid. Note: This does not check that the global state root exists in the ledger.

impl<N> Process<N>

where N: Network,

pub fn construct_call_graph<'a>( &self, transitions: impl ExactSizeIterator<Item = &'a Transition<N>> + DoubleEndedIterator, ) -> Result<HashMap<<N as Network>::TransitionID, Vec<<N as Network>::TransitionID>>, Error>

impl<N> Process<N>

where N: Network,

pub fn verify_fee( &self, consensus_version: ConsensusVersion, varuna_version: VarunaVersion, inclusion_version: InclusionVersion, fee: &Fee<N>, deployment_or_execution_id: Field<N>, ) -> Result<(), Error>

Verifies the given fee is valid. Note: This does not check that the global state root exists in the ledger.

impl<N> Process<N>

where N: Network,

pub fn setup<A, R>(rng: &mut R) -> Result<Process<N>, Error>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Initializes a new process.

pub fn add_stack(&mut self, stack: Stack<N>) -> Option<Arc<Stack<N>>>

Adds a new stack to the process. If the program already exists, then the existing stack is replaced and the original stack is returned. Note. This method assumes that the provided stack is valid.

pub fn stage_stack(&self, stack: Stack<N>)

Stages a stack to be added to the process. The new stack is active, while the old stack is retained in old_stacks. The commit_stacks method must be called to finalize the addition of the new stack. The revert_stacks method can be called to revert the staged stacks.

pub fn commit_stacks(&self)

Commits the staged stacks to the process. This finalizes the addition of the new stacks and clears the old stacks.

pub fn revert_stacks(&self)

Reverts the staged stacks, restoring the previous state of the process. This will remove the new stacks and restore the old stacks.

pub fn mapping_types_exist(&self, program: &ProgramCore<N>) -> Result<(), Error>

Ensure that the types referred to in this program’s mappings exist.

impl<N> Process<N>

where N: Network,

pub fn load() -> Result<Process<N>, Error>

Initializes a new process.

pub fn load_v0() -> Result<Process<N>, Error>

Initializes a new process with the V0 credits.aleo verifiying keys.

pub fn add_program(&mut self, program: &ProgramCore<N>) -> Result<(), Error>

Adds a new program to the process, verifying that it is a valid addition. If the program exists, then the existing stack is replaced and discarded. Note. This method should NOT be used by the on-chain VM to add new program, use finalize_deployment or load_deployment instead instead.

pub fn add_program_with_edition( &mut self, program: &ProgramCore<N>, edition: u16, ) -> Result<(), Error>

Adds a new program with the given edition to the process, verifying that it is a valid addition. If the program exists, then the existing stack is replaced and discarded. Note. This method should NOT be used by the on-chain VM to add new program, use finalize_deployment or load_deployment instead instead.

pub fn add_programs_with_editions( &mut self, programs: &[(ProgramCore<N>, u16)], ) -> Result<(), Error>

Adds a set of programs and editions, in topological order, to the process, deferring validation of the programs until all programs are added. If a program exists, then the existing stack is replaced and discarded. Either all programs are added or none are. Note. This method should NOT be used by the on-chain VM to add new program, use finalize_deployment or load_deployment instead instead.

pub const fn universal_srs(&self) -> &UniversalSRS<N>

Returns the universal SRS.

pub fn contains_program(&self, program_id: &ProgramID<N>) -> bool

Returns true if the process contains the program with the given ID.

pub fn program_ids(&self) -> Vec<ProgramID<N>>

Returns the program IDs of all programs in the process.

pub fn get_stack( &self, program_id: impl TryInto<ProgramID<N>>, ) -> Result<Arc<Stack<N>>, Error>

Returns the stack for the given program ID.

pub fn get_proving_key( &self, program_id: impl TryInto<ProgramID<N>>, function_name: impl TryInto<Identifier<N>>, ) -> Result<ProvingKey<N>, Error>

Returns the proving key for the given program ID and function name.

pub fn get_verifying_key( &self, program_id: impl TryInto<ProgramID<N>>, function_name: impl TryInto<Identifier<N>>, ) -> Result<VerifyingKey<N>, Error>

Returns the verifying key for the given program ID and function name.

pub fn insert_proving_key( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, proving_key: ProvingKey<N>, ) -> Result<(), Error>

Inserts the given proving key, for the given program ID and function name.

pub fn remove_proving_key( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, ) -> Result<(), Error>

Removes the given proving key, for the given program ID and function name.

pub fn insert_verifying_key( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, verifying_key: VerifyingKey<N>, ) -> Result<(), Error>

Inserts the given verifying key, for the given program ID and function name.

pub fn remove_verifying_key( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, ) -> Result<(), Error>

Removes the given verifying key, for the given program ID and function name.

pub fn synthesize_key<A, R>( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, rng: &mut R, ) -> Result<(), Error>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Synthesizes the proving and verifying key for the given program ID and function name.

pub fn synthesize_translation_key<A, R>( &self, program_id: &ProgramID<N>, record_name: &Identifier<N>, rng: &mut R, ) -> Result<(), Error>

where A: Aleo<Network = N>, R: Rng + CryptoRng,

Synthesizes the translation key for the given record name.

Trait Implementations

impl<N> Clone for Process<N>

where N: Clone + Network,

fn clone(&self) -> Process<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.