1use super::*;
2use crate::field::FieldMaskTree;
3use crate::merge::Merge;
4use crate::proto::TryFromProtoError;
5use tap::Pipe;
6
7impl From<sui_sdk_types::Transaction> for Transaction {
12 fn from(value: sui_sdk_types::Transaction) -> Self {
13 Self::merge_from(value, &FieldMaskTree::new_wildcard())
14 }
15}
16
17impl Merge<sui_sdk_types::Transaction> for Transaction {
18 fn merge(&mut self, source: sui_sdk_types::Transaction, mask: &FieldMaskTree) {
19 if mask.contains(Self::BCS_FIELD.name) {
20 let mut bcs = Bcs::serialize(&source).unwrap();
21 bcs.name = Some("TransactionData".to_owned());
22 self.bcs = Some(bcs);
23 }
24
25 if mask.contains(Self::DIGEST_FIELD.name) {
26 self.digest = Some(source.digest().to_string());
27 }
28
29 if mask.contains(Self::VERSION_FIELD.name) {
30 self.version = Some(1);
31 }
32
33 if mask.contains(Self::KIND_FIELD.name) {
34 self.kind = Some(source.kind.into());
35 }
36
37 if mask.contains(Self::SENDER_FIELD.name) {
38 self.sender = Some(source.sender.to_string());
39 }
40
41 if mask.contains(Self::GAS_PAYMENT_FIELD.name) {
42 self.gas_payment = Some(source.gas_payment.into());
43 }
44
45 if mask.contains(Self::EXPIRATION_FIELD.name) {
46 self.expiration = Some(source.expiration.into());
47 }
48 }
49}
50
51impl Merge<&Transaction> for Transaction {
52 fn merge(&mut self, source: &Transaction, mask: &FieldMaskTree) {
53 let Transaction {
54 bcs,
55 digest,
56 version,
57 kind,
58 sender,
59 gas_payment,
60 expiration,
61 } = source;
62
63 if mask.contains(Self::BCS_FIELD.name) {
64 self.bcs = bcs.clone();
65 }
66
67 if mask.contains(Self::DIGEST_FIELD.name) {
68 self.digest = digest.clone();
69 }
70
71 if mask.contains(Self::VERSION_FIELD.name) {
72 self.version = *version;
73 }
74
75 if mask.contains(Self::KIND_FIELD.name) {
76 self.kind = kind.clone();
77 }
78
79 if mask.contains(Self::SENDER_FIELD.name) {
80 self.sender = sender.clone();
81 }
82
83 if mask.contains(Self::GAS_PAYMENT_FIELD.name) {
84 self.gas_payment = gas_payment.clone();
85 }
86
87 if mask.contains(Self::EXPIRATION_FIELD.name) {
88 self.expiration = expiration.clone();
89 }
90 }
91}
92
93impl TryFrom<&Transaction> for sui_sdk_types::Transaction {
94 type Error = TryFromProtoError;
95
96 fn try_from(value: &Transaction) -> Result<Self, Self::Error> {
97 if let Some(bcs) = &value.bcs {
98 return bcs
99 .deserialize()
100 .map_err(|e| TryFromProtoError::invalid(Transaction::BCS_FIELD, e));
101 }
102
103 match value.version {
104 Some(1) => {}
105 v => {
106 return Err(TryFromProtoError::invalid(
107 Transaction::VERSION_FIELD,
108 format!("unknown Transaction version {v:?}"),
109 ));
110 }
111 }
112
113 let kind = value
114 .kind
115 .as_ref()
116 .ok_or_else(|| TryFromProtoError::missing("kind"))?
117 .try_into()?;
118
119 let sender = value
120 .sender
121 .as_ref()
122 .ok_or_else(|| TryFromProtoError::missing("sender"))?
123 .parse()
124 .map_err(|e| TryFromProtoError::invalid(Transaction::SENDER_FIELD, e))?;
125
126 let gas_payment = value
127 .gas_payment
128 .as_ref()
129 .ok_or_else(|| TryFromProtoError::missing("gas_payment"))?
130 .try_into()?;
131
132 let expiration = value
133 .expiration
134 .as_ref()
135 .ok_or_else(|| TryFromProtoError::missing("expiration"))?
136 .try_into()?;
137
138 Ok(Self {
139 kind,
140 sender,
141 gas_payment,
142 expiration,
143 })
144 }
145}
146
147impl From<sui_sdk_types::GasPayment> for GasPayment {
152 fn from(value: sui_sdk_types::GasPayment) -> Self {
153 Self {
154 objects: value.objects.into_iter().map(Into::into).collect(),
155 owner: Some(value.owner.to_string()),
156 price: Some(value.price),
157 budget: Some(value.budget),
158 }
159 }
160}
161
162impl TryFrom<&GasPayment> for sui_sdk_types::GasPayment {
163 type Error = TryFromProtoError;
164
165 fn try_from(value: &GasPayment) -> Result<Self, Self::Error> {
166 let objects = value
167 .objects
168 .iter()
169 .map(TryInto::try_into)
170 .collect::<Result<_, _>>()?;
171
172 let owner = value
173 .owner
174 .as_ref()
175 .ok_or_else(|| TryFromProtoError::missing("owner"))?
176 .parse()
177 .map_err(|e| TryFromProtoError::invalid(GasPayment::OWNER_FIELD, e))?;
178 let price = value
179 .price
180 .ok_or_else(|| TryFromProtoError::missing("price"))?;
181 let budget = value
182 .budget
183 .ok_or_else(|| TryFromProtoError::missing("budget"))?;
184 Ok(Self {
185 objects,
186 owner,
187 price,
188 budget,
189 })
190 }
191}
192
193impl From<sui_sdk_types::TransactionExpiration> for TransactionExpiration {
198 fn from(value: sui_sdk_types::TransactionExpiration) -> Self {
199 use sui_sdk_types::TransactionExpiration::*;
200 use transaction_expiration::TransactionExpirationKind;
201
202 let mut message = Self::default();
203
204 let kind = match value {
205 None => TransactionExpirationKind::None,
206 Epoch(epoch) => {
207 message.epoch = Some(epoch);
208 TransactionExpirationKind::Epoch
209 }
210 ValidDuring {
211 min_epoch,
212 max_epoch,
213 min_timestamp,
214 max_timestamp,
215 chain,
216 nonce,
217 } => {
218 message.epoch = max_epoch;
219 message.min_epoch = min_epoch;
220 message.set_chain(chain);
221 message.set_nonce(nonce);
222 message.min_timestamp = min_timestamp.map(|seconds| prost_types::Timestamp {
223 seconds: seconds as _,
224 nanos: 0,
225 });
226 message.max_timestamp = max_timestamp.map(|seconds| prost_types::Timestamp {
227 seconds: seconds as _,
228 nanos: 0,
229 });
230 TransactionExpirationKind::ValidDuring
231 }
232 Validity {
233 min_epoch,
234 max_epoch,
235 min_timestamp,
236 max_timestamp,
237 chain,
238 nonce,
239 allowed_proposers,
240 } => {
241 message.epoch = max_epoch;
242 message.min_epoch = min_epoch;
243 message.set_chain(chain);
244 message.set_nonce(nonce);
245 message.min_timestamp = min_timestamp.map(|seconds| prost_types::Timestamp {
246 seconds: seconds as _,
247 nanos: 0,
248 });
249 message.max_timestamp = max_timestamp.map(|seconds| prost_types::Timestamp {
250 seconds: seconds as _,
251 nanos: 0,
252 });
253 if let Some(allowed_proposers) = allowed_proposers {
254 message.set_allowed_proposers(AllowedProposers::from(allowed_proposers));
255 }
256 TransactionExpirationKind::Validity
257 }
258 _ => TransactionExpirationKind::Unknown,
259 };
260
261 message.set_kind(kind);
262 message
263 }
264}
265
266impl From<sui_sdk_types::AllowedProposers> for AllowedProposers {
267 fn from(value: sui_sdk_types::AllowedProposers) -> Self {
268 let mut message = Self::default();
269 message.set_epoch(value.epoch);
270 message.proposers = value.proposers;
271 message
272 }
273}
274
275impl From<&AllowedProposers> for sui_sdk_types::AllowedProposers {
276 fn from(value: &AllowedProposers) -> Self {
277 Self {
278 epoch: value.epoch(),
279 proposers: value.proposers.clone(),
280 }
281 }
282}
283
284impl TryFrom<&TransactionExpiration> for sui_sdk_types::TransactionExpiration {
285 type Error = TryFromProtoError;
286
287 fn try_from(value: &TransactionExpiration) -> Result<Self, Self::Error> {
288 use transaction_expiration::TransactionExpirationKind;
289
290 match value.kind() {
291 TransactionExpirationKind::Unknown => {
292 return Err(TryFromProtoError::invalid(
293 TransactionExpiration::KIND_FIELD,
294 "unknown TransactionExpirationKind",
295 ));
296 }
297 TransactionExpirationKind::None => Self::None,
298 TransactionExpirationKind::Epoch => Self::Epoch(value.epoch()),
299 TransactionExpirationKind::ValidDuring => Self::ValidDuring {
300 min_epoch: value.min_epoch_opt(),
301 max_epoch: value.epoch_opt(),
302 min_timestamp: value
303 .min_timestamp_opt()
304 .map(|timestamp| timestamp.seconds as _),
305 max_timestamp: value
306 .max_timestamp_opt()
307 .map(|timestamp| timestamp.seconds as _),
308 chain: value
309 .chain_opt()
310 .ok_or_else(|| TryFromProtoError::missing("chain"))?
311 .parse()
312 .map_err(|e| TryFromProtoError::invalid("chain", e))?,
313 nonce: value
314 .nonce_opt()
315 .ok_or_else(|| TryFromProtoError::missing("nonce"))?,
316 },
317 TransactionExpirationKind::Validity => Self::Validity {
318 min_epoch: value.min_epoch_opt(),
319 max_epoch: value.epoch_opt(),
320 min_timestamp: value
321 .min_timestamp_opt()
322 .map(|timestamp| timestamp.seconds as _),
323 max_timestamp: value
324 .max_timestamp_opt()
325 .map(|timestamp| timestamp.seconds as _),
326 chain: value
327 .chain_opt()
328 .ok_or_else(|| TryFromProtoError::missing("chain"))?
329 .parse()
330 .map_err(|e| TryFromProtoError::invalid("chain", e))?,
331 nonce: value
332 .nonce_opt()
333 .ok_or_else(|| TryFromProtoError::missing("nonce"))?,
334 allowed_proposers: value.allowed_proposers_opt().map(Into::into),
335 },
336 }
337 .pipe(Ok)
338 }
339}
340
341impl From<ProgrammableTransaction> for TransactionKind {
346 fn from(value: ProgrammableTransaction) -> Self {
347 Self::default()
348 .with_programmable_transaction(value)
349 .with_kind(transaction_kind::Kind::ProgrammableTransaction)
350 }
351}
352
353impl From<sui_sdk_types::TransactionKind> for TransactionKind {
354 fn from(value: sui_sdk_types::TransactionKind) -> Self {
355 use sui_sdk_types::TransactionKind as K;
356 use transaction_kind::Kind;
357
358 let message = Self::default();
359
360 match value {
361 K::ProgrammableTransaction(ptb) => message
362 .with_programmable_transaction(ptb)
363 .with_kind(Kind::ProgrammableTransaction),
364 K::ProgrammableSystemTransaction(ptb) => message
365 .with_programmable_transaction(ptb)
366 .with_kind(Kind::ProgrammableSystemTransaction),
367 K::ChangeEpoch(change_epoch) => message
368 .with_change_epoch(change_epoch)
369 .with_kind(Kind::ChangeEpoch),
370 K::Genesis(genesis) => message.with_genesis(genesis).with_kind(Kind::Genesis),
371 K::ConsensusCommitPrologue(prologue) => message
372 .with_consensus_commit_prologue(prologue)
373 .with_kind(Kind::ConsensusCommitPrologueV1),
374 K::AuthenticatorStateUpdate(update) => message
375 .with_authenticator_state_update(update)
376 .with_kind(Kind::AuthenticatorStateUpdate),
377 K::EndOfEpoch(transactions) => message
378 .with_end_of_epoch(EndOfEpochTransaction {
379 transactions: transactions.into_iter().map(Into::into).collect(),
380 })
381 .with_kind(Kind::EndOfEpoch),
382 K::RandomnessStateUpdate(update) => message
383 .with_randomness_state_update(update)
384 .with_kind(Kind::RandomnessStateUpdate),
385 K::ConsensusCommitPrologueV2(prologue) => message
386 .with_consensus_commit_prologue(prologue)
387 .with_kind(Kind::ConsensusCommitPrologueV2),
388 K::ConsensusCommitPrologueV3(prologue) => message
389 .with_consensus_commit_prologue(prologue)
390 .with_kind(Kind::ConsensusCommitPrologueV3),
391 K::ConsensusCommitPrologueV4(prologue) => message
392 .with_consensus_commit_prologue(prologue)
393 .with_kind(Kind::ConsensusCommitPrologueV4),
394 _ => message,
395 }
396 }
397}
398
399impl TryFrom<&TransactionKind> for sui_sdk_types::TransactionKind {
400 type Error = TryFromProtoError;
401
402 fn try_from(value: &TransactionKind) -> Result<Self, Self::Error> {
403 use transaction_kind::Kind;
404
405 match value.kind() {
406 Kind::Unknown => {
407 return Err(TryFromProtoError::invalid(
408 "kind",
409 "unknown TransactionKind",
410 ));
411 }
412 Kind::ProgrammableTransaction => {
413 Self::ProgrammableTransaction(value.programmable_transaction().try_into()?)
414 }
415 Kind::ChangeEpoch => Self::ChangeEpoch(value.change_epoch().try_into()?),
416 Kind::Genesis => Self::Genesis(value.genesis().try_into()?),
417 Kind::ConsensusCommitPrologueV1 => {
418 Self::ConsensusCommitPrologue(value.consensus_commit_prologue().try_into()?)
419 }
420 Kind::AuthenticatorStateUpdate => {
421 Self::AuthenticatorStateUpdate(value.authenticator_state_update().try_into()?)
422 }
423 Kind::EndOfEpoch => Self::EndOfEpoch(
424 value
425 .end_of_epoch()
426 .transactions()
427 .iter()
428 .map(TryInto::try_into)
429 .collect::<Result<_, _>>()?,
430 ),
431 Kind::RandomnessStateUpdate => {
432 Self::RandomnessStateUpdate(value.randomness_state_update().try_into()?)
433 }
434 Kind::ConsensusCommitPrologueV2 => {
435 Self::ConsensusCommitPrologueV2(value.consensus_commit_prologue().try_into()?)
436 }
437 Kind::ConsensusCommitPrologueV3 => {
438 Self::ConsensusCommitPrologueV3(value.consensus_commit_prologue().try_into()?)
439 }
440 Kind::ConsensusCommitPrologueV4 => {
441 Self::ConsensusCommitPrologueV4(value.consensus_commit_prologue().try_into()?)
442 }
443 Kind::ProgrammableSystemTransaction => {
444 Self::ProgrammableSystemTransaction(value.programmable_transaction().try_into()?)
445 }
446 }
447 .pipe(Ok)
448 }
449}
450
451impl From<sui_sdk_types::ConsensusCommitPrologue> for ConsensusCommitPrologue {
456 fn from(value: sui_sdk_types::ConsensusCommitPrologue) -> Self {
457 Self {
458 epoch: Some(value.epoch),
459 round: Some(value.round),
460 commit_timestamp: Some(crate::proto::timestamp_ms_to_proto(
461 value.commit_timestamp_ms,
462 )),
463 consensus_commit_digest: None,
464 sub_dag_index: None,
465 consensus_determined_version_assignments: None,
466 additional_state_digest: None,
467 }
468 }
469}
470
471impl TryFrom<&ConsensusCommitPrologue> for sui_sdk_types::ConsensusCommitPrologue {
472 type Error = TryFromProtoError;
473
474 fn try_from(value: &ConsensusCommitPrologue) -> Result<Self, Self::Error> {
475 let epoch = value
476 .epoch
477 .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
478 let round = value
479 .round
480 .ok_or_else(|| TryFromProtoError::missing("round"))?;
481 let commit_timestamp_ms = value
482 .commit_timestamp
483 .ok_or_else(|| TryFromProtoError::missing("commit_timestamp"))?
484 .pipe(crate::proto::proto_to_timestamp_ms)?;
485
486 Ok(Self {
487 epoch,
488 round,
489 commit_timestamp_ms,
490 })
491 }
492}
493
494impl From<sui_sdk_types::ConsensusCommitPrologueV2> for ConsensusCommitPrologue {
495 fn from(value: sui_sdk_types::ConsensusCommitPrologueV2) -> Self {
496 Self {
497 epoch: Some(value.epoch),
498 round: Some(value.round),
499 commit_timestamp: Some(crate::proto::timestamp_ms_to_proto(
500 value.commit_timestamp_ms,
501 )),
502 consensus_commit_digest: Some(value.consensus_commit_digest.to_string()),
503 sub_dag_index: None,
504 consensus_determined_version_assignments: None,
505 additional_state_digest: None,
506 }
507 }
508}
509
510impl TryFrom<&ConsensusCommitPrologue> for sui_sdk_types::ConsensusCommitPrologueV2 {
511 type Error = TryFromProtoError;
512
513 fn try_from(value: &ConsensusCommitPrologue) -> Result<Self, Self::Error> {
514 let epoch = value
515 .epoch
516 .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
517 let round = value
518 .round
519 .ok_or_else(|| TryFromProtoError::missing("round"))?;
520 let commit_timestamp_ms = value
521 .commit_timestamp
522 .ok_or_else(|| TryFromProtoError::missing("commit_timestamp"))?
523 .pipe(crate::proto::proto_to_timestamp_ms)?;
524
525 let consensus_commit_digest = value
526 .consensus_commit_digest
527 .as_ref()
528 .ok_or_else(|| TryFromProtoError::missing("consensus_commit_digest"))?
529 .parse()
530 .map_err(|e| {
531 TryFromProtoError::invalid(
532 ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD,
533 e,
534 )
535 })?;
536
537 Ok(Self {
538 epoch,
539 round,
540 commit_timestamp_ms,
541 consensus_commit_digest,
542 })
543 }
544}
545
546impl From<sui_sdk_types::ConsensusCommitPrologueV3> for ConsensusCommitPrologue {
547 fn from(value: sui_sdk_types::ConsensusCommitPrologueV3) -> Self {
548 Self {
549 epoch: Some(value.epoch),
550 round: Some(value.round),
551 commit_timestamp: Some(crate::proto::timestamp_ms_to_proto(
552 value.commit_timestamp_ms,
553 )),
554 consensus_commit_digest: Some(value.consensus_commit_digest.to_string()),
555 sub_dag_index: value.sub_dag_index,
556 consensus_determined_version_assignments: Some(
557 value.consensus_determined_version_assignments.into(),
558 ),
559 additional_state_digest: None,
560 }
561 }
562}
563
564impl TryFrom<&ConsensusCommitPrologue> for sui_sdk_types::ConsensusCommitPrologueV3 {
565 type Error = TryFromProtoError;
566
567 fn try_from(value: &ConsensusCommitPrologue) -> Result<Self, Self::Error> {
568 let epoch = value
569 .epoch
570 .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
571 let round = value
572 .round
573 .ok_or_else(|| TryFromProtoError::missing("round"))?;
574 let commit_timestamp_ms = value
575 .commit_timestamp
576 .ok_or_else(|| TryFromProtoError::missing("commit_timestamp"))?
577 .pipe(crate::proto::proto_to_timestamp_ms)?;
578
579 let consensus_commit_digest = value
580 .consensus_commit_digest
581 .as_ref()
582 .ok_or_else(|| TryFromProtoError::missing("consensus_commit_digest"))?
583 .parse()
584 .map_err(|e| {
585 TryFromProtoError::invalid(
586 ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD,
587 e,
588 )
589 })?;
590
591 let consensus_determined_version_assignments = value
592 .consensus_determined_version_assignments
593 .as_ref()
594 .ok_or_else(|| TryFromProtoError::missing("consensus_determined_version_assignments"))?
595 .try_into()?;
596
597 Ok(Self {
598 epoch,
599 round,
600 commit_timestamp_ms,
601 sub_dag_index: value.sub_dag_index,
602 consensus_commit_digest,
603 consensus_determined_version_assignments,
604 })
605 }
606}
607
608impl From<sui_sdk_types::ConsensusCommitPrologueV4> for ConsensusCommitPrologue {
609 fn from(
610 sui_sdk_types::ConsensusCommitPrologueV4 {
611 epoch,
612 round,
613 sub_dag_index,
614 commit_timestamp_ms,
615 consensus_commit_digest,
616 consensus_determined_version_assignments,
617 additional_state_digest,
618 }: sui_sdk_types::ConsensusCommitPrologueV4,
619 ) -> Self {
620 Self {
621 epoch: Some(epoch),
622 round: Some(round),
623 commit_timestamp: Some(crate::proto::timestamp_ms_to_proto(commit_timestamp_ms)),
624 consensus_commit_digest: Some(consensus_commit_digest.to_string()),
625 sub_dag_index,
626 consensus_determined_version_assignments: Some(
627 consensus_determined_version_assignments.into(),
628 ),
629 additional_state_digest: Some(additional_state_digest.to_string()),
630 }
631 }
632}
633
634impl TryFrom<&ConsensusCommitPrologue> for sui_sdk_types::ConsensusCommitPrologueV4 {
635 type Error = TryFromProtoError;
636
637 fn try_from(value: &ConsensusCommitPrologue) -> Result<Self, Self::Error> {
638 let epoch = value
639 .epoch
640 .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
641 let round = value
642 .round
643 .ok_or_else(|| TryFromProtoError::missing("round"))?;
644 let commit_timestamp_ms = value
645 .commit_timestamp
646 .ok_or_else(|| TryFromProtoError::missing("commit_timestamp"))?
647 .pipe(crate::proto::proto_to_timestamp_ms)?;
648
649 let consensus_commit_digest = value
650 .consensus_commit_digest
651 .as_ref()
652 .ok_or_else(|| TryFromProtoError::missing("consensus_commit_digest"))?
653 .parse()
654 .map_err(|e| {
655 TryFromProtoError::invalid(
656 ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD,
657 e,
658 )
659 })?;
660
661 let consensus_determined_version_assignments = value
662 .consensus_determined_version_assignments
663 .as_ref()
664 .ok_or_else(|| TryFromProtoError::missing("consensus_determined_version_assignments"))?
665 .try_into()?;
666
667 let additional_state_digest = value
668 .additional_state_digest
669 .as_ref()
670 .ok_or_else(|| TryFromProtoError::missing("additional_state_digest"))?
671 .parse()
672 .map_err(|e| {
673 TryFromProtoError::invalid(
674 ConsensusCommitPrologue::ADDITIONAL_STATE_DIGEST_FIELD,
675 e,
676 )
677 })?;
678
679 Ok(Self {
680 epoch,
681 round,
682 commit_timestamp_ms,
683 sub_dag_index: value.sub_dag_index,
684 consensus_commit_digest,
685 consensus_determined_version_assignments,
686 additional_state_digest,
687 })
688 }
689}
690
691impl From<sui_sdk_types::ConsensusDeterminedVersionAssignments>
696 for ConsensusDeterminedVersionAssignments
697{
698 fn from(value: sui_sdk_types::ConsensusDeterminedVersionAssignments) -> Self {
699 use sui_sdk_types::ConsensusDeterminedVersionAssignments::*;
700
701 let mut message = Self::default();
702
703 let version = match value {
704 CanceledTransactions {
705 canceled_transactions,
706 } => {
707 message.canceled_transactions =
708 canceled_transactions.into_iter().map(Into::into).collect();
709 1
710 }
711 CanceledTransactionsV2 {
712 canceled_transactions,
713 } => {
714 message.canceled_transactions =
715 canceled_transactions.into_iter().map(Into::into).collect();
716 2
717 }
718 _ => return Self::default(),
719 };
720
721 message.version = Some(version);
722 message
723 }
724}
725
726impl TryFrom<&ConsensusDeterminedVersionAssignments>
727 for sui_sdk_types::ConsensusDeterminedVersionAssignments
728{
729 type Error = TryFromProtoError;
730
731 fn try_from(value: &ConsensusDeterminedVersionAssignments) -> Result<Self, Self::Error> {
732 match value.version() {
733 1 => Self::CanceledTransactions {
734 canceled_transactions: value
735 .canceled_transactions
736 .iter()
737 .map(TryFrom::try_from)
738 .collect::<Result<_, _>>()?,
739 },
740 2 => Self::CanceledTransactionsV2 {
741 canceled_transactions: value
742 .canceled_transactions
743 .iter()
744 .map(TryFrom::try_from)
745 .collect::<Result<_, _>>()?,
746 },
747 _ => {
748 return Err(TryFromProtoError::invalid(
749 ConsensusDeterminedVersionAssignments::VERSION_FIELD,
750 "unknown ConsensusDeterminedVersionAssignments version",
751 ));
752 }
753 }
754 .pipe(Ok)
755 }
756}
757
758impl From<sui_sdk_types::CanceledTransaction> for CanceledTransaction {
763 fn from(value: sui_sdk_types::CanceledTransaction) -> Self {
764 Self {
765 digest: Some(value.digest.to_string()),
766 version_assignments: value
767 .version_assignments
768 .into_iter()
769 .map(Into::into)
770 .collect(),
771 }
772 }
773}
774
775impl TryFrom<&CanceledTransaction> for sui_sdk_types::CanceledTransaction {
776 type Error = TryFromProtoError;
777
778 fn try_from(value: &CanceledTransaction) -> Result<Self, Self::Error> {
779 let digest = value
780 .digest
781 .as_ref()
782 .ok_or_else(|| TryFromProtoError::missing("digest"))?
783 .parse()
784 .map_err(|e| TryFromProtoError::invalid(CanceledTransaction::DIGEST_FIELD, e))?;
785
786 let version_assignments = value
787 .version_assignments
788 .iter()
789 .map(TryInto::try_into)
790 .collect::<Result<_, _>>()?;
791
792 Ok(Self {
793 digest,
794 version_assignments,
795 })
796 }
797}
798
799impl From<sui_sdk_types::CanceledTransactionV2> for CanceledTransaction {
800 fn from(value: sui_sdk_types::CanceledTransactionV2) -> Self {
801 Self {
802 digest: Some(value.digest.to_string()),
803 version_assignments: value
804 .version_assignments
805 .into_iter()
806 .map(Into::into)
807 .collect(),
808 }
809 }
810}
811
812impl TryFrom<&CanceledTransaction> for sui_sdk_types::CanceledTransactionV2 {
813 type Error = TryFromProtoError;
814
815 fn try_from(value: &CanceledTransaction) -> Result<Self, Self::Error> {
816 let digest = value
817 .digest
818 .as_ref()
819 .ok_or_else(|| TryFromProtoError::missing("digest"))?
820 .parse()
821 .map_err(|e| TryFromProtoError::invalid(CanceledTransaction::DIGEST_FIELD, e))?;
822
823 let version_assignments = value
824 .version_assignments
825 .iter()
826 .map(TryInto::try_into)
827 .collect::<Result<_, _>>()?;
828
829 Ok(Self {
830 digest,
831 version_assignments,
832 })
833 }
834}
835
836impl From<sui_sdk_types::VersionAssignment> for VersionAssignment {
841 fn from(value: sui_sdk_types::VersionAssignment) -> Self {
842 Self {
843 object_id: Some(value.object_id.to_string()),
844 start_version: None,
845 version: Some(value.version),
846 }
847 }
848}
849
850impl TryFrom<&VersionAssignment> for sui_sdk_types::VersionAssignment {
851 type Error = TryFromProtoError;
852
853 fn try_from(value: &VersionAssignment) -> Result<Self, Self::Error> {
854 let object_id = value
855 .object_id
856 .as_ref()
857 .ok_or_else(|| TryFromProtoError::missing("object_id"))?
858 .parse()
859 .map_err(|e| TryFromProtoError::invalid(VersionAssignment::OBJECT_ID_FIELD, e))?;
860 let version = value
861 .version
862 .ok_or_else(|| TryFromProtoError::missing("version"))?;
863
864 Ok(Self { object_id, version })
865 }
866}
867
868impl From<sui_sdk_types::VersionAssignmentV2> for VersionAssignment {
869 fn from(value: sui_sdk_types::VersionAssignmentV2) -> Self {
870 Self {
871 object_id: Some(value.object_id.to_string()),
872 start_version: Some(value.start_version),
873 version: Some(value.version),
874 }
875 }
876}
877
878impl TryFrom<&VersionAssignment> for sui_sdk_types::VersionAssignmentV2 {
879 type Error = TryFromProtoError;
880
881 fn try_from(value: &VersionAssignment) -> Result<Self, Self::Error> {
882 let object_id = value
883 .object_id
884 .as_ref()
885 .ok_or_else(|| TryFromProtoError::missing("object_id"))?
886 .parse()
887 .map_err(|e| TryFromProtoError::invalid(VersionAssignment::OBJECT_ID_FIELD, e))?;
888 let start_version = value
889 .start_version
890 .ok_or_else(|| TryFromProtoError::missing(VersionAssignment::START_VERSION_FIELD))?;
891 let version = value
892 .version
893 .ok_or_else(|| TryFromProtoError::missing("version"))?;
894
895 Ok(Self {
896 object_id,
897 start_version,
898 version,
899 })
900 }
901}
902
903impl From<sui_sdk_types::GenesisTransaction> for GenesisTransaction {
908 fn from(value: sui_sdk_types::GenesisTransaction) -> Self {
909 Self {
910 objects: value.objects.into_iter().map(Into::into).collect(),
911 }
912 }
913}
914
915impl TryFrom<&GenesisTransaction> for sui_sdk_types::GenesisTransaction {
916 type Error = TryFromProtoError;
917
918 fn try_from(value: &GenesisTransaction) -> Result<Self, Self::Error> {
919 let objects = value
920 .objects
921 .iter()
922 .map(TryInto::try_into)
923 .collect::<Result<_, _>>()?;
924
925 Ok(Self { objects })
926 }
927}
928
929impl From<sui_sdk_types::RandomnessStateUpdate> for RandomnessStateUpdate {
934 fn from(value: sui_sdk_types::RandomnessStateUpdate) -> Self {
935 Self {
936 epoch: Some(value.epoch),
937 randomness_round: Some(value.randomness_round),
938 random_bytes: Some(value.random_bytes.into()),
939 randomness_object_initial_shared_version: Some(
940 value.randomness_obj_initial_shared_version,
941 ),
942 }
943 }
944}
945
946impl TryFrom<&RandomnessStateUpdate> for sui_sdk_types::RandomnessStateUpdate {
947 type Error = TryFromProtoError;
948
949 fn try_from(
950 RandomnessStateUpdate {
951 epoch,
952 randomness_round,
953 random_bytes,
954 randomness_object_initial_shared_version,
955 }: &RandomnessStateUpdate,
956 ) -> Result<Self, Self::Error> {
957 let epoch = epoch.ok_or_else(|| TryFromProtoError::missing("epoch"))?;
958 let randomness_round =
959 randomness_round.ok_or_else(|| TryFromProtoError::missing("randomness_round"))?;
960 let random_bytes = random_bytes
961 .as_ref()
962 .ok_or_else(|| TryFromProtoError::missing("random_bytes"))?
963 .to_vec();
964 let randomness_obj_initial_shared_version = randomness_object_initial_shared_version
965 .ok_or_else(|| {
966 TryFromProtoError::missing("randomness_object_initial_shared_version")
967 })?;
968 Ok(Self {
969 epoch,
970 randomness_round,
971 random_bytes,
972 randomness_obj_initial_shared_version,
973 })
974 }
975}
976
977impl From<sui_sdk_types::AuthenticatorStateUpdate> for AuthenticatorStateUpdate {
982 fn from(value: sui_sdk_types::AuthenticatorStateUpdate) -> Self {
983 Self {
984 epoch: Some(value.epoch),
985 round: Some(value.round),
986 new_active_jwks: value.new_active_jwks.into_iter().map(Into::into).collect(),
987 authenticator_object_initial_shared_version: Some(
988 value.authenticator_obj_initial_shared_version,
989 ),
990 }
991 }
992}
993
994impl TryFrom<&AuthenticatorStateUpdate> for sui_sdk_types::AuthenticatorStateUpdate {
995 type Error = TryFromProtoError;
996
997 fn try_from(
998 AuthenticatorStateUpdate {
999 epoch,
1000 round,
1001 new_active_jwks,
1002 authenticator_object_initial_shared_version,
1003 }: &AuthenticatorStateUpdate,
1004 ) -> Result<Self, Self::Error> {
1005 let epoch = epoch.ok_or_else(|| TryFromProtoError::missing("epoch"))?;
1006 let round = round.ok_or_else(|| TryFromProtoError::missing("round"))?;
1007 let authenticator_obj_initial_shared_version = authenticator_object_initial_shared_version
1008 .ok_or_else(|| {
1009 TryFromProtoError::missing("authenticator_object_initial_shared_version")
1010 })?;
1011 Ok(Self {
1012 epoch,
1013 round,
1014 new_active_jwks: new_active_jwks
1015 .iter()
1016 .map(TryInto::try_into)
1017 .collect::<Result<_, _>>()?,
1018 authenticator_obj_initial_shared_version,
1019 })
1020 }
1021}
1022
1023impl From<sui_sdk_types::Jwk> for Jwk {
1028 fn from(sui_sdk_types::Jwk { kty, e, n, alg }: sui_sdk_types::Jwk) -> Self {
1029 Self {
1030 kty: Some(kty),
1031 e: Some(e),
1032 n: Some(n),
1033 alg: Some(alg),
1034 }
1035 }
1036}
1037
1038impl TryFrom<&Jwk> for sui_sdk_types::Jwk {
1039 type Error = TryFromProtoError;
1040
1041 fn try_from(Jwk { kty, e, n, alg }: &Jwk) -> Result<Self, Self::Error> {
1042 let kty = kty
1043 .as_ref()
1044 .ok_or_else(|| TryFromProtoError::missing("kty"))?
1045 .into();
1046 let e = e
1047 .as_ref()
1048 .ok_or_else(|| TryFromProtoError::missing("e"))?
1049 .into();
1050 let n = n
1051 .as_ref()
1052 .ok_or_else(|| TryFromProtoError::missing("n"))?
1053 .into();
1054 let alg = alg
1055 .as_ref()
1056 .ok_or_else(|| TryFromProtoError::missing("alg"))?
1057 .into();
1058 Ok(Self { kty, e, n, alg })
1059 }
1060}
1061
1062impl From<sui_sdk_types::JwkId> for JwkId {
1067 fn from(sui_sdk_types::JwkId { iss, kid }: sui_sdk_types::JwkId) -> Self {
1068 Self {
1069 iss: Some(iss),
1070 kid: Some(kid),
1071 }
1072 }
1073}
1074
1075impl From<&sui_sdk_types::JwkId> for JwkId {
1076 fn from(value: &sui_sdk_types::JwkId) -> Self {
1077 Self {
1078 iss: Some(value.iss.clone()),
1079 kid: Some(value.kid.clone()),
1080 }
1081 }
1082}
1083
1084impl TryFrom<&JwkId> for sui_sdk_types::JwkId {
1085 type Error = TryFromProtoError;
1086
1087 fn try_from(JwkId { iss, kid }: &JwkId) -> Result<Self, Self::Error> {
1088 let iss = iss
1089 .as_ref()
1090 .ok_or_else(|| TryFromProtoError::missing("iss"))?
1091 .into();
1092 let kid = kid
1093 .as_ref()
1094 .ok_or_else(|| TryFromProtoError::missing("kid"))?
1095 .into();
1096 Ok(Self { iss, kid })
1097 }
1098}
1099
1100impl From<sui_sdk_types::ActiveJwk> for ActiveJwk {
1105 fn from(value: sui_sdk_types::ActiveJwk) -> Self {
1106 Self {
1107 id: Some(value.jwk_id.into()),
1108 jwk: Some(value.jwk.into()),
1109 epoch: Some(value.epoch),
1110 }
1111 }
1112}
1113
1114impl TryFrom<&ActiveJwk> for sui_sdk_types::ActiveJwk {
1115 type Error = TryFromProtoError;
1116
1117 fn try_from(value: &ActiveJwk) -> Result<Self, Self::Error> {
1118 let jwk_id = value
1119 .id
1120 .as_ref()
1121 .ok_or_else(|| TryFromProtoError::missing("id"))?
1122 .try_into()?;
1123
1124 let jwk = value
1125 .jwk
1126 .as_ref()
1127 .ok_or_else(|| TryFromProtoError::missing("jwk"))?
1128 .try_into()?;
1129
1130 let epoch = value
1131 .epoch
1132 .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
1133
1134 Ok(Self { jwk_id, jwk, epoch })
1135 }
1136}
1137
1138impl From<sui_sdk_types::ChangeEpoch> for ChangeEpoch {
1143 fn from(value: sui_sdk_types::ChangeEpoch) -> Self {
1144 Self {
1145 epoch: Some(value.epoch),
1146 protocol_version: Some(value.protocol_version),
1147 storage_charge: Some(value.storage_charge),
1148 computation_charge: Some(value.computation_charge),
1149 storage_rebate: Some(value.storage_rebate),
1150 non_refundable_storage_fee: Some(value.non_refundable_storage_fee),
1151 epoch_start_timestamp: Some(crate::proto::timestamp_ms_to_proto(
1152 value.epoch_start_timestamp_ms,
1153 )),
1154 system_packages: value.system_packages.into_iter().map(Into::into).collect(),
1155 }
1156 }
1157}
1158
1159impl TryFrom<&ChangeEpoch> for sui_sdk_types::ChangeEpoch {
1160 type Error = TryFromProtoError;
1161
1162 fn try_from(
1163 ChangeEpoch {
1164 epoch,
1165 protocol_version,
1166 storage_charge,
1167 computation_charge,
1168 storage_rebate,
1169 non_refundable_storage_fee,
1170 epoch_start_timestamp,
1171 system_packages,
1172 }: &ChangeEpoch,
1173 ) -> Result<Self, Self::Error> {
1174 let epoch = epoch.ok_or_else(|| TryFromProtoError::missing("epoch"))?;
1175 let protocol_version =
1176 protocol_version.ok_or_else(|| TryFromProtoError::missing("protocol_version"))?;
1177 let storage_charge =
1178 storage_charge.ok_or_else(|| TryFromProtoError::missing("storage_charge"))?;
1179 let computation_charge =
1180 computation_charge.ok_or_else(|| TryFromProtoError::missing("computation_charge"))?;
1181 let storage_rebate =
1182 storage_rebate.ok_or_else(|| TryFromProtoError::missing("storage_rebate"))?;
1183 let non_refundable_storage_fee = non_refundable_storage_fee
1184 .ok_or_else(|| TryFromProtoError::missing("non_refundable_storage_fee"))?;
1185 let epoch_start_timestamp_ms = epoch_start_timestamp
1186 .ok_or_else(|| TryFromProtoError::missing("epoch_start_timestamp_ms"))?
1187 .pipe(crate::proto::proto_to_timestamp_ms)?;
1188
1189 Ok(Self {
1190 epoch,
1191 protocol_version,
1192 storage_charge,
1193 computation_charge,
1194 storage_rebate,
1195 non_refundable_storage_fee,
1196 epoch_start_timestamp_ms,
1197 system_packages: system_packages
1198 .iter()
1199 .map(TryInto::try_into)
1200 .collect::<Result<_, _>>()?,
1201 })
1202 }
1203}
1204
1205impl From<sui_sdk_types::SystemPackage> for SystemPackage {
1210 fn from(value: sui_sdk_types::SystemPackage) -> Self {
1211 Self {
1212 version: Some(value.version),
1213 modules: value.modules.into_iter().map(Into::into).collect(),
1214 dependencies: value.dependencies.iter().map(ToString::to_string).collect(),
1215 }
1216 }
1217}
1218
1219impl TryFrom<&SystemPackage> for sui_sdk_types::SystemPackage {
1220 type Error = TryFromProtoError;
1221
1222 fn try_from(value: &SystemPackage) -> Result<Self, Self::Error> {
1223 Ok(Self {
1224 version: value
1225 .version
1226 .ok_or_else(|| TryFromProtoError::missing("version"))?,
1227 modules: value.modules.iter().map(|bytes| bytes.to_vec()).collect(),
1228 dependencies: value
1229 .dependencies
1230 .iter()
1231 .map(|s| s.parse())
1232 .collect::<Result<_, _>>()
1233 .map_err(|e| TryFromProtoError::invalid(SystemPackage::DEPENDENCIES_FIELD, e))?,
1234 })
1235 }
1236}
1237
1238impl From<sui_sdk_types::EndOfEpochTransactionKind> for EndOfEpochTransactionKind {
1243 fn from(value: sui_sdk_types::EndOfEpochTransactionKind) -> Self {
1244 use end_of_epoch_transaction_kind::Kind;
1245 use sui_sdk_types::EndOfEpochTransactionKind as K;
1246
1247 let message = Self::default();
1248
1249 match value {
1250 K::ChangeEpoch(change_epoch) => message
1251 .with_change_epoch(change_epoch)
1252 .with_kind(Kind::ChangeEpoch),
1253 K::AuthenticatorStateCreate => message.with_kind(Kind::AuthenticatorStateCreate),
1254 K::AuthenticatorStateExpire(expire) => message
1255 .with_authenticator_state_expire(expire)
1256 .with_kind(Kind::AuthenticatorStateExpire),
1257 K::RandomnessStateCreate => message.with_kind(Kind::RandomnessStateCreate),
1258 K::DenyListStateCreate => message.with_kind(Kind::DenyListStateCreate),
1259 K::BridgeStateCreate { chain_id } => message
1260 .with_bridge_chain_id(chain_id)
1261 .with_kind(Kind::BridgeStateCreate),
1262 K::BridgeCommitteeInit {
1263 bridge_object_version,
1264 } => message
1265 .with_bridge_object_version(bridge_object_version)
1266 .with_kind(Kind::BridgeCommitteeInit),
1267 K::StoreExecutionTimeObservations(observations) => message
1268 .with_execution_time_observations(observations)
1269 .with_kind(Kind::StoreExecutionTimeObservations),
1270 K::AccumulatorRootCreate => message.with_kind(Kind::AccumulatorRootCreate),
1271 K::CoinRegistryCreate => message.with_kind(Kind::CoinRegistryCreate),
1272 K::DisplayRegistryCreate => message.with_kind(Kind::DisplayRegistryCreate),
1273 K::AddressAliasStateCreate => message.with_kind(Kind::AddressAliasStateCreate),
1274 K::WriteAccumulatorStorageCost { storage_cost } => message
1275 .with_kind(Kind::WriteAccumulatorStorageCost)
1276 .with_storage_cost(storage_cost),
1277 K::ForwardingAddressRegistryCreate => {
1278 message.with_kind(Kind::ForwardingAddressRegistryCreate)
1279 }
1280 K::FreezeListCreate => message.with_kind(Kind::FreezeListCreate),
1281 _ => message,
1282 }
1283 }
1284}
1285
1286impl TryFrom<&EndOfEpochTransactionKind> for sui_sdk_types::EndOfEpochTransactionKind {
1287 type Error = TryFromProtoError;
1288
1289 fn try_from(value: &EndOfEpochTransactionKind) -> Result<Self, Self::Error> {
1290 use end_of_epoch_transaction_kind::Kind;
1291
1292 match value.kind() {
1293 Kind::Unknown => {
1294 return Err(TryFromProtoError::invalid(
1295 EndOfEpochTransactionKind::KIND_FIELD,
1296 "unknown EndOfEpochTransactionKind",
1297 ));
1298 }
1299 Kind::ChangeEpoch => Self::ChangeEpoch(value.change_epoch().try_into()?),
1300 Kind::AuthenticatorStateCreate => Self::AuthenticatorStateCreate,
1301 Kind::AuthenticatorStateExpire => {
1302 Self::AuthenticatorStateExpire(value.authenticator_state_expire().try_into()?)
1303 }
1304 Kind::RandomnessStateCreate => Self::RandomnessStateCreate,
1305 Kind::DenyListStateCreate => Self::DenyListStateCreate,
1306 Kind::BridgeStateCreate => Self::BridgeStateCreate {
1307 chain_id: value.bridge_chain_id().parse().map_err(|e| {
1308 TryFromProtoError::invalid(EndOfEpochTransactionKind::BRIDGE_CHAIN_ID_FIELD, e)
1309 })?,
1310 },
1311 Kind::BridgeCommitteeInit => Self::BridgeCommitteeInit {
1312 bridge_object_version: value.bridge_object_version(),
1313 },
1314 Kind::StoreExecutionTimeObservations => Self::StoreExecutionTimeObservations(
1315 value.execution_time_observations().try_into()?,
1316 ),
1317 Kind::AccumulatorRootCreate => Self::AccumulatorRootCreate,
1318 Kind::CoinRegistryCreate => Self::CoinRegistryCreate,
1319 Kind::DisplayRegistryCreate => Self::DisplayRegistryCreate,
1320 Kind::AddressAliasStateCreate => Self::AddressAliasStateCreate,
1321 Kind::WriteAccumulatorStorageCost => Self::WriteAccumulatorStorageCost {
1322 storage_cost: value.storage_cost_opt().ok_or_else(|| {
1323 TryFromProtoError::missing(EndOfEpochTransactionKind::STORAGE_COST_FIELD)
1324 })?,
1325 },
1326 Kind::ForwardingAddressRegistryCreate => Self::ForwardingAddressRegistryCreate,
1327 Kind::FreezeListCreate => Self::FreezeListCreate,
1328 }
1329 .pipe(Ok)
1330 }
1331}
1332
1333impl From<sui_sdk_types::AuthenticatorStateExpire> for AuthenticatorStateExpire {
1338 fn from(value: sui_sdk_types::AuthenticatorStateExpire) -> Self {
1339 Self {
1340 min_epoch: Some(value.min_epoch),
1341 authenticator_object_initial_shared_version: Some(
1342 value.authenticator_object_initial_shared_version,
1343 ),
1344 }
1345 }
1346}
1347
1348impl TryFrom<&AuthenticatorStateExpire> for sui_sdk_types::AuthenticatorStateExpire {
1349 type Error = TryFromProtoError;
1350
1351 fn try_from(
1352 AuthenticatorStateExpire {
1353 min_epoch,
1354 authenticator_object_initial_shared_version,
1355 }: &AuthenticatorStateExpire,
1356 ) -> Result<Self, Self::Error> {
1357 let min_epoch = min_epoch.ok_or_else(|| TryFromProtoError::missing("min_epoch"))?;
1358 let authenticator_object_initial_shared_version =
1359 authenticator_object_initial_shared_version.ok_or_else(|| {
1360 TryFromProtoError::missing("authenticator_object_initial_shared_version")
1361 })?;
1362 Ok(Self {
1363 min_epoch,
1364 authenticator_object_initial_shared_version,
1365 })
1366 }
1367}
1368
1369impl From<sui_sdk_types::ExecutionTimeObservations> for ExecutionTimeObservations {
1372 fn from(value: sui_sdk_types::ExecutionTimeObservations) -> Self {
1373 match value {
1374 sui_sdk_types::ExecutionTimeObservations::V1(vec) => Self {
1375 version: Some(1),
1376 observations: vec.into_iter().map(Into::into).collect(),
1377 },
1378 _ => Self::default(),
1379 }
1380 }
1381}
1382
1383impl TryFrom<&ExecutionTimeObservations> for sui_sdk_types::ExecutionTimeObservations {
1384 type Error = TryFromProtoError;
1385
1386 fn try_from(value: &ExecutionTimeObservations) -> Result<Self, Self::Error> {
1387 Ok(Self::V1(
1388 value
1389 .observations
1390 .iter()
1391 .map(|observation| observation.try_into())
1392 .collect::<Result<_, _>>()?,
1393 ))
1394 }
1395}
1396
1397impl
1398 From<(
1399 sui_sdk_types::ExecutionTimeObservationKey,
1400 Vec<sui_sdk_types::ValidatorExecutionTimeObservation>,
1401 )> for ExecutionTimeObservation
1402{
1403 fn from(
1404 value: (
1405 sui_sdk_types::ExecutionTimeObservationKey,
1406 Vec<sui_sdk_types::ValidatorExecutionTimeObservation>,
1407 ),
1408 ) -> Self {
1409 use execution_time_observation::ExecutionTimeObservationKind;
1410 use sui_sdk_types::ExecutionTimeObservationKey;
1411
1412 let mut message = Self::default();
1413
1414 let kind = match value.0 {
1415 ExecutionTimeObservationKey::MoveEntryPoint {
1416 package,
1417 module,
1418 function,
1419 type_arguments,
1420 } => {
1421 message.move_entry_point = Some(MoveCall {
1422 package: Some(package.to_string()),
1423 module: Some(module),
1424 function: Some(function),
1425 type_arguments: type_arguments
1426 .into_iter()
1427 .map(|ty| ty.to_string())
1428 .collect(),
1429 arguments: Vec::new(),
1430 });
1431 ExecutionTimeObservationKind::MoveEntryPoint
1432 }
1433 ExecutionTimeObservationKey::TransferObjects => {
1434 ExecutionTimeObservationKind::TransferObjects
1435 }
1436 ExecutionTimeObservationKey::SplitCoins => ExecutionTimeObservationKind::SplitCoins,
1437 ExecutionTimeObservationKey::MergeCoins => ExecutionTimeObservationKind::MergeCoins,
1438 ExecutionTimeObservationKey::Publish => ExecutionTimeObservationKind::Publish,
1439 ExecutionTimeObservationKey::MakeMoveVec => {
1440 ExecutionTimeObservationKind::MakeMoveVector
1441 }
1442 ExecutionTimeObservationKey::Upgrade => ExecutionTimeObservationKind::Upgrade,
1443
1444 _ => ExecutionTimeObservationKind::Unknown,
1445 };
1446
1447 message.validator_observations = value.1.into_iter().map(Into::into).collect();
1448 message.set_kind(kind);
1449 message
1450 }
1451}
1452
1453impl TryFrom<&ExecutionTimeObservation>
1454 for (
1455 sui_sdk_types::ExecutionTimeObservationKey,
1456 Vec<sui_sdk_types::ValidatorExecutionTimeObservation>,
1457 )
1458{
1459 type Error = TryFromProtoError;
1460
1461 fn try_from(value: &ExecutionTimeObservation) -> Result<Self, Self::Error> {
1462 use execution_time_observation::ExecutionTimeObservationKind;
1463 use sui_sdk_types::ExecutionTimeObservationKey;
1464
1465 let key = match value.kind() {
1466 ExecutionTimeObservationKind::Unknown => {
1467 return Err(TryFromProtoError::invalid(
1468 ExecutionTimeObservation::KIND_FIELD,
1469 "unknown ExecutionTimeObservationKind",
1470 ));
1471 }
1472 ExecutionTimeObservationKind::MoveEntryPoint => {
1473 let move_call = value
1474 .move_entry_point
1475 .as_ref()
1476 .ok_or_else(|| TryFromProtoError::missing("move_entry_point"))?;
1477 ExecutionTimeObservationKey::MoveEntryPoint {
1478 package: move_call
1479 .package()
1480 .parse()
1481 .map_err(|e| TryFromProtoError::invalid(MoveCall::PACKAGE_FIELD, e))?,
1482 module: move_call.module().to_owned(),
1483 function: move_call.function().to_owned(),
1484 type_arguments: move_call
1485 .type_arguments
1486 .iter()
1487 .map(|t| {
1488 t.parse().map_err(|e| {
1489 TryFromProtoError::invalid(MoveCall::TYPE_ARGUMENTS_FIELD, e)
1490 })
1491 })
1492 .collect::<Result<_, _>>()?,
1493 }
1494 }
1495 ExecutionTimeObservationKind::TransferObjects => {
1496 ExecutionTimeObservationKey::TransferObjects
1497 }
1498 ExecutionTimeObservationKind::SplitCoins => ExecutionTimeObservationKey::SplitCoins,
1499 ExecutionTimeObservationKind::MergeCoins => ExecutionTimeObservationKey::MergeCoins,
1500 ExecutionTimeObservationKind::Publish => ExecutionTimeObservationKey::Publish,
1501 ExecutionTimeObservationKind::MakeMoveVector => {
1502 ExecutionTimeObservationKey::MakeMoveVec
1503 }
1504 ExecutionTimeObservationKind::Upgrade => ExecutionTimeObservationKey::Upgrade,
1505 };
1506
1507 let observations = value
1508 .validator_observations
1509 .iter()
1510 .map(sui_sdk_types::ValidatorExecutionTimeObservation::try_from)
1511 .collect::<Result<_, _>>()?;
1512
1513 Ok((key, observations))
1514 }
1515}
1516
1517impl From<sui_sdk_types::ValidatorExecutionTimeObservation> for ValidatorExecutionTimeObservation {
1520 fn from(value: sui_sdk_types::ValidatorExecutionTimeObservation) -> Self {
1521 Self {
1522 validator: Some(value.validator.as_bytes().to_vec().into()),
1523 duration: Some(prost_types::Duration {
1524 seconds: value.duration.as_secs() as i64,
1525 nanos: value.duration.subsec_nanos() as i32,
1526 }),
1527 }
1528 }
1529}
1530
1531impl TryFrom<&ValidatorExecutionTimeObservation>
1532 for sui_sdk_types::ValidatorExecutionTimeObservation
1533{
1534 type Error = TryFromProtoError;
1535
1536 fn try_from(value: &ValidatorExecutionTimeObservation) -> Result<Self, Self::Error> {
1537 Ok(Self {
1538 validator: value
1539 .validator
1540 .as_ref()
1541 .ok_or_else(|| TryFromProtoError::missing("validator"))?
1542 .as_ref()
1543 .pipe(sui_sdk_types::Bls12381PublicKey::from_bytes)
1544 .map_err(|e| {
1545 TryFromProtoError::invalid(
1546 ValidatorExecutionTimeObservation::VALIDATOR_FIELD,
1547 e,
1548 )
1549 })?,
1550 duration: value
1551 .duration
1552 .ok_or_else(|| TryFromProtoError::missing("duration"))?
1553 .try_into()
1554 .map_err(|e| {
1555 TryFromProtoError::invalid(ValidatorExecutionTimeObservation::DURATION_FIELD, e)
1556 })?,
1557 })
1558 }
1559}
1560
1561impl From<sui_sdk_types::ProgrammableTransaction> for ProgrammableTransaction {
1566 fn from(value: sui_sdk_types::ProgrammableTransaction) -> Self {
1567 Self {
1568 inputs: value.inputs.into_iter().map(Into::into).collect(),
1569 commands: value.commands.into_iter().map(Into::into).collect(),
1570 }
1571 }
1572}
1573
1574impl TryFrom<&ProgrammableTransaction> for sui_sdk_types::ProgrammableTransaction {
1575 type Error = TryFromProtoError;
1576
1577 fn try_from(value: &ProgrammableTransaction) -> Result<Self, Self::Error> {
1578 Ok(Self {
1579 inputs: value
1580 .inputs
1581 .iter()
1582 .map(TryInto::try_into)
1583 .collect::<Result<_, _>>()?,
1584 commands: value
1585 .commands
1586 .iter()
1587 .map(TryInto::try_into)
1588 .collect::<Result<_, _>>()?,
1589 })
1590 }
1591}
1592
1593impl From<sui_sdk_types::Input> for Input {
1598 fn from(value: sui_sdk_types::Input) -> Self {
1599 use input::InputKind;
1600 use sui_sdk_types::Input::*;
1601
1602 let mut message = Self::default();
1603
1604 let kind = match value {
1605 Pure(value) => {
1606 message.pure = Some(value.into());
1607 InputKind::Pure
1608 }
1609 ImmutableOrOwned(reference) => {
1610 message.object_id = Some(reference.object_id().to_string());
1611 message.version = Some(reference.version());
1612 message.digest = Some(reference.digest().to_string());
1613 InputKind::ImmutableOrOwned
1614 }
1615 Shared(shared_input) => {
1616 message.object_id = Some(shared_input.object_id().to_string());
1617 message.version = Some(shared_input.version());
1618 message.mutable = Some(shared_input.mutability().is_mutable());
1619 message.set_mutability(shared_input.mutability().into());
1620
1621 InputKind::Shared
1622 }
1623 Receiving(reference) => {
1624 message.object_id = Some(reference.object_id().to_string());
1625 message.version = Some(reference.version());
1626 message.digest = Some(reference.digest().to_string());
1627 InputKind::Receiving
1628 }
1629 FundsWithdrawal(funds_withdrawal) => {
1630 message.set_funds_withdrawal(funds_withdrawal);
1631 InputKind::FundsWithdrawal
1632 }
1633 _ => InputKind::Unknown,
1634 };
1635
1636 message.set_kind(kind);
1637 message
1638 }
1639}
1640
1641impl TryFrom<&Input> for sui_sdk_types::Input {
1642 type Error = TryFromProtoError;
1643
1644 fn try_from(value: &Input) -> Result<Self, Self::Error> {
1645 use input::InputKind;
1646
1647 match value.kind() {
1648 InputKind::Unknown => {
1649 return Err(TryFromProtoError::invalid(
1650 Input::KIND_FIELD,
1651 "unknown InputKind",
1652 ));
1653 }
1654 InputKind::Pure => Self::Pure(
1655 value
1656 .pure
1657 .as_ref()
1658 .ok_or_else(|| TryFromProtoError::missing("pure"))?
1659 .to_vec(),
1660 ),
1661 InputKind::ImmutableOrOwned => {
1662 let object_id = value
1663 .object_id
1664 .as_ref()
1665 .ok_or_else(|| TryFromProtoError::missing("object_id"))?
1666 .parse()
1667 .map_err(|e| TryFromProtoError::invalid(Input::OBJECT_ID_FIELD, e))?;
1668 let version = value
1669 .version
1670 .ok_or_else(|| TryFromProtoError::missing("version"))?;
1671 let digest = value
1672 .digest
1673 .as_ref()
1674 .ok_or_else(|| TryFromProtoError::missing("digest"))?
1675 .parse()
1676 .map_err(|e| TryFromProtoError::invalid(Input::DIGEST_FIELD, e))?;
1677 let reference = sui_sdk_types::ObjectReference::new(object_id, version, digest);
1678 Self::ImmutableOrOwned(reference)
1679 }
1680 InputKind::Shared => {
1681 let object_id = value
1682 .object_id
1683 .as_ref()
1684 .ok_or_else(|| TryFromProtoError::missing("object_id"))?
1685 .parse()
1686 .map_err(|e| TryFromProtoError::invalid(Input::OBJECT_ID_FIELD, e))?;
1687 let initial_shared_version = value
1688 .version
1689 .ok_or_else(|| TryFromProtoError::missing("version"))?;
1690
1691 let shared_input = match value.mutability() {
1692 input::Mutability::Unknown => {
1693 let mutable = value
1694 .mutable
1695 .ok_or_else(|| TryFromProtoError::missing("mutable"))?;
1696 sui_sdk_types::SharedInput::new(object_id, initial_shared_version, mutable)
1697 }
1698 input::Mutability::Immutable => sui_sdk_types::SharedInput::new(
1699 object_id,
1700 initial_shared_version,
1701 sui_sdk_types::Mutability::Immutable,
1702 ),
1703 input::Mutability::Mutable => sui_sdk_types::SharedInput::new(
1704 object_id,
1705 initial_shared_version,
1706 sui_sdk_types::Mutability::Mutable,
1707 ),
1708 input::Mutability::NonExclusiveWrite => sui_sdk_types::SharedInput::new(
1709 object_id,
1710 initial_shared_version,
1711 sui_sdk_types::Mutability::NonExclusiveWrite,
1712 ),
1713 };
1714
1715 Self::Shared(shared_input)
1716 }
1717 InputKind::Receiving => {
1718 let object_id = value
1719 .object_id
1720 .as_ref()
1721 .ok_or_else(|| TryFromProtoError::missing("object_id"))?
1722 .parse()
1723 .map_err(|e| TryFromProtoError::invalid(Input::OBJECT_ID_FIELD, e))?;
1724 let version = value
1725 .version
1726 .ok_or_else(|| TryFromProtoError::missing("version"))?;
1727 let digest = value
1728 .digest
1729 .as_ref()
1730 .ok_or_else(|| TryFromProtoError::missing("digest"))?
1731 .parse()
1732 .map_err(|e| TryFromProtoError::invalid(Input::DIGEST_FIELD, e))?;
1733 let reference = sui_sdk_types::ObjectReference::new(object_id, version, digest);
1734 Self::Receiving(reference)
1735 }
1736 InputKind::FundsWithdrawal => {
1737 let funds_withdrawal = value
1738 .funds_withdrawal_opt()
1739 .ok_or_else(|| TryFromProtoError::missing("funds_withdrawal"))?
1740 .try_into()?;
1741 Self::FundsWithdrawal(funds_withdrawal)
1742 }
1743 }
1744 .pipe(Ok)
1745 }
1746}
1747
1748impl From<sui_sdk_types::Mutability> for input::Mutability {
1749 fn from(value: sui_sdk_types::Mutability) -> Self {
1750 match value {
1751 sui_sdk_types::Mutability::Immutable => Self::Immutable,
1752 sui_sdk_types::Mutability::Mutable => Self::Mutable,
1753 sui_sdk_types::Mutability::NonExclusiveWrite => Self::NonExclusiveWrite,
1754 }
1755 }
1756}
1757
1758impl From<sui_sdk_types::FundsWithdrawal> for FundsWithdrawal {
1763 fn from(value: sui_sdk_types::FundsWithdrawal) -> Self {
1764 let mut message = Self::default();
1765 message.set_coin_type(value.coin_type());
1766 message.set_source(value.source().into());
1767 match value.source() {
1768 sui_sdk_types::WithdrawFrom::SenderAllowance { funder, allowance } => {
1769 message.set_funder(funder.to_string());
1770 message.set_allowance(allowance.to_string());
1771 }
1772 sui_sdk_types::WithdrawFrom::FrozenAddress {
1773 seized_from,
1774 seize_auth,
1775 } => {
1776 message.set_seized_from(seized_from.to_string());
1777 message.set_seize_auth(seize_auth.to_string());
1778 }
1779 _ => {}
1780 }
1781 message.amount = value.amount();
1782 message
1783 }
1784}
1785
1786impl TryFrom<&FundsWithdrawal> for sui_sdk_types::FundsWithdrawal {
1787 type Error = TryFromProtoError;
1788
1789 fn try_from(value: &FundsWithdrawal) -> Result<Self, Self::Error> {
1790 use funds_withdrawal::Source;
1791
1792 let amount = value
1793 .amount_opt()
1794 .ok_or_else(|| TryFromProtoError::missing("amount"))?;
1795 let coin_type = value
1796 .coin_type_opt()
1797 .ok_or_else(|| TryFromProtoError::missing("coin_type"))?
1798 .parse()
1799 .map_err(|e| TryFromProtoError::invalid("coin_type", e))?;
1800 let source = match value.source() {
1801 Source::Unknown => return Err(TryFromProtoError::invalid("source", "unknown source")),
1802 Source::Sender => sui_sdk_types::WithdrawFrom::Sender,
1803 Source::Sponsor => sui_sdk_types::WithdrawFrom::Sponsor,
1804 Source::SenderAllowance => {
1805 let funder = value
1806 .funder_opt()
1807 .ok_or_else(|| TryFromProtoError::missing("funder"))?
1808 .parse()
1809 .map_err(|e| TryFromProtoError::invalid(FundsWithdrawal::FUNDER_FIELD, e))?;
1810 let allowance = value
1811 .allowance_opt()
1812 .ok_or_else(|| TryFromProtoError::missing("allowance"))?
1813 .parse()
1814 .map_err(|e| TryFromProtoError::invalid(FundsWithdrawal::ALLOWANCE_FIELD, e))?;
1815 sui_sdk_types::WithdrawFrom::SenderAllowance { funder, allowance }
1816 }
1817 Source::FrozenAddress => {
1818 let seized_from = value
1819 .seized_from_opt()
1820 .ok_or_else(|| TryFromProtoError::missing("seized_from"))?
1821 .parse()
1822 .map_err(|e| {
1823 TryFromProtoError::invalid(FundsWithdrawal::SEIZED_FROM_FIELD, e)
1824 })?;
1825 let seize_auth = value
1826 .seize_auth_opt()
1827 .ok_or_else(|| TryFromProtoError::missing("seize_auth"))?
1828 .parse()
1829 .map_err(|e| {
1830 TryFromProtoError::invalid(FundsWithdrawal::SEIZE_AUTH_FIELD, e)
1831 })?;
1832 sui_sdk_types::WithdrawFrom::FrozenAddress {
1833 seized_from,
1834 seize_auth,
1835 }
1836 }
1837 };
1838
1839 Ok(Self::new(amount, coin_type, source))
1840 }
1841}
1842
1843impl From<sui_sdk_types::WithdrawFrom> for funds_withdrawal::Source {
1844 fn from(value: sui_sdk_types::WithdrawFrom) -> Self {
1845 match value {
1846 sui_sdk_types::WithdrawFrom::Sender => Self::Sender,
1847 sui_sdk_types::WithdrawFrom::Sponsor => Self::Sponsor,
1848 sui_sdk_types::WithdrawFrom::SenderAllowance { .. } => Self::SenderAllowance,
1849 sui_sdk_types::WithdrawFrom::FrozenAddress { .. } => Self::FrozenAddress,
1850 _ => Self::Unknown,
1851 }
1852 }
1853}
1854
1855impl Argument {
1860 pub fn gas() -> Self {
1861 Self {
1862 kind: Some(argument::ArgumentKind::Gas.into()),
1863 input: None,
1864 result: None,
1865 subresult: None,
1866 }
1867 }
1868
1869 pub fn new_input(input: u16) -> Self {
1870 Self {
1871 kind: Some(argument::ArgumentKind::Input.into()),
1872 input: Some(input.into()),
1873 result: None,
1874 subresult: None,
1875 }
1876 }
1877
1878 pub fn new_result(command: u16) -> Self {
1879 Self {
1880 kind: Some(argument::ArgumentKind::Result.into()),
1881 input: None,
1882 result: Some(command.into()),
1883 subresult: None,
1884 }
1885 }
1886
1887 pub fn nested_result(command: u16, subresult: u16) -> Self {
1888 Self {
1889 kind: Some(argument::ArgumentKind::Result.into()),
1890 input: None,
1891 result: Some(command.into()),
1892 subresult: Some(subresult.into()),
1893 }
1894 }
1895}
1896
1897impl From<sui_sdk_types::Argument> for Argument {
1898 fn from(value: sui_sdk_types::Argument) -> Self {
1899 use argument::ArgumentKind;
1900 use sui_sdk_types::Argument::*;
1901
1902 let mut message = Self::default();
1903
1904 let kind = match value {
1905 Gas => ArgumentKind::Gas,
1906 Input(input) => {
1907 message.input = Some(input.into());
1908 ArgumentKind::Input
1909 }
1910 Result(result) => {
1911 message.result = Some(result.into());
1912 ArgumentKind::Result
1913 }
1914 NestedResult(result, subresult) => {
1915 message.result = Some(result.into());
1916 message.subresult = Some(subresult.into());
1917 ArgumentKind::Result
1918 }
1919 };
1920
1921 message.set_kind(kind);
1922 message
1923 }
1924}
1925
1926impl TryFrom<&Argument> for sui_sdk_types::Argument {
1927 type Error = TryFromProtoError;
1928
1929 fn try_from(value: &Argument) -> Result<Self, Self::Error> {
1930 use argument::ArgumentKind;
1931
1932 match value.kind() {
1933 ArgumentKind::Unknown => {
1934 return Err(TryFromProtoError::invalid(
1935 Argument::KIND_FIELD,
1936 "unknown ArgumentKind",
1937 ));
1938 }
1939 ArgumentKind::Gas => Self::Gas,
1940 ArgumentKind::Input => {
1941 let input = value
1942 .input
1943 .ok_or_else(|| TryFromProtoError::missing("input"))?
1944 .try_into()
1945 .map_err(|e| TryFromProtoError::invalid(Argument::INPUT_FIELD, e))?;
1946 Self::Input(input)
1947 }
1948 ArgumentKind::Result => {
1949 let result = value
1950 .result
1951 .ok_or_else(|| TryFromProtoError::missing("result"))?
1952 .try_into()
1953 .map_err(|e| TryFromProtoError::invalid(Argument::RESULT_FIELD, e))?;
1954
1955 if let Some(subresult) = value.subresult {
1956 Self::NestedResult(
1957 result,
1958 subresult.try_into().map_err(|e| {
1959 TryFromProtoError::invalid(Argument::SUBRESULT_FIELD, e)
1960 })?,
1961 )
1962 } else {
1963 Self::Result(result)
1964 }
1965 }
1966 }
1967 .pipe(Ok)
1968 }
1969}
1970
1971impl From<command::Command> for Command {
1976 fn from(value: command::Command) -> Self {
1977 Self {
1978 command: Some(value),
1979 }
1980 }
1981}
1982
1983impl From<MoveCall> for command::Command {
1984 fn from(value: MoveCall) -> Self {
1985 Self::MoveCall(value)
1986 }
1987}
1988
1989impl From<MoveCall> for Command {
1990 fn from(value: MoveCall) -> Self {
1991 command::Command::from(value).into()
1992 }
1993}
1994
1995impl From<TransferObjects> for command::Command {
1996 fn from(value: TransferObjects) -> Self {
1997 Self::TransferObjects(value)
1998 }
1999}
2000
2001impl From<TransferObjects> for Command {
2002 fn from(value: TransferObjects) -> Self {
2003 command::Command::from(value).into()
2004 }
2005}
2006
2007impl From<sui_sdk_types::Command> for Command {
2008 fn from(value: sui_sdk_types::Command) -> Self {
2009 use command::Command;
2010 use sui_sdk_types::Command::*;
2011
2012 let command = match value {
2013 MoveCall(move_call) => Command::MoveCall(move_call.into()),
2014 TransferObjects(transfer_objects) => Command::TransferObjects(transfer_objects.into()),
2015 SplitCoins(split_coins) => Command::SplitCoins(split_coins.into()),
2016 MergeCoins(merge_coins) => Command::MergeCoins(merge_coins.into()),
2017 Publish(publish) => Command::Publish(publish.into()),
2018 MakeMoveVector(make_move_vector) => Command::MakeMoveVector(make_move_vector.into()),
2019 Upgrade(upgrade) => Command::Upgrade(upgrade.into()),
2020
2021 _ => return Self::default(),
2023 };
2024
2025 Self {
2026 command: Some(command),
2027 }
2028 }
2029}
2030
2031impl TryFrom<&Command> for sui_sdk_types::Command {
2032 type Error = TryFromProtoError;
2033
2034 fn try_from(value: &Command) -> Result<Self, Self::Error> {
2035 use command::Command;
2036
2037 match value
2038 .command
2039 .as_ref()
2040 .ok_or_else(|| TryFromProtoError::missing("command"))?
2041 {
2042 Command::MoveCall(move_call) => Self::MoveCall(move_call.try_into()?),
2043 Command::TransferObjects(transfer_objects) => {
2044 Self::TransferObjects(transfer_objects.try_into()?)
2045 }
2046 Command::SplitCoins(split_coins) => Self::SplitCoins(split_coins.try_into()?),
2047 Command::MergeCoins(merge_coins) => Self::MergeCoins(merge_coins.try_into()?),
2048 Command::Publish(publish) => Self::Publish(publish.try_into()?),
2049 Command::MakeMoveVector(make_move_vector) => {
2050 Self::MakeMoveVector(make_move_vector.try_into()?)
2051 }
2052 Command::Upgrade(upgrade) => Self::Upgrade(upgrade.try_into()?),
2053 }
2054 .pipe(Ok)
2055 }
2056}
2057
2058impl From<sui_sdk_types::MoveCall> for MoveCall {
2063 fn from(value: sui_sdk_types::MoveCall) -> Self {
2064 Self {
2065 package: Some(value.package.to_string()),
2066 module: Some(value.module.to_string()),
2067 function: Some(value.function.to_string()),
2068 type_arguments: value
2069 .type_arguments
2070 .iter()
2071 .map(ToString::to_string)
2072 .collect(),
2073 arguments: value.arguments.into_iter().map(Into::into).collect(),
2074 }
2075 }
2076}
2077
2078impl TryFrom<&MoveCall> for sui_sdk_types::MoveCall {
2079 type Error = TryFromProtoError;
2080
2081 fn try_from(value: &MoveCall) -> Result<Self, Self::Error> {
2082 let package = value
2083 .package
2084 .as_ref()
2085 .ok_or_else(|| TryFromProtoError::missing("package"))?
2086 .parse()
2087 .map_err(|e| TryFromProtoError::invalid(MoveCall::PACKAGE_FIELD, e))?;
2088
2089 let module = value
2090 .module
2091 .as_ref()
2092 .ok_or_else(|| TryFromProtoError::missing("module"))?
2093 .parse()
2094 .map_err(|e| TryFromProtoError::invalid(MoveCall::MODULE_FIELD, e))?;
2095
2096 let function = value
2097 .function
2098 .as_ref()
2099 .ok_or_else(|| TryFromProtoError::missing("function"))?
2100 .parse()
2101 .map_err(|e| TryFromProtoError::invalid(MoveCall::FUNCTION_FIELD, e))?;
2102
2103 let type_arguments = value
2104 .type_arguments
2105 .iter()
2106 .map(|t| {
2107 t.parse()
2108 .map_err(|e| TryFromProtoError::invalid(MoveCall::TYPE_ARGUMENTS_FIELD, e))
2109 })
2110 .collect::<Result<_, _>>()?;
2111 let arguments = value
2112 .arguments
2113 .iter()
2114 .map(TryInto::try_into)
2115 .collect::<Result<_, _>>()?;
2116
2117 Ok(Self {
2118 package,
2119 module,
2120 function,
2121 type_arguments,
2122 arguments,
2123 })
2124 }
2125}
2126
2127impl From<sui_sdk_types::TransferObjects> for TransferObjects {
2132 fn from(value: sui_sdk_types::TransferObjects) -> Self {
2133 Self {
2134 objects: value.objects.into_iter().map(Into::into).collect(),
2135 address: Some(value.address.into()),
2136 }
2137 }
2138}
2139
2140impl TryFrom<&TransferObjects> for sui_sdk_types::TransferObjects {
2141 type Error = TryFromProtoError;
2142
2143 fn try_from(value: &TransferObjects) -> Result<Self, Self::Error> {
2144 let objects = value
2145 .objects
2146 .iter()
2147 .map(TryInto::try_into)
2148 .collect::<Result<_, _>>()?;
2149
2150 let address = value
2151 .address
2152 .as_ref()
2153 .ok_or_else(|| TryFromProtoError::missing("address"))?
2154 .try_into()?;
2155
2156 Ok(Self { objects, address })
2157 }
2158}
2159
2160impl From<sui_sdk_types::SplitCoins> for SplitCoins {
2165 fn from(value: sui_sdk_types::SplitCoins) -> Self {
2166 Self {
2167 coin: Some(value.coin.into()),
2168 amounts: value.amounts.into_iter().map(Into::into).collect(),
2169 }
2170 }
2171}
2172
2173impl TryFrom<&SplitCoins> for sui_sdk_types::SplitCoins {
2174 type Error = TryFromProtoError;
2175
2176 fn try_from(value: &SplitCoins) -> Result<Self, Self::Error> {
2177 let coin = value
2178 .coin
2179 .as_ref()
2180 .ok_or_else(|| TryFromProtoError::missing("coin"))?
2181 .try_into()?;
2182
2183 let amounts = value
2184 .amounts
2185 .iter()
2186 .map(TryInto::try_into)
2187 .collect::<Result<_, _>>()?;
2188
2189 Ok(Self { coin, amounts })
2190 }
2191}
2192
2193impl From<sui_sdk_types::MergeCoins> for MergeCoins {
2198 fn from(value: sui_sdk_types::MergeCoins) -> Self {
2199 Self {
2200 coin: Some(value.coin.into()),
2201 coins_to_merge: value.coins_to_merge.into_iter().map(Into::into).collect(),
2202 }
2203 }
2204}
2205
2206impl TryFrom<&MergeCoins> for sui_sdk_types::MergeCoins {
2207 type Error = TryFromProtoError;
2208
2209 fn try_from(value: &MergeCoins) -> Result<Self, Self::Error> {
2210 let coin = value
2211 .coin
2212 .as_ref()
2213 .ok_or_else(|| TryFromProtoError::missing("coin"))?
2214 .try_into()?;
2215
2216 let coins_to_merge = value
2217 .coins_to_merge
2218 .iter()
2219 .map(TryInto::try_into)
2220 .collect::<Result<_, _>>()?;
2221
2222 Ok(Self {
2223 coin,
2224 coins_to_merge,
2225 })
2226 }
2227}
2228
2229impl From<sui_sdk_types::Publish> for Publish {
2234 fn from(value: sui_sdk_types::Publish) -> Self {
2235 Self {
2236 modules: value.modules.into_iter().map(Into::into).collect(),
2237 dependencies: value.dependencies.iter().map(ToString::to_string).collect(),
2238 }
2239 }
2240}
2241
2242impl TryFrom<&Publish> for sui_sdk_types::Publish {
2243 type Error = TryFromProtoError;
2244
2245 fn try_from(value: &Publish) -> Result<Self, Self::Error> {
2246 let modules = value.modules.iter().map(|bytes| bytes.to_vec()).collect();
2247
2248 let dependencies = value
2249 .dependencies
2250 .iter()
2251 .map(|s| s.parse())
2252 .collect::<Result<_, _>>()
2253 .map_err(|e| TryFromProtoError::invalid(Publish::DEPENDENCIES_FIELD, e))?;
2254
2255 Ok(Self {
2256 modules,
2257 dependencies,
2258 })
2259 }
2260}
2261
2262impl From<sui_sdk_types::MakeMoveVector> for MakeMoveVector {
2267 fn from(value: sui_sdk_types::MakeMoveVector) -> Self {
2268 Self {
2269 element_type: value.type_.map(|t| t.to_string()),
2270 elements: value.elements.into_iter().map(Into::into).collect(),
2271 }
2272 }
2273}
2274
2275impl TryFrom<&MakeMoveVector> for sui_sdk_types::MakeMoveVector {
2276 type Error = TryFromProtoError;
2277
2278 fn try_from(value: &MakeMoveVector) -> Result<Self, Self::Error> {
2279 let element_type = value
2280 .element_type
2281 .as_ref()
2282 .map(|t| {
2283 t.parse()
2284 .map_err(|e| TryFromProtoError::invalid(MakeMoveVector::ELEMENT_TYPE_FIELD, e))
2285 })
2286 .transpose()?;
2287
2288 let elements = value
2289 .elements
2290 .iter()
2291 .map(TryInto::try_into)
2292 .collect::<Result<_, _>>()?;
2293
2294 Ok(Self {
2295 type_: element_type,
2296 elements,
2297 })
2298 }
2299}
2300
2301impl From<sui_sdk_types::Upgrade> for Upgrade {
2306 fn from(value: sui_sdk_types::Upgrade) -> Self {
2307 Self {
2308 modules: value.modules.into_iter().map(Into::into).collect(),
2309 dependencies: value.dependencies.iter().map(ToString::to_string).collect(),
2310 package: Some(value.package.to_string()),
2311 ticket: Some(value.ticket.into()),
2312 }
2313 }
2314}
2315
2316impl TryFrom<&Upgrade> for sui_sdk_types::Upgrade {
2317 type Error = TryFromProtoError;
2318
2319 fn try_from(value: &Upgrade) -> Result<Self, Self::Error> {
2320 let modules = value.modules.iter().map(|bytes| bytes.to_vec()).collect();
2321
2322 let dependencies = value
2323 .dependencies
2324 .iter()
2325 .map(|s| s.parse())
2326 .collect::<Result<_, _>>()
2327 .map_err(|e| TryFromProtoError::invalid(Upgrade::DEPENDENCIES_FIELD, e))?;
2328
2329 let package = value
2330 .package
2331 .as_ref()
2332 .ok_or_else(|| TryFromProtoError::missing("package"))?
2333 .parse()
2334 .map_err(|e| TryFromProtoError::invalid(Upgrade::PACKAGE_FIELD, e))?;
2335
2336 let ticket = value
2337 .ticket
2338 .as_ref()
2339 .ok_or_else(|| TryFromProtoError::missing("ticket"))?
2340 .try_into()?;
2341
2342 Ok(Self {
2343 modules,
2344 dependencies,
2345 package,
2346 ticket,
2347 })
2348 }
2349}