iota_json_rpc_types/
lib.rs

1// Copyright (c) Mysten Labs, Inc.
2// Modifications Copyright (c) 2024 IOTA Stiftung
3// SPDX-License-Identifier: Apache-2.0
4
5pub use balance_changes::*;
6use fastcrypto::{
7    encoding::{Base58, Base64},
8    traits::VerifyingKey,
9};
10pub use iota_checkpoint::*;
11pub use iota_coin::*;
12pub use iota_event::*;
13pub use iota_extended::*;
14pub use iota_gas_cost_summary::*;
15pub use iota_governance::*;
16pub use iota_indexer::*;
17pub use iota_move::*;
18pub use iota_object::*;
19pub use iota_object_response_error::*;
20pub use iota_owner::*;
21use iota_primitives::{
22    Base58 as Base58Schema, Base64 as Base64Schema, ObjectID as ObjectIDSchema,
23    SequenceNumberU64 as SequenceNumberU64Schema, TypeTag as TypeTagSchema,
24};
25pub use iota_protocol::*;
26pub use iota_system_state_summary::*;
27pub use iota_transaction::*;
28use iota_types::{
29    base_types::{ObjectID, TypeTag},
30    crypto::{AuthorityPublicKey, AuthorityPublicKeyBytes},
31    dynamic_field::{DynamicFieldInfo, DynamicFieldName, DynamicFieldType},
32};
33pub use object_changes::*;
34use schemars::JsonSchema;
35use serde::{Deserialize, Serialize};
36use serde_with::{DeserializeAs, SerializeAs, serde_as};
37
38#[cfg(test)]
39#[path = "unit_tests/rpc_types_tests.rs"]
40mod rpc_types_tests;
41
42mod balance_changes;
43mod displays;
44mod iota_checkpoint;
45mod iota_coin;
46mod iota_event;
47mod iota_extended;
48mod iota_gas_cost_summary;
49mod iota_governance;
50mod iota_indexer;
51mod iota_move;
52mod iota_object;
53mod iota_object_response_error;
54mod iota_owner;
55pub mod iota_primitives;
56mod iota_protocol;
57mod iota_system_state_summary;
58mod iota_transaction;
59mod object_changes;
60
61pub type DynamicFieldPage = Page<IotaDynamicFieldInfo, ObjectID>;
62
63/// `next_cursor` points to the last item in the page;
64/// Reading with `next_cursor` will start from the next item after `next_cursor`
65/// if `next_cursor` is `Some`, otherwise it will start from the first item.
66#[derive(Clone, Debug, JsonSchema, Serialize, Deserialize, PartialEq, Eq)]
67#[serde(rename_all = "camelCase")]
68pub struct Page<T, C> {
69    pub data: Vec<T>,
70    pub next_cursor: Option<C>,
71    pub has_next_page: bool,
72}
73
74impl<T, C> Page<T, C> {
75    pub fn empty() -> Self {
76        Self {
77            data: vec![],
78            next_cursor: None,
79            has_next_page: false,
80        }
81    }
82}
83
84#[serde_as]
85#[derive(Clone, Serialize, Deserialize, JsonSchema)]
86#[serde(rename_all = "camelCase", rename = "DynamicFieldName")]
87pub struct DynamicFieldNameSchema {
88    #[schemars(with = "TypeTagSchema")]
89    #[serde_as(as = "TypeTagSchema")]
90    pub type_: TypeTag,
91    // Bincode does not like serde_json::Value, rocksdb will not insert the value without
92    // serializing value as string. TODO: investigate if this can be removed after switch to
93    // BCS.
94    pub value: serde_json::Value,
95}
96
97impl SerializeAs<DynamicFieldName> for DynamicFieldNameSchema {
98    fn serialize_as<S>(name: &DynamicFieldName, serializer: S) -> Result<S::Ok, S::Error>
99    where
100        S: serde::Serializer,
101    {
102        let schema = DynamicFieldNameSchema::from(name.clone());
103        schema.serialize(serializer)
104    }
105}
106
107impl<'de> DeserializeAs<'de, DynamicFieldName> for DynamicFieldNameSchema {
108    fn deserialize_as<D>(deserializer: D) -> Result<DynamicFieldName, D::Error>
109    where
110        D: serde::Deserializer<'de>,
111    {
112        let schema = DynamicFieldNameSchema::deserialize(deserializer)?;
113        Ok(DynamicFieldName::from(schema))
114    }
115}
116
117impl From<DynamicFieldName> for DynamicFieldNameSchema {
118    fn from(name: DynamicFieldName) -> Self {
119        Self {
120            type_: name.type_,
121            value: name.value,
122        }
123    }
124}
125
126impl From<DynamicFieldNameSchema> for DynamicFieldName {
127    fn from(name: DynamicFieldNameSchema) -> Self {
128        Self {
129            type_: name.type_,
130            value: name.value,
131        }
132    }
133}
134
135#[derive(Copy, Clone, Serialize, Deserialize, JsonSchema)]
136#[serde(rename = "DynamicFieldType")]
137pub enum DynamicFieldTypeSchema {
138    DynamicField,
139    DynamicObject,
140}
141
142impl SerializeAs<DynamicFieldType> for DynamicFieldTypeSchema {
143    fn serialize_as<S>(type_: &DynamicFieldType, serializer: S) -> Result<S::Ok, S::Error>
144    where
145        S: serde::Serializer,
146    {
147        let schema = DynamicFieldTypeSchema::from(*type_);
148        schema.serialize(serializer)
149    }
150}
151
152impl<'de> DeserializeAs<'de, DynamicFieldType> for DynamicFieldTypeSchema {
153    fn deserialize_as<D>(deserializer: D) -> Result<DynamicFieldType, D::Error>
154    where
155        D: serde::Deserializer<'de>,
156    {
157        let schema = DynamicFieldTypeSchema::deserialize(deserializer)?;
158        Ok(DynamicFieldType::from(schema))
159    }
160}
161
162impl From<DynamicFieldType> for DynamicFieldTypeSchema {
163    fn from(type_: DynamicFieldType) -> Self {
164        match type_ {
165            DynamicFieldType::DynamicField => Self::DynamicField,
166            DynamicFieldType::DynamicObject => Self::DynamicObject,
167        }
168    }
169}
170
171impl From<DynamicFieldTypeSchema> for DynamicFieldType {
172    fn from(type_: DynamicFieldTypeSchema) -> Self {
173        match type_ {
174            DynamicFieldTypeSchema::DynamicField => Self::DynamicField,
175            DynamicFieldTypeSchema::DynamicObject => Self::DynamicObject,
176        }
177    }
178}
179
180#[serde_as]
181#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
182#[serde(rename_all = "camelCase")]
183#[schemars(rename = "DynamicFieldInfo")]
184pub struct IotaDynamicFieldInfo {
185    #[schemars(with = "DynamicFieldNameSchema")]
186    #[serde_as(as = "DynamicFieldNameSchema")]
187    pub name: DynamicFieldName,
188    #[serde(flatten)]
189    pub bcs_name: BcsName,
190    #[schemars(with = "DynamicFieldTypeSchema")]
191    #[serde_as(as = "DynamicFieldTypeSchema")]
192    pub type_: DynamicFieldType,
193    pub object_type: String,
194    #[schemars(with = "ObjectIDSchema")]
195    pub object_id: ObjectID,
196    #[schemars(with = "SequenceNumberU64Schema")]
197    pub version: iota_types::base_types::SequenceNumber,
198    #[schemars(with = "Base58Schema")]
199    pub digest: iota_types::digests::ObjectDigest,
200}
201
202impl From<DynamicFieldInfo> for IotaDynamicFieldInfo {
203    fn from(
204        DynamicFieldInfo {
205            name,
206            bcs_name,
207            type_,
208            object_type,
209            object_id,
210            version,
211            digest,
212        }: DynamicFieldInfo,
213    ) -> Self {
214        Self {
215            name,
216            bcs_name: BcsName::new(bcs_name),
217            type_,
218            object_type,
219            object_id,
220            version,
221            digest,
222        }
223    }
224}
225
226impl From<IotaDynamicFieldInfo> for DynamicFieldInfo {
227    fn from(
228        IotaDynamicFieldInfo {
229            name,
230            bcs_name,
231            type_,
232            object_type,
233            object_id,
234            version,
235            digest,
236        }: IotaDynamicFieldInfo,
237    ) -> Self {
238        Self {
239            name,
240            bcs_name: bcs_name.into_bytes(),
241            type_,
242            object_type,
243            object_id,
244            version,
245            digest,
246        }
247    }
248}
249
250#[serde_as]
251#[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize, JsonSchema)]
252#[serde(rename_all = "camelCase", tag = "bcsEncoding")]
253#[serde(from = "MaybeTaggedBcsName")]
254pub enum BcsName {
255    Base64 {
256        #[serde_as(as = "Base64")]
257        #[schemars(with = "Base64Schema")]
258        #[serde(rename = "bcsName")]
259        bcs_name: Vec<u8>,
260    },
261    Base58 {
262        #[serde_as(as = "Base58")]
263        #[schemars(with = "Base58Schema")]
264        #[serde(rename = "bcsName")]
265        bcs_name: Vec<u8>,
266    },
267}
268
269impl BcsName {
270    pub fn new(bytes: Vec<u8>) -> Self {
271        Self::Base64 { bcs_name: bytes }
272    }
273
274    pub fn bytes(&self) -> &[u8] {
275        match self {
276            BcsName::Base64 { bcs_name } => bcs_name.as_ref(),
277            BcsName::Base58 { bcs_name } => bcs_name.as_ref(),
278        }
279    }
280
281    pub fn into_bytes(self) -> Vec<u8> {
282        match self {
283            BcsName::Base64 { bcs_name } => bcs_name,
284            BcsName::Base58 { bcs_name } => bcs_name,
285        }
286    }
287}
288
289#[allow(unused)]
290#[serde_as]
291#[derive(Serialize, Deserialize)]
292#[serde(rename_all = "camelCase", untagged)]
293enum MaybeTaggedBcsName {
294    Tagged(TaggedBcsName),
295    Base58 {
296        #[serde_as(as = "Base58")]
297        #[serde(rename = "bcsName")]
298        bcs_name: Vec<u8>,
299    },
300}
301
302#[serde_as]
303#[derive(Serialize, Deserialize)]
304#[serde(rename_all = "camelCase", tag = "bcsEncoding")]
305enum TaggedBcsName {
306    Base64 {
307        #[serde_as(as = "Base64")]
308        #[serde(rename = "bcsName")]
309        bcs_name: Vec<u8>,
310    },
311    Base58 {
312        #[serde_as(as = "Base58")]
313        #[serde(rename = "bcsName")]
314        bcs_name: Vec<u8>,
315    },
316}
317
318impl From<MaybeTaggedBcsName> for BcsName {
319    fn from(name: MaybeTaggedBcsName) -> BcsName {
320        let bcs_name = match name {
321            MaybeTaggedBcsName::Tagged(TaggedBcsName::Base58 { bcs_name })
322            | MaybeTaggedBcsName::Base58 { bcs_name } => bcs_name,
323            MaybeTaggedBcsName::Tagged(TaggedBcsName::Base64 { bcs_name }) => bcs_name,
324        };
325
326        // Bytes are already decoded, force into Base64 variant to avoid serializing to
327        // base58
328        Self::Base64 { bcs_name }
329    }
330}
331
332/// Defines the compressed version of the public key that we pass around
333/// in IOTA.
334#[serde_as]
335#[derive(
336    Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, JsonSchema,
337)]
338#[schemars(rename = "AuthorityPublicKeyBytes")]
339pub struct IotaAuthorityPublicKeyBytes(
340    #[serde_as(as = "Base64")]
341    #[schemars(with = "Base64Schema")]
342    pub [u8; AuthorityPublicKey::LENGTH],
343);
344
345impl From<IotaAuthorityPublicKeyBytes> for AuthorityPublicKeyBytes {
346    fn from(value: IotaAuthorityPublicKeyBytes) -> Self {
347        Self(value.0)
348    }
349}
350
351impl From<AuthorityPublicKeyBytes> for IotaAuthorityPublicKeyBytes {
352    fn from(value: AuthorityPublicKeyBytes) -> Self {
353        Self(value.0)
354    }
355}
356
357#[cfg(test)]
358mod test {
359    use super::*;
360
361    #[test]
362    fn bcs_name_test() {
363        let bytes = vec![0, 1, 2, 3, 4];
364        let untagged_base58 = r#"{"bcsName":"12VfUX"}"#;
365        let tagged_base58 = r#"{"bcsEncoding":"base58","bcsName":"12VfUX"}"#;
366        let tagged_base64 = r#"{"bcsEncoding":"base64","bcsName":"AAECAwQ="}"#;
367
368        assert_eq!(
369            bytes,
370            serde_json::from_str::<BcsName>(untagged_base58)
371                .unwrap()
372                .into_bytes()
373        );
374        assert_eq!(
375            bytes,
376            serde_json::from_str::<BcsName>(tagged_base58)
377                .unwrap()
378                .into_bytes()
379        );
380        assert_eq!(
381            bytes,
382            serde_json::from_str::<BcsName>(tagged_base64)
383                .unwrap()
384                .into_bytes()
385        );
386
387        // Roundtrip base64
388        let name = serde_json::from_str::<BcsName>(tagged_base64).unwrap();
389        let json = serde_json::to_string(&name).unwrap();
390        let from_json = serde_json::from_str::<BcsName>(&json).unwrap();
391        assert_eq!(name, from_json);
392
393        // Roundtrip base58
394        let name = serde_json::from_str::<BcsName>(tagged_base58).unwrap();
395        let json = serde_json::to_string(&name).unwrap();
396        let from_json = serde_json::from_str::<BcsName>(&json).unwrap();
397        assert_eq!(name, from_json);
398    }
399}
iota_json_rpc_types/lib.rs

iota_json_rpc_types/
lib.rs
