1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use std::ops;

use ex3_crypto::sha256;
use ex3_serde::bincode;
use serde::{Deserialize, Serialize};
use serde_bytes::ByteBuf;

use crate::{Nonce, Version, WalletRegisterId};

pub type TransactionHash = [u8; 32];
pub type r#Type = u32;

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct Transaction {
    pub r#type: r#Type,
    pub version: Version,
    pub from: WalletRegisterId,
    /// if the transaction type is [Deposit], this field is None
    pub nonce: Option<Nonce>,
    pub payload: ByteBuf,
    pub signature: Option<ByteBuf>,
}

impl Transaction {
    pub fn hash(&self) -> TransactionHash {
        let bytes = bincode::serialize(&self).unwrap();
        sha256!(&bytes)
    }
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(transparent)]
pub struct EncodedTransaction(pub ByteBuf);

impl From<Transaction> for EncodedTransaction {
    fn from(tx: Transaction) -> Self {
        let bytes = bincode::serialize(&tx).unwrap();
        EncodedTransaction(ByteBuf::from(bytes))
    }
}

impl From<&Transaction> for EncodedTransaction {
    fn from(tx: &Transaction) -> Self {
        let bytes = bincode::serialize(&tx).unwrap();
        EncodedTransaction(ByteBuf::from(bytes))
    }
}

impl From<EncodedTransaction> for Transaction {
    fn from(tx: EncodedTransaction) -> Self {
        bincode::deserialize(tx.0.as_ref()).unwrap()
    }
}

impl From<&EncodedTransaction> for Transaction {
    fn from(tx: &EncodedTransaction) -> Self {
        bincode::deserialize(tx.0.as_ref()).unwrap()
    }
}

impl ops::Deref for EncodedTransaction {
    type Target = ByteBuf;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Transaction type
/// | type                 | code              | remark                               |
/// | -------------------- | ----------------- | ------------------------------------ |
/// | DEPOSIT              | 1u32              | Deposit transaction.                 |
/// | WITHDRAW             | 2u32              | Withdraw transaction.                |
/// | TRANSFER             | 3u32              | Transfer transaction.                |
/// | CREATE_MAIN_SECRET   | 4u32              | Create main secret transaction.      |
/// | DESTROY_MAIN_SECRET  | 5u32              | Destroy main secret transaction.     |
/// | CREATE_API_SECRET    | 6u32              | Create api secret transaction.       |
/// | DESTROY_API_SECRET   | 7u32              | Destroy api secret transaction.      |
/// | SUBMIT_SPOT_ORDER    | 8u32              | Submit spot order.                   |
#[allow(dead_code)]
pub mod transaction_type {
    pub const DEPOSIT: u32 = 1u32;
    pub const WITHDRAW: u32 = 2u32;
    pub const TRANSFER: u32 = 3u32;
    pub const CREATE_MAIN_SECRET: u32 = 4u32;
    pub const DESTROY_MAIN_SECRET: u32 = 5u32;
    pub const CREATE_API_SECRET: u32 = 6u32;
    pub const DESTROY_API_SECRET: u32 = 7u32;
    pub const SPOT_LIMIT_ORDER: u32 = 8u32;
    pub const SPOT_SWAP_ORDER: u32 = 9u32;
}