use borsh::{BorshDeserialize, BorshSerialize};
use serde::{Deserialize, Serialize};
#[derive(
Clone, Debug, Eq, PartialEq, Hash, BorshSerialize, BorshDeserialize, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum ScalarType {
U8,
U16,
U32,
U64,
U128,
I8,
I16,
I32,
I64,
I128,
Bool,
Address,
Hash32,
Bytes,
String,
Vec(Box<ScalarType>),
}
impl ScalarType {
#[must_use]
pub const fn fixed_byte_width(&self) -> Option<usize> {
match self {
Self::U8 | Self::I8 | Self::Bool => Some(1),
Self::U16 | Self::I16 => Some(2),
Self::U32 | Self::I32 => Some(4),
Self::U64 | Self::I64 => Some(8),
Self::U128 | Self::I128 => Some(16),
Self::Address | Self::Hash32 => Some(32),
Self::Bytes | Self::String | Self::Vec(_) => None,
}
}
}
#[derive(
Clone, Debug, Eq, PartialEq, Hash, BorshSerialize, BorshDeserialize, Serialize, Deserialize,
)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum FieldKind {
Scalar {
value: ScalarType,
},
Map {
keys: Vec<ScalarType>,
value: ScalarType,
},
}
#[derive(
Clone, Debug, Eq, PartialEq, Hash, BorshSerialize, BorshDeserialize, Serialize, Deserialize,
)]
pub struct StateField {
pub name: String,
pub kind: FieldKind,
}
#[derive(
Clone,
Debug,
Default,
Eq,
PartialEq,
Hash,
BorshSerialize,
BorshDeserialize,
Serialize,
Deserialize,
)]
pub struct StateSchema {
pub fields: Vec<StateField>,
}
impl StateSchema {
#[must_use]
pub const fn empty() -> Self {
Self { fields: Vec::new() }
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
#[test]
fn scalar_widths_are_correct() {
assert_eq!(ScalarType::U8.fixed_byte_width(), Some(1));
assert_eq!(ScalarType::U128.fixed_byte_width(), Some(16));
assert_eq!(ScalarType::Address.fixed_byte_width(), Some(32));
assert_eq!(ScalarType::Bytes.fixed_byte_width(), None);
assert_eq!(
ScalarType::Vec(Box::new(ScalarType::U64)).fixed_byte_width(),
None
);
}
#[test]
fn schema_borsh_round_trip() {
let schema = StateSchema {
fields: vec![
StateField {
name: "total_supply".into(),
kind: FieldKind::Scalar {
value: ScalarType::U128,
},
},
StateField {
name: "balances".into(),
kind: FieldKind::Map {
keys: vec![ScalarType::Address],
value: ScalarType::U128,
},
},
],
};
let bytes = borsh::to_vec(&schema).unwrap();
let decoded: StateSchema = borsh::from_slice(&bytes).unwrap();
assert_eq!(schema, decoded);
}
}