Enum race_api::event::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

Fields

sender: String

raw: Vec<u8>

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

Ready

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

ShareSecrets

Fields

sender: String

shares: Vec<SecretShare>

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

OperationTimeout

Fields

addrs: Vec<String>

Mask

Fields

sender: String

random_id: RandomId

ciphertexts: Vec<Ciphertext>

Randomize items. This event is sent by transactors.

Lock

Fields

sender: String

random_id: RandomId

ciphertexts_and_digests: Vec<(Ciphertext, SecretDigest)>

Lock items. This event is sent by transactors.

RandomnessReady

Fields

random_id: RandomId

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

Sync

Fields

new_players: Vec<PlayerJoin>

new_servers: Vec<ServerJoin>

transactor_addr: String

access_version: u64

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.

ServerLeave

Fields

server_addr: String

transactor_addr: String

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

NOTE: This event must be handled idempotently.

Leave

Fields

player_addr: String

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

GameStart

Fields

access_version: u64

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

WaitingTimeout

Timeout when waiting for start

DrawRandomItems

Fields

sender: String

random_id: usize

indexes: Vec<usize>

Random drawer takes random items by indexes.

DrawTimeout

Timeout for drawing random items

ActionTimeout

Fields

player_addr: String

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

AnswerDecision

Fields

sender: String

decision_id: DecisionId

ciphertext: Ciphertext

digest: SecretDigest

Answer the decision question with encrypted ciphertext

SecretsReady

Fields

random_ids: Vec<usize>

All required secrets are shared

Shutdown

Shutdown

Implementations

impl Event

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

Trait Implementations

impl BorshDeserialize for Eventwhere 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 Eventwhere 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 copy 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

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

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 Eq for Event

impl StructuralEq for Event

impl StructuralPartialEq for Event