starknet_api 0.18.0-rc.0

Starknet Rust types related to computation and execution.
Documentation 
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

use apollo_sizeof::SizeOf;
use serde::{Deserialize, Serialize};
use starknet_types_core::felt::Felt;

use crate::StarknetApiError;

#[derive(
    Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, SizeOf,
)]
#[cfg_attr(any(test, feature = "testing"), derive(Default))]
#[serde(try_from = "Deserializer")]
pub enum DataAvailabilityMode {
    #[cfg_attr(any(test, feature = "testing"), default)]
    L1 = 0,
    L2 = 1,
}

/// Deserialize a `DataAvailabilityMode` from a given `Deserializer`.
///
/// This implementation supports deserializing the `DataAvailabilityMode` enum from both numerical
/// and textual representations.
#[derive(Deserialize)]
#[serde(untagged)]
enum Deserializer {
    Num(u8),
    Text(String),
}

impl TryFrom<Deserializer> for DataAvailabilityMode {
    type Error = StarknetApiError;

    fn try_from(value: Deserializer) -> Result<Self, Self::Error> {
        match value {
            Deserializer::Num(0_u8) => Ok(DataAvailabilityMode::L1),
            Deserializer::Num(1_u8) => Ok(DataAvailabilityMode::L2),
            Deserializer::Text(text) if &text == "L1" => Ok(DataAvailabilityMode::L1),
            Deserializer::Text(text) if &text == "L2" => Ok(DataAvailabilityMode::L2),
            _ => Err(StarknetApiError::OutOfRange {
                string: "Data availability must be either 'L1' or '0' for L1, or 'L2' or '1' for \
                         L2."
                .to_string(),
            }),
        }
    }
}

impl TryFrom<Felt> for DataAvailabilityMode {
    type Error = StarknetApiError;

    fn try_from(felt: Felt) -> Result<Self, StarknetApiError> {
        if felt == Felt::ZERO {
            return Ok(DataAvailabilityMode::L1);
        }
        if felt == Felt::ONE {
            return Ok(DataAvailabilityMode::L2);
        }
        Err(StarknetApiError::OutOfRange {
            string: format!("Invalid data availability mode: {felt}."),
        })
    }
}

impl From<DataAvailabilityMode> for Felt {
    fn from(data_availability_mode: DataAvailabilityMode) -> Felt {
        match data_availability_mode {
            DataAvailabilityMode::L1 => Felt::ZERO,
            DataAvailabilityMode::L2 => Felt::ONE,
        }
    }
}

impl From<DataAvailabilityMode> for u32 {
    fn from(data_availability_mode: DataAvailabilityMode) -> u32 {
        match data_availability_mode {
            DataAvailabilityMode::L1 => 0,
            DataAvailabilityMode::L2 => 1,
        }
    }
}

#[derive(
    Clone, Default, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum L1DataAvailabilityMode {
    #[default]
    Calldata,
    Blob,
}

impl L1DataAvailabilityMode {
    pub fn from_use_kzg_da(use_kzg_da: bool) -> Self {
        match use_kzg_da {
            true => Self::Blob,
            false => Self::Calldata,
        }
    }

    pub fn is_use_kzg_da(&self) -> bool {
        match self {
            Self::Blob => true,
            Self::Calldata => false,
        }
    }
}