Skip to main content

sui_rpc/proto/sui/rpc/v2/
execution_status.rs

1use 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
16//
17// ExecutionStatus
18//
19
20impl 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
64//
65// ExecutionError
66//
67
68impl 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
533//
534// CommandArgumentError
535//
536
537impl 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
669//
670// TypeArgumentError
671//
672
673impl 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
705//
706// PackageUpgradeError
707//
708
709impl 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
826//
827// MoveLocation
828//
829
830impl 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}