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