use crate::{
account_address::AccountAddress,
identifier::{IdentStr, Identifier},
parser::{parse_struct_tag, parse_type_tag},
};
#[cfg(any(test, feature = "fuzzing"))]
use proptest_derive::Arbitrary;
use serde::{Deserialize, Serialize};
use std::{
fmt::{Display, Formatter},
str::FromStr,
};
pub const CODE_TAG: u8 = 0;
pub const RESOURCE_TAG: u8 = 1;
pub const CORE_CODE_ADDRESS: AccountAddress = AccountAddress::ONE;
#[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
pub enum TypeTag {
#[serde(rename = "bool", alias = "Bool")]
Bool,
#[serde(rename = "u8", alias = "U8")]
U8,
#[serde(rename = "u64", alias = "U64")]
U64,
#[serde(rename = "u128", alias = "U128")]
U128,
#[serde(rename = "address", alias = "Address")]
Address,
#[serde(rename = "signer", alias = "Signer")]
Signer,
#[serde(rename = "vector", alias = "Vector")]
Vector(Box<TypeTag>),
#[serde(rename = "struct", alias = "Struct")]
Struct(StructTag),
}
impl FromStr for TypeTag {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
parse_type_tag(s)
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
pub struct StructTag {
pub address: AccountAddress,
pub module: Identifier,
pub name: Identifier,
#[serde(rename = "type_args", alias = "type_params")]
pub type_params: Vec<TypeTag>,
}
impl StructTag {
pub fn access_vector(&self) -> Vec<u8> {
let mut key = vec![RESOURCE_TAG];
key.append(&mut bcs::to_bytes(self).unwrap());
key
}
pub fn module_id(&self) -> ModuleId {
ModuleId::new(self.address, self.module.to_owned())
}
}
impl FromStr for StructTag {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
parse_struct_tag(s)
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
pub struct ResourceKey {
pub address: AccountAddress,
pub type_: StructTag,
}
impl ResourceKey {
pub fn address(&self) -> AccountAddress {
self.address
}
pub fn type_(&self) -> &StructTag {
&self.type_
}
}
impl ResourceKey {
pub fn new(address: AccountAddress, type_: StructTag) -> Self {
ResourceKey { address, type_ }
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
#[cfg_attr(any(test, feature = "fuzzing"), derive(Arbitrary))]
#[cfg_attr(any(test, feature = "fuzzing"), proptest(no_params))]
pub struct ModuleId {
address: AccountAddress,
name: Identifier,
}
impl From<ModuleId> for (AccountAddress, Identifier) {
fn from(module_id: ModuleId) -> Self {
(module_id.address, module_id.name)
}
}
impl ModuleId {
pub fn new(address: AccountAddress, name: Identifier) -> Self {
ModuleId { address, name }
}
pub fn name(&self) -> &IdentStr {
&self.name
}
pub fn address(&self) -> &AccountAddress {
&self.address
}
pub fn access_vector(&self) -> Vec<u8> {
let mut key = vec![CODE_TAG];
key.append(&mut bcs::to_bytes(self).unwrap());
key
}
}
impl Display for ModuleId {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
write!(f, "{}::{}", self.address, self.name)
}
}
impl ModuleId {
pub fn short_str_lossless(&self) -> String {
format!("0x{}::{}", self.address.short_str_lossless(), self.name)
}
}
impl Display for StructTag {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
write!(
f,
"0x{}::{}::{}",
self.address.short_str_lossless(),
self.module,
self.name
)?;
if let Some(first_ty) = self.type_params.first() {
write!(f, "<")?;
write!(f, "{}", first_ty)?;
for ty in self.type_params.iter().skip(1) {
write!(f, ", {}", ty)?;
}
write!(f, ">")?;
}
Ok(())
}
}
impl Display for TypeTag {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
match self {
TypeTag::Struct(s) => write!(f, "{}", s),
TypeTag::Vector(ty) => write!(f, "vector<{}>", ty),
TypeTag::U8 => write!(f, "u8"),
TypeTag::U64 => write!(f, "u64"),
TypeTag::U128 => write!(f, "u128"),
TypeTag::Address => write!(f, "address"),
TypeTag::Signer => write!(f, "signer"),
TypeTag::Bool => write!(f, "bool"),
}
}
}
impl Display for ResourceKey {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
write!(f, "0x{}/{}", self.address.short_str_lossless(), self.type_)
}
}
impl From<StructTag> for TypeTag {
fn from(t: StructTag) -> TypeTag {
TypeTag::Struct(t)
}
}
#[cfg(test)]
mod tests {
use super::TypeTag;
use crate::{
account_address::AccountAddress, identifier::Identifier, language_storage::StructTag,
};
#[test]
fn test_type_tag_serde() {
let a = TypeTag::Struct(StructTag {
address: AccountAddress::ONE,
module: Identifier::from_utf8(("abc".as_bytes()).to_vec()).unwrap(),
name: Identifier::from_utf8(("abc".as_bytes()).to_vec()).unwrap(),
type_params: vec![TypeTag::U8],
});
let b = serde_json::to_string(&a).unwrap();
let c: TypeTag = serde_json::from_str(&b).unwrap();
assert!(a.eq(&c), "Typetag serde error")
}
}