Struct Stack

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

Implementations

impl<N: Network> Stack<N>

pub fn authorize<A: Aleo<Network = N>, R: Rng + CryptoRng>( &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>>

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

impl<N: Network> Stack<N>

pub fn deploy<A: Aleo<Network = N>, R: Rng + CryptoRng>( &self, rng: &mut R, ) -> Result<Deployment<N>>

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

pub fn verify_deployment<A: Aleo<Network = N>, R: Rng + CryptoRng>( &self, deployment: &Deployment<N>, rng: &mut R, ) -> Result<()>

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

impl<N: Network> Stack<N>

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

Samples a plaintext value according to the given plaintext type.

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

Samples a future value according to the given future type.

impl<N: Network> Stack<N>

pub fn synthesize_key<A: Aleo<Network = N>, R: Rng + CryptoRng>( &self, function_name: &Identifier<N>, rng: &mut R, ) -> Result<()>

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::Field>, ) -> Result<()>

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

impl<N: Network> Stack<N>

pub fn new(process: &Process<N>, program: &Program<N>) -> Result<Self>

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

impl<N: Network> Stack<N>

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>>

Returns the proving key for the given function name.

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

Returns the verifying key for the given function name.

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

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<()>

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 + Network> Clone for Stack<N>

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: Network> PartialEq for Stack<N>

fn eq(&self, other: &Self) -> 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: Network> StackEvaluate<N> for Stack<N>

fn evaluate_closure<A: Aleo<Network = N>>( &self, closure: &Closure<N>, inputs: &[Value<N>], call_stack: CallStack<N>, signer: Address<N>, caller: Address<N>, tvk: Field<N>, ) -> Result<Vec<Value<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: Aleo<Network = N>>( &self, call_stack: CallStack<N>, caller: Option<ProgramID<N>>, ) -> Result<Response<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: Network> StackExecute<N> for Stack<N>

fn execute_closure<A: Aleo<Network = N>>( &self, closure: &Closure<N>, inputs: &[Value<A>], call_stack: CallStack<N>, signer: Address<A>, caller: Address<A>, tvk: Field<A>, ) -> Result<Vec<Value<A>>>

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: Aleo<Network = N>, R: CryptoRng + Rng>( &self, call_stack: CallStack<N>, console_caller: Option<ProgramID<N>>, root_tvk: Option<Field<N>>, rng: &mut R, ) -> Result<Response<N>>

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: Network> StackMatches<N> for Stack<N>

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

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<()>

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<()>

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<()>

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

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

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

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

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

impl<N: Network> StackProgram<N> for Stack<N>

fn program(&self) -> &Program<N>

Returns the program.

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

Returns the program ID.

fn program_depth(&self) -> usize

Returns the program depth.

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>>>

Returns the external stack for the given program ID.

fn get_external_program(&self, program_id: &ProgramID<N>) -> Result<&Program<N>>

Returns the external program for the given program ID.

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

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

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

Returns the expected finalize cost for the given function name.

fn get_function(&self, function_name: &Identifier<N>) -> Result<Function<N>>

Returns the function with the given function name.

fn get_function_ref( &self, function_name: &Identifier<N>, ) -> Result<&Function<N>>

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

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

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

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

Returns a value for the given value type.

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

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

impl<N: Network> StackProgramTypes<N> for Stack<N>

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

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

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

Returns the register types for the given finalize name.

impl<N: Network> Eq for Stack<N>