iota_json_rpc_types/
iota_owner.rs

1// Copyright (c) 2026 IOTA Stiftung
2// SPDX-License-Identifier: Apache-2.0
3
4use iota_sdk_types::{Address, ObjectId, Owner};
5use schemars::JsonSchema;
6use serde::{Deserialize, Serialize};
7use serde_with::{DeserializeAs, SerializeAs, serde_as};
8
9use crate::iota_primitives::{Address as AddressSchema, SequenceNumberU64};
10
11/// Enum of different types of ownership for an object.
12///
13/// # BCS
14///
15/// The BCS serialized form for this type is defined by the following ABNF:
16///
17/// ```text
18/// owner = owner-address / owner-object / owner-shared / owner-immutable
19///
20/// owner-address   = %x00 address
21/// owner-object    = %x01 object-id
22/// owner-shared    = %x02 u64
23/// owner-immutable = %x03
24/// ```
25#[serde_as]
26#[derive(Serialize, Deserialize, JsonSchema)]
27#[serde(rename = "Owner")]
28pub enum OwnerSchema {
29    /// Object is exclusively owned by a single address, and is mutable.
30    #[schemars(with = "AddressSchema")]
31    AddressOwner(#[serde_as(as = "AddressSchema")] Address),
32    /// Object is exclusively owned by a single object, and is mutable.
33    /// The object ID is converted to Address as Address is
34    /// universal.
35    #[schemars(with = "AddressSchema")]
36    ObjectOwner(#[serde_as(as = "AddressSchema")] Address),
37    /// Object is shared, can be used by any address, and is mutable.
38    Shared {
39        /// The version at which the object became shared
40        initial_shared_version: SequenceNumberU64,
41    },
42    /// Object is immutable, and hence ownership doesn't matter.
43    Immutable,
44}
45
46impl SerializeAs<Owner> for OwnerSchema {
47    fn serialize_as<S>(source: &Owner, serializer: S) -> Result<S::Ok, S::Error>
48    where
49        S: serde::Serializer,
50    {
51        OwnerSchema::from(*source).serialize(serializer)
52    }
53}
54
55impl<'de> DeserializeAs<'de, Owner> for OwnerSchema {
56    fn deserialize_as<D>(deserializer: D) -> Result<Owner, D::Error>
57    where
58        D: serde::Deserializer<'de>,
59    {
60        let iota_owner = OwnerSchema::deserialize(deserializer)?;
61        Ok(Owner::from(iota_owner))
62    }
63}
64
65impl std::fmt::Display for OwnerSchema {
66    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
67        match self {
68            Self::AddressOwner(address) => {
69                write!(f, "Account Address ( {address} )")
70            }
71            Self::ObjectOwner(address) => {
72                write!(f, "Object ID: ( {address} )")
73            }
74            Self::Immutable => {
75                write!(f, "Immutable")
76            }
77            Self::Shared {
78                initial_shared_version,
79            } => {
80                write!(f, "Shared( {initial_shared_version} )")
81            }
82        }
83    }
84}
85
86impl From<Owner> for OwnerSchema {
87    fn from(value: Owner) -> Self {
88        match value {
89            Owner::Address(address) => OwnerSchema::AddressOwner(address),
90            Owner::Object(object_id) => OwnerSchema::ObjectOwner(*object_id.as_address()),
91            Owner::Shared(initial_shared_version) => OwnerSchema::Shared {
92                initial_shared_version: initial_shared_version.into(),
93            },
94            Owner::Immutable => OwnerSchema::Immutable,
95            _ => unimplemented!("a new Owner enum variant was added and needs to be handled"),
96        }
97    }
98}
99
100impl From<OwnerSchema> for Owner {
101    fn from(value: OwnerSchema) -> Self {
102        match value {
103            OwnerSchema::AddressOwner(address) => Owner::Address(address),
104            OwnerSchema::ObjectOwner(address) => Owner::Object(ObjectId::from(address)),
105            OwnerSchema::Shared {
106                initial_shared_version,
107            } => Owner::Shared(initial_shared_version.into()),
108            OwnerSchema::Immutable => Owner::Immutable,
109        }
110    }
111}
iota_json_rpc_types/iota_owner.rs

iota_json_rpc_types/
iota_owner.rs
