sui_rpc_api/grpc/v2/move_package_service/
conversions.rs1use 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
23pub 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}