iota_types/
iota_sdk_types_conversions.rs

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