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 }
1240 }
1241}
1242
1243impl From<ExecutionError> for crate::execution_status::ExecutionFailureStatus {
1244 fn from(value: ExecutionError) -> Self {
1245 match value {
1246 ExecutionError::InsufficientGas => Self::InsufficientGas,
1247 ExecutionError::InvalidGasObject => Self::InvalidGasObject,
1248 ExecutionError::InvariantViolation => Self::InvariantViolation,
1249 ExecutionError::FeatureNotYetSupported => Self::FeatureNotYetSupported,
1250 ExecutionError::ObjectTooBig {
1251 object_size,
1252 max_object_size,
1253 } => Self::MoveObjectTooBig {
1254 object_size,
1255 max_object_size,
1256 },
1257 ExecutionError::PackageTooBig {
1258 object_size,
1259 max_object_size,
1260 } => Self::MovePackageTooBig {
1261 object_size,
1262 max_object_size,
1263 },
1264 ExecutionError::CircularObjectOwnership { object } => Self::CircularObjectOwnership {
1265 object: object.into(),
1266 },
1267 ExecutionError::InsufficientCoinBalance => Self::InsufficientCoinBalance,
1268 ExecutionError::CoinBalanceOverflow => Self::CoinBalanceOverflow,
1269 ExecutionError::PublishErrorNonZeroAddress => Self::PublishErrorNonZeroAddress,
1270 ExecutionError::IotaMoveVerificationError => Self::IotaMoveVerificationError,
1271 ExecutionError::MovePrimitiveRuntimeError { location } => {
1272 Self::MovePrimitiveRuntimeError(crate::execution_status::MoveLocationOpt(
1273 location.map(Into::into),
1274 ))
1275 }
1276 ExecutionError::MoveAbort { location, code } => Self::MoveAbort(location.into(), code),
1277 ExecutionError::VmVerificationOrDeserializationError => {
1278 Self::VMVerificationOrDeserializationError
1279 }
1280 ExecutionError::VmInvariantViolation => Self::VMInvariantViolation,
1281 ExecutionError::FunctionNotFound => Self::FunctionNotFound,
1282 ExecutionError::ArityMismatch => Self::ArityMismatch,
1283 ExecutionError::TypeArityMismatch => Self::TypeArityMismatch,
1284 ExecutionError::NonEntryFunctionInvoked => Self::NonEntryFunctionInvoked,
1285 ExecutionError::CommandArgumentError { argument, kind } => {
1286 use crate::execution_status::CommandArgumentError as InternalCmdArgErr;
1287 Self::CommandArgumentError {
1288 arg_idx: argument,
1289 kind: match kind {
1290 CommandArgumentError::TypeMismatch => InternalCmdArgErr::TypeMismatch,
1291 CommandArgumentError::InvalidBcsBytes => InternalCmdArgErr::InvalidBCSBytes,
1292 CommandArgumentError::InvalidUsageOfPureArgument => {
1293 InternalCmdArgErr::InvalidUsageOfPureArg
1294 }
1295 CommandArgumentError::InvalidArgumentToPrivateEntryFunction => {
1296 InternalCmdArgErr::InvalidArgumentToPrivateEntryFunction
1297 }
1298 CommandArgumentError::IndexOutOfBounds { index } => {
1299 InternalCmdArgErr::IndexOutOfBounds { idx: index }
1300 }
1301 CommandArgumentError::SecondaryIndexOutOfBounds { result, subresult } => {
1302 InternalCmdArgErr::SecondaryIndexOutOfBounds {
1303 result_idx: result,
1304 secondary_idx: subresult,
1305 }
1306 }
1307 CommandArgumentError::InvalidResultArity { result } => {
1308 InternalCmdArgErr::InvalidResultArity { result_idx: result }
1309 }
1310 CommandArgumentError::InvalidGasCoinUsage => {
1311 InternalCmdArgErr::InvalidGasCoinUsage
1312 }
1313 CommandArgumentError::InvalidValueUsage => {
1314 InternalCmdArgErr::InvalidValueUsage
1315 }
1316 CommandArgumentError::InvalidObjectByValue => {
1317 InternalCmdArgErr::InvalidObjectByValue
1318 }
1319 CommandArgumentError::InvalidObjectByMutRef => {
1320 InternalCmdArgErr::InvalidObjectByMutRef
1321 }
1322 CommandArgumentError::SharedObjectOperationNotAllowed => {
1323 InternalCmdArgErr::SharedObjectOperationNotAllowed
1324 }
1325 },
1326 }
1327 }
1328 ExecutionError::TypeArgumentError {
1329 type_argument,
1330 kind,
1331 } => {
1332 use crate::execution_status::TypeArgumentError as InternalTypeArgErr;
1333 Self::TypeArgumentError {
1334 argument_idx: type_argument,
1335 kind: match kind {
1336 TypeArgumentError::TypeNotFound => InternalTypeArgErr::TypeNotFound,
1337 TypeArgumentError::ConstraintNotSatisfied => {
1338 InternalTypeArgErr::ConstraintNotSatisfied
1339 }
1340 },
1341 }
1342 }
1343 ExecutionError::UnusedValueWithoutDrop { result, subresult } => {
1344 Self::UnusedValueWithoutDrop {
1345 result_idx: result,
1346 secondary_idx: subresult,
1347 }
1348 }
1349 ExecutionError::InvalidPublicFunctionReturnType { index } => {
1350 Self::InvalidPublicFunctionReturnType { idx: index }
1351 }
1352 ExecutionError::InvalidTransferObject => Self::InvalidTransferObject,
1353 ExecutionError::EffectsTooLarge {
1354 current_size,
1355 max_size,
1356 } => Self::EffectsTooLarge {
1357 current_size,
1358 max_size,
1359 },
1360 ExecutionError::PublishUpgradeMissingDependency => {
1361 Self::PublishUpgradeMissingDependency
1362 }
1363 ExecutionError::PublishUpgradeDependencyDowngrade => {
1364 Self::PublishUpgradeDependencyDowngrade
1365 }
1366 ExecutionError::PackageUpgradeError { kind } => {
1367 use crate::execution_status::PackageUpgradeError as InternalPkgUpgradeErr;
1368 Self::PackageUpgradeError {
1369 upgrade_error: match kind {
1370 PackageUpgradeError::UnableToFetchPackage { package_id } => {
1371 InternalPkgUpgradeErr::UnableToFetchPackage {
1372 package_id: package_id.into(),
1373 }
1374 }
1375 PackageUpgradeError::NotAPackage { object_id } => {
1376 InternalPkgUpgradeErr::NotAPackage {
1377 object_id: object_id.into(),
1378 }
1379 }
1380 PackageUpgradeError::IncompatibleUpgrade => {
1381 InternalPkgUpgradeErr::IncompatibleUpgrade
1382 }
1383 PackageUpgradeError::DigestDoesNotMatch { digest } => {
1384 InternalPkgUpgradeErr::DigestDoesNotMatch {
1385 digest: digest.as_bytes().to_vec(),
1386 }
1387 }
1388 PackageUpgradeError::UnknownUpgradePolicy { policy } => {
1389 InternalPkgUpgradeErr::UnknownUpgradePolicy { policy }
1390 }
1391 PackageUpgradeError::PackageIdDoesNotMatch {
1392 package_id,
1393 ticket_id,
1394 } => InternalPkgUpgradeErr::PackageIDDoesNotMatch {
1395 package_id: package_id.into(),
1396 ticket_id: ticket_id.into(),
1397 },
1398 },
1399 }
1400 }
1401 ExecutionError::WrittenObjectsTooLarge {
1402 object_size,
1403 max_object_size,
1404 } => Self::WrittenObjectsTooLarge {
1405 current_size: object_size,
1406 max_size: max_object_size,
1407 },
1408 ExecutionError::CertificateDenied => Self::CertificateDenied,
1409 ExecutionError::IotaMoveVerificationTimeout => Self::IotaMoveVerificationTimeout,
1410 ExecutionError::SharedObjectOperationNotAllowed => {
1411 Self::SharedObjectOperationNotAllowed
1412 }
1413 ExecutionError::InputObjectDeleted => Self::InputObjectDeleted,
1414 ExecutionError::ExecutionCancelledDueToSharedObjectCongestion { congested_objects } => {
1415 Self::ExecutionCancelledDueToSharedObjectCongestion {
1416 congested_objects: crate::execution_status::CongestedObjects(
1417 congested_objects.into_iter().map(Into::into).collect(),
1418 ),
1419 }
1420 }
1421 ExecutionError::AddressDeniedForCoin { address, coin_type } => {
1422 Self::AddressDeniedForCoin {
1423 address: address.into(),
1424 coin_type,
1425 }
1426 }
1427 ExecutionError::CoinTypeGlobalPause { coin_type } => {
1428 Self::CoinTypeGlobalPause { coin_type }
1429 }
1430 ExecutionError::ExecutionCancelledDueToRandomnessUnavailable => {
1431 Self::ExecutionCancelledDueToRandomnessUnavailable
1432 }
1433 }
1434 }
1435}
1436
1437impl From<crate::execution_status::MoveLocation> for MoveLocation {
1438 fn from(value: crate::execution_status::MoveLocation) -> Self {
1439 Self {
1440 package: ObjectId::new(value.module.address().into_bytes()),
1441 module: Identifier::new(value.module.name().as_str()).expect("invalid module name"),
1442 function: value.function,
1443 instruction: value.instruction,
1444 function_name: value
1445 .function_name
1446 .map(|name| Identifier::new(name).expect("invalid function name")),
1447 }
1448 }
1449}
1450
1451impl From<MoveLocation> for crate::execution_status::MoveLocation {
1452 fn from(value: MoveLocation) -> Self {
1453 Self {
1454 module: ModuleId::new(
1455 move_core_types::account_address::AccountAddress::new(value.package.into_inner()),
1456 crate::Identifier::new(value.module.as_str()).expect("invalid module name"),
1457 ),
1458 function: value.function,
1459 instruction: value.instruction,
1460 function_name: value.function_name.map(|name| name.to_string()),
1461 }
1462 }
1463}
1464
1465impl TryFrom<crate::messages_checkpoint::CheckpointContents> for CheckpointContents {
1466 type Error = SdkTypeConversionError;
1467
1468 fn try_from(
1469 value: crate::messages_checkpoint::CheckpointContents,
1470 ) -> Result<Self, Self::Error> {
1471 Self(
1472 value
1473 .into_iter_with_signatures()
1474 .map(|(digests, signatures)| {
1475 let signatures_result = signatures
1476 .into_iter()
1477 .map(TryInto::try_into)
1478 .collect::<Result<Vec<UserSignature>, _>>();
1479
1480 match signatures_result {
1481 Ok(signatures) => Ok(CheckpointTransactionInfo {
1482 transaction: digests.transaction.into(),
1483 effects: digests.effects.into(),
1484 signatures,
1485 }),
1486 Err(e) => Err(SdkTypeConversionError::from(e)),
1487 }
1488 })
1489 .collect::<Result<Vec<_>, _>>()?,
1490 )
1491 .pipe(Ok)
1492 }
1493}
1494
1495impl TryFrom<CheckpointContents> for crate::messages_checkpoint::CheckpointContents {
1496 type Error = SdkTypeConversionError;
1497
1498 fn try_from(value: CheckpointContents) -> Result<Self, Self::Error> {
1499 let (transactions, user_signatures) = value.0.into_iter().fold(
1500 (Vec::new(), Vec::new()),
1501 |(mut transactions, mut user_signatures), info| {
1502 transactions.push(crate::base_types::ExecutionDigests {
1503 transaction: info.transaction.into(),
1504 effects: info.effects.into(),
1505 });
1506 user_signatures.push(
1507 info.signatures
1508 .into_iter()
1509 .map(TryInto::try_into)
1510 .collect::<Result<_, _>>(),
1511 );
1512 (transactions, user_signatures)
1513 },
1514 );
1515 crate::messages_checkpoint::CheckpointContents::new_with_digests_and_signatures(
1516 transactions,
1517 user_signatures.into_iter().collect::<Result<Vec<_>, _>>()?,
1518 )
1519 .pipe(Ok)
1520 }
1521}
1522
1523impl TryFrom<crate::full_checkpoint_content::CheckpointData> for CheckpointData {
1524 type Error = SdkTypeConversionError;
1525
1526 fn try_from(
1527 value: crate::full_checkpoint_content::CheckpointData,
1528 ) -> Result<Self, Self::Error> {
1529 Self {
1530 checkpoint_summary: value.checkpoint_summary.try_into()?,
1531 checkpoint_contents: value.checkpoint_contents.try_into()?,
1532 transactions: value
1533 .transactions
1534 .into_iter()
1535 .map(TryInto::try_into)
1536 .collect::<Result<_, _>>()?,
1537 }
1538 .pipe(Ok)
1539 }
1540}
1541
1542impl TryFrom<CheckpointData> for crate::full_checkpoint_content::CheckpointData {
1543 type Error = SdkTypeConversionError;
1544
1545 fn try_from(value: CheckpointData) -> Result<Self, Self::Error> {
1546 Self {
1547 checkpoint_summary: value.checkpoint_summary.try_into()?,
1548 checkpoint_contents: value.checkpoint_contents.try_into()?,
1549 transactions: value
1550 .transactions
1551 .into_iter()
1552 .map(TryInto::try_into)
1553 .collect::<Result<_, _>>()?,
1554 }
1555 .pipe(Ok)
1556 }
1557}
1558
1559impl TryFrom<crate::full_checkpoint_content::CheckpointTransaction> for CheckpointTransaction {
1560 type Error = SdkTypeConversionError;
1561
1562 fn try_from(
1563 value: crate::full_checkpoint_content::CheckpointTransaction,
1564 ) -> Result<Self, Self::Error> {
1565 let input_objects = value
1566 .input_objects
1567 .into_iter()
1568 .map(TryInto::try_into)
1569 .collect::<Result<_, _>>();
1570 let output_objects = value
1571 .output_objects
1572 .into_iter()
1573 .map(TryInto::try_into)
1574 .collect::<Result<_, _>>();
1575 match (input_objects, output_objects) {
1576 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1577 transaction: value.transaction.try_into()?,
1578 effects: value.effects.try_into()?,
1579 events: value.events.map(TryInto::try_into).transpose()?,
1580 input_objects,
1581 output_objects,
1582 }),
1583 (Err(e), _) | (_, Err(e)) => Err(e),
1584 }
1585 }
1586}
1587
1588impl TryFrom<CheckpointTransaction> for crate::full_checkpoint_content::CheckpointTransaction {
1589 type Error = SdkTypeConversionError;
1590
1591 fn try_from(value: CheckpointTransaction) -> Result<Self, Self::Error> {
1592 let input_objects = value
1593 .input_objects
1594 .into_iter()
1595 .map(TryInto::try_into)
1596 .collect::<Result<_, _>>();
1597 let output_objects = value
1598 .output_objects
1599 .into_iter()
1600 .map(TryInto::try_into)
1601 .collect::<Result<_, _>>();
1602
1603 match (input_objects, output_objects) {
1604 (Ok(input_objects), Ok(output_objects)) => Ok(Self {
1605 transaction: value.transaction.try_into()?,
1606 effects: value.effects.try_into()?,
1607 events: value.events.map(TryInto::try_into).transpose()?,
1608 input_objects,
1609 output_objects,
1610 }),
1611 (Err(e), _) | (_, Err(e)) => Err(e),
1612 }
1613 }
1614}
1615
1616impl TryFrom<crate::signature::GenericSignature> for UserSignature {
1617 type Error = bcs::Error;
1618
1619 fn try_from(value: crate::signature::GenericSignature) -> Result<Self, Self::Error> {
1620 bcs::from_bytes(&bcs::to_bytes(&value)?)
1621 }
1622}
1623
1624impl TryFrom<UserSignature> for crate::signature::GenericSignature {
1625 type Error = bcs::Error;
1626
1627 fn try_from(value: UserSignature) -> Result<Self, Self::Error> {
1628 bcs::from_bytes(&bcs::to_bytes(&value)?)
1629 }
1630}
1631
1632impl TryFrom<crate::effects::TransactionEvents> for TransactionEvents {
1633 type Error = SdkTypeConversionError;
1634
1635 fn try_from(value: crate::effects::TransactionEvents) -> Result<Self, Self::Error> {
1636 Self(
1637 value
1638 .data
1639 .into_iter()
1640 .map(TryInto::try_into)
1641 .collect::<Result<Vec<_>, _>>()?,
1642 )
1643 .pipe(Ok)
1644 }
1645}
1646
1647impl TryFrom<TransactionEvents> for crate::effects::TransactionEvents {
1648 type Error = SdkTypeConversionError;
1649
1650 fn try_from(value: TransactionEvents) -> Result<Self, Self::Error> {
1651 Self {
1652 data: value
1653 .0
1654 .into_iter()
1655 .map(TryInto::try_into)
1656 .collect::<Result<_, _>>()?,
1657 }
1658 .pipe(Ok)
1659 }
1660}
1661
1662impl TryFrom<crate::event::Event> for Event {
1663 type Error = SdkTypeConversionError;
1664
1665 fn try_from(value: crate::event::Event) -> Result<Self, Self::Error> {
1666 Self {
1667 package_id: value.package_id.into(),
1668 module: Identifier::new(value.transaction_module.as_str())?,
1669 sender: value.sender.into(),
1670 type_: struct_tag_core_to_sdk(value.type_)?,
1671 contents: value.contents,
1672 }
1673 .pipe(Ok)
1674 }
1675}
1676
1677impl TryFrom<Event> for crate::event::Event {
1678 type Error = SdkTypeConversionError;
1679
1680 fn try_from(value: Event) -> Result<Self, Self::Error> {
1681 Self {
1682 package_id: value.package_id.into(),
1683 transaction_module: crate::Identifier::new(value.module.as_str())?,
1684 sender: value.sender.into(),
1685 type_: struct_tag_sdk_to_core(value.type_)?,
1686 contents: value.contents,
1687 }
1688 .pipe(Ok)
1689 }
1690}
1691
1692impl TryFrom<crate::transaction::Command> for Command {
1693 type Error = SdkTypeConversionError;
1694
1695 fn try_from(value: crate::transaction::Command) -> Result<Self, Self::Error> {
1696 use crate::transaction::Command as InternalCmd;
1697 match value {
1698 InternalCmd::MoveCall(programmable_move_call) => Self::MoveCall(MoveCall {
1699 package: programmable_move_call.package.into(),
1700 module: Identifier::new(programmable_move_call.module.as_str())?,
1701 function: Identifier::new(programmable_move_call.function.as_str())?,
1702 type_arguments: programmable_move_call
1703 .type_arguments
1704 .into_iter()
1705 .map(type_tag_core_to_sdk)
1706 .collect::<Result<_, _>>()?,
1707 arguments: programmable_move_call
1708 .arguments
1709 .into_iter()
1710 .map(Into::into)
1711 .collect(),
1712 }),
1713 InternalCmd::TransferObjects(objects, address) => {
1714 Self::TransferObjects(TransferObjects {
1715 objects: objects.into_iter().map(Into::into).collect(),
1716 address: address.into(),
1717 })
1718 }
1719 InternalCmd::SplitCoins(coin, amounts) => Self::SplitCoins(SplitCoins {
1720 coin: coin.into(),
1721 amounts: amounts.into_iter().map(Into::into).collect(),
1722 }),
1723 InternalCmd::MergeCoins(argument, coins_to_merge) => Self::MergeCoins(MergeCoins {
1724 coin: argument.into(),
1725 coins_to_merge: coins_to_merge.into_iter().map(Into::into).collect(),
1726 }),
1727 InternalCmd::Publish(modules, dependencies) => Self::Publish(Publish {
1728 modules,
1729 dependencies: dependencies.into_iter().map(Into::into).collect(),
1730 }),
1731 InternalCmd::MakeMoveVec(type_tag, elements) => Self::MakeMoveVector(MakeMoveVector {
1732 type_: type_tag.map(type_tag_core_to_sdk).transpose()?,
1733 elements: elements.into_iter().map(Into::into).collect(),
1734 }),
1735 InternalCmd::Upgrade(modules, dependencies, package, ticket) => {
1736 Self::Upgrade(Upgrade {
1737 modules,
1738 dependencies: dependencies.into_iter().map(Into::into).collect(),
1739 package: package.into(),
1740 ticket: ticket.into(),
1741 })
1742 }
1743 }
1744 .pipe(Ok)
1745 }
1746}
1747
1748impl TryFrom<Command> for crate::transaction::Command {
1749 type Error = SdkTypeConversionError;
1750
1751 fn try_from(value: Command) -> Result<Self, Self::Error> {
1752 match value {
1753 Command::MoveCall(move_call) => {
1754 Self::MoveCall(Box::new(crate::transaction::ProgrammableMoveCall {
1755 package: move_call.package.into(),
1756 module: crate::Identifier::new(move_call.module.as_str())
1757 .expect("invalid move call module identifier"),
1758 function: crate::Identifier::new(move_call.function.as_str())
1759 .expect("invalid move call function identifier"),
1760 type_arguments: move_call
1761 .type_arguments
1762 .into_iter()
1763 .map(type_tag_sdk_to_core)
1764 .collect::<Result<_, _>>()?,
1765 arguments: move_call.arguments.into_iter().map(Into::into).collect(),
1766 }))
1767 }
1768 Command::TransferObjects(transfer_objects) => Self::TransferObjects(
1769 transfer_objects
1770 .objects
1771 .into_iter()
1772 .map(Into::into)
1773 .collect(),
1774 transfer_objects.address.into(),
1775 ),
1776 Command::SplitCoins(split_coins) => Self::SplitCoins(
1777 split_coins.coin.into(),
1778 split_coins.amounts.into_iter().map(Into::into).collect(),
1779 ),
1780 Command::MergeCoins(merge_coins) => Self::MergeCoins(
1781 merge_coins.coin.into(),
1782 merge_coins
1783 .coins_to_merge
1784 .into_iter()
1785 .map(Into::into)
1786 .collect(),
1787 ),
1788 Command::Publish(publish) => Self::Publish(
1789 publish.modules,
1790 publish.dependencies.into_iter().map(Into::into).collect(),
1791 ),
1792 Command::MakeMoveVector(make_move_vector) => Self::MakeMoveVec(
1793 make_move_vector
1794 .type_
1795 .map(type_tag_sdk_to_core)
1796 .transpose()?,
1797 make_move_vector
1798 .elements
1799 .into_iter()
1800 .map(Into::into)
1801 .collect(),
1802 ),
1803 Command::Upgrade(upgrade) => Self::Upgrade(
1804 upgrade.modules,
1805 upgrade.dependencies.into_iter().map(Into::into).collect(),
1806 upgrade.package.into(),
1807 upgrade.ticket.into(),
1808 ),
1809 }
1810 .pipe(Ok)
1811 }
1812}
1813
1814impl From<crate::transaction::Argument> for Argument {
1815 fn from(value: crate::transaction::Argument) -> Self {
1816 match value {
1817 crate::transaction::Argument::GasCoin => Self::Gas,
1818 crate::transaction::Argument::Input(idx) => Self::Input(idx),
1819 crate::transaction::Argument::Result(idx) => Self::Result(idx),
1820 crate::transaction::Argument::NestedResult(idx1, idx2) => {
1821 Self::NestedResult(idx1, idx2)
1822 }
1823 }
1824 }
1825}
1826
1827impl From<Argument> for crate::transaction::Argument {
1828 fn from(value: Argument) -> Self {
1829 match value {
1830 Argument::Gas => Self::GasCoin,
1831 Argument::Input(idx) => Self::Input(idx),
1832 Argument::Result(idx) => Self::Result(idx),
1833 Argument::NestedResult(idx1, idx2) => Self::NestedResult(idx1, idx2),
1834 }
1835 }
1836}
1837
1838impl From<crate::gas::GasCostSummary> for GasCostSummary {
1839 fn from(value: crate::gas::GasCostSummary) -> Self {
1840 Self::new(
1841 value.computation_cost,
1842 value.computation_cost_burned,
1843 value.storage_cost,
1844 value.storage_rebate,
1845 value.non_refundable_storage_fee,
1846 )
1847 }
1848}
1849
1850impl From<GasCostSummary> for crate::gas::GasCostSummary {
1851 fn from(value: GasCostSummary) -> Self {
1852 Self::new(
1853 value.computation_cost,
1854 value.computation_cost_burned,
1855 value.storage_cost,
1856 value.storage_rebate,
1857 value.non_refundable_storage_fee,
1858 )
1859 }
1860}
1861
1862impl From<crate::messages_checkpoint::EndOfEpochData> for EndOfEpochData {
1863 fn from(value: crate::messages_checkpoint::EndOfEpochData) -> Self {
1864 Self {
1865 next_epoch_committee: value
1866 .next_epoch_committee
1867 .into_iter()
1868 .map(|(public_key, stake)| ValidatorCommitteeMember {
1869 public_key: Bls12381PublicKey::new(public_key.0),
1870 stake,
1871 })
1872 .collect(),
1873 next_epoch_protocol_version: value.next_epoch_protocol_version.as_u64(),
1874 epoch_commitments: value
1875 .epoch_commitments
1876 .into_iter()
1877 .map(Into::into)
1878 .collect(),
1879 epoch_supply_change: value.epoch_supply_change,
1880 }
1881 }
1882}
1883
1884impl From<EndOfEpochData> for crate::messages_checkpoint::EndOfEpochData {
1885 fn from(value: EndOfEpochData) -> Self {
1886 Self {
1887 next_epoch_committee: value
1888 .next_epoch_committee
1889 .into_iter()
1890 .map(|v| (v.public_key.into(), v.stake))
1891 .collect(),
1892 next_epoch_protocol_version: value.next_epoch_protocol_version.into(),
1893 epoch_commitments: value
1894 .epoch_commitments
1895 .into_iter()
1896 .map(Into::into)
1897 .collect(),
1898 epoch_supply_change: value.epoch_supply_change,
1899 }
1900 }
1901}
1902
1903impl From<crate::messages_checkpoint::CheckpointCommitment> for CheckpointCommitment {
1904 fn from(value: crate::messages_checkpoint::CheckpointCommitment) -> Self {
1905 let crate::messages_checkpoint::CheckpointCommitment::ECMHLiveObjectSetDigest(digest) =
1906 value;
1907 Self::EcmhLiveObjectSet {
1908 digest: Digest::new(digest.digest.into_inner()),
1909 }
1910 }
1911}
1912
1913impl From<CheckpointCommitment> for crate::messages_checkpoint::CheckpointCommitment {
1914 fn from(value: CheckpointCommitment) -> Self {
1915 let CheckpointCommitment::EcmhLiveObjectSet { digest } = value;
1916 Self::ECMHLiveObjectSetDigest(crate::messages_checkpoint::ECMHLiveObjectSetDigest {
1917 digest: crate::digests::Digest::new(digest.into_inner()),
1918 })
1919 }
1920}
1921
1922impl TryFrom<crate::messages_checkpoint::CheckpointSummary> for CheckpointSummary {
1923 type Error = SdkTypeConversionError;
1924
1925 fn try_from(value: crate::messages_checkpoint::CheckpointSummary) -> Result<Self, Self::Error> {
1926 Self {
1927 epoch: value.epoch,
1928 sequence_number: value.sequence_number,
1929 network_total_transactions: value.network_total_transactions,
1930 content_digest: value.content_digest.into(),
1931 previous_digest: value.previous_digest.map(Into::into),
1932 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
1933 timestamp_ms: value.timestamp_ms,
1934 checkpoint_commitments: value
1935 .checkpoint_commitments
1936 .into_iter()
1937 .map(Into::into)
1938 .collect(),
1939 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
1940 version_specific_data: value.version_specific_data,
1941 }
1942 .pipe(Ok)
1943 }
1944}
1945
1946impl TryFrom<CheckpointSummary> for crate::messages_checkpoint::CheckpointSummary {
1947 type Error = SdkTypeConversionError;
1948
1949 fn try_from(value: CheckpointSummary) -> Result<Self, Self::Error> {
1950 Self {
1951 epoch: value.epoch,
1952 sequence_number: value.sequence_number,
1953 network_total_transactions: value.network_total_transactions,
1954 content_digest: value.content_digest.into(),
1955 previous_digest: value.previous_digest.map(Into::into),
1956 epoch_rolling_gas_cost_summary: value.epoch_rolling_gas_cost_summary.into(),
1957 timestamp_ms: value.timestamp_ms,
1958 checkpoint_commitments: value
1959 .checkpoint_commitments
1960 .into_iter()
1961 .map(Into::into)
1962 .collect(),
1963 end_of_epoch_data: value.end_of_epoch_data.map(Into::into),
1964 version_specific_data: value.version_specific_data,
1965 }
1966 .pipe(Ok)
1967 }
1968}
1969
1970impl TryFrom<crate::messages_checkpoint::CertifiedCheckpointSummary> for SignedCheckpointSummary {
1971 type Error = SdkTypeConversionError;
1972
1973 fn try_from(
1974 value: crate::messages_checkpoint::CertifiedCheckpointSummary,
1975 ) -> Result<Self, Self::Error> {
1976 let (data, sig) = value.into_data_and_sig();
1977 Self {
1978 checkpoint: data.try_into()?,
1979 signature: sig.into(),
1980 }
1981 .pipe(Ok)
1982 }
1983}
1984
1985impl TryFrom<SignedCheckpointSummary> for crate::messages_checkpoint::CertifiedCheckpointSummary {
1986 type Error = SdkTypeConversionError;
1987
1988 fn try_from(value: SignedCheckpointSummary) -> Result<Self, Self::Error> {
1989 Self::new_from_data_and_sig(
1990 crate::messages_checkpoint::CheckpointSummary::try_from(value.checkpoint)?,
1991 crate::crypto::AuthorityQuorumSignInfo::<true>::from(value.signature),
1992 )
1993 .pipe(Ok)
1994 }
1995}
1996
1997impl<const T: bool> From<crate::crypto::AuthorityQuorumSignInfo<T>>
1998 for ValidatorAggregatedSignature
1999{
2000 fn from(value: crate::crypto::AuthorityQuorumSignInfo<T>) -> Self {
2001 let crate::crypto::AuthorityQuorumSignInfo {
2002 epoch,
2003 signature,
2004 signers_map,
2005 } = value;
2006
2007 Self {
2008 epoch,
2009 signature: Bls12381Signature::from_bytes(signature.as_ref()).unwrap(),
2010 bitmap: signers_map,
2011 }
2012 }
2013}
2014
2015impl<const T: bool> From<ValidatorAggregatedSignature>
2016 for crate::crypto::AuthorityQuorumSignInfo<T>
2017{
2018 fn from(value: ValidatorAggregatedSignature) -> Self {
2019 let ValidatorAggregatedSignature {
2020 epoch,
2021 signature,
2022 bitmap,
2023 } = value;
2024
2025 Self {
2026 epoch,
2027 signature: crate::crypto::AggregateAuthoritySignature::from_bytes(signature.as_bytes())
2028 .unwrap(),
2029 signers_map: bitmap,
2030 }
2031 }
2032}
2033
2034impl From<crate::object::Owner> for Owner {
2035 fn from(value: crate::object::Owner) -> Self {
2036 match value {
2037 crate::object::Owner::AddressOwner(address) => Self::Address(address.into()),
2038 crate::object::Owner::ObjectOwner(object_id) => Self::Object(object_id.into()),
2039 crate::object::Owner::Shared {
2040 initial_shared_version,
2041 } => Self::Shared(initial_shared_version.value()),
2042 crate::object::Owner::Immutable => Self::Immutable,
2043 }
2044 }
2045}
2046
2047impl From<Owner> for crate::object::Owner {
2048 fn from(value: Owner) -> Self {
2049 match value {
2050 Owner::Address(address) => crate::object::Owner::AddressOwner(address.into()),
2051 Owner::Object(object_id) => crate::object::Owner::ObjectOwner(object_id.into()),
2052 Owner::Shared(initial_shared_version) => crate::object::Owner::Shared {
2053 initial_shared_version: initial_shared_version.into(),
2054 },
2055 Owner::Immutable => crate::object::Owner::Immutable,
2056 }
2057 }
2058}
2059
2060impl From<crate::base_types::IotaAddress> for Address {
2061 fn from(value: crate::base_types::IotaAddress) -> Self {
2062 Self::new(value.to_inner())
2063 }
2064}
2065
2066impl From<Address> for crate::base_types::IotaAddress {
2067 fn from(value: Address) -> Self {
2068 crate::base_types::ObjectID::new(value.into_inner()).into()
2069 }
2070}
2071
2072impl From<crate::base_types::ObjectID> for ObjectId {
2073 fn from(value: crate::base_types::ObjectID) -> Self {
2074 Self::new(value.into_bytes())
2075 }
2076}
2077
2078impl From<ObjectId> for crate::base_types::ObjectID {
2079 fn from(value: ObjectId) -> Self {
2080 Self::new(value.into_inner())
2081 }
2082}
2083
2084impl From<crate::base_types::IotaAddress> for ObjectId {
2085 fn from(value: crate::base_types::IotaAddress) -> Self {
2086 Self::new(value.to_inner())
2087 }
2088}
2089
2090impl From<ObjectId> for crate::base_types::IotaAddress {
2091 fn from(value: ObjectId) -> Self {
2092 crate::base_types::ObjectID::new(value.into_inner()).into()
2093 }
2094}
2095
2096impl TryFrom<crate::transaction::SenderSignedData> for SignedTransaction {
2097 type Error = SdkTypeConversionError;
2098
2099 fn try_from(value: crate::transaction::SenderSignedData) -> Result<Self, Self::Error> {
2100 let crate::transaction::SenderSignedTransaction {
2101 intent_message,
2102 tx_signatures,
2103 } = value.into_inner();
2104
2105 Self {
2106 transaction: intent_message.value.try_into()?,
2107 signatures: tx_signatures
2108 .into_iter()
2109 .map(TryInto::try_into)
2110 .collect::<Result<_, _>>()?,
2111 }
2112 .pipe(Ok)
2113 }
2114}
2115
2116impl TryFrom<SignedTransaction> for crate::transaction::SenderSignedData {
2117 type Error = SdkTypeConversionError;
2118
2119 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2120 let SignedTransaction {
2121 transaction,
2122 signatures,
2123 } = value;
2124
2125 Self::new(
2126 transaction.try_into()?,
2127 signatures
2128 .into_iter()
2129 .map(TryInto::try_into)
2130 .collect::<Result<_, _>>()?,
2131 )
2132 .pipe(Ok)
2133 }
2134}
2135
2136impl TryFrom<crate::transaction::Transaction> for SignedTransaction {
2137 type Error = SdkTypeConversionError;
2138
2139 fn try_from(value: crate::transaction::Transaction) -> Result<Self, Self::Error> {
2140 value.into_data().try_into()
2141 }
2142}
2143
2144impl TryFrom<SignedTransaction> for crate::transaction::Transaction {
2145 type Error = SdkTypeConversionError;
2146
2147 fn try_from(value: SignedTransaction) -> Result<Self, Self::Error> {
2148 Ok(Self::new(value.try_into()?))
2149 }
2150}
2151
2152pub fn type_tag_core_to_sdk(
2153 value: move_core_types::language_storage::TypeTag,
2154) -> Result<TypeTag, SdkTypeConversionError> {
2155 match value {
2156 move_core_types::language_storage::TypeTag::Bool => TypeTag::Bool,
2157 move_core_types::language_storage::TypeTag::U8 => TypeTag::U8,
2158 move_core_types::language_storage::TypeTag::U64 => TypeTag::U64,
2159 move_core_types::language_storage::TypeTag::U128 => TypeTag::U128,
2160 move_core_types::language_storage::TypeTag::Address => TypeTag::Address,
2161 move_core_types::language_storage::TypeTag::Signer => TypeTag::Signer,
2162 move_core_types::language_storage::TypeTag::Vector(type_tag) => {
2163 TypeTag::Vector(Box::new(type_tag_core_to_sdk(*type_tag)?))
2164 }
2165 move_core_types::language_storage::TypeTag::Struct(struct_tag) => {
2166 TypeTag::Struct(Box::new(struct_tag_core_to_sdk(*struct_tag)?))
2167 }
2168 move_core_types::language_storage::TypeTag::U16 => TypeTag::U16,
2169 move_core_types::language_storage::TypeTag::U32 => TypeTag::U32,
2170 move_core_types::language_storage::TypeTag::U256 => TypeTag::U256,
2171 }
2172 .pipe(Ok)
2173}
2174
2175pub fn type_tag_sdk_to_core(
2176 value: TypeTag,
2177) -> Result<move_core_types::language_storage::TypeTag, SdkTypeConversionError> {
2178 match value {
2179 TypeTag::Bool => move_core_types::language_storage::TypeTag::Bool,
2180 TypeTag::U8 => move_core_types::language_storage::TypeTag::U8,
2181 TypeTag::U64 => move_core_types::language_storage::TypeTag::U64,
2182 TypeTag::U128 => move_core_types::language_storage::TypeTag::U128,
2183 TypeTag::Address => move_core_types::language_storage::TypeTag::Address,
2184 TypeTag::Signer => move_core_types::language_storage::TypeTag::Signer,
2185 TypeTag::Vector(type_tag) => move_core_types::language_storage::TypeTag::Vector(Box::new(
2186 type_tag_sdk_to_core(*type_tag)?,
2187 )),
2188 TypeTag::Struct(struct_tag) => move_core_types::language_storage::TypeTag::Struct(
2189 Box::new(struct_tag_sdk_to_core(*struct_tag)?),
2190 ),
2191 TypeTag::U16 => move_core_types::language_storage::TypeTag::U16,
2192 TypeTag::U32 => move_core_types::language_storage::TypeTag::U32,
2193 TypeTag::U256 => move_core_types::language_storage::TypeTag::U256,
2194 }
2195 .pipe(Ok)
2196}
2197
2198pub fn struct_tag_core_to_sdk(
2199 value: move_core_types::language_storage::StructTag,
2200) -> Result<StructTag, SdkTypeConversionError> {
2201 let move_core_types::language_storage::StructTag {
2202 address,
2203 module,
2204 name,
2205 type_params,
2206 } = value;
2207
2208 let address = Address::new(address.into_bytes());
2209 let module = Identifier::new(module.as_str())?;
2210 let name = Identifier::new(name.as_str())?;
2211 let type_params = type_params
2212 .into_iter()
2213 .map(type_tag_core_to_sdk)
2214 .collect::<Result<_, _>>()?;
2215 StructTag {
2216 address,
2217 module,
2218 name,
2219 type_params,
2220 }
2221 .pipe(Ok)
2222}
2223
2224pub fn struct_tag_sdk_to_core(
2225 value: StructTag,
2226) -> Result<move_core_types::language_storage::StructTag, SdkTypeConversionError> {
2227 let StructTag {
2228 address,
2229 module,
2230 name,
2231 type_params,
2232 } = value;
2233
2234 let address = move_core_types::account_address::AccountAddress::new(address.into_inner());
2235 let module = move_core_types::identifier::Identifier::new(module.into_inner())?;
2236 let name = move_core_types::identifier::Identifier::new(name.into_inner())?;
2237 let type_params = type_params
2238 .into_iter()
2239 .map(type_tag_sdk_to_core)
2240 .collect::<Result<_, _>>()?;
2241 move_core_types::language_storage::StructTag {
2242 address,
2243 module,
2244 name,
2245 type_params,
2246 }
2247 .pipe(Ok)
2248}
2249
2250impl From<crate::committee::Committee> for ValidatorCommittee {
2251 fn from(value: crate::committee::Committee) -> Self {
2252 Self {
2253 epoch: value.epoch(),
2254 members: value
2255 .voting_rights
2256 .into_iter()
2257 .map(|(name, stake)| ValidatorCommitteeMember {
2258 public_key: name.into(),
2259 stake,
2260 })
2261 .collect(),
2262 }
2263 }
2264}
2265
2266impl From<ValidatorCommittee> for crate::committee::Committee {
2267 fn from(value: ValidatorCommittee) -> Self {
2268 let ValidatorCommittee { epoch, members } = value;
2269
2270 Self::new(
2271 epoch,
2272 members
2273 .into_iter()
2274 .map(|member| (member.public_key.into(), member.stake))
2275 .collect(),
2276 )
2277 }
2278}
2279
2280impl From<crate::crypto::AuthorityPublicKeyBytes> for Bls12381PublicKey {
2281 fn from(value: crate::crypto::AuthorityPublicKeyBytes) -> Self {
2282 Self::new(value.0)
2283 }
2284}
2285
2286impl From<Bls12381PublicKey> for crate::crypto::AuthorityPublicKeyBytes {
2287 fn from(value: Bls12381PublicKey) -> Self {
2288 Self::new(value.into_inner())
2289 }
2290}
2291
2292impl From<UnchangedSharedKind> for crate::effects::UnchangedSharedKind {
2293 fn from(value: UnchangedSharedKind) -> Self {
2294 match value {
2295 UnchangedSharedKind::ReadOnlyRoot { version, digest } => {
2296 Self::ReadOnlyRoot((version.into(), digest.into()))
2297 }
2298 UnchangedSharedKind::MutateDeleted { version } => Self::MutateDeleted(version.into()),
2299 UnchangedSharedKind::ReadDeleted { version } => Self::ReadDeleted(version.into()),
2300 UnchangedSharedKind::Cancelled { version } => Self::Cancelled(version.into()),
2301 UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2302 }
2303 }
2304}
2305
2306impl From<crate::effects::UnchangedSharedKind> for UnchangedSharedKind {
2307 fn from(value: crate::effects::UnchangedSharedKind) -> Self {
2308 match value {
2309 crate::effects::UnchangedSharedKind::ReadOnlyRoot((version, digest)) => {
2310 Self::ReadOnlyRoot {
2311 version: version.into(),
2312 digest: digest.into(),
2313 }
2314 }
2315 crate::effects::UnchangedSharedKind::MutateDeleted(version) => Self::MutateDeleted {
2316 version: version.into(),
2317 },
2318 crate::effects::UnchangedSharedKind::ReadDeleted(version) => Self::ReadDeleted {
2319 version: version.into(),
2320 },
2321 crate::effects::UnchangedSharedKind::Cancelled(version) => Self::Cancelled {
2322 version: version.into(),
2323 },
2324 crate::effects::UnchangedSharedKind::PerEpochConfig => Self::PerEpochConfig,
2325 }
2326 }
2327}
2328
2329impl From<crate::transaction::TransactionExpiration> for TransactionExpiration {
2330 fn from(value: crate::transaction::TransactionExpiration) -> Self {
2331 match value {
2332 crate::transaction::TransactionExpiration::None => Self::None,
2333 crate::transaction::TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2334 }
2335 }
2336}
2337
2338impl From<TransactionExpiration> for crate::transaction::TransactionExpiration {
2339 fn from(value: TransactionExpiration) -> Self {
2340 match value {
2341 TransactionExpiration::None => Self::None,
2342 TransactionExpiration::Epoch(epoch) => Self::Epoch(epoch),
2343 }
2344 }
2345}