sui_rpc_api/grpc/v2/transaction_execution_service/
mod.rs1use 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;
71const 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 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}