Struct aleo_wasm::programs::proving_key::ProvingKey

impl ProvingKey

pub fn is_bond_public_prover(&self) -> bool

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

pub fn is_claim_unbond_public_prover(&self) -> bool

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

pub fn is_fee_private_prover(&self) -> bool

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

pub fn is_fee_public_prover(&self) -> bool

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

pub fn is_inclusion_prover(&self) -> bool

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

pub fn is_join_prover(&self) -> bool

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

pub fn is_set_validator_state_prover(&self) -> bool

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

pub fn is_split_prover(&self) -> bool

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

pub fn is_transfer_private_prover(&self) -> bool

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

pub fn is_transfer_private_to_public_prover(&self) -> bool

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

pub fn is_transfer_public_prover(&self) -> bool

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

pub fn is_transfer_public_to_private_prover(&self) -> bool

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

pub fn is_unbond_delegator_as_validator_prover(&self) -> bool

Verify if the proving key is for the unbond_delegator_as_validator function

@example const provingKey = ProvingKey.fromBytes(“unbond_delegator_as_validator_proving_key.bin”); provingKey.isUnbondDelegatorAsValidatorProver() ? console.log(“Key verified”) : throw new Error(“Invalid key”);

@returns {boolean} returns true if the proving key is for the unbond_delegator_as_validator function, false if otherwise

pub fn is_unbond_public_prover(&self) -> bool

Verify if the proving key is for the unbond_delegator_as_delegator function

@example const provingKey = ProvingKey.fromBytes(“unbond_delegator_as_delegator_proving_key.bin”); provingKey.isUnbondDelegatorAsDelegatorProver() ? console.log(“Key verified”) : throw new Error(“Invalid key”);

@returns {boolean} returns true if the proving key is for the unbond_delegator_as_delegator function, false if otherwise

impl ProvingKey

pub fn checksum(&self) -> String

Return the checksum of the proving key

@returns {string} Checksum of the proving key

pub fn copy(&self) -> ProvingKey

Create a copy of the proving key

@returns {ProvingKey} A copy of the proving key

pub fn from_bytes(bytes: &[u8]) -> Result<ProvingKey, String>

Construct a new proving key from a byte array

@param {Uint8Array} bytes Byte array representation of a proving key @returns {ProvingKey | Error}

pub fn from_string(string: &str) -> Result<ProvingKey, String>

Create a proving key from string

@param {string | Error} String representation of the proving key

pub fn to_bytes(&self) -> Result<Vec<u8>, String>

Return the byte representation of a proving key

@returns {Uint8Array | Error} Byte array representation of a proving key

pub fn to_string(&self) -> String

Get a string representation of the proving key

@returns {string} String representation of the proving key

Methods from Deref<Target = ProvingKey<Testnet3>>§

pub fn prove<R>( &self, function_name: &str, assignment: &Assignment<<N as Environment>::Field>, rng: &mut R ) -> Result<Proof<N>, Error>where R: Rng + CryptoRng,

Returns a proof for the given assignment on the circuit.

Trait Implementations§

impl Clone for ProvingKey

fn clone(&self) -> ProvingKey

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for ProvingKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl Deref for ProvingKey

type Target = ProvingKey<Testnet3>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<ProvingKey<Testnet3>> for ProvingKey

fn from(proving_key: ProvingKey<Testnet3>) -> ProvingKey

Converts to this type from the input type.

impl From<ProvingKey> for JsValue

fn from(value: ProvingKey) -> Self

Converts to this type from the input type.

impl From<ProvingKey> for ProvingKey<Testnet3>

fn from(proving_key: ProvingKey) -> ProvingKey<Testnet3>

Converts to this type from the input type.

impl FromWasmAbi for ProvingKey

type Abi = u32

The wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi. Read more

impl IntoWasmAbi for ProvingKey

type Abi = u32

The wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for ProvingKey

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = Ref<'static, ProvingKey>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for ProvingKey

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for ProvingKey

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option. Read more

impl PartialEq for ProvingKey

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

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

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

impl RefFromWasmAbi for ProvingKey

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, ProvingKey>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.