sui_jsonrpc/msgs/
dynamic_field.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3use std::borrow::Borrow;
4use std::fmt::Display;
5
6use af_sui_types::{
7    DYNAMIC_FIELD_FIELD_STRUCT_NAME,
8    DYNAMIC_FIELD_MODULE_NAME,
9    DYNAMIC_OBJECT_FIELD_MODULE_NAME,
10    DYNAMIC_OBJECT_FIELD_WRAPPER_STRUCT_NAME,
11    IdentStr,
12    ObjectDigest,
13    ObjectId,
14    SUI_FRAMEWORK_ADDRESS,
15    StructTag,
16    TypeTag,
17};
18use serde::{Deserialize, Serialize};
19use serde_with::{DisplayFromStr, IfIsHumanReadable, serde_as};
20use sui_sdk_types::Version;
21
22use super::Page;
23use crate::serde::Base64orBase58;
24
25pub type DynamicFieldPage = Page<DynamicFieldInfo, ObjectId>;
26
27/// Originally `sui_types::dynamic_field::DynamicFieldName`.
28#[serde_as]
29#[derive(Clone, Serialize, Deserialize, Debug)]
30#[serde(rename_all = "camelCase")]
31pub struct DynamicFieldName {
32    #[serde_as(as = "IfIsHumanReadable<DisplayFromStr, _>")]
33    pub type_: TypeTag,
34    #[serde_as(as = "IfIsHumanReadable<_, DisplayFromStr>")]
35    pub value: serde_json::Value,
36}
37
38impl Display for DynamicFieldName {
39    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
40        write!(f, "{}: {}", self.type_, self.value)
41    }
42}
43
44/// Originally `sui_types::dynamic_field::DynamicFieldInfo`.
45#[serde_as]
46#[derive(Clone, Serialize, Deserialize, Debug)]
47#[serde(rename_all = "camelCase")]
48pub struct DynamicFieldInfo {
49    pub name: DynamicFieldName,
50    #[serde_as(as = "IfIsHumanReadable<Base64orBase58, _>")]
51    pub bcs_name: Vec<u8>,
52    pub type_: DynamicFieldType,
53    pub object_type: String,
54    pub object_id: ObjectId,
55    pub version: Version,
56    pub digest: ObjectDigest,
57}
58
59impl DynamicFieldInfo {
60    pub fn is_dynamic_field(tag: &StructTag) -> bool {
61        tag.address == SUI_FRAMEWORK_ADDRESS
62            && Borrow::<IdentStr>::borrow(&tag.module) == DYNAMIC_FIELD_MODULE_NAME
63            && Borrow::<IdentStr>::borrow(&tag.name) == DYNAMIC_FIELD_FIELD_STRUCT_NAME
64    }
65
66    pub fn is_dynamic_object_field_wrapper(tag: &StructTag) -> bool {
67        tag.address == SUI_FRAMEWORK_ADDRESS
68            && Borrow::<IdentStr>::borrow(&tag.module) == DYNAMIC_OBJECT_FIELD_MODULE_NAME
69            && Borrow::<IdentStr>::borrow(&tag.name) == DYNAMIC_OBJECT_FIELD_WRAPPER_STRUCT_NAME
70    }
71
72    pub fn dynamic_field_type(key: TypeTag, value: TypeTag) -> StructTag {
73        StructTag {
74            address: SUI_FRAMEWORK_ADDRESS,
75            name: DYNAMIC_FIELD_FIELD_STRUCT_NAME.to_owned(),
76            module: DYNAMIC_FIELD_MODULE_NAME.to_owned(),
77            type_params: vec![key, value],
78        }
79    }
80
81    pub fn dynamic_object_field_wrapper(key: TypeTag) -> StructTag {
82        StructTag {
83            address: SUI_FRAMEWORK_ADDRESS,
84            module: DYNAMIC_OBJECT_FIELD_MODULE_NAME.to_owned(),
85            name: DYNAMIC_OBJECT_FIELD_WRAPPER_STRUCT_NAME.to_owned(),
86            type_params: vec![key],
87        }
88    }
89}
90
91/// Originally `sui_types::dynamic_field::DynamicFieldType`.
92#[derive(Clone, Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq, Debug)]
93pub enum DynamicFieldType {
94    #[serde(rename_all = "camelCase")]
95    DynamicField,
96    DynamicObject,
97}
98
99impl Display for DynamicFieldType {
100    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
101        match self {
102            DynamicFieldType::DynamicField => write!(f, "DynamicField"),
103            DynamicFieldType::DynamicObject => write!(f, "DynamicObject"),
104        }
105    }
106}