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
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// Copyright 2020-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// OpenEthereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

//! Transaction Id.

use ethereum_types::U64;
use serde_repr::*;

#[derive(Serialize_repr, Eq, Hash, Deserialize_repr, Debug, Copy, Clone, PartialEq)]
#[repr(u8)]
pub enum TypedTxId {
    EIP1559Transaction = 0x02,
    AccessList = 0x01,
    Legacy = 0x00,
}

impl TypedTxId {
    // used in json tets
    pub fn from_u8_id(n: u8) -> Option<Self> {
        match n {
            0 => Some(Self::Legacy),
            1 => Some(Self::AccessList),
            2 => Some(Self::EIP1559Transaction),
            _ => None,
        }
    }

    pub fn try_from_wire_byte(n: u8) -> Result<Self, ()> {
        match n {
            x if x == TypedTxId::EIP1559Transaction as u8 => Ok(TypedTxId::EIP1559Transaction),
            x if x == TypedTxId::AccessList as u8 => Ok(TypedTxId::AccessList),
            x if (x & 0x80) != 0x00 => Ok(TypedTxId::Legacy),
            _ => Err(()),
        }
    }

    #[allow(non_snake_case)]
    pub fn from_U64_option_id(n: Option<U64>) -> Option<Self> {
        match n.map(|t| t.as_u64()) {
            None => Some(Self::Legacy),
            Some(0x00) => Some(Self::Legacy),
            Some(0x01) => Some(Self::AccessList),
            Some(0x02) => Some(Self::EIP1559Transaction),
            _ => None,
        }
    }

    #[allow(non_snake_case)]
    pub fn to_U64_option_id(self) -> Option<U64> {
        Some(U64::from(self as u8))
    }
}

impl Default for TypedTxId {
    fn default() -> TypedTxId {
        TypedTxId::Legacy
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn typed_tx_id_try_from_wire() {
        assert_eq!(
            Ok(TypedTxId::EIP1559Transaction),
            TypedTxId::try_from_wire_byte(0x02)
        );
        assert_eq!(
            Ok(TypedTxId::AccessList),
            TypedTxId::try_from_wire_byte(0x01)
        );
        assert_eq!(Ok(TypedTxId::Legacy), TypedTxId::try_from_wire_byte(0x81));
        assert_eq!(Err(()), TypedTxId::try_from_wire_byte(0x00));
        assert_eq!(Err(()), TypedTxId::try_from_wire_byte(0x03));
    }

    #[test]
    fn typed_tx_id_to_u64_option_id() {
        assert_eq!(Some(U64::from(0x00)), TypedTxId::Legacy.to_U64_option_id());
        assert_eq!(
            Some(U64::from(0x01)),
            TypedTxId::AccessList.to_U64_option_id()
        );
        assert_eq!(
            Some(U64::from(0x02)),
            TypedTxId::EIP1559Transaction.to_U64_option_id()
        );
    }

    #[test]
    fn typed_tx_id_from_u64_option_id() {
        assert_eq!(Some(TypedTxId::Legacy), TypedTxId::from_U64_option_id(None));
        assert_eq!(
            Some(TypedTxId::AccessList),
            TypedTxId::from_U64_option_id(Some(U64::from(0x01)))
        );
        assert_eq!(
            Some(TypedTxId::EIP1559Transaction),
            TypedTxId::from_U64_option_id(Some(U64::from(0x02)))
        );
        assert_eq!(None, TypedTxId::from_U64_option_id(Some(U64::from(0x03))));
    }

    #[test]
    fn typed_tx_id_from_u8_id() {
        assert_eq!(Some(TypedTxId::Legacy), TypedTxId::from_u8_id(0));
        assert_eq!(Some(TypedTxId::AccessList), TypedTxId::from_u8_id(1));
        assert_eq!(
            Some(TypedTxId::EIP1559Transaction),
            TypedTxId::from_u8_id(2)
        );
        assert_eq!(None, TypedTxId::from_u8_id(3));
    }
}