Skip to main content

sui_rpc_api/grpc/v2/move_package_service/
conversions.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4// This module contains conversion functions from sui-package-resolver types to their protobuf representations.
5// We use explicit conversion functions instead of From traits because:
6// 1. The orphan rule prevents implementing From for external types
7// 2. Many conversions require additional context (e.g., package_id, module_name) that From traits cannot provide
8
9use crate::{Result, RpcError};
10use move_binary_format::file_format::{
11    Ability as MoveAbility, AbilitySet as MoveAbilitySet, DatatypeTyParameter,
12    Visibility as MoveVisibility,
13};
14use sui_package_resolver::{DataDef, FunctionDef, MoveData, VariantDef};
15use sui_rpc::proto::sui::rpc::v2::{
16    Ability, DatatypeDescriptor, FieldDescriptor, FunctionDescriptor, Module, OpenSignature,
17    OpenSignatureBody, TypeParameter, VariantDescriptor, datatype_descriptor::DatatypeKind,
18    function_descriptor::Visibility, open_signature::Reference,
19    open_signature_body::Type as SignatureType,
20};
21use sui_types::base_types::ObjectID;
22
23/// A module, datatype or function missing from the package is the caller naming something that
24/// does not exist; every other resolver error is a server-side failure.
25pub fn convert_error(e: sui_package_resolver::error::Error) -> RpcError {
26    use sui_package_resolver::error::Error;
27
28    let code = match e {
29        Error::ModuleNotFound(..) | Error::DatatypeNotFound(..) | Error::FunctionNotFound(..) => {
30            tonic::Code::NotFound
31        }
32        _ => tonic::Code::Internal,
33    };
34    RpcError::new(code, e.to_string())
35}
36
37pub fn convert_datatype(
38    datatype_name: &str,
39    data_def: &DataDef,
40    package_id: &ObjectID,
41    module_name: &str,
42) -> DatatypeDescriptor {
43    let type_parameters = data_def
44        .type_params
45        .iter()
46        .map(convert_type_parameter)
47        .collect();
48    let abilities = convert_ability_set(data_def.abilities);
49
50    let (kind, fields, variants) = match &data_def.data {
51        MoveData::Struct(fields) => {
52            let proto_fields = fields
53                .iter()
54                .enumerate()
55                .map(|(pos, (name, sig))| {
56                    let mut message = FieldDescriptor::default();
57                    message.name = Some(name.clone());
58                    message.position = Some(pos as u32);
59                    message.r#type = Some(convert_open_signature_body(sig));
60                    message
61                })
62                .collect();
63            (DatatypeKind::Struct, proto_fields, vec![])
64        }
65        MoveData::Enum(variants) => {
66            let proto_variants = variants
67                .iter()
68                .enumerate()
69                .map(|(pos, variant)| convert_variant(pos, variant))
70                .collect();
71            (DatatypeKind::Enum, vec![], proto_variants)
72        }
73    };
74
75    let mut message = DatatypeDescriptor::default();
76    message.type_name = Some(format!(
77        "{}::{}::{}",
78        package_id.to_canonical_string(true),
79        module_name,
80        datatype_name
81    ));
82    message.defining_id = Some(data_def.defining_id.to_canonical_string(true));
83    message.module = Some(module_name.to_string());
84    message.name = Some(datatype_name.to_string());
85    message.abilities = abilities;
86    message.type_parameters = type_parameters;
87    message.kind = Some(kind as i32);
88    message.fields = fields;
89    message.variants = variants;
90    message
91}
92
93pub fn convert_module(
94    module_name: &str,
95    resolved_module: &sui_package_resolver::Module,
96    package_id: &ObjectID,
97) -> Result<Module> {
98    let mut datatypes = Vec::new();
99    for datatype_name in resolved_module.datatypes(None, None) {
100        let data_def = resolved_module
101            .data_def(datatype_name)
102            .map_err(convert_error)?
103            .unwrap_or_else(|| {
104                panic!(
105                    "datatype {} does not have a data_def. This shouldn't happen.",
106                    datatype_name
107                )
108            });
109
110        let descriptor = convert_datatype(datatype_name, &data_def, package_id, module_name);
111        datatypes.push(descriptor);
112    }
113
114    let mut functions = Vec::new();
115    for func_name in resolved_module.functions(None, None) {
116        let func_def = resolved_module
117            .function_def(func_name)
118            .map_err(convert_error)?
119            .unwrap_or_else(|| {
120                panic!(
121                    "function {} does not have a function_def. This shouldn't happen.",
122                    func_name
123                )
124            });
125
126        let descriptor = convert_function(func_name, &func_def);
127        functions.push(descriptor);
128    }
129
130    let mut message = Module::default();
131    message.name = Some(module_name.to_string());
132    message.datatypes = datatypes;
133    message.functions = functions;
134    Ok(message)
135}
136
137pub fn convert_function(function_name: &str, func_def: &FunctionDef) -> FunctionDescriptor {
138    let visibility = match func_def.visibility {
139        MoveVisibility::Private => Visibility::Private,
140        MoveVisibility::Public => Visibility::Public,
141        MoveVisibility::Friend => Visibility::Friend,
142    };
143
144    let type_parameters = func_def
145        .type_params
146        .iter()
147        .map(|abilities| {
148            let mut message = TypeParameter::default();
149            message.constraints = convert_ability_set(*abilities);
150            message
151        })
152        .collect();
153
154    let parameters = func_def
155        .parameters
156        .iter()
157        .map(convert_open_signature)
158        .collect();
159    let returns = func_def
160        .return_
161        .iter()
162        .map(convert_open_signature)
163        .collect();
164
165    let mut message = FunctionDescriptor::default();
166    message.name = Some(function_name.to_string());
167    message.visibility = Some(visibility as i32);
168    message.is_entry = Some(func_def.is_entry);
169    message.type_parameters = type_parameters;
170    message.parameters = parameters;
171    message.returns = returns;
172    message
173}
174
175fn convert_type_parameter(tp: &DatatypeTyParameter) -> TypeParameter {
176    let mut message = TypeParameter::default();
177    message.constraints = convert_ability_set(tp.constraints);
178    message.is_phantom = Some(tp.is_phantom);
179    message
180}
181
182fn convert_ability_set(abilities: MoveAbilitySet) -> Vec<i32> {
183    let mut result = Vec::new();
184
185    if abilities.has_ability(MoveAbility::Copy) {
186        result.push(Ability::Copy as i32);
187    }
188    if abilities.has_ability(MoveAbility::Drop) {
189        result.push(Ability::Drop as i32);
190    }
191    if abilities.has_ability(MoveAbility::Store) {
192        result.push(Ability::Store as i32);
193    }
194    if abilities.has_ability(MoveAbility::Key) {
195        result.push(Ability::Key as i32);
196    }
197
198    result
199}
200
201fn convert_variant(position: usize, variant: &VariantDef) -> VariantDescriptor {
202    let fields = variant
203        .signatures
204        .iter()
205        .enumerate()
206        .map(|(pos, (name, sig))| {
207            let mut message = FieldDescriptor::default();
208            message.name = Some(name.clone());
209            message.position = Some(pos as u32);
210            message.r#type = Some(convert_open_signature_body(sig));
211            message
212        })
213        .collect();
214
215    let mut message = VariantDescriptor::default();
216    message.name = Some(variant.name.clone());
217    message.position = Some(position as u32);
218    message.fields = fields;
219    message
220}
221
222fn convert_open_signature(sig: &sui_package_resolver::OpenSignature) -> OpenSignature {
223    let reference = sig.ref_.map(|r| match r {
224        sui_package_resolver::Reference::Immutable => Reference::Immutable as i32,
225        sui_package_resolver::Reference::Mutable => Reference::Mutable as i32,
226    });
227
228    let mut message = OpenSignature::default();
229    message.reference = reference;
230    message.body = Some(convert_open_signature_body(&sig.body));
231    message
232}
233
234fn convert_open_signature_body(
235    body: &sui_package_resolver::OpenSignatureBody,
236) -> OpenSignatureBody {
237    let (type_enum, type_name, type_params, type_param_idx) = match body {
238        sui_package_resolver::OpenSignatureBody::Bool => (SignatureType::Bool, None, vec![], None),
239        sui_package_resolver::OpenSignatureBody::U8 => (SignatureType::U8, None, vec![], None),
240        sui_package_resolver::OpenSignatureBody::U16 => (SignatureType::U16, None, vec![], None),
241        sui_package_resolver::OpenSignatureBody::U32 => (SignatureType::U32, None, vec![], None),
242        sui_package_resolver::OpenSignatureBody::U64 => (SignatureType::U64, None, vec![], None),
243        sui_package_resolver::OpenSignatureBody::U128 => (SignatureType::U128, None, vec![], None),
244        sui_package_resolver::OpenSignatureBody::U256 => (SignatureType::U256, None, vec![], None),
245        sui_package_resolver::OpenSignatureBody::Address => {
246            (SignatureType::Address, None, vec![], None)
247        }
248        sui_package_resolver::OpenSignatureBody::Vector(inner) => {
249            let inner_body = convert_open_signature_body(inner.as_ref());
250            (SignatureType::Vector, None, vec![inner_body], None)
251        }
252        sui_package_resolver::OpenSignatureBody::Datatype(key, args) => {
253            let type_name = format!(
254                "{}::{}::{}",
255                key.package.to_canonical_string(true),
256                key.module,
257                key.name
258            );
259
260            let type_args = args.iter().map(convert_open_signature_body).collect();
261            (SignatureType::Datatype, Some(type_name), type_args, None)
262        }
263        sui_package_resolver::OpenSignatureBody::TypeParameter(idx) => {
264            (SignatureType::Parameter, None, vec![], Some(*idx as u32))
265        }
266    };
267
268    let mut message = OpenSignatureBody::default();
269    message.r#type = Some(type_enum as i32);
270    message.type_name = type_name;
271    message.type_parameter_instantiation = type_params;
272    message.type_parameter = type_param_idx;
273    message
274}