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