Skip to main content

sui_rpc_api/grpc/v2/transaction_execution_service/
mod.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::ErrorReason;
5use crate::RpcError;
6use crate::RpcService;
7use crate::grpc::v2::render::RenderContext;
8use prost_types::FieldMask;
9use sui_rpc::field::FieldMaskTree;
10use sui_rpc::field::FieldMaskUtil;
11use sui_rpc::merge::Merge;
12use sui_rpc::proto::google::rpc::bad_request::FieldViolation;
13use sui_rpc::proto::sui::rpc::v2::ExecuteTransactionRequest;
14use sui_rpc::proto::sui::rpc::v2::ExecuteTransactionResponse;
15use sui_rpc::proto::sui::rpc::v2::ExecutedTransaction;
16use sui_rpc::proto::sui::rpc::v2::ObjectSet;
17use sui_rpc::proto::sui::rpc::v2::SimulateTransactionRequest;
18use sui_rpc::proto::sui::rpc::v2::SimulateTransactionResponse;
19use sui_rpc::proto::sui::rpc::v2::Transaction;
20use sui_rpc::proto::sui::rpc::v2::UserSignature;
21use sui_rpc::proto::sui::rpc::v2::transaction_execution_service_server::TransactionExecutionService;
22use sui_types::balance_change::derive_balance_changes_2;
23use sui_types::transaction_executor::TransactionExecutor;
24use tap::Pipe;
25
26mod simulate;
27
28#[tonic::async_trait]
29impl TransactionExecutionService for RpcService {
30    async fn execute_transaction(
31        &self,
32        request: tonic::Request<ExecuteTransactionRequest>,
33    ) -> Result<tonic::Response<ExecuteTransactionResponse>, tonic::Status> {
34        let executor = self
35            .executor
36            .as_ref()
37            .ok_or_else(|| tonic::Status::unimplemented("no transaction executor"))?;
38
39        execute_transaction(self, executor, request.into_inner())
40            .await
41            .map(tonic::Response::new)
42            .map_err(Into::into)
43    }
44
45    async fn simulate_transaction(
46        &self,
47        request: tonic::Request<SimulateTransactionRequest>,
48    ) -> Result<tonic::Response<SimulateTransactionResponse>, tonic::Status> {
49        let service = self.clone();
50        if let Some(metrics) = &self.metrics {
51            metrics.observe_simulate_client_protocol_version(
52                crate::client_protocol_version::client_protocol_version_for_metrics(
53                    request.metadata(),
54                ),
55            );
56        }
57        let client_protocol_version = crate::client_protocol_version(request.metadata());
58        let request = request.into_inner();
59        tokio::task::spawn_blocking(move || {
60            simulate::simulate_transaction(&service, request, client_protocol_version)
61        })
62        .await
63        .map_err(|e| tonic::Status::internal(format!("simulate_transaction task failed: {e}")))?
64        .map(tonic::Response::new)
65        .map_err(Into::into)
66    }
67}
68
69pub const EXECUTE_TRANSACTION_READ_MASK_DEFAULT: &str =
70    crate::read_mask_defaults::EXECUTE_TRANSACTION;
71// Current maximum number of supported UserSignature's,
72// one for the sender and one for an optional sponsor
73const MAX_NUMBER_OF_SIGNATURES: usize = 2;
74
75#[tracing::instrument(skip(service, executor))]
76pub async fn execute_transaction(
77    service: &RpcService,
78    executor: &std::sync::Arc<dyn TransactionExecutor>,
79    request: ExecuteTransactionRequest,
80) -> Result<ExecuteTransactionResponse, RpcError> {
81    let transaction = request
82        .transaction
83        .as_ref()
84        .ok_or_else(|| FieldViolation::new("transaction").with_reason(ErrorReason::FieldMissing))?
85        .pipe(sui_sdk_types::Transaction::try_from)
86        .map_err(|e| {
87            FieldViolation::new("transaction")
88                .with_description(format!("invalid transaction: {e}"))
89                .with_reason(ErrorReason::FieldInvalid)
90        })?;
91
92    if request.signatures.len() > MAX_NUMBER_OF_SIGNATURES {
93        return Err(FieldViolation::new("signatures")
94            .with_description(format!(
95                "{} provided signatures exceeds the maximum allowed of {}",
96                request.signatures.len(),
97                MAX_NUMBER_OF_SIGNATURES
98            ))
99            .with_reason(ErrorReason::FieldInvalid)
100            .into());
101    }
102
103    let signatures = request
104        .signatures
105        .iter()
106        .enumerate()
107        .map(|(i, signature)| {
108            sui_sdk_types::UserSignature::try_from(signature).map_err(|e| {
109                FieldViolation::new_at("signatures", i)
110                    .with_description(format!("invalid signature: {e}"))
111                    .with_reason(ErrorReason::FieldInvalid)
112            })
113        })
114        .collect::<Result<Vec<_>, _>>()?;
115
116    let signed_transaction = sui_sdk_types::SignedTransaction {
117        transaction: transaction.clone(),
118        signatures: signatures.clone(),
119    };
120
121    let read_mask = {
122        let read_mask = request
123            .read_mask
124            .unwrap_or_else(|| FieldMask::from_str(EXECUTE_TRANSACTION_READ_MASK_DEFAULT));
125        read_mask
126            .validate::<ExecutedTransaction>()
127            .map_err(|path| {
128                FieldViolation::new("read_mask")
129                    .with_description(format!("invalid read_mask path: {path}"))
130                    .with_reason(ErrorReason::FieldInvalid)
131            })?;
132        FieldMaskTree::from(read_mask)
133    };
134
135    let request = sui_types::transaction_driver_types::ExecuteTransactionRequestV3 {
136        transaction: signed_transaction.try_into()?,
137        include_events: read_mask.contains(ExecutedTransaction::EVENTS_FIELD.name),
138        include_input_objects: read_mask.contains(ExecutedTransaction::BALANCE_CHANGES_FIELD.name)
139            || read_mask.contains(ExecutedTransaction::OBJECTS_FIELD.name)
140            || read_mask.contains(ExecutedTransaction::EFFECTS_FIELD.name),
141        include_output_objects: read_mask.contains(ExecutedTransaction::BALANCE_CHANGES_FIELD.name)
142            || read_mask.contains(ExecutedTransaction::OBJECTS_FIELD.name)
143            || read_mask.contains(ExecutedTransaction::EFFECTS_FIELD.name),
144        include_auxiliary_data: false,
145    };
146
147    let sui_types::transaction_driver_types::ExecuteTransactionResponseV3 {
148        effects:
149            sui_types::transaction_driver_types::FinalizedEffects {
150                effects,
151                finality_info: _,
152            },
153        events,
154        input_objects,
155        output_objects,
156        auxiliary_data: _,
157    } = executor.execute_transaction(request, None).await?;
158
159    let executed_transaction = {
160        // Build the objects set first so we can use it for event JSON rendering.
161        // This allows resolving types from packages that were just published in this transaction.
162        let objects = {
163            let mut objects = sui_types::full_checkpoint_content::ObjectSet::default();
164            for o in input_objects
165                .into_iter()
166                .chain(output_objects.into_iter())
167                .flatten()
168            {
169                objects.insert(o);
170            }
171            objects
172        };
173
174        let render_context = RenderContext::new(service.reader.inner(), Some(&objects));
175        let events = read_mask
176            .subtree(ExecutedTransaction::EVENTS_FIELD)
177            .and_then(|mask| {
178                events.map(|events| service.render_events_to_proto(&events, &mask, &render_context))
179            });
180
181        let balance_changes = if read_mask.contains(ExecutedTransaction::BALANCE_CHANGES_FIELD) {
182            derive_balance_changes_2(&effects, &objects)
183                .into_iter()
184                .map(Into::into)
185                .collect()
186        } else {
187            vec![]
188        };
189
190        let effects = read_mask
191            .subtree(ExecutedTransaction::EFFECTS_FIELD)
192            .map(|mask| service.render_effects_to_proto(&effects, &[], &objects, &mask));
193
194        let mut message = ExecutedTransaction::default();
195        message.digest = read_mask
196            .contains(ExecutedTransaction::DIGEST_FIELD)
197            .then(|| transaction.digest().to_string());
198        message.transaction = read_mask
199            .subtree(ExecutedTransaction::TRANSACTION_FIELD)
200            .map(|mask| Transaction::merge_from(transaction, &mask));
201        message.signatures = read_mask
202            .subtree(ExecutedTransaction::SIGNATURES_FIELD)
203            .map(|mask| {
204                signatures
205                    .into_iter()
206                    .map(|s| UserSignature::merge_from(s, &mask))
207                    .collect()
208            })
209            .unwrap_or_default();
210        message.effects = effects;
211        message.events = events;
212        message.balance_changes = balance_changes;
213        message.objects = read_mask
214            .subtree(
215                ExecutedTransaction::path_builder()
216                    .objects()
217                    .objects()
218                    .finish(),
219            )
220            .map(|mask| {
221                ObjectSet::default().with_objects(
222                    objects
223                        .iter()
224                        .map(|o| service.render_object_to_proto(o, &mask, &render_context))
225                        .collect(),
226                )
227            });
228        message
229    };
230
231    Ok(ExecuteTransactionResponse::default().with_transaction(executed_transaction))
232}