Enum Event 

pub enum Event {
    Custom {
        sender: String,
        raw: Vec<u8>,
    },
    Ready,
    ShareSecrets {
        sender: String,
        shares: Vec<SecretShare>,
    },
    OperationTimeout {
        addrs: Vec<String>,
    },
    Mask {
        sender: String,
        random_id: RandomId,
        ciphertexts: Vec<Ciphertext>,
    },
    Lock {
        sender: String,
        random_id: RandomId,
        ciphertexts_and_digests: Vec<(Ciphertext, SecretDigest)>,
    },
    RandomnessReady {
        random_id: RandomId,
    },
    Sync {
        new_players: Vec<PlayerJoin>,
        new_servers: Vec<ServerJoin>,
        transactor_addr: String,
        access_version: u64,
    },
    ServerLeave {
        server_addr: String,
        transactor_addr: String,
    },
    Leave {
        player_addr: String,
    },
    GameStart {
        access_version: u64,
    },
    WaitingTimeout,
    DrawRandomItems {
        sender: String,
        random_id: usize,
        indexes: Vec<usize>,
    },
    DrawTimeout,
    ActionTimeout {
        player_addr: String,
    },
    AnswerDecision {
        sender: String,
        decision_id: DecisionId,
        ciphertext: Ciphertext,
        digest: SecretDigest,
    },
    SecretsReady {
        random_ids: Vec<usize>,
    },
    Shutdown,
}

Game event structure

Variants

Custom

Sent by player clients. Represent game specific events, the raw parts is the serialized data from a custom game event which satisfies CustomEvent.

Fields

sender: String

raw: Vec<u8>

Ready

A event sent by system, the first event sent by transactor when game is loaded.

ShareSecrets

Transactor shares its secert to specific player. The secret_data is encrypted with the receiver’s public key.

Fields

sender: String

shares: Vec<SecretShare>

OperationTimeout

Fields

addrs: Vec<String>

Mask

Randomize items. This event is sent by transactors.

Fields

sender: String

random_id: RandomId

ciphertexts: Vec<Ciphertext>

Lock

Lock items. This event is sent by transactors.

Fields

sender: String

random_id: RandomId

ciphertexts_and_digests: Vec<(Ciphertext, SecretDigest)>

RandomnessReady

All randomness is prepared. This event is sent by transactor.

Fields

random_id: RandomId

Sync

Sync with on-chain account. New players/servers will be added frist to game context and then to game handler (WASM). This event is sent by transactor based on the diff of the account states.

Fields

new_players: Vec<PlayerJoin>

new_servers: Vec<ServerJoin>

transactor_addr: String

access_version: u64

ServerLeave

A server left the game. transactor_addr is the new current transactor address.

NOTE: This event must be handled idempotently.

Fields

server_addr: String

transactor_addr: String

Leave

Client left game This event is sent by transactor based on client’s connection status.

Fields

player_addr: String

GameStart

Transactor uses this event as the start for each game. The access_version can be used to filter out which players are included.

Fields

access_version: u64

WaitingTimeout

Timeout when waiting for start

DrawRandomItems

Random drawer takes random items by indexes.

Fields

sender: String

random_id: usize

indexes: Vec<usize>

DrawTimeout

Timeout for drawing random items

ActionTimeout

Timeout when waiting for player’s action Sent by transactor.

Fields

player_addr: String

AnswerDecision

Answer the decision question with encrypted ciphertext

Fields

sender: String

decision_id: DecisionId

ciphertext: Ciphertext

digest: SecretDigest

SecretsReady

All required secrets are shared

Fields

random_ids: Vec<usize>

Shutdown

Shutdown

Implementations

impl Event

pub fn custom<S: Into<String>, E: CustomEvent>(sender: S, e: &E) -> Self

Trait Implementations

impl BorshDeserialize for Event

where String: BorshDeserialize, Vec<u8>: BorshDeserialize, Vec<SecretShare>: BorshDeserialize, Vec<String>: BorshDeserialize, RandomId: BorshDeserialize, Vec<Ciphertext>: BorshDeserialize, Vec<(Ciphertext, SecretDigest)>: BorshDeserialize, Vec<PlayerJoin>: BorshDeserialize, Vec<ServerJoin>: BorshDeserialize, u64: BorshDeserialize, usize: BorshDeserialize, Vec<usize>: BorshDeserialize, DecisionId: BorshDeserialize, Ciphertext: BorshDeserialize, SecretDigest: 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 Event

where String: BorshSerialize, Vec<u8>: BorshSerialize, Vec<SecretShare>: BorshSerialize, Vec<String>: BorshSerialize, RandomId: BorshSerialize, Vec<Ciphertext>: BorshSerialize, Vec<(Ciphertext, SecretDigest)>: BorshSerialize, Vec<PlayerJoin>: BorshSerialize, Vec<ServerJoin>: BorshSerialize, u64: BorshSerialize, usize: BorshSerialize, Vec<usize>: BorshSerialize, DecisionId: BorshSerialize, Ciphertext: BorshSerialize, SecretDigest: 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 Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl Display for Event

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

Formats the value using the given formatter.

impl PartialEq for Event

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

impl StructuralPartialEq for Event