Skip to main content

sui_rpc_api/grpc/v2/move_package_service/
mod.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::{ErrorReason, Result, RpcError, RpcService};
5use sui_rpc::proto::google::rpc::bad_request::FieldViolation;
6use sui_rpc::proto::sui::rpc::v2::move_package_service_server::MovePackageService;
7use sui_rpc::proto::sui::rpc::v2::{
8    GetDatatypeRequest, GetDatatypeResponse, GetFunctionRequest, GetFunctionResponse,
9    GetPackageRequest, GetPackageResponse, ListPackageVersionsRequest, ListPackageVersionsResponse,
10    ListSystemPackagesRequest, ListSystemPackagesResponse,
11};
12use sui_types::{base_types::ObjectID, move_package::MovePackage, object::Object};
13
14pub mod conversions;
15mod get_datatype;
16mod get_function;
17mod get_package;
18mod list_package_versions;
19mod list_system_packages;
20
21pub use get_datatype::get_datatype_response;
22pub use get_function::get_function_response;
23pub use get_package::get_package_response;
24pub use list_package_versions::{
25    AllPackageVersionsQuery, PackageVersionCursor, PackageVersionsQuery, check_checkpoint_range,
26    pages_by_token, unknown_package_response, validate_request,
27};
28
29#[tonic::async_trait]
30impl MovePackageService for RpcService {
31    async fn get_package(
32        &self,
33        request: tonic::Request<GetPackageRequest>,
34    ) -> Result<tonic::Response<GetPackageResponse>, tonic::Status> {
35        get_package::get_package(self, request.into_inner())
36            .map(tonic::Response::new)
37            .map_err(Into::into)
38    }
39
40    async fn get_datatype(
41        &self,
42        request: tonic::Request<GetDatatypeRequest>,
43    ) -> Result<tonic::Response<GetDatatypeResponse>, tonic::Status> {
44        get_datatype::get_datatype(self, request.into_inner())
45            .map(tonic::Response::new)
46            .map_err(Into::into)
47    }
48
49    async fn get_function(
50        &self,
51        request: tonic::Request<GetFunctionRequest>,
52    ) -> Result<tonic::Response<GetFunctionResponse>, tonic::Status> {
53        get_function::get_function(self, request.into_inner())
54            .map(tonic::Response::new)
55            .map_err(Into::into)
56    }
57
58    async fn list_package_versions(
59        &self,
60        request: tonic::Request<ListPackageVersionsRequest>,
61    ) -> Result<tonic::Response<ListPackageVersionsResponse>, tonic::Status> {
62        let service = self.clone();
63        tokio::task::spawn_blocking(move || {
64            list_package_versions::list_package_versions(&service, request.into_inner())
65        })
66        .await
67        .map_err(|e| tonic::Status::internal(format!("list_package_versions task failed: {e}")))?
68        .map(tonic::Response::new)
69        .map_err(Into::into)
70    }
71
72    async fn list_system_packages(
73        &self,
74        request: tonic::Request<ListSystemPackagesRequest>,
75    ) -> Result<tonic::Response<ListSystemPackagesResponse>, tonic::Status> {
76        list_system_packages::list_system_packages(self, request.into_inner())
77            .map(tonic::Response::new)
78            .map_err(Into::into)
79    }
80}
81
82/// Parse and validate the package ID, then fetch the package.
83pub(crate) fn load_package(service: &RpcService, package_id_str: &str) -> Result<MovePackage> {
84    load_package_by_id(service, parse_package_id(package_id_str)?)
85}
86
87/// Parse and validate a package ID string.
88pub(crate) fn parse_package_id(package_id_str: &str) -> Result<ObjectID> {
89    package_id_str.parse::<ObjectID>().map_err(|e| {
90        FieldViolation::new("package_id")
91            .with_description(format!("invalid package_id: {e}"))
92            .with_reason(ErrorReason::FieldInvalid)
93            .into()
94    })
95}
96
97/// Fetch an object by ID and convert it into a package.
98fn load_package_by_id(service: &RpcService, package_id: ObjectID) -> Result<MovePackage> {
99    let object = service
100        .reader
101        .inner()
102        .get_object(&package_id)
103        .ok_or_else(RpcError::not_found)?;
104    object_as_package(object)
105}
106
107/// Fetch the package stored under `package_id` at exactly `version`, or `None` if this node does
108/// not store that version. System packages are upgraded in place, so all their versions share one
109/// ID and only the version tells them apart.
110pub(crate) fn load_package_by_id_and_version(
111    service: &RpcService,
112    package_id: ObjectID,
113    version: u64,
114) -> Result<Option<MovePackage>> {
115    service
116        .reader
117        .inner()
118        .get_object_by_key(&package_id, version.into())
119        .map(object_as_package)
120        .transpose()
121}
122
123fn object_as_package(object: Object) -> Result<MovePackage> {
124    object
125        .into_inner()
126        .data
127        .try_into_package()
128        .ok_or_else(|| RpcError::new(tonic::Code::InvalidArgument, "object is not a package"))
129}