Struct Stack

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

Implementations

impl<N> Stack<N>

where N: Network,

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

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

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

impl<N> Stack<N>

where N: Network,

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

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

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

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

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

Checks each function in the program on the given verifying key and certificate.

impl<N> Stack<N>

where N: Network,

pub fn sample_plaintext<R>( &self, plaintext_type: &PlaintextType<N>, rng: &mut R, ) -> Result<Plaintext<N>, Error>

where R: Rng + CryptoRng,

Samples a plaintext value according to the given plaintext type.

pub fn sample_future<R>( &self, locator: &Locator<N>, rng: &mut R, ) -> Result<Future<N>, Error>

where R: Rng + CryptoRng,

Samples a future value according to the given future type.

impl<N> Stack<N>

where N: Network,

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

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

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

pub fn synthesize_from_assignment( &self, function_name: &Identifier<N>, assignment: &Assignment<<N as Environment>::Field>, ) -> Result<(), Error>

Synthesizes and stores the (proving_key, verifying_key) for the given function name and assignment.

impl<N> Stack<N>

where N: Network,

pub fn new( process: &Process<N>, program: &ProgramCore<N, Instruction<N>, Command<N>>, ) -> Result<Stack<N>, Error>

Initializes a new stack, if it does not already exist, given the process and the program.

impl<N> Stack<N>

where N: Network,

pub fn contains_proving_key(&self, function_name: &Identifier<N>) -> bool

Returns true if the proving key for the given function name exists.

pub fn contains_verifying_key(&self, function_name: &Identifier<N>) -> bool

Returns true if the verifying key for the given function name exists.

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

Returns the proving key for the given function name.

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

Returns the verifying key for the given function name.

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

Inserts the given proving key for the given function name.

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

Inserts the given verifying key for the given function name.

pub fn remove_proving_key(&self, function_name: &Identifier<N>)

Removes the proving key for the given function name.

pub fn remove_verifying_key(&self, function_name: &Identifier<N>)

Removes the verifying key for the given function name.

Trait Implementations

impl<N> Clone for Stack<N>

where N: Clone + Network,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> PartialEq for Stack<N>

where N: Network,

fn eq(&self, other: &Stack<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> StackEvaluate<N> for Stack<N>

where N: Network,

fn evaluate_closure<A>( &self, closure: &ClosureCore<N, Instruction<N>>, inputs: &[Value<N>], call_stack: CallStack<N>, signer: Address<N>, caller: Address<N>, tvk: Field<N>, ) -> Result<Vec<Value<N>>, Error>

where A: Aleo<Network = N>,

Evaluates a program closure on the given inputs.

Errors

This method will halt if the given inputs are not the same length as the input statements.

fn evaluate_function<A>( &self, call_stack: CallStack<N>, caller: Option<ProgramID<N>>, ) -> Result<Response<N>, Error>

where A: Aleo<Network = N>,

Evaluates a program function on the given inputs.

Errors

This method will halt if the given inputs are not the same length as the input statements.

impl<N> StackExecute<N> for Stack<N>

where N: Network,

fn execute_closure<A>( &self, closure: &ClosureCore<N, Instruction<N>>, inputs: &[Value<A>], call_stack: CallStack<N>, signer: Address<A>, caller: Address<A>, tvk: Field<A>, ) -> Result<Vec<Value<A>>, Error>

where A: Aleo<Network = N>,

Executes a program closure on the given inputs.

Errors

This method will halt if the given inputs are not the same length as the input statements.

fn execute_function<A, R>( &self, call_stack: CallStack<N>, console_caller: Option<ProgramID<N>>, root_tvk: Option<Field<N>>, rng: &mut R, ) -> Result<Response<N>, Error>

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

Executes a program function on the given inputs.

Note: To execute a transition, do not call this method. Instead, call Process::execute.

Errors

This method will halt if the given inputs are not the same length as the input statements.

impl<N> StackMatches<N> for Stack<N>

where N: Network,

fn matches_value_type( &self, value: &Value<N>, value_type: &ValueType<N>, ) -> Result<(), Error>

Checks that the given value matches the layout of the value type.

fn matches_register_type( &self, stack_value: &Value<N>, register_type: &RegisterType<N>, ) -> Result<(), Error>

Checks that the given stack value matches the layout of the register type.

fn matches_external_record( &self, record: &Record<N, Plaintext<N>>, locator: &Locator<N>, ) -> Result<(), Error>

Checks that the given record matches the layout of the external record type.

fn matches_record( &self, record: &Record<N, Plaintext<N>>, record_name: &Identifier<N>, ) -> Result<(), Error>

Checks that the given record matches the layout of the record type.

fn matches_plaintext( &self, plaintext: &Plaintext<N>, plaintext_type: &PlaintextType<N>, ) -> Result<(), Error>

Checks that the given plaintext matches the layout of the plaintext type.

fn matches_future( &self, future: &Future<N>, locator: &Locator<N>, ) -> Result<(), Error>

Checks that the given future matches the layout of the future type.

impl<N> StackProgram<N> for Stack<N>

where N: Network,

fn program(&self) -> &ProgramCore<N, Instruction<N>, Command<N>>

Returns the program.

fn program_id(&self) -> &ProgramID<N>

Returns the program ID.

fn program_depth(&self) -> usize

Returns the program depth.

fn program_address(&self) -> &Address<N>

Returns the program address.

fn contains_external_record(&self, locator: &Locator<N>) -> bool

Returns true if the stack contains the external record.

fn get_external_stack( &self, program_id: &ProgramID<N>, ) -> Result<&Arc<Stack<N>>, Error>

Returns the external stack for the given program ID.

fn get_external_program( &self, program_id: &ProgramID<N>, ) -> Result<&ProgramCore<N, Instruction<N>, Command<N>>, Error>

Returns the external program for the given program ID.

fn get_external_record( &self, locator: &Locator<N>, ) -> Result<&RecordType<N>, Error>

Returns the external record if the stack contains the external record.

fn get_finalize_cost(&self, function_name: &Identifier<N>) -> Result<u64, Error>

Returns the expected finalize cost for the given function name.

fn get_function( &self, function_name: &Identifier<N>, ) -> Result<FunctionCore<N, Instruction<N>, Command<N>>, Error>

Returns the function with the given function name.

fn get_function_ref( &self, function_name: &Identifier<N>, ) -> Result<&FunctionCore<N, Instruction<N>, Command<N>>, Error>

Returns a reference to the function with the given function name.

fn get_number_of_calls( &self, function_name: &Identifier<N>, ) -> Result<usize, Error>

Returns the expected number of calls for the given function name.

fn sample_value<R>( &self, burner_address: &Address<N>, value_type: &ValueType<N>, rng: &mut R, ) -> Result<Value<N>, Error>

where R: Rng + CryptoRng,

Returns a value for the given value type.

fn sample_record<R>( &self, burner_address: &Address<N>, record_name: &Identifier<N>, nonce: Group<N>, rng: &mut R, ) -> Result<Record<N, Plaintext<N>>, Error>

where R: Rng + CryptoRng,

Returns a record for the given record name, with the given burner address and nonce.

impl<N> StackProgramTypes<N> for Stack<N>

where N: Network,

fn get_register_types( &self, name: &Identifier<N>, ) -> Result<&RegisterTypes<N>, Error>

Returns the register types for the given closure or function name.

fn get_finalize_types( &self, name: &Identifier<N>, ) -> Result<&FinalizeTypes<N>, Error>

Returns the register types for the given finalize name.

impl<N> Eq for Stack<N>

where N: Network,