sui_rpc/proto/sui/rpc/v2/
execution_status.rs1use super::*;
2use crate::proto::TryFromProtoError;
3use tap::Pipe;
4
5impl ::prost::Name for ExecutionError {
6 const NAME: &'static str = "ExecutionError";
7 const PACKAGE: &'static str = "sui.rpc.v2";
8 fn full_name() -> ::prost::alloc::string::String {
9 "sui.rpc.v2.ExecutionError".into()
10 }
11 fn type_url() -> ::prost::alloc::string::String {
12 "/sui.rpc.v2.ExecutionError".into()
13 }
14}
15
16impl From<sui_sdk_types::ExecutionStatus> for ExecutionStatus {
21 fn from(value: sui_sdk_types::ExecutionStatus) -> Self {
22 match value {
23 sui_sdk_types::ExecutionStatus::Success => Self {
24 success: Some(true),
25 error: None,
26 },
27 sui_sdk_types::ExecutionStatus::Failure { error, command } => {
28 let mut error_message = ExecutionError::from(error);
29 error_message.command = command;
30 Self {
31 success: Some(false),
32 error: Some(error_message),
33 }
34 }
35 }
36 }
37}
38
39impl TryFrom<&ExecutionStatus> for sui_sdk_types::ExecutionStatus {
40 type Error = TryFromProtoError;
41
42 fn try_from(value: &ExecutionStatus) -> Result<Self, Self::Error> {
43 let success = value
44 .success
45 .ok_or_else(|| TryFromProtoError::missing(ExecutionStatus::SUCCESS_FIELD))?;
46 match (success, &value.error) {
47 (true, None) => Self::Success,
48 (false, Some(error)) => Self::Failure {
49 error: sui_sdk_types::ExecutionError::try_from(error)
50 .map_err(|e| e.nested(ExecutionStatus::ERROR_FIELD))?,
51 command: error.command,
52 },
53 (true, Some(_)) | (false, None) => {
54 return Err(TryFromProtoError::invalid(
55 ExecutionStatus::ERROR_FIELD,
56 "invalid execution status",
57 ));
58 }
59 }
60 .pipe(Ok)
61 }
62}
63
64impl From<sui_sdk_types::ExecutionError> for ExecutionError {
69 fn from(value: sui_sdk_types::ExecutionError) -> Self {
70 use execution_error::ErrorDetails;
71 use execution_error::ExecutionErrorKind;
72 use sui_sdk_types::ExecutionError as E;
73
74 let mut message = Self::default();
75
76 let kind = match value {
77 E::InsufficientGas => ExecutionErrorKind::InsufficientGas,
78 E::InvalidGasObject => ExecutionErrorKind::InvalidGasObject,
79 E::InvariantViolation => ExecutionErrorKind::InvariantViolation,
80 E::FeatureNotYetSupported => ExecutionErrorKind::FeatureNotYetSupported,
81 E::ObjectTooBig {
82 object_size,
83 max_object_size,
84 } => {
85 message.error_details = Some(ErrorDetails::SizeError(SizeError {
86 size: Some(object_size),
87 max_size: Some(max_object_size),
88 }));
89 ExecutionErrorKind::ObjectTooBig
90 }
91 E::PackageTooBig {
92 object_size,
93 max_object_size,
94 } => {
95 message.error_details = Some(ErrorDetails::SizeError(SizeError {
96 size: Some(object_size),
97 max_size: Some(max_object_size),
98 }));
99 ExecutionErrorKind::PackageTooBig
100 }
101 E::CircularObjectOwnership { object } => {
102 message.error_details = Some(ErrorDetails::ObjectId(object.to_string()));
103 ExecutionErrorKind::CircularObjectOwnership
104 }
105 E::InsufficientCoinBalance => ExecutionErrorKind::InsufficientCoinBalance,
106 E::CoinBalanceOverflow => ExecutionErrorKind::CoinBalanceOverflow,
107 E::PublishErrorNonZeroAddress => ExecutionErrorKind::PublishErrorNonZeroAddress,
108 E::SuiMoveVerificationError => ExecutionErrorKind::SuiMoveVerificationError,
109 E::MovePrimitiveRuntimeError { location } => {
110 message.error_details = location.map(|l| {
111 ErrorDetails::Abort(MoveAbort {
112 location: Some(l.into()),
113 ..Default::default()
114 })
115 });
116 ExecutionErrorKind::MovePrimitiveRuntimeError
117 }
118 E::MoveAbort { location, code } => {
119 message.error_details = Some(ErrorDetails::Abort(MoveAbort {
120 abort_code: Some(code),
121 location: Some(location.into()),
122 clever_error: None,
123 }));
124 ExecutionErrorKind::MoveAbort
125 }
126 E::VmVerificationOrDeserializationError => {
127 ExecutionErrorKind::VmVerificationOrDeserializationError
128 }
129 E::VmInvariantViolation => ExecutionErrorKind::VmInvariantViolation,
130 E::FunctionNotFound => ExecutionErrorKind::FunctionNotFound,
131 E::ArityMismatch => ExecutionErrorKind::ArityMismatch,
132 E::TypeArityMismatch => ExecutionErrorKind::TypeArityMismatch,
133 E::NonEntryFunctionInvoked => ExecutionErrorKind::NonEntryFunctionInvoked,
134 E::CommandArgumentError { argument, kind } => {
135 let mut command_argument_error = CommandArgumentError::from(kind);
136 command_argument_error.argument = Some(argument.into());
137 message.error_details =
138 Some(ErrorDetails::CommandArgumentError(command_argument_error));
139 ExecutionErrorKind::CommandArgumentError
140 }
141 E::TypeArgumentError {
142 type_argument,
143 kind,
144 } => {
145 let type_argument_error = TypeArgumentError {
146 type_argument: Some(type_argument.into()),
147 kind: Some(type_argument_error::TypeArgumentErrorKind::from(kind).into()),
148 };
149 message.error_details = Some(ErrorDetails::TypeArgumentError(type_argument_error));
150 ExecutionErrorKind::TypeArgumentError
151 }
152 E::UnusedValueWithoutDrop { result, subresult } => {
153 message.error_details = Some(ErrorDetails::IndexError(IndexError {
154 index: Some(result.into()),
155 subresult: Some(subresult.into()),
156 }));
157 ExecutionErrorKind::UnusedValueWithoutDrop
158 }
159 E::InvalidPublicFunctionReturnType { index } => {
160 message.error_details = Some(ErrorDetails::IndexError(IndexError {
161 index: Some(index.into()),
162 subresult: None,
163 }));
164 ExecutionErrorKind::InvalidPublicFunctionReturnType
165 }
166 E::InvalidTransferObject => ExecutionErrorKind::InvalidTransferObject,
167 E::EffectsTooLarge {
168 current_size,
169 max_size,
170 } => {
171 message.error_details = Some(ErrorDetails::SizeError(SizeError {
172 size: Some(current_size),
173 max_size: Some(max_size),
174 }));
175 ExecutionErrorKind::EffectsTooLarge
176 }
177 E::PublishUpgradeMissingDependency => {
178 ExecutionErrorKind::PublishUpgradeMissingDependency
179 }
180 E::PublishUpgradeDependencyDowngrade => {
181 ExecutionErrorKind::PublishUpgradeDependencyDowngrade
182 }
183 E::PackageUpgradeError { kind } => {
184 message.error_details = Some(ErrorDetails::PackageUpgradeError(kind.into()));
185 ExecutionErrorKind::PackageUpgradeError
186 }
187 E::WrittenObjectsTooLarge {
188 object_size,
189 max_object_size,
190 } => {
191 message.error_details = Some(ErrorDetails::SizeError(SizeError {
192 size: Some(object_size),
193 max_size: Some(max_object_size),
194 }));
195
196 ExecutionErrorKind::WrittenObjectsTooLarge
197 }
198 E::CertificateDenied => ExecutionErrorKind::CertificateDenied,
199 E::SuiMoveVerificationTimedout => ExecutionErrorKind::SuiMoveVerificationTimedout,
200 E::ConsensusObjectOperationNotAllowed => {
201 ExecutionErrorKind::ConsensusObjectOperationNotAllowed
202 }
203 E::InputObjectDeleted => ExecutionErrorKind::InputObjectDeleted,
204 E::ExecutionCanceledDueToConsensusObjectCongestion { congested_objects } => {
205 message.error_details = Some(ErrorDetails::CongestedObjects(CongestedObjects {
206 objects: congested_objects.iter().map(ToString::to_string).collect(),
207 }));
208
209 ExecutionErrorKind::ExecutionCanceledDueToConsensusObjectCongestion
210 }
211 E::AddressDeniedForCoin { address, coin_type } => {
212 message.error_details = Some(ErrorDetails::CoinDenyListError(CoinDenyListError {
213 address: Some(address.to_string()),
214 coin_type: Some(coin_type),
215 }));
216 ExecutionErrorKind::AddressDeniedForCoin
217 }
218 E::CoinTypeGlobalPause { coin_type } => {
219 message.error_details = Some(ErrorDetails::CoinDenyListError(CoinDenyListError {
220 address: None,
221 coin_type: Some(coin_type),
222 }));
223 ExecutionErrorKind::CoinTypeGlobalPause
224 }
225 E::ExecutionCanceledDueToRandomnessUnavailable => {
226 ExecutionErrorKind::ExecutionCanceledDueToRandomnessUnavailable
227 }
228 E::MoveVectorElemTooBig {
229 value_size,
230 max_scaled_size,
231 } => {
232 message.error_details = Some(ErrorDetails::SizeError(SizeError {
233 size: Some(value_size),
234 max_size: Some(max_scaled_size),
235 }));
236
237 ExecutionErrorKind::MoveVectorElemTooBig
238 }
239 E::MoveRawValueTooBig {
240 value_size,
241 max_scaled_size,
242 } => {
243 message.error_details = Some(ErrorDetails::SizeError(SizeError {
244 size: Some(value_size),
245 max_size: Some(max_scaled_size),
246 }));
247 ExecutionErrorKind::MoveRawValueTooBig
248 }
249 E::InvalidLinkage => ExecutionErrorKind::InvalidLinkage,
250 E::InsufficientFundsForWithdraw => ExecutionErrorKind::InsufficientFundsForWithdraw,
251 E::NonExclusiveWriteInputObjectModified { object } => {
252 message.set_object_id(object);
253 ExecutionErrorKind::NonExclusiveWriteInputObjectModified
254 }
255 E::TransactionExpired => ExecutionErrorKind::TransactionExpired,
256 _ => ExecutionErrorKind::Unknown,
257 };
258
259 message.set_kind(kind);
260 message
261 }
262}
263
264impl TryFrom<&ExecutionError> for sui_sdk_types::ExecutionError {
265 type Error = TryFromProtoError;
266
267 fn try_from(value: &ExecutionError) -> Result<Self, Self::Error> {
268 use execution_error::ErrorDetails;
269 use execution_error::ExecutionErrorKind as K;
270
271 match value.kind() {
272 K::Unknown => return Err(TryFromProtoError::invalid(ExecutionError::KIND_FIELD, "unknown ExecutionErrorKind")),
273 K::InsufficientGas => Self::InsufficientGas,
274 K::InvalidGasObject => Self::InvalidGasObject,
275 K::InvariantViolation => Self::InvariantViolation,
276 K::FeatureNotYetSupported => Self::FeatureNotYetSupported,
277 K::ObjectTooBig => {
278 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
279 &value.error_details
280 else {
281 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
282 };
283 Self::ObjectTooBig {
284 object_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
285 max_object_size: max_size
286 .ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
287 }
288 }
289 K::PackageTooBig => {
290 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
291 &value.error_details
292 else {
293 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
294 };
295 Self::PackageTooBig {
296 object_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
297 max_object_size: max_size
298 .ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
299 }
300 }
301 K::CircularObjectOwnership => {
302 let Some(ErrorDetails::ObjectId(object_id)) = &value.error_details else {
303 return Err(TryFromProtoError::missing(ExecutionError::OBJECT_ID_FIELD));
304 };
305 Self::CircularObjectOwnership {
306 object: object_id.parse().map_err(|e| TryFromProtoError::invalid(ExecutionError::OBJECT_ID_FIELD, e))?,
307 }
308 }
309 K::InsufficientCoinBalance => Self::InsufficientCoinBalance,
310 K::CoinBalanceOverflow => Self::CoinBalanceOverflow,
311 K::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
312 K::SuiMoveVerificationError => Self::SuiMoveVerificationError,
313 K::MovePrimitiveRuntimeError => {
314 let location = if let Some(ErrorDetails::Abort(abort)) = &value.error_details {
315 abort.location.as_ref().map(TryInto::try_into).transpose()?
316 } else {
317 None
318 };
319 Self::MovePrimitiveRuntimeError { location }
320 }
321 K::MoveAbort => {
322 let Some(ErrorDetails::Abort(abort)) = &value.error_details else {
323 return Err(TryFromProtoError::missing("abort"));
324 };
325 Self::MoveAbort {
326 location: abort
327 .location
328 .as_ref()
329 .ok_or_else(|| TryFromProtoError::missing("location"))?
330 .try_into()?,
331 code: abort
332 .abort_code
333 .ok_or_else(|| TryFromProtoError::missing("abort_code"))?,
334 }
335 }
336 K::VmVerificationOrDeserializationError => Self::VmVerificationOrDeserializationError,
337 K::VmInvariantViolation => Self::VmInvariantViolation,
338 K::FunctionNotFound => Self::FunctionNotFound,
339 K::ArityMismatch => Self::ArityMismatch,
340 K::TypeArityMismatch => Self::TypeArityMismatch,
341 K::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
342 K::CommandArgumentError => {
343 let Some(ErrorDetails::CommandArgumentError(command_argument_error)) =
344 &value.error_details
345 else {
346 return Err(TryFromProtoError::missing("command_argument_error"));
347 };
348 Self::CommandArgumentError {
349 argument: command_argument_error
350 .argument
351 .ok_or_else(|| TryFromProtoError::missing("argument"))?
352 .try_into()
353 .map_err(|e| TryFromProtoError::invalid(CommandArgumentError::ARGUMENT_FIELD, e))?,
354 kind: command_argument_error.try_into()?,
355 }
356 }
357 K::TypeArgumentError => {
358 let Some(ErrorDetails::TypeArgumentError(type_argument_error)) =
359 &value.error_details
360 else {
361 return Err(TryFromProtoError::missing("type_argument_error"));
362 };
363 Self::TypeArgumentError {
364 type_argument: type_argument_error
365 .type_argument
366 .ok_or_else(|| TryFromProtoError::missing("type_argument"))?
367 .try_into()
368 .map_err(|e| TryFromProtoError::invalid(TypeArgumentError::TYPE_ARGUMENT_FIELD, e))?,
369 kind: type_argument_error.kind().try_into()?,
370 }
371 }
372 K::UnusedValueWithoutDrop => {
373 let Some(ErrorDetails::IndexError(IndexError { index, subresult })) =
374 &value.error_details
375 else {
376 return Err(TryFromProtoError::missing("index_error"));
377 };
378 Self::UnusedValueWithoutDrop {
379 result: index
380 .ok_or_else(|| TryFromProtoError::missing("result"))?
381 .try_into()
382 .map_err(|e| TryFromProtoError::invalid(IndexError::INDEX_FIELD, e))?,
383 subresult: subresult
384 .ok_or_else(|| TryFromProtoError::missing("subresult"))?
385 .try_into()
386 .map_err(|e| TryFromProtoError::invalid(IndexError::SUBRESULT_FIELD, e))?,
387 }
388 }
389 K::InvalidPublicFunctionReturnType => {
390 let Some(ErrorDetails::IndexError(IndexError { index, .. })) =
391 &value.error_details
392 else {
393 return Err(TryFromProtoError::missing("index_error"));
394 };
395 Self::InvalidPublicFunctionReturnType {
396 index: index
397 .ok_or_else(|| TryFromProtoError::missing("index"))?
398 .try_into()
399 .map_err(|e| TryFromProtoError::invalid(IndexError::INDEX_FIELD, e))?,
400 }
401 }
402 K::InvalidTransferObject => Self::InvalidTransferObject,
403 K::EffectsTooLarge => {
404 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
405 &value.error_details
406 else {
407 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
408 };
409 Self::EffectsTooLarge {
410 current_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
411 max_size: max_size.ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
412 }
413 }
414 K::PublishUpgradeMissingDependency => Self::PublishUpgradeMissingDependency,
415 K::PublishUpgradeDependencyDowngrade => Self::PublishUpgradeDependencyDowngrade,
416 K::PackageUpgradeError => {
417 let Some(ErrorDetails::PackageUpgradeError(package_upgrade_error)) =
418 &value.error_details
419 else {
420 return Err(TryFromProtoError::missing("package_upgrade_error"));
421 };
422 Self::PackageUpgradeError {
423 kind: package_upgrade_error.try_into()?,
424 }
425 }
426 K::WrittenObjectsTooLarge => {
427 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
428 &value.error_details
429 else {
430 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
431 };
432
433 Self::WrittenObjectsTooLarge {
434 object_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
435 max_object_size: max_size
436 .ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
437 }
438 }
439 K::CertificateDenied => Self::CertificateDenied,
440 K::SuiMoveVerificationTimedout => Self::SuiMoveVerificationTimedout,
441 K::ConsensusObjectOperationNotAllowed => Self::ConsensusObjectOperationNotAllowed,
442 K::InputObjectDeleted => Self::InputObjectDeleted,
443 K::ExecutionCanceledDueToConsensusObjectCongestion => {
444 let Some(ErrorDetails::CongestedObjects(CongestedObjects { objects })) =
445 &value.error_details
446 else {
447 return Err(TryFromProtoError::missing("congested_objects"));
448 };
449
450 Self::ExecutionCanceledDueToConsensusObjectCongestion {
451 congested_objects: objects
452 .iter()
453 .map(|s| s.parse())
454 .collect::<Result<_, _>>()
455 .map_err(|e| TryFromProtoError::invalid(CongestedObjects::OBJECTS_FIELD, e))?,
456 }
457 }
458 K::AddressDeniedForCoin => {
459 let Some(ErrorDetails::CoinDenyListError(CoinDenyListError {
460 address,
461 coin_type,
462 })) = &value.error_details
463 else {
464 return Err(TryFromProtoError::missing("coin_deny_list_error"));
465 };
466 Self::AddressDeniedForCoin {
467 address: address
468 .as_ref()
469 .ok_or_else(|| TryFromProtoError::missing("address"))?
470 .parse()
471 .map_err(|e| TryFromProtoError::invalid(CoinDenyListError::ADDRESS_FIELD, e))?,
472 coin_type: coin_type
473 .as_ref()
474 .ok_or_else(|| TryFromProtoError::missing("coin_type"))?
475 .to_owned(),
476 }
477 }
478 K::CoinTypeGlobalPause => {
479 let Some(ErrorDetails::CoinDenyListError(CoinDenyListError {
480 coin_type,
481 ..
482 })) = &value.error_details
483 else {
484 return Err(TryFromProtoError::missing("coin_deny_list_error"));
485 };
486 Self::CoinTypeGlobalPause {
487 coin_type: coin_type
488 .as_ref()
489 .ok_or_else(|| TryFromProtoError::missing("coin_type"))?
490 .to_owned(),
491 }
492 }
493 K::ExecutionCanceledDueToRandomnessUnavailable => {
494 Self::ExecutionCanceledDueToRandomnessUnavailable
495 }
496 K::MoveVectorElemTooBig => {
497 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
498 &value.error_details
499 else {
500 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
501 };
502
503 Self::MoveVectorElemTooBig {
504 value_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
505 max_scaled_size: max_size
506 .ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
507 }
508 }
509 K::MoveRawValueTooBig => {
510 let Some(ErrorDetails::SizeError(SizeError { size, max_size })) =
511 &value.error_details
512 else {
513 return Err(TryFromProtoError::missing(ExecutionError::SIZE_ERROR_FIELD));
514 };
515
516 Self::MoveRawValueTooBig {
517 value_size: size.ok_or_else(|| TryFromProtoError::missing(SizeError::SIZE_FIELD))?,
518 max_scaled_size: max_size
519 .ok_or_else(|| TryFromProtoError::missing(SizeError::MAX_SIZE_FIELD))?,
520 }
521 }
522 K::InvalidLinkage => Self::InvalidLinkage,
523 K::InsufficientFundsForWithdraw => Self::InsufficientFundsForWithdraw,
524 K::NonExclusiveWriteInputObjectModified => Self::NonExclusiveWriteInputObjectModified {
525 object: value.object_id().parse().map_err(|e| TryFromProtoError::invalid("object_id", e))?
526 },
527 K::TransactionExpired => Self::TransactionExpired,
528 }
529 .pipe(Ok)
530 }
531}
532
533impl From<sui_sdk_types::CommandArgumentError> for CommandArgumentError {
538 fn from(value: sui_sdk_types::CommandArgumentError) -> Self {
539 use command_argument_error::CommandArgumentErrorKind;
540 use sui_sdk_types::CommandArgumentError as E;
541
542 let mut message = Self::default();
543
544 let kind = match value {
545 E::TypeMismatch => CommandArgumentErrorKind::TypeMismatch,
546 E::InvalidBcsBytes => CommandArgumentErrorKind::InvalidBcsBytes,
547 E::InvalidUsageOfPureArgument => CommandArgumentErrorKind::InvalidUsageOfPureArgument,
548 E::InvalidArgumentToPrivateEntryFunction => {
549 CommandArgumentErrorKind::InvalidArgumentToPrivateEntryFunction
550 }
551 E::IndexOutOfBounds { index } => {
552 message.index_error = Some(IndexError {
553 index: Some(index.into()),
554 subresult: None,
555 });
556 CommandArgumentErrorKind::IndexOutOfBounds
557 }
558 E::SecondaryIndexOutOfBounds { result, subresult } => {
559 message.index_error = Some(IndexError {
560 index: Some(result.into()),
561 subresult: Some(subresult.into()),
562 });
563 CommandArgumentErrorKind::SecondaryIndexOutOfBounds
564 }
565 E::InvalidResultArity { result } => {
566 message.index_error = Some(IndexError {
567 index: Some(result.into()),
568 subresult: None,
569 });
570 CommandArgumentErrorKind::InvalidResultArity
571 }
572 E::InvalidGasCoinUsage => CommandArgumentErrorKind::InvalidGasCoinUsage,
573 E::InvalidValueUsage => CommandArgumentErrorKind::InvalidValueUsage,
574 E::InvalidObjectByValue => CommandArgumentErrorKind::InvalidObjectByValue,
575 E::InvalidObjectByMutRef => CommandArgumentErrorKind::InvalidObjectByMutRef,
576 E::ConsensusObjectOperationNotAllowed => {
577 CommandArgumentErrorKind::ConsensusObjectOperationNotAllowed
578 }
579 E::InvalidArgumentArity => CommandArgumentErrorKind::InvalidArgumentArity,
580 E::InvalidTransferObject => CommandArgumentErrorKind::InvalidTransferObject,
581 E::InvalidMakeMoveVecNonObjectArgument => {
582 CommandArgumentErrorKind::InvalidMakeMoveVecNonObjectArgument
583 }
584 E::ArgumentWithoutValue => CommandArgumentErrorKind::ArgumentWithoutValue,
585 E::CannotMoveBorrowedValue => CommandArgumentErrorKind::CannotMoveBorrowedValue,
586 E::CannotWriteToExtendedReference => {
587 CommandArgumentErrorKind::CannotWriteToExtendedReference
588 }
589 E::InvalidReferenceArgument => CommandArgumentErrorKind::InvalidReferenceArgument,
590 E::InvalidTxContext => CommandArgumentErrorKind::InvalidTxContext,
591 _ => CommandArgumentErrorKind::Unknown,
592 };
593
594 message.set_kind(kind);
595 message
596 }
597}
598
599impl TryFrom<&CommandArgumentError> for sui_sdk_types::CommandArgumentError {
600 type Error = TryFromProtoError;
601
602 fn try_from(value: &CommandArgumentError) -> Result<Self, Self::Error> {
603 use command_argument_error::CommandArgumentErrorKind as K;
604
605 match value.kind() {
606 K::Unknown => {
607 return Err(TryFromProtoError::invalid(
608 CommandArgumentError::KIND_FIELD,
609 "unknown CommandArgumentErrorKind",
610 ));
611 }
612 K::TypeMismatch => Self::TypeMismatch,
613 K::InvalidBcsBytes => Self::InvalidBcsBytes,
614 K::InvalidUsageOfPureArgument => Self::InvalidUsageOfPureArgument,
615 K::InvalidArgumentToPrivateEntryFunction => Self::InvalidArgumentToPrivateEntryFunction,
616 K::IndexOutOfBounds => Self::IndexOutOfBounds {
617 index: value
618 .index_error
619 .ok_or_else(|| TryFromProtoError::missing("index_error"))?
620 .index
621 .ok_or_else(|| TryFromProtoError::missing("index"))?
622 .try_into()
623 .map_err(|e| TryFromProtoError::invalid(IndexError::INDEX_FIELD, e))?,
624 },
625 K::SecondaryIndexOutOfBounds => {
626 let index_error = value
627 .index_error
628 .ok_or_else(|| TryFromProtoError::missing("index_error"))?;
629 Self::SecondaryIndexOutOfBounds {
630 result: index_error
631 .index
632 .ok_or_else(|| TryFromProtoError::missing("index"))?
633 .try_into()
634 .map_err(|e| TryFromProtoError::invalid(IndexError::INDEX_FIELD, e))?,
635 subresult: index_error
636 .subresult
637 .ok_or_else(|| TryFromProtoError::missing("subresult"))?
638 .try_into()
639 .map_err(|e| TryFromProtoError::invalid(IndexError::SUBRESULT_FIELD, e))?,
640 }
641 }
642 K::InvalidResultArity => Self::InvalidResultArity {
643 result: value
644 .index_error
645 .ok_or_else(|| TryFromProtoError::missing("index_error"))?
646 .index
647 .ok_or_else(|| TryFromProtoError::missing("index"))?
648 .try_into()
649 .map_err(|e| TryFromProtoError::invalid(IndexError::INDEX_FIELD, e))?,
650 },
651 K::InvalidGasCoinUsage => Self::InvalidGasCoinUsage,
652 K::InvalidValueUsage => Self::InvalidValueUsage,
653 K::InvalidObjectByValue => Self::InvalidObjectByValue,
654 K::InvalidObjectByMutRef => Self::InvalidObjectByMutRef,
655 K::ConsensusObjectOperationNotAllowed => Self::ConsensusObjectOperationNotAllowed,
656 K::InvalidArgumentArity => Self::InvalidArgumentArity,
657 K::InvalidTransferObject => Self::InvalidTransferObject,
658 K::InvalidMakeMoveVecNonObjectArgument => Self::InvalidMakeMoveVecNonObjectArgument,
659 K::ArgumentWithoutValue => Self::ArgumentWithoutValue,
660 K::CannotMoveBorrowedValue => Self::CannotMoveBorrowedValue,
661 K::CannotWriteToExtendedReference => Self::CannotWriteToExtendedReference,
662 K::InvalidReferenceArgument => Self::InvalidReferenceArgument,
663 K::InvalidTxContext => Self::InvalidTxContext,
664 }
665 .pipe(Ok)
666 }
667}
668
669impl From<sui_sdk_types::TypeArgumentError> for type_argument_error::TypeArgumentErrorKind {
674 fn from(value: sui_sdk_types::TypeArgumentError) -> Self {
675 use sui_sdk_types::TypeArgumentError::*;
676
677 match value {
678 TypeNotFound => Self::TypeNotFound,
679 ConstraintNotSatisfied => Self::ConstraintNotSatisfied,
680 _ => Self::Unknown,
681 }
682 }
683}
684
685impl TryFrom<type_argument_error::TypeArgumentErrorKind> for sui_sdk_types::TypeArgumentError {
686 type Error = TryFromProtoError;
687
688 fn try_from(value: type_argument_error::TypeArgumentErrorKind) -> Result<Self, Self::Error> {
689 use type_argument_error::TypeArgumentErrorKind as K;
690
691 match value {
692 K::Unknown => {
693 return Err(TryFromProtoError::invalid(
694 "kind",
695 "unknown TypeArgumentErrorKind",
696 ));
697 }
698 K::TypeNotFound => Self::TypeNotFound,
699 K::ConstraintNotSatisfied => Self::ConstraintNotSatisfied,
700 }
701 .pipe(Ok)
702 }
703}
704
705impl From<sui_sdk_types::PackageUpgradeError> for PackageUpgradeError {
710 fn from(value: sui_sdk_types::PackageUpgradeError) -> Self {
711 use package_upgrade_error::PackageUpgradeErrorKind;
712 use sui_sdk_types::PackageUpgradeError as E;
713
714 let mut message = Self::default();
715
716 let kind = match value {
717 E::UnableToFetchPackage { package_id } => {
718 message.package_id = Some(package_id.to_string());
719 PackageUpgradeErrorKind::UnableToFetchPackage
720 }
721 E::NotAPackage { object_id } => {
722 message.package_id = Some(object_id.to_string());
723 PackageUpgradeErrorKind::NotAPackage
724 }
725 E::IncompatibleUpgrade => PackageUpgradeErrorKind::IncompatibleUpgrade,
726 E::DigestDoesNotMatch { digest } => {
727 message.digest = Some(digest.to_string());
728 PackageUpgradeErrorKind::DigestDoesNotMatch
729 }
730 E::UnknownUpgradePolicy { policy } => {
731 message.policy = Some(policy.into());
732 PackageUpgradeErrorKind::UnknownUpgradePolicy
733 }
734 E::PackageIdDoesNotMatch {
735 package_id,
736 ticket_id,
737 } => {
738 message.package_id = Some(package_id.to_string());
739 message.ticket_id = Some(ticket_id.to_string());
740 PackageUpgradeErrorKind::PackageIdDoesNotMatch
741 }
742 _ => PackageUpgradeErrorKind::Unknown,
743 };
744
745 message.set_kind(kind);
746 message
747 }
748}
749
750impl TryFrom<&PackageUpgradeError> for sui_sdk_types::PackageUpgradeError {
751 type Error = TryFromProtoError;
752
753 fn try_from(value: &PackageUpgradeError) -> Result<Self, Self::Error> {
754 use package_upgrade_error::PackageUpgradeErrorKind as K;
755
756 match value.kind() {
757 K::Unknown => {
758 return Err(TryFromProtoError::invalid(
759 PackageUpgradeError::KIND_FIELD,
760 "unknown PackageUpgradeErrorKind",
761 ));
762 }
763 K::UnableToFetchPackage => Self::UnableToFetchPackage {
764 package_id: value
765 .package_id
766 .as_ref()
767 .ok_or_else(|| TryFromProtoError::missing("package_id"))?
768 .parse()
769 .map_err(|e| {
770 TryFromProtoError::invalid(PackageUpgradeError::PACKAGE_ID_FIELD, e)
771 })?,
772 },
773 K::NotAPackage => Self::NotAPackage {
774 object_id: value
775 .package_id
776 .as_ref()
777 .ok_or_else(|| TryFromProtoError::missing("package_id"))?
778 .parse()
779 .map_err(|e| {
780 TryFromProtoError::invalid(PackageUpgradeError::PACKAGE_ID_FIELD, e)
781 })?,
782 },
783 K::IncompatibleUpgrade => Self::IncompatibleUpgrade,
784 K::DigestDoesNotMatch => Self::DigestDoesNotMatch {
785 digest: value
786 .digest
787 .as_ref()
788 .ok_or_else(|| TryFromProtoError::missing("digest"))?
789 .parse()
790 .map_err(|e| {
791 TryFromProtoError::invalid(PackageUpgradeError::DIGEST_FIELD, e)
792 })?,
793 },
794 K::UnknownUpgradePolicy => Self::UnknownUpgradePolicy {
795 policy: value
796 .policy
797 .ok_or_else(|| TryFromProtoError::missing("policy"))?
798 .try_into()
799 .map_err(|e| {
800 TryFromProtoError::invalid(PackageUpgradeError::POLICY_FIELD, e)
801 })?,
802 },
803 K::PackageIdDoesNotMatch => Self::PackageIdDoesNotMatch {
804 package_id: value
805 .package_id
806 .as_ref()
807 .ok_or_else(|| TryFromProtoError::missing("package_id"))?
808 .parse()
809 .map_err(|e| {
810 TryFromProtoError::invalid(PackageUpgradeError::PACKAGE_ID_FIELD, e)
811 })?,
812 ticket_id: value
813 .ticket_id
814 .as_ref()
815 .ok_or_else(|| TryFromProtoError::missing("ticket_id"))?
816 .parse()
817 .map_err(|e| {
818 TryFromProtoError::invalid(PackageUpgradeError::TICKET_ID_FIELD, e)
819 })?,
820 },
821 }
822 .pipe(Ok)
823 }
824}
825
826impl From<sui_sdk_types::MoveLocation> for MoveLocation {
831 fn from(value: sui_sdk_types::MoveLocation) -> Self {
832 Self {
833 package: Some(value.package.to_string()),
834 module: Some(value.module.to_string()),
835 function: Some(value.function.into()),
836 instruction: Some(value.instruction.into()),
837 function_name: value.function_name.map(|name| name.to_string()),
838 }
839 }
840}
841
842impl TryFrom<&MoveLocation> for sui_sdk_types::MoveLocation {
843 type Error = TryFromProtoError;
844
845 fn try_from(value: &MoveLocation) -> Result<Self, Self::Error> {
846 let package = value
847 .package
848 .as_ref()
849 .ok_or_else(|| TryFromProtoError::missing("package"))?
850 .parse()
851 .map_err(|e| TryFromProtoError::invalid(MoveLocation::PACKAGE_FIELD, e))?;
852 let module = value
853 .module
854 .as_ref()
855 .ok_or_else(|| TryFromProtoError::missing("module"))?
856 .parse()
857 .map_err(|e| TryFromProtoError::invalid(MoveLocation::MODULE_FIELD, e))?;
858 let function = value
859 .function
860 .ok_or_else(|| TryFromProtoError::missing("function"))?
861 .try_into()
862 .map_err(|e| TryFromProtoError::invalid(MoveLocation::FUNCTION_FIELD, e))?;
863 let instruction = value
864 .instruction
865 .ok_or_else(|| TryFromProtoError::missing("instruction"))?
866 .try_into()
867 .map_err(|e| TryFromProtoError::invalid(MoveLocation::INSTRUCTION_FIELD, e))?;
868 let function_name = value
869 .function_name
870 .as_ref()
871 .map(|name| {
872 name.parse()
873 .map_err(|e| TryFromProtoError::invalid(MoveLocation::FUNCTION_NAME_FIELD, e))
874 })
875 .transpose()?;
876
877 Ok(Self {
878 package,
879 module,
880 function,
881 instruction,
882 function_name,
883 })
884 }
885}