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