1use fastcrypto::traits::ToFromBytes;
14use iota_sdk_types::{
15 address::Address,
16 checkpoint::{
17 CheckpointCommitment, CheckpointContents, CheckpointData, CheckpointSummary,
18 CheckpointTransaction, CheckpointTransactionInfo, EndOfEpochData, SignedCheckpointSummary,
19 },
20 crypto::{Bls12381PublicKey, Bls12381Signature, Jwk, JwkId, UserSignature},
21 digest::Digest,
22 effects::{
23 ChangedObject, IdOperation, ObjectIn, ObjectOut, TransactionEffects, TransactionEffectsV1,
24 UnchangedSharedKind, UnchangedSharedObject,
25 },
26 events::{Event, TransactionEvents},
27 execution_status::{
28 CommandArgumentError, ExecutionError, ExecutionStatus, MoveLocation, PackageUpgradeError,
29 TypeArgumentError,
30 },
31 gas::GasCostSummary,
32 object::{
33 GenesisObject, MovePackage, MoveStruct, Object, ObjectData, ObjectReference, Owner,
34 TypeOrigin, UpgradeInfo,
35 },
36 object_id::ObjectId,
37 transaction::{
38 ActiveJwk, Argument, AuthenticatorStateExpire, AuthenticatorStateUpdateV1,
39 CancelledTransaction, ChangeEpoch, ChangeEpochV2, ChangeEpochV3, ChangeEpochV4, Command,
40 ConsensusCommitPrologueV1, ConsensusDeterminedVersionAssignments,
41 EndOfEpochTransactionKind, GasPayment, GenesisTransaction, Input, MakeMoveVector,
42 MergeCoins, MoveCall, ProgrammableTransaction, Publish, RandomnessStateUpdate,
43 SignedTransaction, SplitCoins, SystemPackage, Transaction, TransactionExpiration,
44 TransactionKind, TransactionV1, TransferObjects, Upgrade, VersionAssignment,
45 },
46 type_tag::{Identifier, StructTag, TypeParseError, TypeTag},
47 validator::{ValidatorAggregatedSignature, ValidatorCommittee, ValidatorCommitteeMember},
48};
49use move_core_types::language_storage::ModuleId;
50use tap::Pipe;
51
52use crate::{object::ObjectInner, transaction::TransactionDataAPI as _};
53
54#[derive(Debug)]
55pub struct SdkTypeConversionError(pub String);
56
57impl std::fmt::Display for SdkTypeConversionError {
58 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
59 f.write_str(&self.0)
60 }
61}
62
63impl std::error::Error for SdkTypeConversionError {}
64
65impl From<TypeParseError> for SdkTypeConversionError {
66 fn from(value: TypeParseError) -> Self {
67 Self(value.to_string())
68 }
69}
70
71impl From<anyhow::Error> for SdkTypeConversionError {
72 fn from(value: anyhow::Error) -> Self {
73 Self(value.to_string())
74 }
75}
76
77impl From<bcs::Error> for SdkTypeConversionError {
78 fn from(value: bcs::Error) -> Self {
79 Self(value.to_string())
80 }
81}
82
83impl TryFrom<crate::object::Object> for Object {
84 type Error = SdkTypeConversionError;
85
86 fn try_from(value: crate::object::Object) -> Result<Self, Self::Error> {
87 Self {
88 data: value.data.clone().try_into()?,
89 owner: value.owner.into(),
90 previous_transaction: value.previous_transaction.into(),
91 storage_rebate: value.storage_rebate,
92 }
93 .pipe(Ok)
94 }
95}
96
97impl TryFrom<Object> for crate::object::Object {
98 type Error = SdkTypeConversionError;
99
100 fn try_from(value: Object) -> Result<Self, Self::Error> {
101 Self::from(ObjectInner {
102 data: value.data.try_into()?,
103 owner: value.owner.into(),
104 previous_transaction: value.previous_transaction.into(),
105 storage_rebate: value.storage_rebate,
106 })
107 .pipe(Ok)
108 }
109}
110
111impl TryFrom<crate::object::Data> for ObjectData {
112 type Error = SdkTypeConversionError;
113
114 fn try_from(value: crate::object::Data) -> Result<Self, Self::Error> {
115 match value {
116 crate::object::Data::Move(move_object) => Self::Struct(move_object_to_sdk(move_object)),
117 crate::object::Data::Package(move_package) => {
118 Self::Package(move_package_to_sdk(move_package))
119 }
120 }
121 .pipe(Ok)
122 }
123}
124
125impl TryFrom<ObjectData> for crate::object::Data {
126 type Error = SdkTypeConversionError;
127
128 fn try_from(value: ObjectData) -> Result<Self, Self::Error> {
129 match value {
130 ObjectData::Struct(move_object) => Self::Move(sdk_object_to_move(move_object)?),
131 ObjectData::Package(move_package) => Self::Package(sdk_package_to_move(move_package)),
132 }
133 .pipe(Ok)
134 }
135}
136
137fn move_type_tag_to_sdk(tt: move_core_types::language_storage::TypeTag) -> TypeTag {
138 use move_core_types::language_storage::TypeTag as MoveTypeTag;
139 match tt {
140 MoveTypeTag::Bool => TypeTag::Bool,
141 MoveTypeTag::U8 => TypeTag::U8,
142 MoveTypeTag::U64 => TypeTag::U64,
143 MoveTypeTag::U128 => TypeTag::U128,
144 MoveTypeTag::Address => TypeTag::Address,
145 MoveTypeTag::Signer => TypeTag::Signer,
146 MoveTypeTag::Vector(type_tag) => TypeTag::Vector(Box::new(move_type_tag_to_sdk(*type_tag))),
147 MoveTypeTag::Struct(struct_tag) => {
148 TypeTag::Struct(Box::new(move_struct_tag_to_sdk(*struct_tag)))
149 }
150 MoveTypeTag::U16 => TypeTag::U16,
151 MoveTypeTag::U32 => TypeTag::U32,
152 MoveTypeTag::U256 => TypeTag::U256,
153 }
154}
155
156fn move_struct_tag_to_sdk(st: move_core_types::language_storage::StructTag) -> StructTag {
157 StructTag::new(
158 Address::new(st.address.into_bytes()),
159 Identifier::new(st.module.as_str()).expect("module identifier conversion failed"),
160 Identifier::new(st.name.as_str()).expect("struct name identifier conversion failed"),
161 st.type_params
162 .into_iter()
163 .map(move_type_tag_to_sdk)
164 .collect(),
165 )
166}
167
168fn move_package_to_sdk(package: crate::move_package::MovePackage) -> MovePackage {
169 MovePackage {
170 id: package.id().into(),
171 version: package.version().value(),
172 modules: package
173 .module_map
174 .into_iter()
175 .map(|(name, bytes)| {
176 (
177 Identifier::new(name).expect("package name identifier conversion failed"),
178 bytes,
179 )
180 })
181 .collect(),
182 type_origin_table: package
183 .type_origin_table
184 .into_iter()
185 .map(move_type_origin_to_sdk)
186 .collect(),
187 linkage_table: package
188 .linkage_table
189 .into_iter()
190 .map(|(id, info)| (id.into(), move_upgrade_info_to_sdk(info)))
191 .collect(),
192 }
193}
194
195fn sdk_package_to_move(package: MovePackage) -> crate::move_package::MovePackage {
196 crate::move_package::MovePackage {
197 id: package.id.into(),
198 version: package.version.into(),
199 module_map: package
200 .modules
201 .into_iter()
202 .map(|(name, bytes)| (name.to_string(), bytes))
203 .collect(),
204 type_origin_table: package
205 .type_origin_table
206 .into_iter()
207 .map(sdk_type_origin_to_move)
208 .collect(),
209 linkage_table: package
210 .linkage_table
211 .into_iter()
212 .map(|(id, info)| (id.into(), sdk_upgrade_info_to_move(info)))
213 .collect(),
214 }
215}
216
217fn move_object_to_sdk(obj: crate::object::MoveObject) -> MoveStruct {
218 MoveStruct {
219 type_: move_object_type_to_sdk(obj.type_),
220 version: obj.version.value(),
221 contents: obj.contents,
222 }
223}
224
225fn sdk_object_to_move(
226 obj: MoveStruct,
227) -> Result<crate::object::MoveObject, SdkTypeConversionError> {
228 crate::object::MoveObject {
229 type_: sdk_object_type_to_move(obj.type_)?,
230 version: obj.version.into(),
231 contents: obj.contents,
232 }
233 .pipe(Ok)
234}
235
236fn move_object_type_to_sdk(type_: crate::base_types::MoveObjectType) -> StructTag {
237 move_struct_tag_to_sdk(move_core_types::language_storage::StructTag {
238 address: type_.address(),
239 module: type_.module().to_owned(),
240 name: type_.name().to_owned(),
241 type_params: type_.type_params(),
242 })
243}
244
245fn sdk_object_type_to_move(
246 type_: StructTag,
247) -> Result<crate::base_types::MoveObjectType, SdkTypeConversionError> {
248 crate::base_types::MoveObjectType::from(move_core_types::language_storage::StructTag {
249 address: move_core_types::account_address::AccountAddress::new(
250 type_.address().into_inner(),
251 ),
252 module: crate::Identifier::new(type_.module().as_str())?,
253 name: crate::Identifier::new(type_.name().as_str())?,
254 type_params: type_
255 .type_params()
256 .iter()
257 .map(type_tag_sdk_to_core)
258 .collect::<Result<_, _>>()?,
259 })
260 .pipe(Ok)
261}
262
263fn move_type_origin_to_sdk(origin: crate::move_package::TypeOrigin) -> TypeOrigin {
264 TypeOrigin {
265 module_name: Identifier::new(&origin.module_name)
266 .expect("module identifier conversion failed"),
267 struct_name: Identifier::new(&origin.datatype_name)
268 .expect("struct identifier conversion failed"),
269 package: origin.package.into(),
270 }
271}
272
273fn sdk_type_origin_to_move(origin: TypeOrigin) -> crate::move_package::TypeOrigin {
274 crate::move_package::TypeOrigin {
275 module_name: origin.module_name.to_string(),
276 datatype_name: origin.struct_name.to_string(),
277 package: origin.package.into(),
278 }
279}
280
281fn move_upgrade_info_to_sdk(info: crate::move_package::UpgradeInfo) -> UpgradeInfo {
282 UpgradeInfo {
283 upgraded_id: info.upgraded_id.into(),
284 upgraded_version: info.upgraded_version.value(),
285 }
286}
287
288fn sdk_upgrade_info_to_move(info: UpgradeInfo) -> crate::move_package::UpgradeInfo {
289 crate::move_package::UpgradeInfo {
290 upgraded_id: info.upgraded_id.into(),
291 upgraded_version: info.upgraded_version.into(),
292 }
293}
294
295impl TryFrom<crate::transaction::TransactionData> for TransactionV1 {
296 type Error = SdkTypeConversionError;
297
298 fn try_from(value: crate::transaction::TransactionData) -> Result<Self, Self::Error> {
299 match value {
300 crate::transaction::TransactionData::V1(value) => value.try_into(),
301 }
302 }
303}
304
305impl TryFrom<TransactionV1> for crate::transaction::TransactionData {
306 type Error = SdkTypeConversionError;
307
308 fn try_from(value: TransactionV1) -> Result<Self, Self::Error> {
309 Ok(Self::V1(value.try_into()?))
310 }
311}
312
313impl TryFrom<crate::transaction::TransactionData> for Transaction {
314 type Error = SdkTypeConversionError;
315
316 fn try_from(value: crate::transaction::TransactionData) -> Result<Self, Self::Error> {
317 match value {
318 crate::transaction::TransactionData::V1(value) => Ok(Self::V1(value.try_into()?)),
319 }
320 }
321}
322
323impl TryFrom<Transaction> for crate::transaction::TransactionData {
324 type Error = SdkTypeConversionError;
325
326 fn try_from(value: Transaction) -> Result<Self, Self::Error> {
327 match value {
328 Transaction::V1(value) => value.try_into(),
329 _ => unreachable!("a new enum variant was added and needs to be handled"),
330 }
331 }
332}
333
334impl TryFrom<crate::transaction::TransactionDataV1> for TransactionV1 {
335 type Error = SdkTypeConversionError;
336
337 fn try_from(value: crate::transaction::TransactionDataV1) -> Result<Self, Self::Error> {
338 Self {
339 sender: Address::new(value.sender().to_inner()),
340 gas_payment: GasPayment {
341 objects: value
342 .gas()
343 .iter()
344 .map(|(id, seq, digest)| {
345 ObjectReference::new((*id).into(), seq.value(), (*digest).into())
346 })
347 .collect(),
348 owner: Address::new(value.gas_data().owner.to_inner()),
349 price: value.gas_data().price,
350 budget: value.gas_data().budget,
351 },
352 expiration: match value.expiration() {
353 crate::transaction::TransactionExpiration::None => TransactionExpiration::None,
354 crate::transaction::TransactionExpiration::Epoch(e) => {
355 TransactionExpiration::Epoch(*e)
356 }
357 },
358 kind: value.into_kind().try_into()?,
359 }
360 .pipe(Ok)
361 }
362}
363
364impl TryFrom<TransactionV1> for crate::transaction::TransactionDataV1 {
365 type Error = SdkTypeConversionError;
366
367 fn try_from(value: TransactionV1) -> Result<Self, Self::Error> {
368 Self {
369 kind: value.kind.try_into()?,
370 sender: value.sender.into(),
371 gas_data: crate::transaction::GasData {
372 payment: value
373 .gas_payment
374 .objects
375 .into_iter()
376 .map(ObjectReference::into_parts)
377 .map(|(id, seq, digest)| (id.into(), seq.into(), digest.into()))
378 .collect(),
379 owner: value.gas_payment.owner.into(),
380 price: value.gas_payment.price,
381 budget: value.gas_payment.budget,
382 },
383 expiration: match value.expiration {
384 TransactionExpiration::None => crate::transaction::TransactionExpiration::None,
385 TransactionExpiration::Epoch(e) => {
386 crate::transaction::TransactionExpiration::Epoch(e)
387 }
388 _ => unreachable!("a new enum variant was added and needs to be handled"),
389 },
390 }
391 .pipe(Ok)
392 }
393}
394
395impl TryFrom<crate::transaction::TransactionKind> for TransactionKind {
396 type Error = SdkTypeConversionError;
397
398 fn try_from(value: crate::transaction::TransactionKind) -> Result<Self, Self::Error> {
399 use crate::transaction::TransactionKind as InternalTxnKind;
400
401 match value {
402 InternalTxnKind::ProgrammableTransaction(programmable_transaction) => {
403 TransactionKind::ProgrammableTransaction(ProgrammableTransaction {
404 inputs: programmable_transaction
405 .inputs
406 .into_iter()
407 .map(Into::into)
408 .collect(),
409 commands: programmable_transaction
410 .commands
411 .into_iter()
412 .map(TryInto::try_into)
413 .collect::<Result<_, _>>()?,
414 })
415 }
416 InternalTxnKind::Genesis(genesis_transaction) => {
417 TransactionKind::Genesis(GenesisTransaction {
418 objects: genesis_transaction
419 .objects
420 .into_iter()
421 .map(|obj| match obj {
422 crate::transaction::GenesisObject::RawObject { data, owner } => {
423 match data.try_into() {
424 Ok(data) => Ok(GenesisObject {
425 data,
426 owner: owner.into(),
427 }),
428 Err(e) => Err(e),
429 }
430 }
431 })
432 .collect::<Result<_,_>>()?,
433 events: genesis_transaction
434 .events
435 .into_iter()
436 .map(|event| {
437 let module = Identifier::new(event.transaction_module.as_str());
438 let type_ = struct_tag_core_to_sdk(event.type_);
439
440 match (module, type_) {
441 (Ok(module), Ok(type_)) => Ok(Event {
442 package_id: event.package_id.into(),
443 module,
444 sender: event.sender.into(),
445 type_,
446 contents: event.contents,
447 }),
448 _ => Err(SdkTypeConversionError(
449 "invalid transaction module or struct tag".to_string(),
450 )),
451 }
452 })
453 .collect::<Result<_,_>>()?,
454 })
455 }
456 InternalTxnKind::ConsensusCommitPrologueV1(consensus_commit_prologue_v1) => {
457 let consensus_determined_version_assignments = match consensus_commit_prologue_v1.consensus_determined_version_assignments {
458 crate::messages_consensus::ConsensusDeterminedVersionAssignments::CancelledTransactions(vec) =>
459 ConsensusDeterminedVersionAssignments::CancelledTransactions {
460 cancelled_transactions: vec.into_iter().map(|value| CancelledTransaction {
461 digest: value.0.into(),
462 version_assignments:
463 value
464 .1
465 .into_iter()
466 .map(|value| VersionAssignment { object_id: value.0.into(), version: value.1.value() })
467 .collect(),
468 }).collect()
469 },
470 };
471 TransactionKind::ConsensusCommitPrologueV1(ConsensusCommitPrologueV1 {
472 epoch: consensus_commit_prologue_v1.epoch,
473 round: consensus_commit_prologue_v1.round,
474 sub_dag_index: consensus_commit_prologue_v1.sub_dag_index,
475 commit_timestamp_ms: consensus_commit_prologue_v1.commit_timestamp_ms,
476 consensus_commit_digest: consensus_commit_prologue_v1
477 .consensus_commit_digest
478 .into(),
479 consensus_determined_version_assignments,
480 })
481 }
482 InternalTxnKind::AuthenticatorStateUpdateV1(authenticator_state_update_v1) => {
483 TransactionKind::AuthenticatorStateUpdateV1(AuthenticatorStateUpdateV1 {
484 epoch: authenticator_state_update_v1.epoch,
485 round: authenticator_state_update_v1.round,
486 new_active_jwks: authenticator_state_update_v1
487 .new_active_jwks
488 .into_iter()
489 .map(|jwk| ActiveJwk {
490 jwk_id: JwkId {
491 iss: jwk.jwk_id.iss,
492 kid: jwk.jwk_id.kid,
493 },
494 jwk: Jwk {
495 kty: jwk.jwk.kty,
496 e: jwk.jwk.e,
497 n: jwk.jwk.n,
498 alg: jwk.jwk.alg,
499 },
500 epoch: jwk.epoch,
501 })
502 .collect(),
503 authenticator_obj_initial_shared_version: authenticator_state_update_v1
504 .authenticator_obj_initial_shared_version
505 .value(),
506 })
507 }
508 InternalTxnKind::EndOfEpochTransaction(vec) => {
509 TransactionKind::EndOfEpoch(vec.into_iter().map(Into::into).collect())
510 }
511 InternalTxnKind::RandomnessStateUpdate(randomness_state_update) => {
512 TransactionKind::RandomnessStateUpdate(RandomnessStateUpdate {
513 epoch: randomness_state_update.epoch,
514 randomness_round: randomness_state_update.randomness_round.0,
515 random_bytes: randomness_state_update.random_bytes,
516 randomness_obj_initial_shared_version: randomness_state_update
517 .randomness_obj_initial_shared_version
518 .value(),
519 })
520 }
521 }
522 .pipe(Ok)
523 }
524}
525
526impl TryFrom<TransactionKind> for crate::transaction::TransactionKind {
527 type Error = SdkTypeConversionError;
528
529 fn try_from(value: TransactionKind) -> Result<Self, Self::Error> {
530 match value {
531 TransactionKind::ProgrammableTransaction(programmable_transaction) => {
532 Self::ProgrammableTransaction(crate::transaction::ProgrammableTransaction {
533 inputs: programmable_transaction
534 .inputs
535 .into_iter()
536 .map(Into::into)
537 .collect(),
538 commands: programmable_transaction
539 .commands
540 .into_iter()
541 .map(TryInto::try_into)
542 .collect::<Result<_,_>>()?,
543 })
544 }
545 TransactionKind::Genesis(genesis_transaction) => {
546 Self::Genesis(crate::transaction::GenesisTransaction {
547 objects: genesis_transaction
548 .objects
549 .into_iter()
550 .map(|obj| {
551 match obj.data.try_into() {
552 Ok(data) => Ok(crate::transaction::GenesisObject::RawObject {
553 data,
554 owner: obj.owner.into(),
555 }),
556 Err(e) => Err(e),
557 }
558 })
559 .collect::<Result<_,_>>()?,
560 events: genesis_transaction
561 .events
562 .into_iter()
563 .map(|event| {
564 let transaction_module = crate::Identifier::new(event.module.as_str());
565 let type_ = struct_tag_sdk_to_core(&event.type_);
566
567 match (transaction_module, type_) {
568 (Ok(transaction_module), Ok(type_)) => Ok(crate::event::Event {
569 package_id: event.package_id.into(),
570 transaction_module,
571 sender: event.sender.into(),
572 type_,
573 contents: event.contents,
574 }),
575 _ => Err(SdkTypeConversionError(
576 "invalid transaction module or struct tag".to_string(),
577 )),
578 }
579 })
580 .collect::<Result<_,_>>()?,
581 })
582 }
583 TransactionKind::ConsensusCommitPrologueV1(consensus_commit_prologue_v1) => {
584 let consensus_determined_version_assignments = match consensus_commit_prologue_v1.consensus_determined_version_assignments {
585 ConsensusDeterminedVersionAssignments::CancelledTransactions { cancelled_transactions } =>
586 crate::messages_consensus::ConsensusDeterminedVersionAssignments::CancelledTransactions(
587 cancelled_transactions.into_iter().map(|value|
588 (
589 value.digest.into(),
590 value
591 .version_assignments
592 .into_iter()
593 .map(|value| (value.object_id.into(), value.version.into()))
594 .collect()
595 )
596 ).collect()
597 ),
598 _ => unreachable!("a new enum variant was added and needs to be handled")
599 };
600 Self::ConsensusCommitPrologueV1(
601 crate::messages_consensus::ConsensusCommitPrologueV1 {
602 epoch: consensus_commit_prologue_v1.epoch,
603 round: consensus_commit_prologue_v1.round,
604 sub_dag_index: consensus_commit_prologue_v1.sub_dag_index,
605 commit_timestamp_ms: consensus_commit_prologue_v1.commit_timestamp_ms,
606 consensus_commit_digest: consensus_commit_prologue_v1
607 .consensus_commit_digest
608 .into(),
609 consensus_determined_version_assignments,
610 },
611 )
612 }
613 TransactionKind::AuthenticatorStateUpdateV1(authenticator_state_update_v1) => {
614 Self::AuthenticatorStateUpdateV1(crate::transaction::AuthenticatorStateUpdateV1 {
615 epoch: authenticator_state_update_v1.epoch,
616 round: authenticator_state_update_v1.round,
617 new_active_jwks: authenticator_state_update_v1
618 .new_active_jwks
619 .into_iter()
620 .map(|jwk| crate::authenticator_state::ActiveJwk {
621 jwk_id: crate::authenticator_state::JwkId {
622 iss: jwk.jwk_id.iss,
623 kid: jwk.jwk_id.kid,
624 },
625 jwk: crate::authenticator_state::JWK {
626 kty: jwk.jwk.kty,
627 e: jwk.jwk.e,
628 n: jwk.jwk.n,
629 alg: jwk.jwk.alg,
630 },
631 epoch: jwk.epoch,
632 })
633 .collect(),
634 authenticator_obj_initial_shared_version: authenticator_state_update_v1
635 .authenticator_obj_initial_shared_version
636 .into(),
637 })
638 }
639 TransactionKind::EndOfEpoch(vec) => {
640 Self::EndOfEpochTransaction(vec.into_iter().map(Into::into).collect())
641 }
642 TransactionKind::RandomnessStateUpdate(randomness_state_update) => {
643 Self::RandomnessStateUpdate(crate::transaction::RandomnessStateUpdate {
644 epoch: randomness_state_update.epoch,
645 randomness_round: crate::crypto::RandomnessRound(
646 randomness_state_update.randomness_round,
647 ),
648 random_bytes: randomness_state_update.random_bytes,
649 randomness_obj_initial_shared_version: randomness_state_update
650 .randomness_obj_initial_shared_version
651 .into(),
652 })
653 }
654 _ => unreachable!("a new enum variant was added and needs to be handled")
655 }
656 .pipe(Ok)
657 }
658}
659
660impl From<crate::transaction::EndOfEpochTransactionKind> for EndOfEpochTransactionKind {
661 fn from(value: crate::transaction::EndOfEpochTransactionKind) -> Self {
662 match value {
663 crate::transaction::EndOfEpochTransactionKind::ChangeEpoch(change_epoch) => {
664 EndOfEpochTransactionKind::ChangeEpoch(ChangeEpoch {
665 epoch: change_epoch.epoch,
666 protocol_version: change_epoch.protocol_version.as_u64(),
667 storage_charge: change_epoch.storage_charge,
668 computation_charge: change_epoch.computation_charge,
669 storage_rebate: change_epoch.storage_rebate,
670 non_refundable_storage_fee: change_epoch.non_refundable_storage_fee,
671 epoch_start_timestamp_ms: change_epoch.epoch_start_timestamp_ms,
672 system_packages: change_epoch
673 .system_packages
674 .into_iter()
675 .map(|(version, modules, dependencies)| SystemPackage {
676 version: version.value(),
677 modules,
678 dependencies: dependencies.into_iter().map(Into::into).collect(),
679 })
680 .collect(),
681 })
682 }
683 crate::transaction::EndOfEpochTransactionKind::ChangeEpochV2(change_epoch_v2) => {
684 EndOfEpochTransactionKind::ChangeEpochV2(ChangeEpochV2 {
685 epoch: change_epoch_v2.epoch,
686 protocol_version: change_epoch_v2.protocol_version.as_u64(),
687 storage_charge: change_epoch_v2.storage_charge,
688 computation_charge: change_epoch_v2.computation_charge,
689 computation_charge_burned: change_epoch_v2.computation_charge_burned,
690 storage_rebate: change_epoch_v2.storage_rebate,
691 non_refundable_storage_fee: change_epoch_v2.non_refundable_storage_fee,
692 epoch_start_timestamp_ms: change_epoch_v2.epoch_start_timestamp_ms,
693 system_packages: change_epoch_v2
694 .system_packages
695 .into_iter()
696 .map(|(version, modules, dependencies)| SystemPackage {
697 version: version.value(),
698 modules,
699 dependencies: dependencies.into_iter().map(Into::into).collect(),
700 })
701 .collect(),
702 })
703 }
704 crate::transaction::EndOfEpochTransactionKind::ChangeEpochV3(change_epoch_v3) => {
705 EndOfEpochTransactionKind::ChangeEpochV3(ChangeEpochV3 {
706 epoch: change_epoch_v3.epoch,
707 protocol_version: change_epoch_v3.protocol_version.as_u64(),
708 storage_charge: change_epoch_v3.storage_charge,
709 computation_charge: change_epoch_v3.computation_charge,
710 computation_charge_burned: change_epoch_v3.computation_charge_burned,
711 storage_rebate: change_epoch_v3.storage_rebate,
712 non_refundable_storage_fee: change_epoch_v3.non_refundable_storage_fee,
713 epoch_start_timestamp_ms: change_epoch_v3.epoch_start_timestamp_ms,
714 system_packages: change_epoch_v3
715 .system_packages
716 .into_iter()
717 .map(|(version, modules, dependencies)| SystemPackage {
718 version: version.value(),
719 modules,
720 dependencies: dependencies.into_iter().map(Into::into).collect(),
721 })
722 .collect(),
723 eligible_active_validators: change_epoch_v3.eligible_active_validators,
724 })
725 }
726
727 crate::transaction::EndOfEpochTransactionKind::ChangeEpochV4(change_epoch_v4) => {
728 EndOfEpochTransactionKind::ChangeEpochV4(ChangeEpochV4 {
729 epoch: change_epoch_v4.epoch,
730 protocol_version: change_epoch_v4.protocol_version.as_u64(),
731 storage_charge: change_epoch_v4.storage_charge,
732 computation_charge: change_epoch_v4.computation_charge,
733 computation_charge_burned: change_epoch_v4.computation_charge_burned,
734 storage_rebate: change_epoch_v4.storage_rebate,
735 non_refundable_storage_fee: change_epoch_v4.non_refundable_storage_fee,
736 epoch_start_timestamp_ms: change_epoch_v4.epoch_start_timestamp_ms,
737 system_packages: change_epoch_v4
738 .system_packages
739 .into_iter()
740 .map(|(version, modules, dependencies)| SystemPackage {
741 version: version.value(),
742 modules,
743 dependencies: dependencies.into_iter().map(Into::into).collect(),
744 })
745 .collect(),
746 eligible_active_validators: change_epoch_v4.eligible_active_validators,
747 scores: change_epoch_v4.scores,
748 adjust_rewards_by_score: change_epoch_v4.adjust_rewards_by_score,
749 })
750 }
751 crate::transaction::EndOfEpochTransactionKind::AuthenticatorStateCreate => {
752 EndOfEpochTransactionKind::AuthenticatorStateCreate
753 }
754 crate::transaction::EndOfEpochTransactionKind::AuthenticatorStateExpire(
755 authenticator_state_expire,
756 ) => EndOfEpochTransactionKind::AuthenticatorStateExpire(AuthenticatorStateExpire {
757 min_epoch: authenticator_state_expire.min_epoch,
758 authenticator_obj_initial_shared_version: authenticator_state_expire
759 .authenticator_obj_initial_shared_version
760 .value(),
761 }),
762 }
763 }
764}
765
766impl From<EndOfEpochTransactionKind> for crate::transaction::EndOfEpochTransactionKind {
767 fn from(value: EndOfEpochTransactionKind) -> Self {
768 match value {
769 EndOfEpochTransactionKind::ChangeEpoch(change_epoch) => {
770 Self::ChangeEpoch(crate::transaction::ChangeEpoch {
771 epoch: change_epoch.epoch,
772 protocol_version: change_epoch.protocol_version.into(),
773 storage_charge: change_epoch.storage_charge,
774 computation_charge: change_epoch.computation_charge,
775 storage_rebate: change_epoch.storage_rebate,
776 non_refundable_storage_fee: change_epoch.non_refundable_storage_fee,
777 epoch_start_timestamp_ms: change_epoch.epoch_start_timestamp_ms,
778 system_packages: change_epoch
779 .system_packages
780 .into_iter()
781 .map(|package| {
782 (
783 package.version.into(),
784 package.modules,
785 package.dependencies.into_iter().map(Into::into).collect(),
786 )
787 })
788 .collect(),
789 })
790 }
791 EndOfEpochTransactionKind::ChangeEpochV2(change_epoch_v2) => {
792 Self::ChangeEpochV2(crate::transaction::ChangeEpochV2 {
793 epoch: change_epoch_v2.epoch,
794 protocol_version: change_epoch_v2.protocol_version.into(),
795 storage_charge: change_epoch_v2.storage_charge,
796 computation_charge: change_epoch_v2.computation_charge,
797 computation_charge_burned: change_epoch_v2.computation_charge_burned,
798 storage_rebate: change_epoch_v2.storage_rebate,
799 non_refundable_storage_fee: change_epoch_v2.non_refundable_storage_fee,
800 epoch_start_timestamp_ms: change_epoch_v2.epoch_start_timestamp_ms,
801 system_packages: change_epoch_v2
802 .system_packages
803 .into_iter()
804 .map(|package| {
805 (
806 package.version.into(),
807 package.modules,
808 package.dependencies.into_iter().map(Into::into).collect(),
809 )
810 })
811 .collect(),
812 })
813 }
814 EndOfEpochTransactionKind::ChangeEpochV3(change_epoch_v3) => {
815 Self::ChangeEpochV3(crate::transaction::ChangeEpochV3 {
816 epoch: change_epoch_v3.epoch,
817 protocol_version: change_epoch_v3.protocol_version.into(),
818 storage_charge: change_epoch_v3.storage_charge,
819 computation_charge: change_epoch_v3.computation_charge,
820 computation_charge_burned: change_epoch_v3.computation_charge_burned,
821 storage_rebate: change_epoch_v3.storage_rebate,
822 non_refundable_storage_fee: change_epoch_v3.non_refundable_storage_fee,
823 epoch_start_timestamp_ms: change_epoch_v3.epoch_start_timestamp_ms,
824 system_packages: change_epoch_v3
825 .system_packages
826 .into_iter()
827 .map(|package| {
828 (
829 package.version.into(),
830 package.modules,
831 package.dependencies.into_iter().map(Into::into).collect(),
832 )
833 })
834 .collect(),
835 eligible_active_validators: change_epoch_v3.eligible_active_validators,
836 })
837 }
838 EndOfEpochTransactionKind::ChangeEpochV4(change_epoch_v4) => {
839 Self::ChangeEpochV4(crate::transaction::ChangeEpochV4 {
840 epoch: change_epoch_v4.epoch,
841 protocol_version: change_epoch_v4.protocol_version.into(),
842 storage_charge: change_epoch_v4.storage_charge,
843 computation_charge: change_epoch_v4.computation_charge,
844 computation_charge_burned: change_epoch_v4.computation_charge_burned,
845 storage_rebate: change_epoch_v4.storage_rebate,
846 non_refundable_storage_fee: change_epoch_v4.non_refundable_storage_fee,
847 epoch_start_timestamp_ms: change_epoch_v4.epoch_start_timestamp_ms,
848 system_packages: change_epoch_v4
849 .system_packages
850 .into_iter()
851 .map(|package| {
852 (
853 package.version.into(),
854 package.modules,
855 package.dependencies.into_iter().map(Into::into).collect(),
856 )
857 })
858 .collect(),
859 eligible_active_validators: change_epoch_v4.eligible_active_validators,
860 scores: change_epoch_v4.scores,
861 adjust_rewards_by_score: change_epoch_v4.adjust_rewards_by_score,
862 })
863 }
864 EndOfEpochTransactionKind::AuthenticatorStateCreate => Self::AuthenticatorStateCreate,
865 EndOfEpochTransactionKind::AuthenticatorStateExpire(authenticator_state_expire) => {
866 Self::AuthenticatorStateExpire(crate::transaction::AuthenticatorStateExpire {
867 min_epoch: authenticator_state_expire.min_epoch,
868 authenticator_obj_initial_shared_version: authenticator_state_expire
869 .authenticator_obj_initial_shared_version
870 .into(),
871 })
872 }
873 _ => unreachable!("a new enum variant was added and needs to be handled"),
874 }
875 }
876}
877
878impl From<crate::transaction::CallArg> for Input {
879 fn from(value: crate::transaction::CallArg) -> Self {
880 match value {
881 crate::transaction::CallArg::Pure(vec) => Self::Pure { value: vec },
882 crate::transaction::CallArg::Object(object_arg) => match object_arg {
883 crate::transaction::ObjectArg::ImmOrOwnedObject(obj_ref) => {
884 Self::ImmutableOrOwned(core_obj_ref_to_sdk(obj_ref))
885 }
886 crate::transaction::ObjectArg::SharedObject {
887 id,
888 initial_shared_version,
889 mutable,
890 } => Self::Shared {
891 object_id: id.into(),
892 initial_shared_version: initial_shared_version.value(),
893 mutable,
894 },
895 crate::transaction::ObjectArg::Receiving(obj_ref) => {
896 Self::Receiving(core_obj_ref_to_sdk(obj_ref))
897 }
898 },
899 }
900 }
901}
902
903impl From<Input> for crate::transaction::CallArg {
904 fn from(value: Input) -> Self {
905 use crate::transaction::ObjectArg;
906 match value {
907 Input::Pure { value } => Self::Pure(value),
908 Input::ImmutableOrOwned(object_reference) => Self::Object(ObjectArg::ImmOrOwnedObject(
909 sdk_obj_ref_to_core(object_reference),
910 )),
911 Input::Shared {
912 object_id,
913 initial_shared_version,
914 mutable,
915 } => Self::Object(ObjectArg::SharedObject {
916 id: object_id.into(),
917 initial_shared_version: initial_shared_version.into(),
918 mutable,
919 }),
920 Input::Receiving(object_reference) => {
921 Self::Object(ObjectArg::Receiving(sdk_obj_ref_to_core(object_reference)))
922 }
923 _ => unreachable!("a new enum variant was added and needs to be handled"),
924 }
925 }
926}
927
928fn core_obj_ref_to_sdk(obj_ref: crate::base_types::ObjectRef) -> ObjectReference {
929 ObjectReference::new(obj_ref.0.into(), obj_ref.1.value(), obj_ref.2.into())
930}
931
932fn sdk_obj_ref_to_core(obj_ref: ObjectReference) -> crate::base_types::ObjectRef {
933 let (id, seq, digest) = obj_ref.into_parts();
934 (id.into(), seq.into(), digest.into())
935}
936
937impl TryFrom<crate::effects::TransactionEffects> for TransactionEffects {
938 type Error = SdkTypeConversionError;
939
940 fn try_from(value: crate::effects::TransactionEffects) -> Result<Self, Self::Error> {
941 match value {
942 crate::effects::TransactionEffects::V1(effects) => {
943 Self::V1(Box::new(TransactionEffectsV1 {
944 epoch: effects.executed_epoch,
945 gas_used: GasCostSummary::new(
946 effects.gas_used.computation_cost,
947 effects.gas_used.computation_cost_burned,
948 effects.gas_used.storage_cost,
949 effects.gas_used.storage_rebate,
950 effects.gas_used.non_refundable_storage_fee,
951 ),
952 gas_object_index: effects.gas_object_index,
953 transaction_digest: effects.transaction_digest.into(),
954 events_digest: effects.events_digest.map(Into::into),
955 dependencies: effects.dependencies.into_iter().map(Into::into).collect(),
956 lamport_version: effects.lamport_version.value(),
957 changed_objects: effects
958 .changed_objects
959 .into_iter()
960 .map(|(id, change)| ChangedObject {
961 object_id: id.into(),
962 input_state: match change.input_state {
963 crate::effects::ObjectIn::NotExist => ObjectIn::Missing,
964 crate::effects::ObjectIn::Exist(((version, digest), owner)) => {
965 ObjectIn::Data {
966 version: version.value(),
967 digest: digest.into(),
968 owner: owner.into(),
969 }
970 }
971 },
972 output_state: match change.output_state {
973 crate::effects::ObjectOut::NotExist => ObjectOut::Missing,
974 crate::effects::ObjectOut::ObjectWrite((digest, owner)) => {
975 ObjectOut::ObjectWrite {
976 digest: digest.into(),
977 owner: owner.into(),
978 }
979 }
980 crate::effects::ObjectOut::PackageWrite((seq, digest)) => {
981 ObjectOut::PackageWrite {
982 version: seq.value(),
983 digest: digest.into(),
984 }
985 }
986 },
987 id_operation: match change.id_operation {
988 crate::effects::IDOperation::None => IdOperation::None,
989 crate::effects::IDOperation::Created => IdOperation::Created,
990 crate::effects::IDOperation::Deleted => IdOperation::Deleted,
991 },
992 })
993 .collect(),
994 unchanged_shared_objects: effects
995 .unchanged_shared_objects
996 .into_iter()
997 .map(|(id, kind)| UnchangedSharedObject {
998 object_id: id.into(),
999 kind: match kind {
1000 crate::effects::UnchangedSharedKind::ReadOnlyRoot((
1001 version,
1002 digest,
1003 )) => UnchangedSharedKind::ReadOnlyRoot {
1004 version: version.value(),
1005 digest: digest.into(),
1006 },
1007 crate::effects::UnchangedSharedKind::MutateDeleted(
1008 sequence_number,
1009 ) => UnchangedSharedKind::MutateDeleted {
1010 version: sequence_number.value(),
1011 },
1012 crate::effects::UnchangedSharedKind::ReadDeleted(
1013 sequence_number,
1014 ) => UnchangedSharedKind::ReadDeleted {
1015 version: sequence_number.value(),
1016 },
1017 crate::effects::UnchangedSharedKind::Cancelled(sequence_number) => {
1018 UnchangedSharedKind::Cancelled {
1019 version: sequence_number.value(),
1020 }
1021 }
1022 crate::effects::UnchangedSharedKind::PerEpochConfig => {
1023 UnchangedSharedKind::PerEpochConfig
1024 }
1025 },
1026 })
1027 .collect(),
1028 auxiliary_data_digest: effects.aux_data_digest.map(Into::into),
1029 status: effects.status.into(),
1030 }))
1031 .pipe(Ok)
1032 }
1033 }
1034 }
1035}
1036
1037impl TryFrom<TransactionEffects> for crate::effects::TransactionEffects {
1038 type Error = SdkTypeConversionError;
1039
1040 fn try_from(value: TransactionEffects) -> Result<Self, Self::Error> {
1041 match value {
1042 TransactionEffects::V1(transaction_effects_v1) => {
1043 let effects: crate::effects::TransactionEffects =
1044 crate::effects::effects_v1::TransactionEffectsV1 {
1045 status: transaction_effects_v1.status.into(),
1046 executed_epoch: transaction_effects_v1.epoch,
1047 gas_used: crate::gas::GasCostSummary::new(
1048 transaction_effects_v1.gas_used.computation_cost,
1049 transaction_effects_v1.gas_used.computation_cost_burned,
1050 transaction_effects_v1.gas_used.storage_cost,
1051 transaction_effects_v1.gas_used.storage_rebate,
1052 transaction_effects_v1.gas_used.non_refundable_storage_fee,
1053 ),
1054 transaction_digest: transaction_effects_v1.transaction_digest.into(),
1055 gas_object_index: transaction_effects_v1.gas_object_index,
1056 events_digest: transaction_effects_v1.events_digest.map(Into::into),
1057 dependencies: transaction_effects_v1
1058 .dependencies
1059 .into_iter()
1060 .map(Into::into)
1061 .collect(),
1062 lamport_version: transaction_effects_v1.lamport_version.into(),
1063 changed_objects: transaction_effects_v1
1064 .changed_objects
1065 .into_iter()
1066 .map(|obj| {
1067 (
1068 obj.object_id.into(),
1069 crate::effects::EffectsObjectChange {
1070 input_state: match obj.input_state {
1071 ObjectIn::Missing => crate::effects::ObjectIn::NotExist,
1072 ObjectIn::Data {
1073 version,
1074 digest,
1075 owner,
1076 } => crate::effects::ObjectIn::Exist((
1077 (version.into(), digest.into()),
1078 owner.into(),
1079 )),
1080 _ => unreachable!("a new enum variant was added and needs to be handled")
1081 },
1082 output_state: match obj.output_state {
1083 ObjectOut::Missing => {
1084 crate::effects::ObjectOut::NotExist
1085 }
1086 ObjectOut::ObjectWrite { digest, owner } => {
1087 crate::effects::ObjectOut::ObjectWrite((
1088 digest.into(),
1089 owner.into(),
1090 ))
1091 }
1092 ObjectOut::PackageWrite { version, digest } => {
1093 crate::effects::ObjectOut::PackageWrite((
1094 version.into(),
1095 digest.into(),
1096 ))
1097 }
1098 _ => unreachable!("a new enum variant was added and needs to be handled")
1099 },
1100 id_operation: match obj.id_operation {
1101 IdOperation::None => crate::effects::IDOperation::None,
1102 IdOperation::Created => {
1103 crate::effects::IDOperation::Created
1104 }
1105 IdOperation::Deleted => {
1106 crate::effects::IDOperation::Deleted
1107 }
1108 _ => unreachable!("a new enum variant was added and needs to be handled")
1109 },
1110 },
1111 )
1112 })
1113 .collect(),
1114 unchanged_shared_objects: transaction_effects_v1
1115 .unchanged_shared_objects
1116 .into_iter()
1117 .map(|obj| {
1118 (
1119 obj.object_id.into(),
1120 match obj.kind {
1121 UnchangedSharedKind::ReadOnlyRoot { version, digest } => {
1122 crate::effects::UnchangedSharedKind::ReadOnlyRoot((
1123 version.into(),
1124 digest.into(),
1125 ))
1126 }
1127 UnchangedSharedKind::MutateDeleted { version } => {
1128 crate::effects::UnchangedSharedKind::MutateDeleted(
1129 version.into(),
1130 )
1131 }
1132 UnchangedSharedKind::ReadDeleted { version } => {
1133 crate::effects::UnchangedSharedKind::ReadDeleted(
1134 version.into(),
1135 )
1136 }
1137 UnchangedSharedKind::Cancelled { version } => {
1138 crate::effects::UnchangedSharedKind::Cancelled(
1139 version.into(),
1140 )
1141 }
1142 UnchangedSharedKind::PerEpochConfig => {
1143 crate::effects::UnchangedSharedKind::PerEpochConfig
1144 }
1145 _ => unreachable!("a new enum variant was added and needs to be handled")
1146 },
1147 )
1148 })
1149 .collect(),
1150 aux_data_digest: transaction_effects_v1
1151 .auxiliary_data_digest
1152 .map(Into::into),
1153 }
1154 .into();
1155
1156 Ok(effects)
1157 }
1158 _ => unreachable!("a new enum variant was added and needs to be handled"),
1159 }
1160 }
1161}
1162
1163macro_rules! impl_convert_digest {
1164 ($name:ident) => {
1165 impl From<crate::digests::$name> for Digest {
1166 fn from(value: crate::digests::$name) -> Self {
1167 Self::new(value.into_inner())
1168 }
1169 }
1170
1171 impl From<Digest> for crate::digests::$name {
1172 fn from(value: Digest) -> Self {
1173 Self::new(value.into_inner())
1174 }
1175 }
1176 };
1177}
1178
1179impl_convert_digest!(Digest);
1180impl_convert_digest!(ObjectDigest);
1181impl_convert_digest!(CheckpointDigest);
1182impl_convert_digest!(TransactionDigest);
1183impl_convert_digest!(TransactionEffectsDigest);
1184impl_convert_digest!(TransactionEventsDigest);
1185impl_convert_digest!(CheckpointContentsDigest);
1186impl_convert_digest!(ConsensusCommitDigest);
1187impl_convert_digest!(EffectsAuxDataDigest);
1188
1189impl From<crate::execution_status::ExecutionStatus> for ExecutionStatus {
1190 fn from(value: crate::execution_status::ExecutionStatus) -> Self {
1191 match value {
1192 crate::execution_status::ExecutionStatus::Success => Self::Success,
1193 crate::execution_status::ExecutionStatus::Failure { error, command } => Self::Failure {
1194 error: error.into(),
1195 command: command.map(|v| v as u64),
1196 },
1197 }
1198 }
1199}
1200
1201impl From<ExecutionStatus> for crate::execution_status::ExecutionStatus {
1202 fn from(value: ExecutionStatus) -> Self {
1203 match value {
1204 ExecutionStatus::Success => Self::Success,
1205 ExecutionStatus::Failure { error, command } => Self::Failure {
1206 error: error.into(),
1207 command: command.map(|v| v as usize),
1208 },
1209 _ => unreachable!("a new enum variant was added and needs to be handled"),
1210 }
1211 }
1212}
1213
1214impl From<crate::execution_status::ExecutionFailureStatus> for ExecutionError {
1215 fn from(value: crate::execution_status::ExecutionFailureStatus) -> Self {
1216 use crate::execution_status::ExecutionFailureStatus;
1217 match value {
1218 ExecutionFailureStatus::InsufficientGas => Self::InsufficientGas,
1219 ExecutionFailureStatus::InvalidGasObject => Self::InvalidGasObject,
1220 ExecutionFailureStatus::InvariantViolation => Self::InvariantViolation,
1221 ExecutionFailureStatus::FeatureNotYetSupported => Self::FeatureNotYetSupported,
1222 ExecutionFailureStatus::MoveObjectTooBig {
1223 object_size,
1224 max_object_size,
1225 } => Self::ObjectTooBig {
1226 object_size,
1227 max_object_size,
1228 },
1229 ExecutionFailureStatus::MovePackageTooBig {
1230 object_size,
1231 max_object_size,
1232 } => Self::PackageTooBig {
1233 object_size,
1234 max_object_size,
1235 },
1236 ExecutionFailureStatus::CircularObjectOwnership { object } => {
1237 Self::CircularObjectOwnership {
1238 object: object.into(),
1239 }
1240 }
1241 ExecutionFailureStatus::InsufficientCoinBalance => Self::InsufficientCoinBalance,
1242 ExecutionFailureStatus::CoinBalanceOverflow => Self::CoinBalanceOverflow,
1243 ExecutionFailureStatus::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
1244 ExecutionFailureStatus::IotaMoveVerificationError => Self::IotaMoveVerificationError,
1245 ExecutionFailureStatus::MovePrimitiveRuntimeError(move_location_opt) => {
1246 Self::MovePrimitiveRuntimeError {
1247 location: move_location_opt.0.map(Into::into),
1248 }
1249 }
1250 ExecutionFailureStatus::MoveAbort(move_location, code) => Self::MoveAbort {
1251 location: move_location.into(),
1252 code,
1253 },
1254 ExecutionFailureStatus::VMVerificationOrDeserializationError => {
1255 Self::VmVerificationOrDeserializationError
1256 }
1257 ExecutionFailureStatus::VMInvariantViolation => Self::VmInvariantViolation,
1258 ExecutionFailureStatus::FunctionNotFound => Self::FunctionNotFound,
1259 ExecutionFailureStatus::ArityMismatch => Self::ArityMismatch,
1260 ExecutionFailureStatus::TypeArityMismatch => Self::TypeArityMismatch,
1261 ExecutionFailureStatus::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
1262 ExecutionFailureStatus::CommandArgumentError { arg_idx, kind } => {
1263 use crate::execution_status::CommandArgumentError as InternalCmdArgErr;
1264 Self::CommandArgumentError {
1265 argument: arg_idx,
1266 kind: match kind {
1267 InternalCmdArgErr::TypeMismatch => CommandArgumentError::TypeMismatch,
1268 InternalCmdArgErr::InvalidBCSBytes => CommandArgumentError::InvalidBcsBytes,
1269 InternalCmdArgErr::InvalidUsageOfPureArg => {
1270 CommandArgumentError::InvalidUsageOfPureArgument
1271 }
1272 InternalCmdArgErr::InvalidArgumentToPrivateEntryFunction => {
1273 CommandArgumentError::InvalidArgumentToPrivateEntryFunction
1274 }
1275 InternalCmdArgErr::IndexOutOfBounds { idx } => {
1276 CommandArgumentError::IndexOutOfBounds { index: idx }
1277 }
1278 InternalCmdArgErr::SecondaryIndexOutOfBounds {
1279 result_idx,
1280 secondary_idx,
1281 } => CommandArgumentError::SecondaryIndexOutOfBounds {
1282 result: result_idx,
1283 subresult: secondary_idx,
1284 },
1285 InternalCmdArgErr::InvalidResultArity { result_idx } => {
1286 CommandArgumentError::InvalidResultArity { result: result_idx }
1287 }
1288 InternalCmdArgErr::InvalidGasCoinUsage => {
1289 CommandArgumentError::InvalidGasCoinUsage
1290 }
1291 InternalCmdArgErr::InvalidValueUsage => {
1292 CommandArgumentError::InvalidValueUsage
1293 }
1294 InternalCmdArgErr::InvalidObjectByValue => {
1295 CommandArgumentError::InvalidObjectByValue
1296 }
1297 InternalCmdArgErr::InvalidObjectByMutRef => {
1298 CommandArgumentError::InvalidObjectByMutRef
1299 }
1300 InternalCmdArgErr::SharedObjectOperationNotAllowed => {
1301 CommandArgumentError::SharedObjectOperationNotAllowed
1302 }
1303 InternalCmdArgErr::InvalidArgumentArity => {
1304 CommandArgumentError::InvalidArgumentArity
1305 }
1306 },
1307 }
1308 }
1309 ExecutionFailureStatus::TypeArgumentError { argument_idx, kind } => {
1310 use crate::execution_status::TypeArgumentError as InternalTypeArgErr;
1311 Self::TypeArgumentError {
1312 type_argument: argument_idx,
1313 kind: match kind {
1314 InternalTypeArgErr::TypeNotFound => TypeArgumentError::TypeNotFound,
1315 InternalTypeArgErr::ConstraintNotSatisfied => {
1316 TypeArgumentError::ConstraintNotSatisfied
1317 }
1318 },
1319 }
1320 }
1321 ExecutionFailureStatus::UnusedValueWithoutDrop {
1322 result_idx,
1323 secondary_idx,
1324 } => Self::UnusedValueWithoutDrop {
1325 result: result_idx,
1326 subresult: secondary_idx,
1327 },
1328 ExecutionFailureStatus::InvalidPublicFunctionReturnType { idx } => {
1329 Self::InvalidPublicFunctionReturnType { index: idx }
1330 }
1331 ExecutionFailureStatus::InvalidTransferObject => Self::InvalidTransferObject,
1332 ExecutionFailureStatus::EffectsTooLarge {
1333 current_size,
1334 max_size,
1335 } => Self::EffectsTooLarge {
1336 current_size,
1337 max_size,
1338 },
1339 ExecutionFailureStatus::PublishUpgradeMissingDependency => {
1340 Self::PublishUpgradeMissingDependency
1341 }
1342 ExecutionFailureStatus::PublishUpgradeDependencyDowngrade => {
1343 Self::PublishUpgradeDependencyDowngrade
1344 }
1345 ExecutionFailureStatus::PackageUpgradeError { upgrade_error } => {
1346 use crate::execution_status::PackageUpgradeError as InternalPkgUpgradeErr;
1347 Self::PackageUpgradeError {
1348 kind: match upgrade_error {
1349 InternalPkgUpgradeErr::UnableToFetchPackage { package_id } => {
1350 PackageUpgradeError::UnableToFetchPackage {
1351 package_id: package_id.into(),
1352 }
1353 }
1354 InternalPkgUpgradeErr::NotAPackage { object_id } => {
1355 PackageUpgradeError::NotAPackage {
1356 object_id: object_id.into(),
1357 }
1358 }
1359 InternalPkgUpgradeErr::IncompatibleUpgrade => {
1360 PackageUpgradeError::IncompatibleUpgrade
1361 }
1362 InternalPkgUpgradeErr::DigestDoesNotMatch { digest } => {
1363 PackageUpgradeError::DigestDoesNotMatch {
1364 digest: Digest::from_bytes(digest).expect("invalid digest bytes"),
1365 }
1366 }
1367 InternalPkgUpgradeErr::UnknownUpgradePolicy { policy } => {
1368 PackageUpgradeError::UnknownUpgradePolicy { policy }
1369 }
1370 InternalPkgUpgradeErr::PackageIDDoesNotMatch {
1371 package_id,
1372 ticket_id,
1373 } => PackageUpgradeError::PackageIdDoesNotMatch {
1374 package_id: package_id.into(),
1375 ticket_id: ticket_id.into(),
1376 },
1377 },
1378 }
1379 }
1380 ExecutionFailureStatus::WrittenObjectsTooLarge {
1381 current_size,
1382 max_size,
1383 } => Self::WrittenObjectsTooLarge {
1384 object_size: current_size,
1385 max_object_size: max_size,
1386 },
1387 ExecutionFailureStatus::CertificateDenied => Self::CertificateDenied,
1388 ExecutionFailureStatus::IotaMoveVerificationTimeout => {
1389 Self::IotaMoveVerificationTimeout
1390 }
1391 ExecutionFailureStatus::SharedObjectOperationNotAllowed => {
1392 Self::SharedObjectOperationNotAllowed
1393 }
1394 ExecutionFailureStatus::InputObjectDeleted => Self::InputObjectDeleted,
1395 ExecutionFailureStatus::ExecutionCancelledDueToSharedObjectCongestion {
1396 congested_objects,
1397 } => Self::ExecutionCancelledDueToSharedObjectCongestion {
1398 congested_objects: congested_objects.0.into_iter().map(Into::into).collect(),
1399 },
1400 ExecutionFailureStatus::AddressDeniedForCoin { address, coin_type } => {
1401 Self::AddressDeniedForCoin {
1402 address: address.into(),
1403 coin_type,
1404 }
1405 }
1406 ExecutionFailureStatus::CoinTypeGlobalPause { coin_type } => {
1407 Self::CoinTypeGlobalPause { coin_type }
1408 }
1409 ExecutionFailureStatus::ExecutionCancelledDueToRandomnessUnavailable => {
1410 Self::ExecutionCancelledDueToRandomnessUnavailable
1411 }
1412 ExecutionFailureStatus::ExecutionCancelledDueToSharedObjectCongestionV2 {
1413 congested_objects,
1414 suggested_gas_price,
1415 } => Self::ExecutionCancelledDueToSharedObjectCongestionV2 {
1416 congested_objects: congested_objects.0.into_iter().map(Into::into).collect(),
1417 suggested_gas_price,
1418 },
1419 ExecutionFailureStatus::InvalidLinkage => Self::InvalidLinkage,
1420 }
1421 }
1422}
1423
1424impl From<ExecutionError> for crate::execution_status::ExecutionFailureStatus {
1425 fn from(value: ExecutionError) -> Self {
1426 match value {
1427 ExecutionError::InsufficientGas => Self::InsufficientGas,
1428 ExecutionError::InvalidGasObject => Self::InvalidGasObject,
1429 ExecutionError::InvariantViolation => Self::InvariantViolation,
1430 ExecutionError::FeatureNotYetSupported => Self::FeatureNotYetSupported,
1431 ExecutionError::ObjectTooBig {
1432 object_size,
1433 max_object_size,
1434 } => Self::MoveObjectTooBig {
1435 object_size,
1436 max_object_size,
1437 },
1438 ExecutionError::PackageTooBig {
1439 object_size,
1440 max_object_size,
1441 } => Self::MovePackageTooBig {
1442 object_size,
1443 max_object_size,
1444 },
1445 ExecutionError::CircularObjectOwnership { object } => Self::CircularObjectOwnership {
1446 object: object.into(),
1447 },
1448 ExecutionError::InsufficientCoinBalance => Self::InsufficientCoinBalance,
1449 ExecutionError::CoinBalanceOverflow => Self::CoinBalanceOverflow,
1450 ExecutionError::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
1451 ExecutionError::IotaMoveVerificationError => Self::IotaMoveVerificationError,
1452 ExecutionError::MovePrimitiveRuntimeError { location } => {
1453 Self::MovePrimitiveRuntimeError(crate::execution_status::MoveLocationOpt(
1454 location.map(Into::into),
1455 ))
1456 }
1457 ExecutionError::MoveAbort { location, code } => Self::MoveAbort(location.into(), code),
1458 ExecutionError::VmVerificationOrDeserializationError => {
1459 Self::VMVerificationOrDeserializationError
1460 }
1461 ExecutionError::VmInvariantViolation => Self::VMInvariantViolation,
1462 ExecutionError::FunctionNotFound => Self::FunctionNotFound,
1463 ExecutionError::ArityMismatch => Self::ArityMismatch,
1464 ExecutionError::TypeArityMismatch => Self::TypeArityMismatch,
1465 ExecutionError::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
1466 ExecutionError::CommandArgumentError { argument, kind } => {
1467 use crate::execution_status::CommandArgumentError as InternalCmdArgErr;
1468 Self::CommandArgumentError {
1469 arg_idx: argument,
1470 kind: match kind {
1471 CommandArgumentError::TypeMismatch => InternalCmdArgErr::TypeMismatch,
1472 CommandArgumentError::InvalidBcsBytes => InternalCmdArgErr::InvalidBCSBytes,
1473 CommandArgumentError::InvalidUsageOfPureArgument => {
1474 InternalCmdArgErr::InvalidUsageOfPureArg
1475 }
1476 CommandArgumentError::InvalidArgumentToPrivateEntryFunction => {
1477 InternalCmdArgErr::InvalidArgumentToPrivateEntryFunction
1478 }
1479 CommandArgumentError::IndexOutOfBounds { index } => {
1480 InternalCmdArgErr::IndexOutOfBounds { idx: index }
1481 }
1482 CommandArgumentError::SecondaryIndexOutOfBounds { result, subresult } => {
1483 InternalCmdArgErr::SecondaryIndexOutOfBounds {
1484 result_idx: result,
1485 secondary_idx: subresult,
1486 }
1487 }
1488 CommandArgumentError::InvalidResultArity { result } => {
1489 InternalCmdArgErr::InvalidResultArity { result_idx: result }
1490 }
1491 CommandArgumentError::InvalidGasCoinUsage => {
1492 InternalCmdArgErr::InvalidGasCoinUsage
1493 }
1494 CommandArgumentError::InvalidValueUsage => {
1495 InternalCmdArgErr::InvalidValueUsage
1496 }
1497 CommandArgumentError::InvalidObjectByValue => {
1498 InternalCmdArgErr::InvalidObjectByValue
1499 }
1500 CommandArgumentError::InvalidObjectByMutRef => {
1501 InternalCmdArgErr::InvalidObjectByMutRef
1502 }
1503 CommandArgumentError::SharedObjectOperationNotAllowed => {
1504 InternalCmdArgErr::SharedObjectOperationNotAllowed
1505 }
1506 CommandArgumentError::InvalidArgumentArity => {
1507 InternalCmdArgErr::InvalidArgumentArity
1508 }
1509 _ => unreachable!("a new enum variant was added and needs to be handled"),
1510 },
1511 }
1512 }
1513 ExecutionError::TypeArgumentError {
1514 type_argument,
1515 kind,
1516 } => {
1517 use crate::execution_status::TypeArgumentError as InternalTypeArgErr;
1518 Self::TypeArgumentError {
1519 argument_idx: type_argument,
1520 kind: match kind {
1521 TypeArgumentError::TypeNotFound => InternalTypeArgErr::TypeNotFound,
1522 TypeArgumentError::ConstraintNotSatisfied => {
1523 InternalTypeArgErr::ConstraintNotSatisfied
1524 }
1525 _ => unreachable!("a new enum variant was added and needs to be handled"),
1526 },
1527 }
1528 }
1529 ExecutionError::UnusedValueWithoutDrop { result, subresult } => {
1530 Self::UnusedValueWithoutDrop {
1531 result_idx: result,
1532 secondary_idx: subresult,
1533 }
1534 }
1535 ExecutionError::InvalidPublicFunctionReturnType { index } => {
1536 Self::InvalidPublicFunctionReturnType { idx: index }
1537 }
1538 ExecutionError::InvalidTransferObject => Self::InvalidTransferObject,
1539 ExecutionError::EffectsTooLarge {
1540 current_size,
1541 max_size,
1542 } => Self::EffectsTooLarge {
1543 current_size,
1544 max_size,
1545 },
1546 ExecutionError::PublishUpgradeMissingDependency => {
1547 Self::PublishUpgradeMissingDependency
1548 }
1549 ExecutionError::PublishUpgradeDependencyDowngrade => {
1550 Self::PublishUpgradeDependencyDowngrade
1551 }
1552 ExecutionError::PackageUpgradeError { kind } => {
1553 use crate::execution_status::PackageUpgradeError as InternalPkgUpgradeErr;
1554 Self::PackageUpgradeError {
1555 upgrade_error: match kind {
1556 PackageUpgradeError::UnableToFetchPackage { package_id } => {
1557 InternalPkgUpgradeErr::UnableToFetchPackage {
1558 package_id: package_id.into(),
1559 }
1560 }
1561 PackageUpgradeError::NotAPackage { object_id } => {
1562 InternalPkgUpgradeErr::NotAPackage {
1563 object_id: object_id.into(),
1564 }
1565 }
1566 PackageUpgradeError::IncompatibleUpgrade => {
1567 InternalPkgUpgradeErr::IncompatibleUpgrade
1568 }
1569 PackageUpgradeError::DigestDoesNotMatch { digest } => {
1570 InternalPkgUpgradeErr::DigestDoesNotMatch {
1571 digest: digest.as_bytes().to_vec(),
1572 }
1573 }
1574 PackageUpgradeError::UnknownUpgradePolicy { policy } => {
1575 InternalPkgUpgradeErr::UnknownUpgradePolicy { policy }
1576 }
1577 PackageUpgradeError::PackageIdDoesNotMatch {
1578 package_id,
1579 ticket_id,
1580 } => InternalPkgUpgradeErr::PackageIDDoesNotMatch {
1581 package_id: package_id.into(),
1582 ticket_id: ticket_id.into(),
1583 },
1584 _ => unreachable!("a new enum variant was added and needs to be handled"),
1585 },
1586 }
1587 }
1588 ExecutionError::WrittenObjectsTooLarge {
1589 object_size,
1590 max_object_size,
1591 } => Self::WrittenObjectsTooLarge {
1592 current_size: object_size,
1593 max_size: max_object_size,
1594 },
1595 ExecutionError::CertificateDenied => Self::CertificateDenied,
1596 ExecutionError::IotaMoveVerificationTimeout => Self::IotaMoveVerificationTimeout,
1597 ExecutionError::SharedObjectOperationNotAllowed => {
1598 Self::SharedObjectOperationNotAllowed
1599 }
1600 ExecutionError::InputObjectDeleted => Self::InputObjectDeleted,
1601 ExecutionError::ExecutionCancelledDueToSharedObjectCongestion { congested_objects } => {
1602 Self::ExecutionCancelledDueToSharedObjectCongestion {
1603 congested_objects: crate::execution_status::CongestedObjects(
1604 congested_objects.into_iter().map(Into::into).collect(),
1605 ),
1606 }
1607 }
1608 ExecutionError::AddressDeniedForCoin { address, coin_type } => {
1609 Self::AddressDeniedForCoin {
1610 address: address.into(),
1611 coin_type,
1612 }
1613 }
1614 ExecutionError::CoinTypeGlobalPause { coin_type } => {
1615 Self::CoinTypeGlobalPause { coin_type }
1616 }
1617 ExecutionError::ExecutionCancelledDueToRandomnessUnavailable => {
1618 Self::ExecutionCancelledDueToRandomnessUnavailable
1619 }
1620 ExecutionError::ExecutionCancelledDueToSharedObjectCongestionV2 {
1621 congested_objects,
1622 suggested_gas_price,
1623 } => Self::ExecutionCancelledDueToSharedObjectCongestionV2 {
1624 congested_objects: crate::execution_status::CongestedObjects(
1625 congested_objects.into_iter().map(Into::into).collect(),
1626 ),
1627 suggested_gas_price,
1628 },
1629 ExecutionError::InvalidLinkage => Self::InvalidLinkage,
1630 _ => unreachable!("a new enum variant was added and needs to be handled"),
1631 }
1632 }
1633}
1634
1635impl From<crate::execution_status::MoveLocation> for MoveLocation {
1636 fn from(value: crate::execution_status::MoveLocation) -> Self {
1637 Self {
1638 package: ObjectId::new(value.module.address().into_bytes()),
1639 module: Identifier::new(value.module.name().as_str()).expect("invalid module name"),
1640 function: value.function,
1641 instruction: value.instruction,
1642 function_name: value
1643 .function_name
1644 .map(|name| Identifier::new(name).expect("invalid function name")),
1645 }
1646 }
1647}
1648
1649impl From<MoveLocation> for crate::execution_status::MoveLocation {
1650 fn from(value: MoveLocation) -> Self {
1651 Self {
1652 module: ModuleId::new(
1653 move_core_types::account_address::AccountAddress::new(value.package.into_inner()),
1654 crate::Identifier::new(value.module.as_str()).expect("invalid module name"),
1655 ),
1656 function: value.function,
1657 instruction: value.instruction,
1658 function_name: value.function_name.map(|name| name.to_string()),
1659 }
1660 }
1661}
1662
1663impl TryFrom<crate::messages_checkpoint::CheckpointContents> for CheckpointContents {
1664 type Error = SdkTypeConversionError;
1665
1666 fn try_from(
1667 value: crate::messages_checkpoint::CheckpointContents,
1668 ) -> Result<Self, Self::Error> {
1669 Self(
1670 value
1671 .into_iter_with_signatures()
1672 .map(|(digests, signatures)| {
1673 let signatures_result = signatures
1674 .into_iter()
1675 .map(TryInto::try_into)
1676 .collect::<Result<Vec<UserSignature>, _>>();
1677
1678 match signatures_result {
1679 Ok(signatures) => Ok(CheckpointTransactionInfo {
1680 transaction: digests.transaction.into(),
1681 effects: digests.effects.into(),
1682 signatures,
1683 }),
1684 Err(e) => Err(SdkTypeConversionError::from(e)),
1685 }
1686 })
1687 .collect::<Result<Vec<_>, _>>()?,
1688 )
1689 .pipe(Ok)
1690 }
1691}
1692
1693impl TryFrom<CheckpointContents> for crate::messages_checkpoint::CheckpointContents {
1694 type Error = SdkTypeConversionError;
1695
1696 fn try_from(value: CheckpointContents) -> Result<Self, Self::Error> {
1697 let (transactions, user_signatures) = value.0.into_iter().fold(
1698 (Vec::new(), Vec::new()),
1699 |(mut transactions, mut user_signatures), info| {
1700 transactions.push(crate::base_types::ExecutionDigests {
1701 transaction: info.transaction.into(),
1702 effects: info.effects.into(),
1703 });
1704 user_signatures.push(
1705 info.signatures
1706 .into_iter()
1707 .map(TryInto::try_into)
1708 .collect::<Result<_, _>>(),
1709 );
1710 (transactions, user_signatures)
1711 },
1712 );
1713 crate::messages_checkpoint::CheckpointContents::new_with_digests_and_signatures(
1714 transactions,
1715 user_signatures.into_iter().collect::<Result<Vec<_>, _>>()?,
1716 )
1717 .pipe(Ok)
1718 }
1719}
1720
1721impl TryFrom<crate::full_checkpoint_content::CheckpointData> for CheckpointData {
1722 type Error = SdkTypeConversionError;
1723
1724 fn try_from(
1725 value: crate::full_checkpoint_content::CheckpointData,
1726 ) -> Result<Self, Self::Error> {
1727 Self {
1728 checkpoint_summary: value.checkpoint_summary.try_into()?,
1729 checkpoint_contents: value.checkpoint_contents.try_into()?,
1730 transactions: value
1731 .transactions
1732 .into_iter()
1733 .map(TryInto::try_into)
1734 .collect::<Result<_, _>>()?,
1735 }
1736 .pipe(Ok)
1737 }
1738}
1739
1740impl TryFrom<CheckpointData> for crate::full_checkpoint_content::CheckpointData {
1741 type Error = SdkTypeConversionError;
1742
1743 fn try_from(value: CheckpointData) -> Result<Self, Self::Error> {
1744 Self {
1745 checkpoint_summary: value.checkpoint_summary.try_into()?,
1746 checkpoint_contents: value.checkpoint_contents.try_into()?,
1747 transactions: value
1748 .transactions
1749 .into_iter()
1750 .map(TryInto::try_into)
1751 .collect::<Result<_, _>>()?,
1752 }
1753 .pipe(Ok)
1754 }
1755}
1756
1757impl TryFrom<crate::full_checkpoint_content::CheckpointTransaction> for CheckpointTransaction {
1758 type Error = SdkTypeConversionError;
1759
1760 fn try_from(
1761 value: crate::full_checkpoint_content::CheckpointTransaction,
1762 ) -> Result<Self, Self::Error> {
1763 let input_objects = value
1764 .input_objects
1765 .into_iter()
1766 .map(TryInto::try_into)
1767 .collect::<Result<_, _>>();
1768 let output_objects = value
1769 .output_objects
1770 .into_iter()
1771 .map(TryInto::try_into)
1772 .collect::<Result<_, _>>();
1773 match (input_objects, output_objects) {
1774 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1775 transaction: value.transaction.try_into()?,
1776 effects: value.effects.try_into()?,
1777 events: value.events.map(TryInto::try_into).transpose()?,
1778 input_objects,
1779 output_objects,
1780 }),
1781 (Err(e), _) | (_, Err(e)) => Err(e),
1782 }
1783 }
1784}
1785
1786impl TryFrom<CheckpointTransaction> for crate::full_checkpoint_content::CheckpointTransaction {
1787 type Error = SdkTypeConversionError;
1788
1789 fn try_from(value: CheckpointTransaction) -> Result<Self, Self::Error> {
1790 let input_objects = value
1791 .input_objects
1792 .into_iter()
1793 .map(TryInto::try_into)
1794 .collect::<Result<_, _>>();
1795 let output_objects = value
1796 .output_objects
1797 .into_iter()
1798 .map(TryInto::try_into)
1799 .collect::<Result<_, _>>();
1800
1801 match (input_objects, output_objects) {
1802 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1803 transaction: value.transaction.try_into()?,
1804 effects: value.effects.try_into()?,
1805 events: value.events.map(TryInto::try_into).transpose()?,
1806 input_objects,
1807 output_objects,
1808 }),
1809 (Err(e), _) | (_, Err(e)) => Err(e),
1810 }
1811 }
1812}
1813
1814impl TryFrom<crate::signature::GenericSignature> for UserSignature {
1815 type Error = bcs::Error;
1816
1817 fn try_from(value: crate::signature::GenericSignature) -> Result<Self, Self::Error> {
1818 bcs::from_bytes(&bcs::to_bytes(&value)?)
1819 }
1820}
1821
1822impl TryFrom<UserSignature> for crate::signature::GenericSignature {
1823 type Error = bcs::Error;
1824
1825 fn try_from(value: UserSignature) -> Result<Self, Self::Error> {
1826 bcs::from_bytes(&bcs::to_bytes(&value)?)
1827 }
1828}
1829
1830impl TryFrom<crate::effects::TransactionEvents> for TransactionEvents {
1831 type Error = SdkTypeConversionError;
1832
1833 fn try_from(value: crate::effects::TransactionEvents) -> Result<Self, Self::Error> {
1834 Self(
1835 value
1836 .data
1837 .into_iter()
1838 .map(TryInto::try_into)
1839 .collect::<Result<Vec<_>, _>>()?,
1840 )
1841 .pipe(Ok)
1842 }
1843}
1844
1845impl TryFrom<TransactionEvents> for crate::effects::TransactionEvents {
1846 type Error = SdkTypeConversionError;
1847
1848 fn try_from(value: TransactionEvents) -> Result<Self, Self::Error> {
1849 Self {
1850 data: value
1851 .0
1852 .into_iter()
1853 .map(TryInto::try_into)
1854 .collect::<Result<_, _>>()?,
1855 }
1856 .pipe(Ok)
1857 }
1858}
1859
1860impl TryFrom<crate::event::Event> for Event {
1861 type Error = SdkTypeConversionError;
1862
1863 fn try_from(value: crate::event::Event) -> Result<Self, Self::Error> {
1864 Self {
1865 package_id: value.package_id.into(),
1866 module: Identifier::new(value.transaction_module.as_str())?,
1867 sender: value.sender.into(),
1868 type_: struct_tag_core_to_sdk(value.type_)?,
1869 contents: value.contents,
1870 }
1871 .pipe(Ok)
1872 }
1873}
1874
1875impl TryFrom<Event> for crate::event::Event {
1876 type Error = SdkTypeConversionError;
1877
1878 fn try_from(value: Event) -> Result<Self, Self::Error> {
1879 Self {
1880 package_id: value.package_id.into(),
1881 transaction_module: crate::Identifier::new(value.module.as_str())?,
1882 sender: value.sender.into(),
1883 type_: struct_tag_sdk_to_core(&value.type_)?,
1884 contents: value.contents,
1885 }
1886 .pipe(Ok)
1887 }
1888}
1889
1890impl TryFrom<crate::transaction::Command> for Command {
1891 type Error = SdkTypeConversionError;
1892
1893 fn try_from(value: crate::transaction::Command) -> Result<Self, Self::Error> {
1894 use crate::transaction::Command as InternalCmd;
1895 match value {
1896 InternalCmd::MoveCall(programmable_move_call) => Self::MoveCall(MoveCall {
1897 package: programmable_move_call.package.into(),
1898 module: Identifier::new(programmable_move_call.module.as_str())?,
1899 function: Identifier::new(programmable_move_call.function.as_str())?,
1900 type_arguments: programmable_move_call
1901 .type_arguments
1902 .into_iter()
1903 .map(|type_input| {
1904 type_input
1905 .into_type_tag()
1906 .map_err(|err| err.into())
1907 .and_then(type_tag_core_to_sdk)
1908 })
1909 .collect::<Result<_, _>>()?,
1910 arguments: programmable_move_call
1911 .arguments
1912 .into_iter()
1913 .map(Into::into)
1914 .collect(),
1915 }),
1916 InternalCmd::TransferObjects(objects, address) => {
1917 Self::TransferObjects(TransferObjects {
1918 objects: objects.into_iter().map(Into::into).collect(),
1919 address: address.into(),
1920 })
1921 }
1922 InternalCmd::SplitCoins(coin, amounts) => Self::SplitCoins(SplitCoins {
1923 coin: coin.into(),
1924 amounts: amounts.into_iter().map(Into::into).collect(),
1925 }),
1926 InternalCmd::MergeCoins(argument, coins_to_merge) => Self::MergeCoins(MergeCoins {
1927 coin: argument.into(),
1928 coins_to_merge: coins_to_merge.into_iter().map(Into::into).collect(),
1929 }),
1930 InternalCmd::Publish(modules, dependencies) => Self::Publish(Publish {
1931 modules,
1932 dependencies: dependencies.into_iter().map(Into::into).collect(),
1933 }),
1934 InternalCmd::MakeMoveVec(type_tag, elements) => Self::MakeMoveVector(MakeMoveVector {
1935 type_: type_tag
1936 .map(|type_input| {
1937 type_input
1938 .into_type_tag()
1939 .map_err(|err| err.into())
1940 .and_then(type_tag_core_to_sdk)
1941 })
1942 .transpose()?,
1943 elements: elements.into_iter().map(Into::into).collect(),
1944 }),
1945 InternalCmd::Upgrade(modules, dependencies, package, ticket) => {
1946 Self::Upgrade(Upgrade {
1947 modules,
1948 dependencies: dependencies.into_iter().map(Into::into).collect(),
1949 package: package.into(),
1950 ticket: ticket.into(),
1951 })
1952 }
1953 }
1954 .pipe(Ok)
1955 }
1956}
1957
1958impl TryFrom<Command> for crate::transaction::Command {
1959 type Error = SdkTypeConversionError;
1960
1961 fn try_from(value: Command) -> Result<Self, Self::Error> {
1962 match value {
1963 Command::MoveCall(move_call) => Self::move_call(
1964 move_call.package.into(),
1965 crate::Identifier::new(move_call.module.as_str())
1966 .expect("invalid move call module identifier"),
1967 crate::Identifier::new(move_call.function.as_str())
1968 .expect("invalid move call function identifier"),
1969 move_call
1970 .type_arguments
1971 .iter()
1972 .map(type_tag_sdk_to_core)
1973 .collect::<Result<_, _>>()?,
1974 move_call.arguments.into_iter().map(Into::into).collect(),
1975 ),
1976 Command::TransferObjects(transfer_objects) => Self::TransferObjects(
1977 transfer_objects
1978 .objects
1979 .into_iter()
1980 .map(Into::into)
1981 .collect(),
1982 transfer_objects.address.into(),
1983 ),
1984 Command::SplitCoins(split_coins) => Self::SplitCoins(
1985 split_coins.coin.into(),
1986 split_coins.amounts.into_iter().map(Into::into).collect(),
1987 ),
1988 Command::MergeCoins(merge_coins) => Self::MergeCoins(
1989 merge_coins.coin.into(),
1990 merge_coins
1991 .coins_to_merge
1992 .into_iter()
1993 .map(Into::into)
1994 .collect(),
1995 ),
1996 Command::Publish(publish) => Self::Publish(
1997 publish.modules,
1998 publish.dependencies.into_iter().map(Into::into).collect(),
1999 ),
2000 Command::MakeMoveVector(make_move_vector) => Self::make_move_vec(
2001 make_move_vector
2002 .type_
2003 .as_ref()
2004 .map(type_tag_sdk_to_core)
2005 .transpose()?,
2006 make_move_vector
2007 .elements
2008 .into_iter()
2009 .map(Into::into)
2010 .collect(),
2011 ),
2012 Command::Upgrade(upgrade) => Self::Upgrade(
2013 upgrade.modules,
2014 upgrade.dependencies.into_iter().map(Into::into).collect(),
2015 upgrade.package.into(),
2016 upgrade.ticket.into(),
2017 ),
2018 _ => unreachable!("a new enum variant was added and needs to be handled"),
2019 }
2020 .pipe(Ok)
2021 }
2022}
2023
2024impl From<crate::transaction::Argument> for Argument {
2025 fn from(value: crate::transaction::Argument) -> Self {
2026 match value {
2027 crate::transaction::Argument::GasCoin => Self::Gas,
2028 crate::transaction::Argument::Input(idx) => Self::Input(idx),
2029 crate::transaction::Argument::Result(idx) => Self::Result(idx),
2030 crate::transaction::Argument::NestedResult(idx1, idx2) => {
2031 Self::NestedResult(idx1, idx2)
2032 }
2033 }
2034 }
2035}
2036
2037impl From<Argument> for crate::transaction::Argument {
2038 fn from(value: Argument) -> Self {
2039 match value {
2040 Argument::Gas => Self::GasCoin,
2041 Argument::Input(idx) => Self::Input(idx),
2042 Argument::Result(idx) => Self::Result(idx),
2043 Argument::NestedResult(idx1, idx2) => Self::NestedResult(idx1, idx2),
2044 _ => unreachable!("a new enum variant was added and needs to be handled"),
2045 }
2046 }
2047}
2048
2049impl From<crate::gas::GasCostSummary> for GasCostSummary {
2050 fn from(value: crate::gas::GasCostSummary) -> Self {
2051 Self::new(
2052 value.computation_cost,
2053 value.computation_cost_burned,
2054 value.storage_cost,
2055 value.storage_rebate,
2056 value.non_refundable_storage_fee,
2057 )
2058 }
2059}
2060
2061impl From<GasCostSummary> for crate::gas::GasCostSummary {
2062 fn from(value: GasCostSummary) -> Self {
2063 Self::new(
2064 value.computation_cost,
2065 value.computation_cost_burned,
2066 value.storage_cost,
2067 value.storage_rebate,
2068 value.non_refundable_storage_fee,
2069 )
2070 }
2071}
2072
2073impl From<crate::messages_checkpoint::EndOfEpochData> for EndOfEpochData {
2074 fn from(value: crate::messages_checkpoint::EndOfEpochData) -> Self {
2075 Self {
2076 next_epoch_committee: value
2077 .next_epoch_committee
2078 .into_iter()
2079 .map(|(public_key, stake)| ValidatorCommitteeMember {
2080 public_key: Bls12381PublicKey::new(public_key.0),
2081 stake,
2082 })
2083 .collect(),
2084 next_epoch_protocol_version: value.next_epoch_protocol_version.as_u64(),
2085 epoch_commitments: value
2086 .epoch_commitments
2087 .into_iter()
2088 .map(Into::into)
2089 .collect(),
2090 epoch_supply_change: value.epoch_supply_change,
2091 }
2092 }
2093}
2094
2095impl From<EndOfEpochData> for crate::messages_checkpoint::EndOfEpochData {
2096 fn from(value: EndOfEpochData) -> Self {
2097 Self {
2098 next_epoch_committee: value
2099 .next_epoch_committee
2100 .into_iter()
2101 .map(|v| (v.public_key.into(), v.stake))
2102 .collect(),
2103 next_epoch_protocol_version: value.next_epoch_protocol_version.into(),
2104 epoch_commitments: value
2105 .epoch_commitments
2106 .into_iter()
2107 .map(Into::into)
2108 .collect(),
2109 epoch_supply_change: value.epoch_supply_change,
2110 }
2111 }
2112}
2113
2114impl From<crate::messages_checkpoint::CheckpointCommitment> for CheckpointCommitment {
2115 fn from(value: crate::messages_checkpoint::CheckpointCommitment) -> Self {
2116 let crate::messages_checkpoint::CheckpointCommitment::ECMHLiveObjectSetDigest(digest) =
2117 value;
2118 Self::EcmhLiveObjectSet {
2119 digest: Digest::new(digest.digest.into_inner()),
2120 }
2121 }
2122}
2123
2124impl From<CheckpointCommitment> for crate::messages_checkpoint::CheckpointCommitment {
2125 fn from(value: CheckpointCommitment) -> Self {
2126 let CheckpointCommitment::EcmhLiveObjectSet { digest } = value else {
2127 unreachable!("a new enum variant was added and needs to be handled");
2128 };
2129 Self::ECMHLiveObjectSetDigest(crate::messages_checkpoint::ECMHLiveObjectSetDigest {
2130 digest: crate::digests::Digest::new(digest.into_inner()),
2131 })
2132 }
2133}
2134
2135impl TryFrom<crate::messages_checkpoint::CheckpointSummary> for CheckpointSummary {
2136 type Error = SdkTypeConversionError;
2137
2138 fn try_from(value: crate::messages_checkpoint::CheckpointSummary) -> Result<Self, Self::Error> {
2139 Self {
2140 epoch: value.epoch,
2141 sequence_number: value.sequence_number,
2142 network_total_transactions: value.network_total_transactions,
2143 content_digest: value.content_digest.into(),
2144 previous_digest: value.previous_digest.map(Into::into),
2145 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
2146 timestamp_ms: value.timestamp_ms,
2147 checkpoint_commitments: value
2148 .checkpoint_commitments
2149 .into_iter()
2150 .map(Into::into)
2151 .collect(),
2152 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
2153 version_specific_data: value.version_specific_data,
2154 }
2155 .pipe(Ok)
2156 }
2157}
2158
2159impl TryFrom<CheckpointSummary> for crate::messages_checkpoint::CheckpointSummary {
2160 type Error = SdkTypeConversionError;
2161
2162 fn try_from(value: CheckpointSummary) -> Result<Self, Self::Error> {
2163 Self {
2164 epoch: value.epoch,
2165 sequence_number: value.sequence_number,
2166 network_total_transactions: value.network_total_transactions,
2167 content_digest: value.content_digest.into(),
2168 previous_digest: value.previous_digest.map(Into::into),
2169 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
2170 timestamp_ms: value.timestamp_ms,
2171 checkpoint_commitments: value
2172 .checkpoint_commitments
2173 .into_iter()
2174 .map(Into::into)
2175 .collect(),
2176 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
2177 version_specific_data: value.version_specific_data,
2178 }
2179 .pipe(Ok)
2180 }
2181}
2182
2183impl TryFrom<crate::messages_checkpoint::CertifiedCheckpointSummary> for SignedCheckpointSummary {
2184 type Error = SdkTypeConversionError;
2185
2186 fn try_from(
2187 value: crate::messages_checkpoint::CertifiedCheckpointSummary,
2188 ) -> Result<Self, Self::Error> {
2189 let (data, sig) = value.into_data_and_sig();
2190 Self {
2191 checkpoint: data.try_into()?,
2192 signature: sig.into(),
2193 }
2194 .pipe(Ok)
2195 }
2196}
2197
2198impl TryFrom<SignedCheckpointSummary> for crate::messages_checkpoint::CertifiedCheckpointSummary {
2199 type Error = SdkTypeConversionError;
2200
2201 fn try_from(value: SignedCheckpointSummary) -> Result<Self, Self::Error> {
2202 Self::new_from_data_and_sig(
2203 crate::messages_checkpoint::CheckpointSummary::try_from(value.checkpoint)?,
2204 crate::crypto::AuthorityQuorumSignInfo::<true>::from(value.signature),
2205 )
2206 .pipe(Ok)
2207 }
2208}
2209
2210impl<const T: bool> From<crate::crypto::AuthorityQuorumSignInfo<T>>
2211 for ValidatorAggregatedSignature
2212{
2213 fn from(value: crate::crypto::AuthorityQuorumSignInfo<T>) -> Self {
2214 let crate::crypto::AuthorityQuorumSignInfo {
2215 epoch,
2216 signature,
2217 signers_map,
2218 } = value;
2219
2220 Self {
2221 epoch,
2222 signature: Bls12381Signature::from_bytes(signature.as_ref()).unwrap(),
2223 bitmap: signers_map,
2224 }
2225 }
2226}
2227
2228impl<const T: bool> From<ValidatorAggregatedSignature>
2229 for crate::crypto::AuthorityQuorumSignInfo<T>
2230{
2231 fn from(value: ValidatorAggregatedSignature) -> Self {
2232 let ValidatorAggregatedSignature {
2233 epoch,
2234 signature,
2235 bitmap,
2236 } = value;
2237
2238 Self {
2239 epoch,
2240 signature: crate::crypto::AggregateAuthoritySignature::from_bytes(signature.as_bytes())
2241 .unwrap(),
2242 signers_map: bitmap,
2243 }
2244 }
2245}
2246
2247impl From<crate::object::Owner> for Owner {
2248 fn from(value: crate::object::Owner) -> Self {
2249 match value {
2250 crate::object::Owner::AddressOwner(address) => Self::Address(address.into()),
2251 crate::object::Owner::ObjectOwner(object_id) => Self::Object(object_id.into()),
2252 crate::object::Owner::Shared {
2253 initial_shared_version,
2254 } => Self::Shared(initial_shared_version.value()),
2255 crate::object::Owner::Immutable => Self::Immutable,
2256 }
2257 }
2258}
2259
2260impl From<Owner> for crate::object::Owner {
2261 fn from(value: Owner) -> Self {
2262 match value {
2263 Owner::Address(address) => crate::object::Owner::AddressOwner(address.into()),
2264 Owner::Object(object_id) => crate::object::Owner::ObjectOwner(object_id.into()),
2265 Owner::Shared(initial_shared_version) => crate::object::Owner::Shared {
2266 initial_shared_version: initial_shared_version.into(),
2267 },
2268 Owner::Immutable => crate::object::Owner::Immutable,
2269 _ => unreachable!("a new enum variant was added and needs to be handled"),
2270 }
2271 }
2272}
2273
2274impl From<crate::base_types::IotaAddress> for Address {
2275 fn from(value: crate::base_types::IotaAddress) -> Self {
2276 Self::new(value.to_inner())
2277 }
2278}
2279
2280impl From<Address> for crate::base_types::IotaAddress {
2281 fn from(value: Address) -> Self {
2282 crate::base_types::ObjectID::new(value.into_inner()).into()
2283 }
2284}
2285
2286impl From<crate::base_types::ObjectID> for ObjectId {
2287 fn from(value: crate::base_types::ObjectID) -> Self {
2288 Self::new(value.into_bytes())
2289 }
2290}
2291
2292impl From<ObjectId> for crate::base_types::ObjectID {
2293 fn from(value: ObjectId) -> Self {
2294 Self::new(value.into_inner())
2295 }
2296}
2297
2298impl From<crate::base_types::IotaAddress> for ObjectId {
2299 fn from(value: crate::base_types::IotaAddress) -> Self {
2300 Self::new(value.to_inner())
2301 }
2302}
2303
2304impl From<ObjectId> for crate::base_types::IotaAddress {
2305 fn from(value: ObjectId) -> Self {
2306 crate::base_types::ObjectID::new(value.into_inner()).into()
2307 }
2308}
2309
2310impl TryFrom<crate::transaction::SenderSignedData> for SignedTransaction {
2311 type Error = SdkTypeConversionError;
2312
2313 fn try_from(value: crate::transaction::SenderSignedData) -> Result<Self, Self::Error> {
2314 let crate::transaction::SenderSignedTransaction {
2315 intent_message,
2316 tx_signatures,
2317 } = value.into_inner();
2318
2319 Self {
2320 transaction: intent_message.value.try_into()?,
2321 signatures: tx_signatures
2322 .into_iter()
2323 .map(TryInto::try_into)
2324 .collect::<Result<_, _>>()?,
2325 }
2326 .pipe(Ok)
2327 }
2328}
2329
2330impl TryFrom<SignedTransaction> for crate::transaction::SenderSignedData {
2331 type Error = SdkTypeConversionError;
2332
2333 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2334 let SignedTransaction {
2335 transaction,
2336 signatures,
2337 } = value;
2338
2339 Self::new(
2340 transaction.try_into()?,
2341 signatures
2342 .into_iter()
2343 .map(TryInto::try_into)
2344 .collect::<Result<_, _>>()?,
2345 )
2346 .pipe(Ok)
2347 }
2348}
2349
2350impl TryFrom<crate::transaction::Transaction> for SignedTransaction {
2351 type Error = SdkTypeConversionError;
2352
2353 fn try_from(value: crate::transaction::Transaction) -> Result<Self, Self::Error> {
2354 value.into_data().try_into()
2355 }
2356}
2357
2358impl TryFrom<SignedTransaction> for crate::transaction::Transaction {
2359 type Error = SdkTypeConversionError;
2360
2361 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2362 Ok(Self::new(value.try_into()?))
2363 }
2364}
2365
2366pub fn type_tag_core_to_sdk(
2367 value: move_core_types::language_storage::TypeTag,
2368) -> Result<TypeTag, SdkTypeConversionError> {
2369 match value {
2370 move_core_types::language_storage::TypeTag::Bool => TypeTag::Bool,
2371 move_core_types::language_storage::TypeTag::U8 => TypeTag::U8,
2372 move_core_types::language_storage::TypeTag::U64 => TypeTag::U64,
2373 move_core_types::language_storage::TypeTag::U128 => TypeTag::U128,
2374 move_core_types::language_storage::TypeTag::Address => TypeTag::Address,
2375 move_core_types::language_storage::TypeTag::Signer => TypeTag::Signer,
2376 move_core_types::language_storage::TypeTag::Vector(type_tag) => {
2377 TypeTag::Vector(Box::new(type_tag_core_to_sdk(*type_tag)?))
2378 }
2379 move_core_types::language_storage::TypeTag::Struct(struct_tag) => {
2380 TypeTag::Struct(Box::new(struct_tag_core_to_sdk(*struct_tag)?))
2381 }
2382 move_core_types::language_storage::TypeTag::U16 => TypeTag::U16,
2383 move_core_types::language_storage::TypeTag::U32 => TypeTag::U32,
2384 move_core_types::language_storage::TypeTag::U256 => TypeTag::U256,
2385 }
2386 .pipe(Ok)
2387}
2388
2389pub fn type_tag_sdk_to_core(
2390 value: &TypeTag,
2391) -> Result<move_core_types::language_storage::TypeTag, SdkTypeConversionError> {
2392 match value {
2393 TypeTag::Bool => move_core_types::language_storage::TypeTag::Bool,
2394 TypeTag::U8 => move_core_types::language_storage::TypeTag::U8,
2395 TypeTag::U64 => move_core_types::language_storage::TypeTag::U64,
2396 TypeTag::U128 => move_core_types::language_storage::TypeTag::U128,
2397 TypeTag::Address => move_core_types::language_storage::TypeTag::Address,
2398 TypeTag::Signer => move_core_types::language_storage::TypeTag::Signer,
2399 TypeTag::Vector(type_tag) => move_core_types::language_storage::TypeTag::Vector(Box::new(
2400 type_tag_sdk_to_core(type_tag)?,
2401 )),
2402 TypeTag::Struct(struct_tag) => move_core_types::language_storage::TypeTag::Struct(
2403 Box::new(struct_tag_sdk_to_core(struct_tag)?),
2404 ),
2405 TypeTag::U16 => move_core_types::language_storage::TypeTag::U16,
2406 TypeTag::U32 => move_core_types::language_storage::TypeTag::U32,
2407 TypeTag::U256 => move_core_types::language_storage::TypeTag::U256,
2408 }
2409 .pipe(Ok)
2410}
2411
2412pub fn struct_tag_core_to_sdk(
2413 value: move_core_types::language_storage::StructTag,
2414) -> Result<StructTag, SdkTypeConversionError> {
2415 let move_core_types::language_storage::StructTag {
2416 address,
2417 module,
2418 name,
2419 type_params,
2420 } = value;
2421
2422 let address = Address::new(address.into_bytes());
2423 let module = Identifier::new(module.as_str())?;
2424 let name = Identifier::new(name.as_str())?;
2425 let type_params = type_params
2426 .into_iter()
2427 .map(type_tag_core_to_sdk)
2428 .collect::<Result<_, _>>()?;
2429 StructTag::new(address, module, name, type_params).pipe(Ok)
2430}
2431
2432pub fn struct_tag_sdk_to_core(
2433 value: &StructTag,
2434) -> Result<move_core_types::language_storage::StructTag, SdkTypeConversionError> {
2435 let address =
2436 move_core_types::account_address::AccountAddress::new(value.address().into_inner());
2437 let module = move_core_types::identifier::Identifier::new(value.module().clone().into_inner())?;
2438 let name = move_core_types::identifier::Identifier::new(value.name().clone().into_inner())?;
2439 let type_params = value
2440 .type_params()
2441 .iter()
2442 .map(type_tag_sdk_to_core)
2443 .collect::<Result<_, _>>()?;
2444 move_core_types::language_storage::StructTag {
2445 address,
2446 module,
2447 name,
2448 type_params,
2449 }
2450 .pipe(Ok)
2451}
2452
2453impl From<crate::committee::Committee> for ValidatorCommittee {
2454 fn from(value: crate::committee::Committee) -> Self {
2455 Self {
2456 epoch: value.epoch(),
2457 members: value
2458 .voting_rights
2459 .into_iter()
2460 .map(|(name, stake)| ValidatorCommitteeMember {
2461 public_key: name.into(),
2462 stake,
2463 })
2464 .collect(),
2465 }
2466 }
2467}
2468
2469impl From<ValidatorCommittee> for crate::committee::Committee {
2470 fn from(value: ValidatorCommittee) -> Self {
2471 let ValidatorCommittee { epoch, members } = value;
2472
2473 Self::new(
2474 epoch,
2475 members
2476 .into_iter()
2477 .map(|member| (member.public_key.into(), member.stake))
2478 .collect(),
2479 )
2480 }
2481}
2482
2483impl From<crate::crypto::AuthorityPublicKeyBytes> for Bls12381PublicKey {
2484 fn from(value: crate::crypto::AuthorityPublicKeyBytes) -> Self {
2485 Self::new(value.0)
2486 }
2487}
2488
2489impl From<Bls12381PublicKey> for crate::crypto::AuthorityPublicKeyBytes {
2490 fn from(value: Bls12381PublicKey) -> Self {
2491 Self::new(value.into_inner())
2492 }
2493}
2494
2495impl From<UnchangedSharedKind> for crate::effects::UnchangedSharedKind {
2496 fn from(value: UnchangedSharedKind) -> Self {
2497 match value {
2498 UnchangedSharedKind::ReadOnlyRoot { version, digest } => {
2499 Self::ReadOnlyRoot((version.into(), digest.into()))
2500 }
2501 UnchangedSharedKind::MutateDeleted { version } => Self::MutateDeleted(version.into()),
2502 UnchangedSharedKind::ReadDeleted { version } => Self::ReadDeleted(version.into()),
2503 UnchangedSharedKind::Cancelled { version } => Self::Cancelled(version.into()),
2504 UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2505 _ => unreachable!("a new enum variant was added and needs to be handled"),
2506 }
2507 }
2508}
2509
2510impl From<crate::effects::UnchangedSharedKind> for UnchangedSharedKind {
2511 fn from(value: crate::effects::UnchangedSharedKind) -> Self {
2512 match value {
2513 crate::effects::UnchangedSharedKind::ReadOnlyRoot((version, digest)) => {
2514 Self::ReadOnlyRoot {
2515 version: version.into(),
2516 digest: digest.into(),
2517 }
2518 }
2519 crate::effects::UnchangedSharedKind::MutateDeleted(version) => Self::MutateDeleted {
2520 version: version.into(),
2521 },
2522 crate::effects::UnchangedSharedKind::ReadDeleted(version) => Self::ReadDeleted {
2523 version: version.into(),
2524 },
2525 crate::effects::UnchangedSharedKind::Cancelled(version) => Self::Cancelled {
2526 version: version.into(),
2527 },
2528 crate::effects::UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2529 }
2530 }
2531}
2532
2533impl From<crate::transaction::TransactionExpiration> for TransactionExpiration {
2534 fn from(value: crate::transaction::TransactionExpiration) -> Self {
2535 match value {
2536 crate::transaction::TransactionExpiration::None => Self::None,
2537 crate::transaction::TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2538 }
2539 }
2540}
2541
2542impl From<TransactionExpiration> for crate::transaction::TransactionExpiration {
2543 fn from(value: TransactionExpiration) -> Self {
2544 match value {
2545 TransactionExpiration::None => Self::None,
2546 TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2547 _ => unreachable!("a new enum variant was added and needs to be handled"),
2548 }
2549 }
2550}