1use fastcrypto::traits::ToFromBytes;
14use iota_sdk2::types::{
15 object::{MovePackage, MoveStruct},
16 transaction::{ChangeEpoch, ChangeEpochV2},
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::AuthenticatorStateCreate => {
625 EndOfEpochTransactionKind::AuthenticatorStateCreate
626 }
627 crate::transaction::EndOfEpochTransactionKind::AuthenticatorStateExpire(
628 authenticator_state_expire,
629 ) => EndOfEpochTransactionKind::AuthenticatorStateExpire(AuthenticatorStateExpire {
630 min_epoch: authenticator_state_expire.min_epoch,
631 authenticator_obj_initial_shared_version: authenticator_state_expire
632 .authenticator_obj_initial_shared_version
633 .value(),
634 }),
635 crate::transaction::EndOfEpochTransactionKind::BridgeStateCreate(chain_identifier) => {
636 EndOfEpochTransactionKind::BridgeStateCreate {
637 chain_id: CheckpointDigest::new(chain_identifier.digest().into()),
638 }
639 }
640 crate::transaction::EndOfEpochTransactionKind::BridgeCommitteeInit(sequence_number) => {
641 EndOfEpochTransactionKind::BridgeCommitteeInit {
642 bridge_object_version: sequence_number.value(),
643 }
644 }
645 }
646 }
647}
648
649impl From<EndOfEpochTransactionKind> for crate::transaction::EndOfEpochTransactionKind {
650 fn from(value: EndOfEpochTransactionKind) -> Self {
651 match value {
652 EndOfEpochTransactionKind::ChangeEpoch(change_epoch) => {
653 Self::ChangeEpoch(crate::transaction::ChangeEpoch {
654 epoch: change_epoch.epoch,
655 protocol_version: change_epoch.protocol_version.into(),
656 storage_charge: change_epoch.storage_charge,
657 computation_charge: change_epoch.computation_charge,
658 storage_rebate: change_epoch.storage_rebate,
659 non_refundable_storage_fee: change_epoch.non_refundable_storage_fee,
660 epoch_start_timestamp_ms: change_epoch.epoch_start_timestamp_ms,
661 system_packages: change_epoch
662 .system_packages
663 .into_iter()
664 .map(|package| {
665 (
666 package.version.into(),
667 package.modules,
668 package.dependencies.into_iter().map(Into::into).collect(),
669 )
670 })
671 .collect(),
672 })
673 }
674 EndOfEpochTransactionKind::ChangeEpochV2(change_epoch_v2) => {
675 Self::ChangeEpochV2(crate::transaction::ChangeEpochV2 {
676 epoch: change_epoch_v2.epoch,
677 protocol_version: change_epoch_v2.protocol_version.into(),
678 storage_charge: change_epoch_v2.storage_charge,
679 computation_charge: change_epoch_v2.computation_charge,
680 computation_charge_burned: change_epoch_v2.computation_charge_burned,
681 storage_rebate: change_epoch_v2.storage_rebate,
682 non_refundable_storage_fee: change_epoch_v2.non_refundable_storage_fee,
683 epoch_start_timestamp_ms: change_epoch_v2.epoch_start_timestamp_ms,
684 system_packages: change_epoch_v2
685 .system_packages
686 .into_iter()
687 .map(|package| {
688 (
689 package.version.into(),
690 package.modules,
691 package.dependencies.into_iter().map(Into::into).collect(),
692 )
693 })
694 .collect(),
695 })
696 }
697 EndOfEpochTransactionKind::AuthenticatorStateCreate => Self::AuthenticatorStateCreate,
698 EndOfEpochTransactionKind::AuthenticatorStateExpire(authenticator_state_expire) => {
699 Self::AuthenticatorStateExpire(crate::transaction::AuthenticatorStateExpire {
700 min_epoch: authenticator_state_expire.min_epoch,
701 authenticator_obj_initial_shared_version: authenticator_state_expire
702 .authenticator_obj_initial_shared_version
703 .into(),
704 })
705 }
706 EndOfEpochTransactionKind::BridgeStateCreate { chain_id } => {
707 Self::BridgeStateCreate(crate::digests::ChainIdentifier(chain_id.into()))
708 }
709 EndOfEpochTransactionKind::BridgeCommitteeInit {
710 bridge_object_version,
711 } => Self::BridgeCommitteeInit(bridge_object_version.into()),
712 }
713 }
714}
715
716impl From<crate::transaction::CallArg> for InputArgument {
717 fn from(value: crate::transaction::CallArg) -> Self {
718 match value {
719 crate::transaction::CallArg::Pure(vec) => Self::Pure { value: vec },
720 crate::transaction::CallArg::Object(object_arg) => match object_arg {
721 crate::transaction::ObjectArg::ImmOrOwnedObject(obj_ref) => {
722 Self::ImmutableOrOwned(core_obj_ref_to_sdk(obj_ref))
723 }
724 crate::transaction::ObjectArg::SharedObject {
725 id,
726 initial_shared_version,
727 mutable,
728 } => Self::Shared {
729 object_id: id.into(),
730 initial_shared_version: initial_shared_version.value(),
731 mutable,
732 },
733 crate::transaction::ObjectArg::Receiving(obj_ref) => {
734 Self::Receiving(core_obj_ref_to_sdk(obj_ref))
735 }
736 },
737 }
738 }
739}
740
741impl From<InputArgument> for crate::transaction::CallArg {
742 fn from(value: InputArgument) -> Self {
743 use crate::transaction::ObjectArg;
744 match value {
745 InputArgument::Pure { value } => Self::Pure(value),
746 InputArgument::ImmutableOrOwned(object_reference) => Self::Object(
747 ObjectArg::ImmOrOwnedObject(sdk_obj_ref_to_core(object_reference)),
748 ),
749 InputArgument::Shared {
750 object_id,
751 initial_shared_version,
752 mutable,
753 } => Self::Object(ObjectArg::SharedObject {
754 id: object_id.into(),
755 initial_shared_version: initial_shared_version.into(),
756 mutable,
757 }),
758 InputArgument::Receiving(object_reference) => {
759 Self::Object(ObjectArg::Receiving(sdk_obj_ref_to_core(object_reference)))
760 }
761 }
762 }
763}
764
765fn core_obj_ref_to_sdk(obj_ref: crate::base_types::ObjectRef) -> ObjectReference {
766 ObjectReference::new(obj_ref.0.into(), obj_ref.1.value(), obj_ref.2.into())
767}
768
769fn sdk_obj_ref_to_core(obj_ref: ObjectReference) -> crate::base_types::ObjectRef {
770 let (id, seq, digest) = obj_ref.into_parts();
771 (id.into(), seq.into(), digest.into())
772}
773
774impl TryFrom<crate::effects::TransactionEffects> for TransactionEffects {
775 type Error = SdkTypeConversionError;
776
777 fn try_from(value: crate::effects::TransactionEffects) -> Result<Self, Self::Error> {
778 match value {
779 crate::effects::TransactionEffects::V1(effects) => {
780 Self::V1(Box::new(TransactionEffectsV1 {
781 epoch: effects.executed_epoch,
782 gas_used: GasCostSummary::new(
783 effects.gas_used.computation_cost,
784 effects.gas_used.computation_cost_burned,
785 effects.gas_used.storage_cost,
786 effects.gas_used.storage_rebate,
787 effects.gas_used.non_refundable_storage_fee,
788 ),
789 gas_object_index: effects.gas_object_index,
790 transaction_digest: effects.transaction_digest.into(),
791 events_digest: effects.events_digest.map(Into::into),
792 dependencies: effects.dependencies.into_iter().map(Into::into).collect(),
793 lamport_version: effects.lamport_version.value(),
794 changed_objects: effects
795 .changed_objects
796 .into_iter()
797 .map(|(id, change)| ChangedObject {
798 object_id: id.into(),
799 change: EffectsObjectChange {
800 input_state: match change.input_state {
801 crate::effects::ObjectIn::NotExist => ObjectIn::NotExist,
802 crate::effects::ObjectIn::Exist(((version, digest), owner)) => {
803 ObjectIn::Exist {
804 version: version.value(),
805 digest: digest.into(),
806 owner: owner.into(),
807 }
808 }
809 },
810 output_state: match change.output_state {
811 crate::effects::ObjectOut::NotExist => ObjectOut::NotExist,
812 crate::effects::ObjectOut::ObjectWrite((digest, owner)) => {
813 ObjectOut::ObjectWrite {
814 digest: digest.into(),
815 owner: owner.into(),
816 }
817 }
818 crate::effects::ObjectOut::PackageWrite((seq, digest)) => {
819 ObjectOut::PackageWrite {
820 version: seq.value(),
821 digest: digest.into(),
822 }
823 }
824 },
825 id_operation: match change.id_operation {
826 crate::effects::IDOperation::None => IdOperation::None,
827 crate::effects::IDOperation::Created => IdOperation::Created,
828 crate::effects::IDOperation::Deleted => IdOperation::Deleted,
829 },
830 },
831 })
832 .collect(),
833 unchanged_shared_objects: effects
834 .unchanged_shared_objects
835 .into_iter()
836 .map(|(id, kind)| UnchangedSharedObject {
837 object_id: id.into(),
838 kind: match kind {
839 crate::effects::UnchangedSharedKind::ReadOnlyRoot((
840 version,
841 digest,
842 )) => UnchangedSharedKind::ReadOnlyRoot {
843 version: version.value(),
844 digest: digest.into(),
845 },
846 crate::effects::UnchangedSharedKind::MutateDeleted(
847 sequence_number,
848 ) => UnchangedSharedKind::MutateDeleted {
849 version: sequence_number.value(),
850 },
851 crate::effects::UnchangedSharedKind::ReadDeleted(
852 sequence_number,
853 ) => UnchangedSharedKind::ReadDeleted {
854 version: sequence_number.value(),
855 },
856 crate::effects::UnchangedSharedKind::Cancelled(sequence_number) => {
857 UnchangedSharedKind::Cancelled {
858 version: sequence_number.value(),
859 }
860 }
861 crate::effects::UnchangedSharedKind::PerEpochConfig => {
862 UnchangedSharedKind::PerEpochConfig
863 }
864 },
865 })
866 .collect(),
867 auxiliary_data_digest: effects.aux_data_digest.map(Into::into),
868 status: effects.status.into(),
869 }))
870 .pipe(Ok)
871 }
872 }
873 }
874}
875
876impl TryFrom<TransactionEffects> for crate::effects::TransactionEffects {
877 type Error = SdkTypeConversionError;
878
879 fn try_from(value: TransactionEffects) -> Result<Self, Self::Error> {
880 match value {
881 TransactionEffects::V1(transaction_effects_v1) => {
882 let effects: crate::effects::TransactionEffects =
883 crate::effects::effects_v1::TransactionEffectsV1 {
884 status: transaction_effects_v1.status.into(),
885 executed_epoch: transaction_effects_v1.epoch,
886 gas_used: crate::gas::GasCostSummary::new(
887 transaction_effects_v1.gas_used.computation_cost,
888 transaction_effects_v1.gas_used.computation_cost_burned,
889 transaction_effects_v1.gas_used.storage_cost,
890 transaction_effects_v1.gas_used.storage_rebate,
891 transaction_effects_v1.gas_used.non_refundable_storage_fee,
892 ),
893 transaction_digest: transaction_effects_v1.transaction_digest.into(),
894 gas_object_index: transaction_effects_v1.gas_object_index,
895 events_digest: transaction_effects_v1.events_digest.map(Into::into),
896 dependencies: transaction_effects_v1
897 .dependencies
898 .into_iter()
899 .map(Into::into)
900 .collect(),
901 lamport_version: transaction_effects_v1.lamport_version.into(),
902 changed_objects: transaction_effects_v1
903 .changed_objects
904 .into_iter()
905 .map(|obj| {
906 (
907 obj.object_id.into(),
908 crate::effects::EffectsObjectChange {
909 input_state: match obj.change.input_state {
910 ObjectIn::NotExist => {
911 crate::effects::ObjectIn::NotExist
912 }
913 ObjectIn::Exist {
914 version,
915 digest,
916 owner,
917 } => crate::effects::ObjectIn::Exist((
918 (version.into(), digest.into()),
919 owner.into(),
920 )),
921 },
922 output_state: match obj.change.output_state {
923 ObjectOut::NotExist => {
924 crate::effects::ObjectOut::NotExist
925 }
926 ObjectOut::ObjectWrite { digest, owner } => {
927 crate::effects::ObjectOut::ObjectWrite((
928 digest.into(),
929 owner.into(),
930 ))
931 }
932 ObjectOut::PackageWrite { version, digest } => {
933 crate::effects::ObjectOut::PackageWrite((
934 version.into(),
935 digest.into(),
936 ))
937 }
938 },
939 id_operation: match obj.change.id_operation {
940 IdOperation::None => crate::effects::IDOperation::None,
941 IdOperation::Created => {
942 crate::effects::IDOperation::Created
943 }
944 IdOperation::Deleted => {
945 crate::effects::IDOperation::Deleted
946 }
947 },
948 },
949 )
950 })
951 .collect(),
952 unchanged_shared_objects: transaction_effects_v1
953 .unchanged_shared_objects
954 .into_iter()
955 .map(|obj| {
956 (
957 obj.object_id.into(),
958 match obj.kind {
959 UnchangedSharedKind::ReadOnlyRoot { version, digest } => {
960 crate::effects::UnchangedSharedKind::ReadOnlyRoot((
961 version.into(),
962 digest.into(),
963 ))
964 }
965 UnchangedSharedKind::MutateDeleted { version } => {
966 crate::effects::UnchangedSharedKind::MutateDeleted(
967 version.into(),
968 )
969 }
970 UnchangedSharedKind::ReadDeleted { version } => {
971 crate::effects::UnchangedSharedKind::ReadDeleted(
972 version.into(),
973 )
974 }
975 UnchangedSharedKind::Cancelled { version } => {
976 crate::effects::UnchangedSharedKind::Cancelled(
977 version.into(),
978 )
979 }
980 UnchangedSharedKind::PerEpochConfig => {
981 crate::effects::UnchangedSharedKind::PerEpochConfig
982 }
983 },
984 )
985 })
986 .collect(),
987 aux_data_digest: transaction_effects_v1
988 .auxiliary_data_digest
989 .map(Into::into),
990 }
991 .into();
992
993 Ok(effects)
994 }
995 }
996 }
997}
998
999macro_rules! impl_convert_digest {
1000 ($name:ident) => {
1001 impl From<crate::digests::$name> for $name {
1002 fn from(value: crate::digests::$name) -> Self {
1003 Self::new(value.into_inner())
1004 }
1005 }
1006
1007 impl From<$name> for crate::digests::$name {
1008 fn from(value: $name) -> Self {
1009 Self::new(value.into_inner())
1010 }
1011 }
1012 };
1013}
1014
1015impl_convert_digest!(Digest);
1016impl_convert_digest!(ObjectDigest);
1017impl_convert_digest!(CheckpointDigest);
1018impl_convert_digest!(TransactionDigest);
1019impl_convert_digest!(TransactionEffectsDigest);
1020impl_convert_digest!(TransactionEventsDigest);
1021impl_convert_digest!(CheckpointContentsDigest);
1022impl_convert_digest!(ConsensusCommitDigest);
1023
1024impl From<crate::digests::EffectsAuxDataDigest> for EffectsAuxiliaryDataDigest {
1025 fn from(value: crate::digests::EffectsAuxDataDigest) -> Self {
1026 Self::new(value.into_inner())
1027 }
1028}
1029
1030impl From<EffectsAuxiliaryDataDigest> for crate::digests::EffectsAuxDataDigest {
1031 fn from(value: EffectsAuxiliaryDataDigest) -> Self {
1032 Self::new(value.into_inner())
1033 }
1034}
1035
1036impl From<crate::execution_status::ExecutionStatus> for ExecutionStatus {
1037 fn from(value: crate::execution_status::ExecutionStatus) -> Self {
1038 match value {
1039 crate::execution_status::ExecutionStatus::Success => Self::Success,
1040 crate::execution_status::ExecutionStatus::Failure { error, command } => Self::Failure {
1041 error: error.into(),
1042 command: command.map(|v| v as u64),
1043 },
1044 }
1045 }
1046}
1047
1048impl From<ExecutionStatus> for crate::execution_status::ExecutionStatus {
1049 fn from(value: ExecutionStatus) -> Self {
1050 match value {
1051 ExecutionStatus::Success => Self::Success,
1052 ExecutionStatus::Failure { error, command } => Self::Failure {
1053 error: error.into(),
1054 command: command.map(|v| v as usize),
1055 },
1056 }
1057 }
1058}
1059
1060impl From<crate::execution_status::ExecutionFailureStatus> for ExecutionError {
1061 fn from(value: crate::execution_status::ExecutionFailureStatus) -> Self {
1062 use crate::execution_status::ExecutionFailureStatus;
1063 match value {
1064 ExecutionFailureStatus::InsufficientGas => Self::InsufficientGas,
1065 ExecutionFailureStatus::InvalidGasObject => Self::InvalidGasObject,
1066 ExecutionFailureStatus::InvariantViolation => Self::InvariantViolation,
1067 ExecutionFailureStatus::FeatureNotYetSupported => Self::FeatureNotYetSupported,
1068 ExecutionFailureStatus::MoveObjectTooBig {
1069 object_size,
1070 max_object_size,
1071 } => Self::ObjectTooBig {
1072 object_size,
1073 max_object_size,
1074 },
1075 ExecutionFailureStatus::MovePackageTooBig {
1076 object_size,
1077 max_object_size,
1078 } => Self::PackageTooBig {
1079 object_size,
1080 max_object_size,
1081 },
1082 ExecutionFailureStatus::CircularObjectOwnership { object } => {
1083 Self::CircularObjectOwnership {
1084 object: object.into(),
1085 }
1086 }
1087 ExecutionFailureStatus::InsufficientCoinBalance => Self::InsufficientCoinBalance,
1088 ExecutionFailureStatus::CoinBalanceOverflow => Self::CoinBalanceOverflow,
1089 ExecutionFailureStatus::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
1090 ExecutionFailureStatus::IotaMoveVerificationError => Self::IotaMoveVerificationError,
1091 ExecutionFailureStatus::MovePrimitiveRuntimeError(move_location_opt) => {
1092 Self::MovePrimitiveRuntimeError {
1093 location: move_location_opt.0.map(Into::into),
1094 }
1095 }
1096 ExecutionFailureStatus::MoveAbort(move_location, code) => Self::MoveAbort {
1097 location: move_location.into(),
1098 code,
1099 },
1100 ExecutionFailureStatus::VMVerificationOrDeserializationError => {
1101 Self::VmVerificationOrDeserializationError
1102 }
1103 ExecutionFailureStatus::VMInvariantViolation => Self::VmInvariantViolation,
1104 ExecutionFailureStatus::FunctionNotFound => Self::FunctionNotFound,
1105 ExecutionFailureStatus::ArityMismatch => Self::ArityMismatch,
1106 ExecutionFailureStatus::TypeArityMismatch => Self::TypeArityMismatch,
1107 ExecutionFailureStatus::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
1108 ExecutionFailureStatus::CommandArgumentError { arg_idx, kind } => {
1109 use crate::execution_status::CommandArgumentError as InternalCmdArgErr;
1110 Self::CommandArgumentError {
1111 argument: arg_idx,
1112 kind: match kind {
1113 InternalCmdArgErr::TypeMismatch => CommandArgumentError::TypeMismatch,
1114 InternalCmdArgErr::InvalidBCSBytes => CommandArgumentError::InvalidBcsBytes,
1115 InternalCmdArgErr::InvalidUsageOfPureArg => {
1116 CommandArgumentError::InvalidUsageOfPureArgument
1117 }
1118 InternalCmdArgErr::InvalidArgumentToPrivateEntryFunction => {
1119 CommandArgumentError::InvalidArgumentToPrivateEntryFunction
1120 }
1121 InternalCmdArgErr::IndexOutOfBounds { idx } => {
1122 CommandArgumentError::IndexOutOfBounds { index: idx }
1123 }
1124 InternalCmdArgErr::SecondaryIndexOutOfBounds {
1125 result_idx,
1126 secondary_idx,
1127 } => CommandArgumentError::SecondaryIndexOutOfBounds {
1128 result: result_idx,
1129 subresult: secondary_idx,
1130 },
1131 InternalCmdArgErr::InvalidResultArity { result_idx } => {
1132 CommandArgumentError::InvalidResultArity { result: result_idx }
1133 }
1134 InternalCmdArgErr::InvalidGasCoinUsage => {
1135 CommandArgumentError::InvalidGasCoinUsage
1136 }
1137 InternalCmdArgErr::InvalidValueUsage => {
1138 CommandArgumentError::InvalidValueUsage
1139 }
1140 InternalCmdArgErr::InvalidObjectByValue => {
1141 CommandArgumentError::InvalidObjectByValue
1142 }
1143 InternalCmdArgErr::InvalidObjectByMutRef => {
1144 CommandArgumentError::InvalidObjectByMutRef
1145 }
1146 InternalCmdArgErr::SharedObjectOperationNotAllowed => {
1147 CommandArgumentError::SharedObjectOperationNotAllowed
1148 }
1149 },
1150 }
1151 }
1152 ExecutionFailureStatus::TypeArgumentError { argument_idx, kind } => {
1153 use crate::execution_status::TypeArgumentError as InternalTypeArgErr;
1154 Self::TypeArgumentError {
1155 type_argument: argument_idx,
1156 kind: match kind {
1157 InternalTypeArgErr::TypeNotFound => TypeArgumentError::TypeNotFound,
1158 InternalTypeArgErr::ConstraintNotSatisfied => {
1159 TypeArgumentError::ConstraintNotSatisfied
1160 }
1161 },
1162 }
1163 }
1164 ExecutionFailureStatus::UnusedValueWithoutDrop {
1165 result_idx,
1166 secondary_idx,
1167 } => Self::UnusedValueWithoutDrop {
1168 result: result_idx,
1169 subresult: secondary_idx,
1170 },
1171 ExecutionFailureStatus::InvalidPublicFunctionReturnType { idx } => {
1172 Self::InvalidPublicFunctionReturnType { index: idx }
1173 }
1174 ExecutionFailureStatus::InvalidTransferObject => Self::InvalidTransferObject,
1175 ExecutionFailureStatus::EffectsTooLarge {
1176 current_size,
1177 max_size,
1178 } => Self::EffectsTooLarge {
1179 current_size,
1180 max_size,
1181 },
1182 ExecutionFailureStatus::PublishUpgradeMissingDependency => {
1183 Self::PublishUpgradeMissingDependency
1184 }
1185 ExecutionFailureStatus::PublishUpgradeDependencyDowngrade => {
1186 Self::PublishUpgradeDependencyDowngrade
1187 }
1188 ExecutionFailureStatus::PackageUpgradeError { upgrade_error } => {
1189 use crate::execution_status::PackageUpgradeError as InternalPkgUpgradeErr;
1190 Self::PackageUpgradeError {
1191 kind: match upgrade_error {
1192 InternalPkgUpgradeErr::UnableToFetchPackage { package_id } => {
1193 PackageUpgradeError::UnableToFetchPackage {
1194 package_id: package_id.into(),
1195 }
1196 }
1197 InternalPkgUpgradeErr::NotAPackage { object_id } => {
1198 PackageUpgradeError::NotAPackage {
1199 object_id: object_id.into(),
1200 }
1201 }
1202 InternalPkgUpgradeErr::IncompatibleUpgrade => {
1203 PackageUpgradeError::IncompatibleUpgrade
1204 }
1205 InternalPkgUpgradeErr::DigestDoesNotMatch { digest } => {
1206 PackageUpgradeError::DigestDoesNotMatch {
1207 digest: Digest::from_bytes(digest).expect("invalid digest bytes"),
1208 }
1209 }
1210 InternalPkgUpgradeErr::UnknownUpgradePolicy { policy } => {
1211 PackageUpgradeError::UnknownUpgradePolicy { policy }
1212 }
1213 InternalPkgUpgradeErr::PackageIDDoesNotMatch {
1214 package_id,
1215 ticket_id,
1216 } => PackageUpgradeError::PackageIdDoesNotMatch {
1217 package_id: package_id.into(),
1218 ticket_id: ticket_id.into(),
1219 },
1220 },
1221 }
1222 }
1223 ExecutionFailureStatus::WrittenObjectsTooLarge {
1224 current_size,
1225 max_size,
1226 } => Self::WrittenObjectsTooLarge {
1227 object_size: current_size,
1228 max_object_size: max_size,
1229 },
1230 ExecutionFailureStatus::CertificateDenied => Self::CertificateDenied,
1231 ExecutionFailureStatus::IotaMoveVerificationTimeout => {
1232 Self::IotaMoveVerificationTimeout
1233 }
1234 ExecutionFailureStatus::SharedObjectOperationNotAllowed => {
1235 Self::SharedObjectOperationNotAllowed
1236 }
1237 ExecutionFailureStatus::InputObjectDeleted => Self::InputObjectDeleted,
1238 ExecutionFailureStatus::ExecutionCancelledDueToSharedObjectCongestion {
1239 congested_objects,
1240 } => Self::ExecutionCancelledDueToSharedObjectCongestion {
1241 congested_objects: congested_objects.0.into_iter().map(Into::into).collect(),
1242 },
1243 ExecutionFailureStatus::AddressDeniedForCoin { address, coin_type } => {
1244 Self::AddressDeniedForCoin {
1245 address: address.into(),
1246 coin_type,
1247 }
1248 }
1249 ExecutionFailureStatus::CoinTypeGlobalPause { coin_type } => {
1250 Self::CoinTypeGlobalPause { coin_type }
1251 }
1252 ExecutionFailureStatus::ExecutionCancelledDueToRandomnessUnavailable => {
1253 Self::ExecutionCancelledDueToRandomnessUnavailable
1254 }
1255 }
1256 }
1257}
1258
1259impl From<ExecutionError> for crate::execution_status::ExecutionFailureStatus {
1260 fn from(value: ExecutionError) -> Self {
1261 match value {
1262 ExecutionError::InsufficientGas => Self::InsufficientGas,
1263 ExecutionError::InvalidGasObject => Self::InvalidGasObject,
1264 ExecutionError::InvariantViolation => Self::InvariantViolation,
1265 ExecutionError::FeatureNotYetSupported => Self::FeatureNotYetSupported,
1266 ExecutionError::ObjectTooBig {
1267 object_size,
1268 max_object_size,
1269 } => Self::MoveObjectTooBig {
1270 object_size,
1271 max_object_size,
1272 },
1273 ExecutionError::PackageTooBig {
1274 object_size,
1275 max_object_size,
1276 } => Self::MovePackageTooBig {
1277 object_size,
1278 max_object_size,
1279 },
1280 ExecutionError::CircularObjectOwnership { object } => Self::CircularObjectOwnership {
1281 object: object.into(),
1282 },
1283 ExecutionError::InsufficientCoinBalance => Self::InsufficientCoinBalance,
1284 ExecutionError::CoinBalanceOverflow => Self::CoinBalanceOverflow,
1285 ExecutionError::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
1286 ExecutionError::IotaMoveVerificationError => Self::IotaMoveVerificationError,
1287 ExecutionError::MovePrimitiveRuntimeError { location } => {
1288 Self::MovePrimitiveRuntimeError(crate::execution_status::MoveLocationOpt(
1289 location.map(Into::into),
1290 ))
1291 }
1292 ExecutionError::MoveAbort { location, code } => Self::MoveAbort(location.into(), code),
1293 ExecutionError::VmVerificationOrDeserializationError => {
1294 Self::VMVerificationOrDeserializationError
1295 }
1296 ExecutionError::VmInvariantViolation => Self::VMInvariantViolation,
1297 ExecutionError::FunctionNotFound => Self::FunctionNotFound,
1298 ExecutionError::ArityMismatch => Self::ArityMismatch,
1299 ExecutionError::TypeArityMismatch => Self::TypeArityMismatch,
1300 ExecutionError::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
1301 ExecutionError::CommandArgumentError { argument, kind } => {
1302 use crate::execution_status::CommandArgumentError as InternalCmdArgErr;
1303 Self::CommandArgumentError {
1304 arg_idx: argument,
1305 kind: match kind {
1306 CommandArgumentError::TypeMismatch => InternalCmdArgErr::TypeMismatch,
1307 CommandArgumentError::InvalidBcsBytes => InternalCmdArgErr::InvalidBCSBytes,
1308 CommandArgumentError::InvalidUsageOfPureArgument => {
1309 InternalCmdArgErr::InvalidUsageOfPureArg
1310 }
1311 CommandArgumentError::InvalidArgumentToPrivateEntryFunction => {
1312 InternalCmdArgErr::InvalidArgumentToPrivateEntryFunction
1313 }
1314 CommandArgumentError::IndexOutOfBounds { index } => {
1315 InternalCmdArgErr::IndexOutOfBounds { idx: index }
1316 }
1317 CommandArgumentError::SecondaryIndexOutOfBounds { result, subresult } => {
1318 InternalCmdArgErr::SecondaryIndexOutOfBounds {
1319 result_idx: result,
1320 secondary_idx: subresult,
1321 }
1322 }
1323 CommandArgumentError::InvalidResultArity { result } => {
1324 InternalCmdArgErr::InvalidResultArity { result_idx: result }
1325 }
1326 CommandArgumentError::InvalidGasCoinUsage => {
1327 InternalCmdArgErr::InvalidGasCoinUsage
1328 }
1329 CommandArgumentError::InvalidValueUsage => {
1330 InternalCmdArgErr::InvalidValueUsage
1331 }
1332 CommandArgumentError::InvalidObjectByValue => {
1333 InternalCmdArgErr::InvalidObjectByValue
1334 }
1335 CommandArgumentError::InvalidObjectByMutRef => {
1336 InternalCmdArgErr::InvalidObjectByMutRef
1337 }
1338 CommandArgumentError::SharedObjectOperationNotAllowed => {
1339 InternalCmdArgErr::SharedObjectOperationNotAllowed
1340 }
1341 },
1342 }
1343 }
1344 ExecutionError::TypeArgumentError {
1345 type_argument,
1346 kind,
1347 } => {
1348 use crate::execution_status::TypeArgumentError as InternalTypeArgErr;
1349 Self::TypeArgumentError {
1350 argument_idx: type_argument,
1351 kind: match kind {
1352 TypeArgumentError::TypeNotFound => InternalTypeArgErr::TypeNotFound,
1353 TypeArgumentError::ConstraintNotSatisfied => {
1354 InternalTypeArgErr::ConstraintNotSatisfied
1355 }
1356 },
1357 }
1358 }
1359 ExecutionError::UnusedValueWithoutDrop { result, subresult } => {
1360 Self::UnusedValueWithoutDrop {
1361 result_idx: result,
1362 secondary_idx: subresult,
1363 }
1364 }
1365 ExecutionError::InvalidPublicFunctionReturnType { index } => {
1366 Self::InvalidPublicFunctionReturnType { idx: index }
1367 }
1368 ExecutionError::InvalidTransferObject => Self::InvalidTransferObject,
1369 ExecutionError::EffectsTooLarge {
1370 current_size,
1371 max_size,
1372 } => Self::EffectsTooLarge {
1373 current_size,
1374 max_size,
1375 },
1376 ExecutionError::PublishUpgradeMissingDependency => {
1377 Self::PublishUpgradeMissingDependency
1378 }
1379 ExecutionError::PublishUpgradeDependencyDowngrade => {
1380 Self::PublishUpgradeDependencyDowngrade
1381 }
1382 ExecutionError::PackageUpgradeError { kind } => {
1383 use crate::execution_status::PackageUpgradeError as InternalPkgUpgradeErr;
1384 Self::PackageUpgradeError {
1385 upgrade_error: match kind {
1386 PackageUpgradeError::UnableToFetchPackage { package_id } => {
1387 InternalPkgUpgradeErr::UnableToFetchPackage {
1388 package_id: package_id.into(),
1389 }
1390 }
1391 PackageUpgradeError::NotAPackage { object_id } => {
1392 InternalPkgUpgradeErr::NotAPackage {
1393 object_id: object_id.into(),
1394 }
1395 }
1396 PackageUpgradeError::IncompatibleUpgrade => {
1397 InternalPkgUpgradeErr::IncompatibleUpgrade
1398 }
1399 PackageUpgradeError::DigestDoesNotMatch { digest } => {
1400 InternalPkgUpgradeErr::DigestDoesNotMatch {
1401 digest: digest.as_bytes().to_vec(),
1402 }
1403 }
1404 PackageUpgradeError::UnknownUpgradePolicy { policy } => {
1405 InternalPkgUpgradeErr::UnknownUpgradePolicy { policy }
1406 }
1407 PackageUpgradeError::PackageIdDoesNotMatch {
1408 package_id,
1409 ticket_id,
1410 } => InternalPkgUpgradeErr::PackageIDDoesNotMatch {
1411 package_id: package_id.into(),
1412 ticket_id: ticket_id.into(),
1413 },
1414 },
1415 }
1416 }
1417 ExecutionError::WrittenObjectsTooLarge {
1418 object_size,
1419 max_object_size,
1420 } => Self::WrittenObjectsTooLarge {
1421 current_size: object_size,
1422 max_size: max_object_size,
1423 },
1424 ExecutionError::CertificateDenied => Self::CertificateDenied,
1425 ExecutionError::IotaMoveVerificationTimeout => Self::IotaMoveVerificationTimeout,
1426 ExecutionError::SharedObjectOperationNotAllowed => {
1427 Self::SharedObjectOperationNotAllowed
1428 }
1429 ExecutionError::InputObjectDeleted => Self::InputObjectDeleted,
1430 ExecutionError::ExecutionCancelledDueToSharedObjectCongestion { congested_objects } => {
1431 Self::ExecutionCancelledDueToSharedObjectCongestion {
1432 congested_objects: crate::execution_status::CongestedObjects(
1433 congested_objects.into_iter().map(Into::into).collect(),
1434 ),
1435 }
1436 }
1437 ExecutionError::AddressDeniedForCoin { address, coin_type } => {
1438 Self::AddressDeniedForCoin {
1439 address: address.into(),
1440 coin_type,
1441 }
1442 }
1443 ExecutionError::CoinTypeGlobalPause { coin_type } => {
1444 Self::CoinTypeGlobalPause { coin_type }
1445 }
1446 ExecutionError::ExecutionCancelledDueToRandomnessUnavailable => {
1447 Self::ExecutionCancelledDueToRandomnessUnavailable
1448 }
1449 }
1450 }
1451}
1452
1453impl From<crate::execution_status::MoveLocation> for MoveLocation {
1454 fn from(value: crate::execution_status::MoveLocation) -> Self {
1455 Self {
1456 package: ObjectId::new(value.module.address().into_bytes()),
1457 module: Identifier::new(value.module.name().as_str()).expect("invalid module name"),
1458 function: value.function,
1459 instruction: value.instruction,
1460 function_name: value
1461 .function_name
1462 .map(|name| Identifier::new(name).expect("invalid function name")),
1463 }
1464 }
1465}
1466
1467impl From<MoveLocation> for crate::execution_status::MoveLocation {
1468 fn from(value: MoveLocation) -> Self {
1469 Self {
1470 module: ModuleId::new(
1471 move_core_types::account_address::AccountAddress::new(value.package.into_inner()),
1472 crate::Identifier::new(value.module.as_str()).expect("invalid module name"),
1473 ),
1474 function: value.function,
1475 instruction: value.instruction,
1476 function_name: value.function_name.map(|name| name.to_string()),
1477 }
1478 }
1479}
1480
1481impl TryFrom<crate::messages_checkpoint::CheckpointContents> for CheckpointContents {
1482 type Error = SdkTypeConversionError;
1483
1484 fn try_from(
1485 value: crate::messages_checkpoint::CheckpointContents,
1486 ) -> Result<Self, Self::Error> {
1487 Self(
1488 value
1489 .into_iter_with_signatures()
1490 .map(|(digests, signatures)| {
1491 let signatures_result = signatures
1492 .into_iter()
1493 .map(TryInto::try_into)
1494 .collect::<Result<Vec<UserSignature>, _>>();
1495
1496 match signatures_result {
1497 Ok(signatures) => Ok(CheckpointTransactionInfo {
1498 transaction: digests.transaction.into(),
1499 effects: digests.effects.into(),
1500 signatures,
1501 }),
1502 Err(e) => Err(SdkTypeConversionError::from(e)),
1503 }
1504 })
1505 .collect::<Result<Vec<_>, _>>()?,
1506 )
1507 .pipe(Ok)
1508 }
1509}
1510
1511impl TryFrom<CheckpointContents> for crate::messages_checkpoint::CheckpointContents {
1512 type Error = SdkTypeConversionError;
1513
1514 fn try_from(value: CheckpointContents) -> Result<Self, Self::Error> {
1515 let (transactions, user_signatures) = value.0.into_iter().fold(
1516 (Vec::new(), Vec::new()),
1517 |(mut transactions, mut user_signatures), info| {
1518 transactions.push(crate::base_types::ExecutionDigests {
1519 transaction: info.transaction.into(),
1520 effects: info.effects.into(),
1521 });
1522 user_signatures.push(
1523 info.signatures
1524 .into_iter()
1525 .map(TryInto::try_into)
1526 .collect::<Result<_, _>>(),
1527 );
1528 (transactions, user_signatures)
1529 },
1530 );
1531 crate::messages_checkpoint::CheckpointContents::new_with_digests_and_signatures(
1532 transactions,
1533 user_signatures.into_iter().collect::<Result<Vec<_>, _>>()?,
1534 )
1535 .pipe(Ok)
1536 }
1537}
1538
1539impl TryFrom<crate::full_checkpoint_content::CheckpointData> for CheckpointData {
1540 type Error = SdkTypeConversionError;
1541
1542 fn try_from(
1543 value: crate::full_checkpoint_content::CheckpointData,
1544 ) -> Result<Self, Self::Error> {
1545 Self {
1546 checkpoint_summary: value.checkpoint_summary.try_into()?,
1547 checkpoint_contents: value.checkpoint_contents.try_into()?,
1548 transactions: value
1549 .transactions
1550 .into_iter()
1551 .map(TryInto::try_into)
1552 .collect::<Result<_, _>>()?,
1553 }
1554 .pipe(Ok)
1555 }
1556}
1557
1558impl TryFrom<CheckpointData> for crate::full_checkpoint_content::CheckpointData {
1559 type Error = SdkTypeConversionError;
1560
1561 fn try_from(value: CheckpointData) -> Result<Self, Self::Error> {
1562 Self {
1563 checkpoint_summary: value.checkpoint_summary.try_into()?,
1564 checkpoint_contents: value.checkpoint_contents.try_into()?,
1565 transactions: value
1566 .transactions
1567 .into_iter()
1568 .map(TryInto::try_into)
1569 .collect::<Result<_, _>>()?,
1570 }
1571 .pipe(Ok)
1572 }
1573}
1574
1575impl TryFrom<crate::full_checkpoint_content::CheckpointTransaction> for CheckpointTransaction {
1576 type Error = SdkTypeConversionError;
1577
1578 fn try_from(
1579 value: crate::full_checkpoint_content::CheckpointTransaction,
1580 ) -> Result<Self, Self::Error> {
1581 let input_objects = value
1582 .input_objects
1583 .into_iter()
1584 .map(TryInto::try_into)
1585 .collect::<Result<_, _>>();
1586 let output_objects = value
1587 .output_objects
1588 .into_iter()
1589 .map(TryInto::try_into)
1590 .collect::<Result<_, _>>();
1591 match (input_objects, output_objects) {
1592 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1593 transaction: value.transaction.try_into()?,
1594 effects: value.effects.try_into()?,
1595 events: value.events.map(TryInto::try_into).transpose()?,
1596 input_objects,
1597 output_objects,
1598 }),
1599 (Err(e), _) | (_, Err(e)) => Err(e),
1600 }
1601 }
1602}
1603
1604impl TryFrom<CheckpointTransaction> for crate::full_checkpoint_content::CheckpointTransaction {
1605 type Error = SdkTypeConversionError;
1606
1607 fn try_from(value: CheckpointTransaction) -> Result<Self, Self::Error> {
1608 let input_objects = value
1609 .input_objects
1610 .into_iter()
1611 .map(TryInto::try_into)
1612 .collect::<Result<_, _>>();
1613 let output_objects = value
1614 .output_objects
1615 .into_iter()
1616 .map(TryInto::try_into)
1617 .collect::<Result<_, _>>();
1618
1619 match (input_objects, output_objects) {
1620 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1621 transaction: value.transaction.try_into()?,
1622 effects: value.effects.try_into()?,
1623 events: value.events.map(TryInto::try_into).transpose()?,
1624 input_objects,
1625 output_objects,
1626 }),
1627 (Err(e), _) | (_, Err(e)) => Err(e),
1628 }
1629 }
1630}
1631
1632impl TryFrom<crate::signature::GenericSignature> for UserSignature {
1633 type Error = bcs::Error;
1634
1635 fn try_from(value: crate::signature::GenericSignature) -> Result<Self, Self::Error> {
1636 bcs::from_bytes(&bcs::to_bytes(&value)?)
1637 }
1638}
1639
1640impl TryFrom<UserSignature> for crate::signature::GenericSignature {
1641 type Error = bcs::Error;
1642
1643 fn try_from(value: UserSignature) -> Result<Self, Self::Error> {
1644 bcs::from_bytes(&bcs::to_bytes(&value)?)
1645 }
1646}
1647
1648impl TryFrom<crate::effects::TransactionEvents> for TransactionEvents {
1649 type Error = SdkTypeConversionError;
1650
1651 fn try_from(value: crate::effects::TransactionEvents) -> Result<Self, Self::Error> {
1652 Self(
1653 value
1654 .data
1655 .into_iter()
1656 .map(TryInto::try_into)
1657 .collect::<Result<Vec<_>, _>>()?,
1658 )
1659 .pipe(Ok)
1660 }
1661}
1662
1663impl TryFrom<TransactionEvents> for crate::effects::TransactionEvents {
1664 type Error = SdkTypeConversionError;
1665
1666 fn try_from(value: TransactionEvents) -> Result<Self, Self::Error> {
1667 Self {
1668 data: value
1669 .0
1670 .into_iter()
1671 .map(TryInto::try_into)
1672 .collect::<Result<_, _>>()?,
1673 }
1674 .pipe(Ok)
1675 }
1676}
1677
1678impl TryFrom<crate::event::Event> for Event {
1679 type Error = SdkTypeConversionError;
1680
1681 fn try_from(value: crate::event::Event) -> Result<Self, Self::Error> {
1682 Self {
1683 package_id: value.package_id.into(),
1684 module: Identifier::new(value.transaction_module.as_str())?,
1685 sender: value.sender.into(),
1686 type_: struct_tag_core_to_sdk(value.type_)?,
1687 contents: value.contents,
1688 }
1689 .pipe(Ok)
1690 }
1691}
1692
1693impl TryFrom<Event> for crate::event::Event {
1694 type Error = SdkTypeConversionError;
1695
1696 fn try_from(value: Event) -> Result<Self, Self::Error> {
1697 Self {
1698 package_id: value.package_id.into(),
1699 transaction_module: crate::Identifier::new(value.module.as_str())?,
1700 sender: value.sender.into(),
1701 type_: struct_tag_sdk_to_core(value.type_)?,
1702 contents: value.contents,
1703 }
1704 .pipe(Ok)
1705 }
1706}
1707
1708impl TryFrom<crate::transaction::Command> for Command {
1709 type Error = SdkTypeConversionError;
1710
1711 fn try_from(value: crate::transaction::Command) -> Result<Self, Self::Error> {
1712 use crate::transaction::Command as InternalCmd;
1713 match value {
1714 InternalCmd::MoveCall(programmable_move_call) => Self::MoveCall(MoveCall {
1715 package: programmable_move_call.package.into(),
1716 module: Identifier::new(programmable_move_call.module.as_str())?,
1717 function: Identifier::new(programmable_move_call.function.as_str())?,
1718 type_arguments: programmable_move_call
1719 .type_arguments
1720 .into_iter()
1721 .map(type_tag_core_to_sdk)
1722 .collect::<Result<_, _>>()?,
1723 arguments: programmable_move_call
1724 .arguments
1725 .into_iter()
1726 .map(Into::into)
1727 .collect(),
1728 }),
1729 InternalCmd::TransferObjects(objects, address) => {
1730 Self::TransferObjects(TransferObjects {
1731 objects: objects.into_iter().map(Into::into).collect(),
1732 address: address.into(),
1733 })
1734 }
1735 InternalCmd::SplitCoins(coin, amounts) => Self::SplitCoins(SplitCoins {
1736 coin: coin.into(),
1737 amounts: amounts.into_iter().map(Into::into).collect(),
1738 }),
1739 InternalCmd::MergeCoins(argument, coins_to_merge) => Self::MergeCoins(MergeCoins {
1740 coin: argument.into(),
1741 coins_to_merge: coins_to_merge.into_iter().map(Into::into).collect(),
1742 }),
1743 InternalCmd::Publish(modules, dependencies) => Self::Publish(Publish {
1744 modules,
1745 dependencies: dependencies.into_iter().map(Into::into).collect(),
1746 }),
1747 InternalCmd::MakeMoveVec(type_tag, elements) => Self::MakeMoveVector(MakeMoveVector {
1748 type_: type_tag.map(type_tag_core_to_sdk).transpose()?,
1749 elements: elements.into_iter().map(Into::into).collect(),
1750 }),
1751 InternalCmd::Upgrade(modules, dependencies, package, ticket) => {
1752 Self::Upgrade(Upgrade {
1753 modules,
1754 dependencies: dependencies.into_iter().map(Into::into).collect(),
1755 package: package.into(),
1756 ticket: ticket.into(),
1757 })
1758 }
1759 }
1760 .pipe(Ok)
1761 }
1762}
1763
1764impl TryFrom<Command> for crate::transaction::Command {
1765 type Error = SdkTypeConversionError;
1766
1767 fn try_from(value: Command) -> Result<Self, Self::Error> {
1768 match value {
1769 Command::MoveCall(move_call) => {
1770 Self::MoveCall(Box::new(crate::transaction::ProgrammableMoveCall {
1771 package: move_call.package.into(),
1772 module: crate::Identifier::new(move_call.module.as_str())
1773 .expect("invalid move call module identifier"),
1774 function: crate::Identifier::new(move_call.function.as_str())
1775 .expect("invalid move call function identifier"),
1776 type_arguments: move_call
1777 .type_arguments
1778 .into_iter()
1779 .map(type_tag_sdk_to_core)
1780 .collect::<Result<_, _>>()?,
1781 arguments: move_call.arguments.into_iter().map(Into::into).collect(),
1782 }))
1783 }
1784 Command::TransferObjects(transfer_objects) => Self::TransferObjects(
1785 transfer_objects
1786 .objects
1787 .into_iter()
1788 .map(Into::into)
1789 .collect(),
1790 transfer_objects.address.into(),
1791 ),
1792 Command::SplitCoins(split_coins) => Self::SplitCoins(
1793 split_coins.coin.into(),
1794 split_coins.amounts.into_iter().map(Into::into).collect(),
1795 ),
1796 Command::MergeCoins(merge_coins) => Self::MergeCoins(
1797 merge_coins.coin.into(),
1798 merge_coins
1799 .coins_to_merge
1800 .into_iter()
1801 .map(Into::into)
1802 .collect(),
1803 ),
1804 Command::Publish(publish) => Self::Publish(
1805 publish.modules,
1806 publish.dependencies.into_iter().map(Into::into).collect(),
1807 ),
1808 Command::MakeMoveVector(make_move_vector) => Self::MakeMoveVec(
1809 make_move_vector
1810 .type_
1811 .map(type_tag_sdk_to_core)
1812 .transpose()?,
1813 make_move_vector
1814 .elements
1815 .into_iter()
1816 .map(Into::into)
1817 .collect(),
1818 ),
1819 Command::Upgrade(upgrade) => Self::Upgrade(
1820 upgrade.modules,
1821 upgrade.dependencies.into_iter().map(Into::into).collect(),
1822 upgrade.package.into(),
1823 upgrade.ticket.into(),
1824 ),
1825 }
1826 .pipe(Ok)
1827 }
1828}
1829
1830impl From<crate::transaction::Argument> for Argument {
1831 fn from(value: crate::transaction::Argument) -> Self {
1832 match value {
1833 crate::transaction::Argument::GasCoin => Self::Gas,
1834 crate::transaction::Argument::Input(idx) => Self::Input(idx),
1835 crate::transaction::Argument::Result(idx) => Self::Result(idx),
1836 crate::transaction::Argument::NestedResult(idx1, idx2) => {
1837 Self::NestedResult(idx1, idx2)
1838 }
1839 }
1840 }
1841}
1842
1843impl From<Argument> for crate::transaction::Argument {
1844 fn from(value: Argument) -> Self {
1845 match value {
1846 Argument::Gas => Self::GasCoin,
1847 Argument::Input(idx) => Self::Input(idx),
1848 Argument::Result(idx) => Self::Result(idx),
1849 Argument::NestedResult(idx1, idx2) => Self::NestedResult(idx1, idx2),
1850 }
1851 }
1852}
1853
1854impl From<crate::gas::GasCostSummary> for GasCostSummary {
1855 fn from(value: crate::gas::GasCostSummary) -> Self {
1856 Self::new(
1857 value.computation_cost,
1858 value.computation_cost_burned,
1859 value.storage_cost,
1860 value.storage_rebate,
1861 value.non_refundable_storage_fee,
1862 )
1863 }
1864}
1865
1866impl From<GasCostSummary> for crate::gas::GasCostSummary {
1867 fn from(value: GasCostSummary) -> Self {
1868 Self::new(
1869 value.computation_cost,
1870 value.computation_cost_burned,
1871 value.storage_cost,
1872 value.storage_rebate,
1873 value.non_refundable_storage_fee,
1874 )
1875 }
1876}
1877
1878impl From<crate::messages_checkpoint::EndOfEpochData> for EndOfEpochData {
1879 fn from(value: crate::messages_checkpoint::EndOfEpochData) -> Self {
1880 Self {
1881 next_epoch_committee: value
1882 .next_epoch_committee
1883 .into_iter()
1884 .map(|(public_key, stake)| ValidatorCommitteeMember {
1885 public_key: Bls12381PublicKey::new(public_key.0),
1886 stake,
1887 })
1888 .collect(),
1889 next_epoch_protocol_version: value.next_epoch_protocol_version.as_u64(),
1890 epoch_commitments: value
1891 .epoch_commitments
1892 .into_iter()
1893 .map(Into::into)
1894 .collect(),
1895 epoch_supply_change: value.epoch_supply_change,
1896 }
1897 }
1898}
1899
1900impl From<EndOfEpochData> for crate::messages_checkpoint::EndOfEpochData {
1901 fn from(value: EndOfEpochData) -> Self {
1902 Self {
1903 next_epoch_committee: value
1904 .next_epoch_committee
1905 .into_iter()
1906 .map(|v| (v.public_key.into(), v.stake))
1907 .collect(),
1908 next_epoch_protocol_version: value.next_epoch_protocol_version.into(),
1909 epoch_commitments: value
1910 .epoch_commitments
1911 .into_iter()
1912 .map(Into::into)
1913 .collect(),
1914 epoch_supply_change: value.epoch_supply_change,
1915 }
1916 }
1917}
1918
1919impl From<crate::messages_checkpoint::CheckpointCommitment> for CheckpointCommitment {
1920 fn from(value: crate::messages_checkpoint::CheckpointCommitment) -> Self {
1921 let crate::messages_checkpoint::CheckpointCommitment::ECMHLiveObjectSetDigest(digest) =
1922 value;
1923 Self::EcmhLiveObjectSet {
1924 digest: Digest::new(digest.digest.into_inner()),
1925 }
1926 }
1927}
1928
1929impl From<CheckpointCommitment> for crate::messages_checkpoint::CheckpointCommitment {
1930 fn from(value: CheckpointCommitment) -> Self {
1931 let CheckpointCommitment::EcmhLiveObjectSet { digest } = value;
1932 Self::ECMHLiveObjectSetDigest(crate::messages_checkpoint::ECMHLiveObjectSetDigest {
1933 digest: crate::digests::Digest::new(digest.into_inner()),
1934 })
1935 }
1936}
1937
1938impl TryFrom<crate::messages_checkpoint::CheckpointSummary> for CheckpointSummary {
1939 type Error = SdkTypeConversionError;
1940
1941 fn try_from(value: crate::messages_checkpoint::CheckpointSummary) -> Result<Self, Self::Error> {
1942 Self {
1943 epoch: value.epoch,
1944 sequence_number: value.sequence_number,
1945 network_total_transactions: value.network_total_transactions,
1946 content_digest: value.content_digest.into(),
1947 previous_digest: value.previous_digest.map(Into::into),
1948 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
1949 timestamp_ms: value.timestamp_ms,
1950 checkpoint_commitments: value
1951 .checkpoint_commitments
1952 .into_iter()
1953 .map(Into::into)
1954 .collect(),
1955 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
1956 version_specific_data: value.version_specific_data,
1957 }
1958 .pipe(Ok)
1959 }
1960}
1961
1962impl TryFrom<CheckpointSummary> for crate::messages_checkpoint::CheckpointSummary {
1963 type Error = SdkTypeConversionError;
1964
1965 fn try_from(value: CheckpointSummary) -> Result<Self, Self::Error> {
1966 Self {
1967 epoch: value.epoch,
1968 sequence_number: value.sequence_number,
1969 network_total_transactions: value.network_total_transactions,
1970 content_digest: value.content_digest.into(),
1971 previous_digest: value.previous_digest.map(Into::into),
1972 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
1973 timestamp_ms: value.timestamp_ms,
1974 checkpoint_commitments: value
1975 .checkpoint_commitments
1976 .into_iter()
1977 .map(Into::into)
1978 .collect(),
1979 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
1980 version_specific_data: value.version_specific_data,
1981 }
1982 .pipe(Ok)
1983 }
1984}
1985
1986impl TryFrom<crate::messages_checkpoint::CertifiedCheckpointSummary> for SignedCheckpointSummary {
1987 type Error = SdkTypeConversionError;
1988
1989 fn try_from(
1990 value: crate::messages_checkpoint::CertifiedCheckpointSummary,
1991 ) -> Result<Self, Self::Error> {
1992 let (data, sig) = value.into_data_and_sig();
1993 Self {
1994 checkpoint: data.try_into()?,
1995 signature: sig.into(),
1996 }
1997 .pipe(Ok)
1998 }
1999}
2000
2001impl TryFrom<SignedCheckpointSummary> for crate::messages_checkpoint::CertifiedCheckpointSummary {
2002 type Error = SdkTypeConversionError;
2003
2004 fn try_from(value: SignedCheckpointSummary) -> Result<Self, Self::Error> {
2005 Self::new_from_data_and_sig(
2006 crate::messages_checkpoint::CheckpointSummary::try_from(value.checkpoint)?,
2007 crate::crypto::AuthorityQuorumSignInfo::<true>::from(value.signature),
2008 )
2009 .pipe(Ok)
2010 }
2011}
2012
2013impl<const T: bool> From<crate::crypto::AuthorityQuorumSignInfo<T>>
2014 for ValidatorAggregatedSignature
2015{
2016 fn from(value: crate::crypto::AuthorityQuorumSignInfo<T>) -> Self {
2017 let crate::crypto::AuthorityQuorumSignInfo {
2018 epoch,
2019 signature,
2020 signers_map,
2021 } = value;
2022
2023 Self {
2024 epoch,
2025 signature: Bls12381Signature::from_bytes(signature.as_ref()).unwrap(),
2026 bitmap: signers_map,
2027 }
2028 }
2029}
2030
2031impl<const T: bool> From<ValidatorAggregatedSignature>
2032 for crate::crypto::AuthorityQuorumSignInfo<T>
2033{
2034 fn from(value: ValidatorAggregatedSignature) -> Self {
2035 let ValidatorAggregatedSignature {
2036 epoch,
2037 signature,
2038 bitmap,
2039 } = value;
2040
2041 Self {
2042 epoch,
2043 signature: crate::crypto::AggregateAuthoritySignature::from_bytes(signature.as_bytes())
2044 .unwrap(),
2045 signers_map: bitmap,
2046 }
2047 }
2048}
2049
2050impl From<crate::object::Owner> for Owner {
2051 fn from(value: crate::object::Owner) -> Self {
2052 match value {
2053 crate::object::Owner::AddressOwner(address) => Self::Address(address.into()),
2054 crate::object::Owner::ObjectOwner(object_id) => Self::Object(object_id.into()),
2055 crate::object::Owner::Shared {
2056 initial_shared_version,
2057 } => Self::Shared(initial_shared_version.value()),
2058 crate::object::Owner::Immutable => Self::Immutable,
2059 }
2060 }
2061}
2062
2063impl From<Owner> for crate::object::Owner {
2064 fn from(value: Owner) -> Self {
2065 match value {
2066 Owner::Address(address) => crate::object::Owner::AddressOwner(address.into()),
2067 Owner::Object(object_id) => crate::object::Owner::ObjectOwner(object_id.into()),
2068 Owner::Shared(initial_shared_version) => crate::object::Owner::Shared {
2069 initial_shared_version: initial_shared_version.into(),
2070 },
2071 Owner::Immutable => crate::object::Owner::Immutable,
2072 }
2073 }
2074}
2075
2076impl From<crate::base_types::IotaAddress> for Address {
2077 fn from(value: crate::base_types::IotaAddress) -> Self {
2078 Self::new(value.to_inner())
2079 }
2080}
2081
2082impl From<Address> for crate::base_types::IotaAddress {
2083 fn from(value: Address) -> Self {
2084 crate::base_types::ObjectID::new(value.into_inner()).into()
2085 }
2086}
2087
2088impl From<crate::base_types::ObjectID> for ObjectId {
2089 fn from(value: crate::base_types::ObjectID) -> Self {
2090 Self::new(value.into_bytes())
2091 }
2092}
2093
2094impl From<ObjectId> for crate::base_types::ObjectID {
2095 fn from(value: ObjectId) -> Self {
2096 Self::new(value.into_inner())
2097 }
2098}
2099
2100impl From<crate::base_types::IotaAddress> for ObjectId {
2101 fn from(value: crate::base_types::IotaAddress) -> Self {
2102 Self::new(value.to_inner())
2103 }
2104}
2105
2106impl From<ObjectId> for crate::base_types::IotaAddress {
2107 fn from(value: ObjectId) -> Self {
2108 crate::base_types::ObjectID::new(value.into_inner()).into()
2109 }
2110}
2111
2112impl TryFrom<crate::transaction::SenderSignedData> for SignedTransaction {
2113 type Error = SdkTypeConversionError;
2114
2115 fn try_from(value: crate::transaction::SenderSignedData) -> Result<Self, Self::Error> {
2116 let crate::transaction::SenderSignedTransaction {
2117 intent_message,
2118 tx_signatures,
2119 } = value.into_inner();
2120
2121 Self {
2122 transaction: intent_message.value.try_into()?,
2123 signatures: tx_signatures
2124 .into_iter()
2125 .map(TryInto::try_into)
2126 .collect::<Result<_, _>>()?,
2127 }
2128 .pipe(Ok)
2129 }
2130}
2131
2132impl TryFrom<SignedTransaction> for crate::transaction::SenderSignedData {
2133 type Error = SdkTypeConversionError;
2134
2135 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2136 let SignedTransaction {
2137 transaction,
2138 signatures,
2139 } = value;
2140
2141 Self::new(
2142 transaction.try_into()?,
2143 signatures
2144 .into_iter()
2145 .map(TryInto::try_into)
2146 .collect::<Result<_, _>>()?,
2147 )
2148 .pipe(Ok)
2149 }
2150}
2151
2152impl TryFrom<crate::transaction::Transaction> for SignedTransaction {
2153 type Error = SdkTypeConversionError;
2154
2155 fn try_from(value: crate::transaction::Transaction) -> Result<Self, Self::Error> {
2156 value.into_data().try_into()
2157 }
2158}
2159
2160impl TryFrom<SignedTransaction> for crate::transaction::Transaction {
2161 type Error = SdkTypeConversionError;
2162
2163 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2164 Ok(Self::new(value.try_into()?))
2165 }
2166}
2167
2168pub fn type_tag_core_to_sdk(
2169 value: move_core_types::language_storage::TypeTag,
2170) -> Result<TypeTag, SdkTypeConversionError> {
2171 match value {
2172 move_core_types::language_storage::TypeTag::Bool => TypeTag::Bool,
2173 move_core_types::language_storage::TypeTag::U8 => TypeTag::U8,
2174 move_core_types::language_storage::TypeTag::U64 => TypeTag::U64,
2175 move_core_types::language_storage::TypeTag::U128 => TypeTag::U128,
2176 move_core_types::language_storage::TypeTag::Address => TypeTag::Address,
2177 move_core_types::language_storage::TypeTag::Signer => TypeTag::Signer,
2178 move_core_types::language_storage::TypeTag::Vector(type_tag) => {
2179 TypeTag::Vector(Box::new(type_tag_core_to_sdk(*type_tag)?))
2180 }
2181 move_core_types::language_storage::TypeTag::Struct(struct_tag) => {
2182 TypeTag::Struct(Box::new(struct_tag_core_to_sdk(*struct_tag)?))
2183 }
2184 move_core_types::language_storage::TypeTag::U16 => TypeTag::U16,
2185 move_core_types::language_storage::TypeTag::U32 => TypeTag::U32,
2186 move_core_types::language_storage::TypeTag::U256 => TypeTag::U256,
2187 }
2188 .pipe(Ok)
2189}
2190
2191pub fn type_tag_sdk_to_core(
2192 value: TypeTag,
2193) -> Result<move_core_types::language_storage::TypeTag, SdkTypeConversionError> {
2194 match value {
2195 TypeTag::Bool => move_core_types::language_storage::TypeTag::Bool,
2196 TypeTag::U8 => move_core_types::language_storage::TypeTag::U8,
2197 TypeTag::U64 => move_core_types::language_storage::TypeTag::U64,
2198 TypeTag::U128 => move_core_types::language_storage::TypeTag::U128,
2199 TypeTag::Address => move_core_types::language_storage::TypeTag::Address,
2200 TypeTag::Signer => move_core_types::language_storage::TypeTag::Signer,
2201 TypeTag::Vector(type_tag) => move_core_types::language_storage::TypeTag::Vector(Box::new(
2202 type_tag_sdk_to_core(*type_tag)?,
2203 )),
2204 TypeTag::Struct(struct_tag) => move_core_types::language_storage::TypeTag::Struct(
2205 Box::new(struct_tag_sdk_to_core(*struct_tag)?),
2206 ),
2207 TypeTag::U16 => move_core_types::language_storage::TypeTag::U16,
2208 TypeTag::U32 => move_core_types::language_storage::TypeTag::U32,
2209 TypeTag::U256 => move_core_types::language_storage::TypeTag::U256,
2210 }
2211 .pipe(Ok)
2212}
2213
2214pub fn struct_tag_core_to_sdk(
2215 value: move_core_types::language_storage::StructTag,
2216) -> Result<StructTag, SdkTypeConversionError> {
2217 let move_core_types::language_storage::StructTag {
2218 address,
2219 module,
2220 name,
2221 type_params,
2222 } = value;
2223
2224 let address = Address::new(address.into_bytes());
2225 let module = Identifier::new(module.as_str())?;
2226 let name = Identifier::new(name.as_str())?;
2227 let type_params = type_params
2228 .into_iter()
2229 .map(type_tag_core_to_sdk)
2230 .collect::<Result<_, _>>()?;
2231 StructTag {
2232 address,
2233 module,
2234 name,
2235 type_params,
2236 }
2237 .pipe(Ok)
2238}
2239
2240pub fn struct_tag_sdk_to_core(
2241 value: StructTag,
2242) -> Result<move_core_types::language_storage::StructTag, SdkTypeConversionError> {
2243 let StructTag {
2244 address,
2245 module,
2246 name,
2247 type_params,
2248 } = value;
2249
2250 let address = move_core_types::account_address::AccountAddress::new(address.into_inner());
2251 let module = move_core_types::identifier::Identifier::new(module.into_inner())?;
2252 let name = move_core_types::identifier::Identifier::new(name.into_inner())?;
2253 let type_params = type_params
2254 .into_iter()
2255 .map(type_tag_sdk_to_core)
2256 .collect::<Result<_, _>>()?;
2257 move_core_types::language_storage::StructTag {
2258 address,
2259 module,
2260 name,
2261 type_params,
2262 }
2263 .pipe(Ok)
2264}
2265
2266impl From<crate::committee::Committee> for ValidatorCommittee {
2267 fn from(value: crate::committee::Committee) -> Self {
2268 Self {
2269 epoch: value.epoch(),
2270 members: value
2271 .voting_rights
2272 .into_iter()
2273 .map(|(name, stake)| ValidatorCommitteeMember {
2274 public_key: name.into(),
2275 stake,
2276 })
2277 .collect(),
2278 }
2279 }
2280}
2281
2282impl From<ValidatorCommittee> for crate::committee::Committee {
2283 fn from(value: ValidatorCommittee) -> Self {
2284 let ValidatorCommittee { epoch, members } = value;
2285
2286 Self::new(
2287 epoch,
2288 members
2289 .into_iter()
2290 .map(|member| (member.public_key.into(), member.stake))
2291 .collect(),
2292 )
2293 }
2294}
2295
2296impl From<crate::crypto::AuthorityPublicKeyBytes> for Bls12381PublicKey {
2297 fn from(value: crate::crypto::AuthorityPublicKeyBytes) -> Self {
2298 Self::new(value.0)
2299 }
2300}
2301
2302impl From<Bls12381PublicKey> for crate::crypto::AuthorityPublicKeyBytes {
2303 fn from(value: Bls12381PublicKey) -> Self {
2304 Self::new(value.into_inner())
2305 }
2306}
2307
2308impl From<UnchangedSharedKind> for crate::effects::UnchangedSharedKind {
2309 fn from(value: UnchangedSharedKind) -> Self {
2310 match value {
2311 UnchangedSharedKind::ReadOnlyRoot { version, digest } => {
2312 Self::ReadOnlyRoot((version.into(), digest.into()))
2313 }
2314 UnchangedSharedKind::MutateDeleted { version } => Self::MutateDeleted(version.into()),
2315 UnchangedSharedKind::ReadDeleted { version } => Self::ReadDeleted(version.into()),
2316 UnchangedSharedKind::Cancelled { version } => Self::Cancelled(version.into()),
2317 UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2318 }
2319 }
2320}
2321
2322impl From<crate::effects::UnchangedSharedKind> for UnchangedSharedKind {
2323 fn from(value: crate::effects::UnchangedSharedKind) -> Self {
2324 match value {
2325 crate::effects::UnchangedSharedKind::ReadOnlyRoot((version, digest)) => {
2326 Self::ReadOnlyRoot {
2327 version: version.into(),
2328 digest: digest.into(),
2329 }
2330 }
2331 crate::effects::UnchangedSharedKind::MutateDeleted(version) => Self::MutateDeleted {
2332 version: version.into(),
2333 },
2334 crate::effects::UnchangedSharedKind::ReadDeleted(version) => Self::ReadDeleted {
2335 version: version.into(),
2336 },
2337 crate::effects::UnchangedSharedKind::Cancelled(version) => Self::Cancelled {
2338 version: version.into(),
2339 },
2340 crate::effects::UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2341 }
2342 }
2343}
2344
2345impl From<crate::transaction::TransactionExpiration> for TransactionExpiration {
2346 fn from(value: crate::transaction::TransactionExpiration) -> Self {
2347 match value {
2348 crate::transaction::TransactionExpiration::None => Self::None,
2349 crate::transaction::TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2350 }
2351 }
2352}
2353
2354impl From<TransactionExpiration> for crate::transaction::TransactionExpiration {
2355 fn from(value: TransactionExpiration) -> Self {
2356 match value {
2357 TransactionExpiration::None => Self::None,
2358 TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2359 }
2360 }
2361}