read move function, module and struct RPC endpoints (#3852)

crates/sui-json-rpc-types/Cargo.toml

@@ -18,6 +18,7 @@ either = "1.7.0"
 itertools = "0.10.3"
 tracing = "0.1.36"
 
+move-binary-format = { git = "https://github.com/move-language/move", rev = "79071528524f08b12e9abb84c1094d8e976aa17a" }
 move-core-types = { git = "https://github.com/move-language/move", rev = "79071528524f08b12e9abb84c1094d8e976aa17a", features = ["address20"] }
 move-bytecode-utils = { git = "https://github.com/move-language/move", rev = "79071528524f08b12e9abb84c1094d8e976aa17a" }
 

crates/sui-json-rpc-types/src/lib.rs

@@ -12,6 +12,11 @@ use std::fmt::{Display, Formatter};
 use colored::Colorize;
 use either::Either;
 use itertools::Itertools;
+use move_binary_format::file_format::{Ability, AbilitySet, StructTypeParameter, Visibility};
+use move_binary_format::normalized::{
+    Field as NormalizedField, Function as SuiNormalizedFunction, Module as NormalizedModule,
+    Struct as NormalizedStruct, Type as NormalizedType,
+};
 use move_bytecode_utils::module_cache::GetModule;
 use move_core_types::identifier::Identifier;
 use move_core_types::language_storage::{StructTag, TypeTag};
@@ -51,6 +56,238 @@ use sui_types::sui_serde::{Base64, Encoding};
 mod rpc_types_tests;
 
 pub type GatewayTxSeqNumber = u64;
+pub type SuiMoveTypeParameterIndex = u16;
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub enum SuiMoveAbility {
+    Copy,
+    Drop,
+    Store,
+    Key,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveAbilitySet {
+    pub abilities: Vec<SuiMoveAbility>,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub enum SuiMoveVisibility {
+    Private,
+    Public,
+    Friend,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveStructTypeParameter {
+    pub constraints: SuiMoveAbilitySet,
+    pub is_phantom: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveNormalizedField {
+    pub name: String,
+    pub type_: SuiMoveNormalizedType,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveNormalizedStruct {
+    pub abilities: SuiMoveAbilitySet,
+    pub type_parameters: Vec<SuiMoveStructTypeParameter>,
+    pub fields: Vec<SuiMoveNormalizedField>,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub enum SuiMoveNormalizedType {
+    Bool,
+    U8,
+    U64,
+    U128,
+    Address,
+    Signer,
+    Struct {
+        address: String,
+        module: String,
+        name: String,
+        type_arguments: Vec<SuiMoveNormalizedType>,
+    },
+    Vector(Box<SuiMoveNormalizedType>),
+    TypeParameter(SuiMoveTypeParameterIndex),
+    Reference(Box<SuiMoveNormalizedType>),
+    MutableReference(Box<SuiMoveNormalizedType>),
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveNormalizedFunction {
+    pub visibility: SuiMoveVisibility,
+    pub is_entry: bool,
+    pub type_parameters: Vec<SuiMoveAbilitySet>,
+    pub parameters: Vec<SuiMoveNormalizedType>,
+    pub return_: Vec<SuiMoveNormalizedType>,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveModuleId {
+    address: String,
+    name: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema)]
+pub struct SuiMoveNormalizedModule {
+    pub file_format_version: u32,
+    pub address: String,
+    pub name: String,
+    pub friends: Vec<SuiMoveModuleId>,
+    pub structs: BTreeMap<String, SuiMoveNormalizedStruct>,
+    pub exposed_functions: BTreeMap<String, SuiMoveNormalizedFunction>,
+}
+
+impl From<NormalizedModule> for SuiMoveNormalizedModule {
+    fn from(module: NormalizedModule) -> Self {
+        Self {
+            file_format_version: module.file_format_version,
+            address: module.address.to_hex_literal(),
+            name: module.name.to_string(),
+            friends: module
+                .friends
+                .into_iter()
+                .map(|module_id| SuiMoveModuleId {
+                    address: module_id.address().to_hex_literal(),
+                    name: module_id.name().to_string(),
+                })
+                .collect::<Vec<SuiMoveModuleId>>(),
+            structs: module
+                .structs
+                .into_iter()
+                .map(|(name, struct_)| (name.to_string(), SuiMoveNormalizedStruct::from(struct_)))
+                .collect::<BTreeMap<String, SuiMoveNormalizedStruct>>(),
+            exposed_functions: module
+                .exposed_functions
+                .into_iter()
+                .map(|(name, function)| {
+                    (name.to_string(), SuiMoveNormalizedFunction::from(function))
+                })
+                .collect::<BTreeMap<String, SuiMoveNormalizedFunction>>(),
+        }
+    }
+}
+
+impl From<SuiNormalizedFunction> for SuiMoveNormalizedFunction {
+    fn from(function: SuiNormalizedFunction) -> Self {
+        Self {
+            visibility: match function.visibility {
+                Visibility::Private => SuiMoveVisibility::Private,
+                Visibility::Public => SuiMoveVisibility::Public,
+                Visibility::Friend => SuiMoveVisibility::Friend,
+            },
+            is_entry: function.is_entry,
+            type_parameters: function
+                .type_parameters
+                .into_iter()
+                .map(|a| a.into())
+                .collect::<Vec<SuiMoveAbilitySet>>(),
+            parameters: function
+                .parameters
+                .into_iter()
+                .map(SuiMoveNormalizedType::from)
+                .collect::<Vec<SuiMoveNormalizedType>>(),
+            return_: function
+                .return_
+                .into_iter()
+                .map(SuiMoveNormalizedType::from)
+                .collect::<Vec<SuiMoveNormalizedType>>(),
+        }
+    }
+}
+
+impl From<NormalizedStruct> for SuiMoveNormalizedStruct {
+    fn from(struct_: NormalizedStruct) -> Self {
+        Self {
+            abilities: struct_.abilities.into(),
+            type_parameters: struct_
+                .type_parameters
+                .into_iter()
+                .map(SuiMoveStructTypeParameter::from)
+                .collect::<Vec<SuiMoveStructTypeParameter>>(),
+            fields: struct_
+                .fields
+                .into_iter()
+                .map(SuiMoveNormalizedField::from)
+                .collect::<Vec<SuiMoveNormalizedField>>(),
+        }
+    }
+}
+
+impl From<StructTypeParameter> for SuiMoveStructTypeParameter {
+    fn from(type_parameter: StructTypeParameter) -> Self {
+        Self {
+            constraints: type_parameter.constraints.into(),
+            is_phantom: type_parameter.is_phantom,
+        }
+    }
+}
+
+impl From<NormalizedField> for SuiMoveNormalizedField {
+    fn from(normalized_field: NormalizedField) -> Self {
+        Self {
+            name: normalized_field.name.to_string(),
+            type_: SuiMoveNormalizedType::from(normalized_field.type_),
+        }
+    }
+}
+
+impl From<NormalizedType> for SuiMoveNormalizedType {
+    fn from(type_: NormalizedType) -> Self {
+        match type_ {
+            NormalizedType::Bool => SuiMoveNormalizedType::Bool,
+            NormalizedType::U8 => SuiMoveNormalizedType::U8,
+            NormalizedType::U64 => SuiMoveNormalizedType::U64,
+            NormalizedType::U128 => SuiMoveNormalizedType::U128,
+            NormalizedType::Address => SuiMoveNormalizedType::Address,
+            NormalizedType::Signer => SuiMoveNormalizedType::Signer,
+            NormalizedType::Struct {
+                address,
+                module,
+                name,
+                type_arguments,
+            } => SuiMoveNormalizedType::Struct {
+                address: address.to_hex_literal(),
+                module: module.to_string(),
+                name: name.to_string(),
+                type_arguments: type_arguments
+                    .into_iter()
+                    .map(SuiMoveNormalizedType::from)
+                    .collect::<Vec<SuiMoveNormalizedType>>(),
+            },
+            NormalizedType::Vector(v) => {
+                SuiMoveNormalizedType::Vector(Box::new(SuiMoveNormalizedType::from(*v)))
+            }
+            NormalizedType::TypeParameter(t) => SuiMoveNormalizedType::TypeParameter(t),
+            NormalizedType::Reference(r) => {
+                SuiMoveNormalizedType::Reference(Box::new(SuiMoveNormalizedType::from(*r)))
+            }
+            NormalizedType::MutableReference(mr) => {
+                SuiMoveNormalizedType::MutableReference(Box::new(SuiMoveNormalizedType::from(*mr)))
+            }
+        }
+    }
+}
+
+impl From<AbilitySet> for SuiMoveAbilitySet {
+    fn from(set: AbilitySet) -> SuiMoveAbilitySet {
+        Self {
+            abilities: set
+                .into_iter()
+                .map(|a| match a {
+                    Ability::Copy => SuiMoveAbility::Copy,
+                    Ability::Drop => SuiMoveAbility::Drop,
+                    Ability::Key => SuiMoveAbility::Key,
+                    Ability::Store => SuiMoveAbility::Store,
+                })
+                .collect::<Vec<SuiMoveAbility>>(),
+        }
+    }
+}
 
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 pub enum ObjectValueKind {

crates/sui-json-rpc/src/api.rs

@@ -1,13 +1,16 @@
 // Copyright (c) 2022, Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::collections::BTreeMap;
+
 use jsonrpsee::core::RpcResult;
 use jsonrpsee_proc_macros::rpc;
 use sui_json::SuiJsonValue;
 use sui_json_rpc_types::{
     GatewayTxSeqNumber, GetObjectDataResponse, GetRawObjectDataResponse, MoveFunctionArgType,
-    RPCTransactionRequestParams, SuiEventEnvelope, SuiEventFilter, SuiObjectInfo, SuiTypeTag,
-    TransactionBytes, TransactionEffectsResponse, TransactionResponse,
+    RPCTransactionRequestParams, SuiEventEnvelope, SuiEventFilter, SuiMoveNormalizedFunction,
+    SuiMoveNormalizedModule, SuiMoveNormalizedStruct, SuiObjectInfo, SuiTypeTag, TransactionBytes,
+    TransactionEffectsResponse, TransactionResponse,
 };
 use sui_open_rpc_macros::open_rpc;
 use sui_types::base_types::{ObjectID, SuiAddress, TransactionDigest};
@@ -110,11 +113,44 @@ pub trait RpcFullNodeReadApi {
     #[method(name = "getMoveFunctionArgTypes")]
     async fn get_move_function_arg_types(
         &self,
-        object_id: ObjectID,
+        package: ObjectID,
         module: String,
         function: String,
     ) -> RpcResult<Vec<MoveFunctionArgType>>;
 
+    /// Return structured representations of all modules in the given package
+    #[method(name = "getNormalizedMoveModulesByPackage")]
+    async fn get_normalized_move_modules_by_package(
+        &self,
+        package: ObjectID,
+    ) -> RpcResult<BTreeMap<String, SuiMoveNormalizedModule>>;
+
+    /// Return a structured representation of Move module
+    #[method(name = "getNormalizedMoveModule")]
+    async fn get_normalized_move_module(
+        &self,
+        package: ObjectID,
+        module_name: String,
+    ) -> RpcResult<SuiMoveNormalizedModule>;
+
+    /// Return a structured representation of Move struct
+    #[method(name = "getNormalizedMoveStruct")]
+    async fn get_normalized_move_struct(
+        &self,
+        package: ObjectID,
+        module_name: String,
+        struct_name: String,
+    ) -> RpcResult<SuiMoveNormalizedStruct>;
+
+    /// Return a structured representation of Move function
+    #[method(name = "getNormalizedMoveFunction")]
+    async fn get_normalized_move_function(
+        &self,
+        package: ObjectID,
+        module_name: String,
+        function_name: String,
+    ) -> RpcResult<SuiMoveNormalizedFunction>;
+
     /// Return list of transactions for a specified input object.
     #[method(name = "getTransactionsByInputObject")]
     async fn get_transactions_by_input_object(