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