Struct RandomState 

pub struct RandomState {
    pub id: RandomId,
    pub size: usize,
    pub owners: Vec<String>,
    pub options: Vec<String>,
    pub status: RandomStatus,
    pub masks: Vec<Mask>,
    pub ciphertexts: Vec<LockedCiphertext>,
    pub secret_shares: Vec<Share>,
    pub revealed: HashMap<usize, String>,
}

RandomState represents the public information for a single randomness.

Fields

id: RandomId

size: usize

owners: Vec<String>

options: Vec<String>

status: RandomStatus

masks: Vec<Mask>

ciphertexts: Vec<LockedCiphertext>

secret_shares: Vec<Share>

revealed: HashMap<usize, String>

Implementations

impl RandomState

pub fn is_fully_masked(&self) -> bool

pub fn is_fully_locked(&self) -> bool

pub fn is_shared(&self) -> bool

pub fn is_ready(&self) -> bool

pub fn get_ciphertext(&self, index: usize) -> Option<&LockedCiphertext>

pub fn get_ciphertext_unchecked(&self, index: usize) -> &LockedCiphertext

pub fn try_new( id: RandomId, spec: RandomSpec, owners: &[String], ) -> Result<Self>

pub fn mask<S: AsRef<str>>( &mut self, addr: S, ciphertexts: Vec<Ciphertext>, ) -> Result<()>

pub fn lock<S>( &mut self, addr: S, ciphertexts_and_digests: Vec<(Ciphertext, SecretDigest)>, ) -> Result<()>

where S: Into<String> + AsRef<str> + Clone,

pub fn assign<S>(&mut self, addr: S, indexes: Vec<usize>) -> Result<()>

where S: ToOwned<Owned = String>,

pub fn reveal(&mut self, indexes: Vec<usize>) -> Result<()>

pub fn list_required_secrets_by_from_addr( &self, from_addr: &str, ) -> Vec<SecretIdent>

pub fn list_revealed_secrets(&self) -> Result<HashMap<usize, Vec<Ciphertext>>>

pub fn list_assigned_ciphertexts( &self, addr: &str, ) -> HashMap<usize, Ciphertext>

List all ciphertexts assigned to a specific address. Return a mapping from item index to ciphertext.

pub fn list_revealed_ciphertexts(&self) -> HashMap<usize, Ciphertext>

pub fn list_shared_secrets( &self, to_addr: &str, ) -> Result<HashMap<usize, Vec<SecretKey>>>

List shared secrets by receiver address. Return a mapping from item index to list of secrets(each is in HEX format). Return [Error::SecretsNotReady] in case of any missing secret.

pub fn add_revealed(&mut self, revealed: HashMap<usize, String>) -> Result<()>

pub fn get_revealed(&self) -> &HashMap<usize, String>

pub fn add_secret( &mut self, from_addr: String, to_addr: Option<String>, index: usize, secret: SecretKey, ) -> Result<()>

pub fn list_operating_addrs(&self) -> Vec<String>

Return addresses those haven’t submitted operation

pub fn update_status(&mut self)

Update randomness status

Trait Implementations

impl BorshDeserialize for RandomState

where RandomId: BorshDeserialize, usize: BorshDeserialize, Vec<String>: BorshDeserialize, RandomStatus: BorshDeserialize, Vec<Mask>: BorshDeserialize, Vec<LockedCiphertext>: BorshDeserialize, Vec<Share>: BorshDeserialize, HashMap<usize, String>: BorshDeserialize,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for RandomState

where RandomId: BorshSerialize, usize: BorshSerialize, Vec<String>: BorshSerialize, RandomStatus: BorshSerialize, Vec<Mask>: BorshSerialize, Vec<LockedCiphertext>: BorshSerialize, Vec<Share>: BorshSerialize, HashMap<usize, String>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for RandomState

fn clone(&self) -> RandomState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RandomState

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

Formats the value using the given formatter.

impl Default for RandomState

fn default() -> RandomState

Returns the “default value” for a type.

impl Eq for RandomState

impl PartialEq for RandomState

fn eq(&self, other: &RandomState) -> 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 StructuralPartialEq for RandomState