Skip to main content

sui_rpc/proto/sui/rpc/v2/
transaction.rs

1use super::*;
2use crate::field::FieldMaskTree;
3use crate::merge::Merge;
4use crate::proto::TryFromProtoError;
5use tap::Pipe;
6
7//
8// Transaction
9//
10
11impl 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
147//
148// GasPayment
149//
150
151impl 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
193//
194// TransactionExpiration
195//
196
197impl 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
341//
342// TransactionKind
343//
344
345impl 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
451//
452// ConsensusCommitPrologue
453//
454
455impl 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
691//
692// ConsensusDeterminedVersionAssignments
693//
694
695impl 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
758//
759// CanceledTransaction
760//
761
762impl 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
836//
837// VersionAssignment
838//
839
840impl 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
903//
904// GenesisTransaction
905//
906
907impl 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
929//
930// RandomnessStateUpdate
931//
932
933impl 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
977//
978// AuthenticatorStateUpdate
979//
980
981impl 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
1023//
1024// Jwk
1025//
1026
1027impl 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
1062//
1063// JwkId
1064//
1065
1066impl 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
1100//
1101// ActiveJwk
1102//
1103
1104impl 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
1138//
1139// ChangeEpoch
1140//
1141
1142impl 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
1205//
1206// SystemPackage
1207//
1208
1209impl 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
1238//
1239// EndOfEpochTransactionkind
1240//
1241
1242impl 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
1333//
1334// AuthenticatorStateExpire
1335//
1336
1337impl 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
1369// ExecutionTimeObservations
1370
1371impl 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
1517// ValidatorExecutionTimeObservation
1518
1519impl 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
1561//
1562// ProgrammableTransaction
1563//
1564
1565impl 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
1593//
1594// Input
1595//
1596
1597impl 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
1758//
1759// FundsWithdrawal
1760//
1761
1762impl 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
1855//
1856// Argument
1857//
1858
1859impl 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
1971//
1972// Command
1973//
1974
1975impl 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            //
2022            _ => 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
2058//
2059// MoveCall
2060//
2061
2062impl 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
2127//
2128// TransferObjects
2129//
2130
2131impl 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
2160//
2161// SplitCoins
2162//
2163
2164impl 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
2193//
2194// MergeCoins
2195//
2196
2197impl 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
2229//
2230// Publish
2231//
2232
2233impl 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
2262//
2263// MakeMoveVector
2264//
2265
2266impl 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
2301//
2302// Upgrade
2303//
2304
2305impl 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}