race_api/types/
common.rs

1use borsh::{BorshDeserialize, BorshSerialize};
2#[cfg(feature = "serde")]
3use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize, PartialOrd, Ord)]
6#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
7#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
8pub enum SettleOp {
9    Add(u64),
10    Sub(u64),
11    Eject,
12    AssignSlot(String),
13}
14
15#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
16#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
17#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
18pub struct Settle {
19    pub addr: String,
20    pub op: SettleOp,
21}
22
23impl Settle {
24    pub fn add<S: Into<String>>(addr: S, amount: u64) -> Self {
25        Self {
26            addr: addr.into(),
27            op: SettleOp::Add(amount),
28        }
29    }
30    pub fn sub<S: Into<String>>(addr: S, amount: u64) -> Self {
31        Self {
32            addr: addr.into(),
33            op: SettleOp::Sub(amount),
34        }
35    }
36    pub fn eject<S: Into<String>>(addr: S) -> Self {
37        Self {
38            addr: addr.into(),
39            op: SettleOp::Eject,
40        }
41    }
42    pub fn assign<S: Into<String>>(addr: S, identifier: String) -> Self {
43        Self {
44            addr: addr.into(),
45            op: SettleOp::AssignSlot(identifier),
46        }
47    }
48}
49
50pub type Addr = String;
51pub type Amount = u64;
52pub type RandomId = usize;
53pub type DecisionId = usize;
54pub type Ciphertext = Vec<u8>;
55pub type SecretDigest = Vec<u8>;
56pub type SecretKey = Vec<u8>;
57
58#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
59#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
60pub struct Signature {
61    pub signer: String,
62    pub timestamp: u64,
63    pub signature: Vec<u8>,
64}
65
66impl std::fmt::Display for Signature {
67    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68        write!(
69            f,
70            "[{:?}](signer: {}, timestamp: {})",
71            self.signature, self.signer, self.timestamp
72        )
73    }
74}
75
76#[derive(Hash, Debug, BorshDeserialize, BorshSerialize, Clone, PartialEq, Eq, PartialOrd, Ord)]
77#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
78#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
79pub struct SecretIdent {
80    pub from_addr: String,
81    pub to_addr: Option<String>,
82    pub random_id: RandomId,
83    pub index: usize,
84}
85
86impl SecretIdent {
87    pub fn new_for_assigned<S: Into<String>>(
88        random_id: RandomId,
89        index: usize,
90        from_addr: S,
91        to_addr: S,
92    ) -> Self {
93        SecretIdent {
94            from_addr: from_addr.into(),
95            to_addr: Some(to_addr.into()),
96            random_id,
97            index,
98        }
99    }
100
101    pub fn new_for_revealed<S: Into<String>>(
102        random_id: RandomId,
103        index: usize,
104        from_addr: S,
105    ) -> Self {
106        SecretIdent {
107            from_addr: from_addr.into(),
108            to_addr: None,
109            random_id,
110            index,
111        }
112    }
113}
114
115#[derive(Hash, Debug, BorshDeserialize, BorshSerialize, Clone, PartialEq, Eq)]
116#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
117#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
118pub enum SecretShare {
119    Random {
120        from_addr: String,
121        to_addr: Option<String>,
122        random_id: RandomId,
123        index: usize,
124        secret: Vec<u8>,
125    },
126    Answer {
127        from_addr: String,
128        decision_id: DecisionId,
129        secret: Vec<u8>,
130    },
131}
132
133impl std::fmt::Display for SecretShare {
134    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
135        match self {
136            SecretShare::Random {
137                from_addr,
138                to_addr,
139                random_id,
140                index,
141                ..
142            } => {
143                write!(
144                    f,
145                    "#{}[{}]=>[{}]@{}",
146                    random_id,
147                    from_addr,
148                    match to_addr {
149                        Some(ref addr) => addr.as_str(),
150                        None => "ALL",
151                    },
152                    index
153                )
154            }
155            SecretShare::Answer {
156                from_addr,
157                decision_id,
158                ..
159            } => {
160                write!(f, "#{}[{}]", decision_id, from_addr)
161            }
162        }
163    }
164}
165
166impl SecretShare {
167    pub fn new_for_random(
168        random_id: RandomId,
169        index: usize,
170        from_addr: Addr,
171        to_addr: Option<Addr>,
172        secret: SecretKey,
173    ) -> Self {
174        SecretShare::Random {
175            from_addr,
176            to_addr,
177            random_id,
178            index,
179            secret,
180        }
181    }
182
183    pub fn new_for_answer(decision_id: DecisionId, from_addr: Addr, secret: SecretKey) -> Self {
184        SecretShare::Answer {
185            decision_id,
186            from_addr,
187            secret,
188        }
189    }
190}
191
192#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
193#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
194#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
195pub enum VoteType {
196    ServerVoteTransactorDropOff,
197    ClientVoteTransactorDropOff,
198}
199
200#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
201#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
202#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
203pub enum RecipientSlotType {
204    Nft,
205    Token,
206}
207
208#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
209#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
210#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
211pub enum RecipientSlotOwner {
212    Unassigned { identifier: String },
213    Assigned { addr: String },
214}
215
216#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
217#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
218#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
219pub struct RecipientSlotShare {
220    pub owner: RecipientSlotOwner,
221    pub weights: u16,
222    pub claim_amount: u64,
223}
224
225#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
226#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
227// #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
228pub struct RecipientSlot {
229    pub id: u8,
230    pub slot_type: RecipientSlotType,
231    pub token_addr: String,
232    pub shares: Vec<RecipientSlotShare>,
233    pub balance: u64,
234}
235
236#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
237#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
238#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
239pub enum EntryType {
240    /// A player can join the game by sending assets to game account directly
241    #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
242    Cash { min_deposit: u64, max_deposit: u64 },
243    /// A player can join the game by pay a ticket.
244    #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
245    Ticket {
246        slot_id: u8,
247        amount: u64,
248    },
249    /// A player can join the game by showing a gate NFT
250    #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
251    Gating { collection: String },
252}
253
254impl Default for EntryType {
255    fn default() -> Self {
256        EntryType::Cash {
257            min_deposit: 0,
258            max_deposit: 1000000,
259        }
260    }
261}
262
263#[derive(Clone, BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq)]
264#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
265#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
266pub struct Transfer {
267    pub slot_id: u8,
268    pub amount: u64,
269}
270
271/// Represent a player call the join instruction in contract.
272#[derive(Debug, Default, PartialEq, Eq, Clone, BorshSerialize, BorshDeserialize)]
273#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
274#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
275pub struct PlayerJoin {
276    pub addr: String,
277    pub position: u16,
278    pub balance: u64,
279    pub access_version: u64,
280    pub verify_key: String,
281}
282
283impl PlayerJoin {
284    pub fn new<S: Into<String>>(
285        addr: S,
286        position: u16,
287        balance: u64,
288        access_version: u64,
289        verify_key: String,
290    ) -> Self {
291        Self {
292            addr: addr.into(),
293            position,
294            balance,
295            access_version,
296            verify_key,
297        }
298    }
299}
300
301/// Represent a player call the deposit instruction in contract.
302#[derive(Debug, PartialEq, Eq, Clone, BorshSerialize, BorshDeserialize)]
303#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
304#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
305pub struct PlayerDeposit {
306    pub addr: String,
307    pub amount: u64,
308    pub settle_version: u64,
309}
310
311impl PlayerDeposit {
312    pub fn new<S: Into<String>>(addr: S, balance: u64, settle_version: u64) -> Self {
313        Self {
314            addr: addr.into(),
315            amount: balance,
316            settle_version,
317        }
318    }
319}
320
321#[derive(Debug, PartialEq, Eq, Clone, BorshSerialize, BorshDeserialize)]
322#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
323#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
324pub struct ServerJoin {
325    pub addr: String,
326    pub endpoint: String,
327    pub access_version: u64,
328    pub verify_key: String,
329}
330
331impl ServerJoin {
332    pub fn new<S: Into<String>>(
333        addr: S,
334        endpoint: String,
335        access_version: u64,
336        verify_key: String,
337    ) -> Self {
338        Self {
339            addr: addr.into(),
340            endpoint,
341            access_version,
342            verify_key,
343        }
344    }
345}
346
347#[derive(Debug, Default, BorshSerialize, BorshDeserialize, PartialEq, Eq, Copy, Clone)]
348pub enum GameStatus {
349    #[default]
350    Uninit,
351    Running,
352    Closed,
353}
354
355impl std::fmt::Display for GameStatus {
356    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357        match self {
358            GameStatus::Uninit => write!(f, "uninit"),
359            GameStatus::Running => write!(f, "running"),
360            GameStatus::Closed => write!(f, "closed"),
361        }
362    }
363}
race_api/types/common.rs

race_api/types/
common.rs
