Struct solana_zk_token_sdk::encryption::auth_encryption::AeKey

pub struct AeKey(/* private fields */);

Implementations

impl AeKey

pub fn new_from_signer( signer: &dyn Signer, public_seed: &[u8] ) -> Result<Self, Box<dyn Error>>

Deterministically derives an authenticated encryption key from a Solana signer and a public seed.

This function exists for applications where a user may not wish to maintain a Solana signer and an authenticated encryption key separately. Instead, a user can derive the ElGamal keypair on-the-fly whenever encrytion/decryption is needed.

pub fn seed_from_signer( signer: &dyn Signer, public_seed: &[u8] ) -> Result<Vec<u8>, SignerError>

Derive a seed from a Solana signer used to generate an authenticated encryption key.

The seed is derived as the hash of the signature of a public seed.

pub fn new_rand() -> Self

Generates a random authenticated encryption key.

This function is randomized. It internally samples a scalar element using OsRng.

pub fn encrypt(&self, amount: u64) -> AeCiphertext

Encrypts an amount under the authenticated encryption key.

pub fn decrypt(&self, ciphertext: &AeCiphertext) -> Option<u64>

Trait Implementations

impl Debug for AeKey

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

Formats the value using the given formatter.

impl EncodableKey for AeKey

fn read<R: Read>(reader: &mut R) -> Result<Self, Box<dyn Error>>

fn write<W: Write>(&self, writer: &mut W) -> Result<String, Box<dyn Error>>

fn read_from_file<F>(path: F) -> Result<Self, Box<dyn Error>>

where F: AsRef<Path>,

fn write_to_file<F>(&self, outfile: F) -> Result<String, Box<dyn Error>>

where F: AsRef<Path>,

impl SeedDerivable for AeKey

fn from_seed(seed: &[u8]) -> Result<Self, Box<dyn Error>>

fn from_seed_and_derivation_path( _seed: &[u8], _derivation_path: Option<DerivationPath> ) -> Result<Self, Box<dyn Error>>

fn from_seed_phrase_and_passphrase( seed_phrase: &str, passphrase: &str ) -> Result<Self, Box<dyn Error>>

impl Zeroize for AeKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.