1use crate::crypto::SuiSignature;
7
8fn ms_to_timestamp(ms: u64) -> prost_types::Timestamp {
9 prost_types::Timestamp {
10 seconds: (ms / 1000) as _,
11 nanos: ((ms % 1000) * 1_000_000) as _,
12 }
13}
14use crate::message_envelope::Message as _;
15use fastcrypto::traits::ToFromBytes;
16use sui_rpc::field::FieldMaskTree;
17use sui_rpc::merge::Merge;
18use sui_rpc::proto::TryFromProtoError;
19use sui_rpc::proto::sui::rpc::v2::*;
20
21impl Merge<&crate::full_checkpoint_content::Checkpoint> for Checkpoint {
26 fn merge(&mut self, source: &crate::full_checkpoint_content::Checkpoint, mask: &FieldMaskTree) {
27 let sequence_number = source.summary.sequence_number;
28 let timestamp_ms = source.summary.timestamp_ms;
29
30 let summary = source.summary.data();
31 let signature = source.summary.auth_sig();
32
33 self.merge(summary, mask);
34 self.merge(signature.clone(), mask);
35
36 if mask.contains(Checkpoint::CONTENTS_FIELD.name) {
37 self.merge(&source.contents, mask);
38 }
39
40 if let Some(submask) = mask
41 .subtree(Checkpoint::OBJECTS_FIELD)
42 .and_then(|submask| submask.subtree(ObjectSet::OBJECTS_FIELD))
43 {
44 let set = source
45 .object_set
46 .iter()
47 .map(|o| sui_rpc::proto::sui::rpc::v2::Object::merge_from(o, &submask))
48 .collect();
49 self.objects = Some(ObjectSet::default().with_objects(set));
50 }
51
52 if let Some(submask) = mask.subtree(Checkpoint::TRANSACTIONS_FIELD.name) {
53 self.transactions = source
54 .transactions
55 .iter()
56 .map(|t| {
57 let mut transaction = ExecutedTransaction::merge_from(t, &submask);
58 transaction.checkpoint = submask
59 .contains(ExecutedTransaction::CHECKPOINT_FIELD)
60 .then_some(sequence_number);
61 transaction.timestamp = submask
62 .contains(ExecutedTransaction::TIMESTAMP_FIELD)
63 .then(|| sui_rpc::proto::timestamp_ms_to_proto(timestamp_ms));
64 transaction
65 })
66 .collect();
67 }
68 }
69}
70
71impl Merge<&crate::full_checkpoint_content::ExecutedTransaction> for ExecutedTransaction {
72 fn merge(
73 &mut self,
74 source: &crate::full_checkpoint_content::ExecutedTransaction,
75 mask: &FieldMaskTree,
76 ) {
77 if mask.contains(ExecutedTransaction::DIGEST_FIELD) {
78 self.digest = Some(source.transaction.digest().to_string());
79 }
80
81 if let Some(submask) = mask.subtree(ExecutedTransaction::TRANSACTION_FIELD) {
82 self.transaction = Some(Transaction::merge_from(&source.transaction, &submask));
83 }
84
85 if let Some(submask) = mask.subtree(ExecutedTransaction::SIGNATURES_FIELD) {
86 self.signatures = source
87 .signatures
88 .iter()
89 .map(|s| UserSignature::merge_from(s, &submask))
90 .collect();
91 }
92
93 if let Some(submask) = mask.subtree(ExecutedTransaction::EFFECTS_FIELD) {
94 let mut effects = TransactionEffects::merge_from(&source.effects, &submask);
95 if submask.contains(TransactionEffects::UNCHANGED_LOADED_RUNTIME_OBJECTS_FIELD) {
96 effects.set_unchanged_loaded_runtime_objects(
97 source
98 .unchanged_loaded_runtime_objects
99 .iter()
100 .map(Into::into)
101 .collect(),
102 );
103 }
104 self.effects = Some(effects);
105 }
106
107 if let Some(submask) = mask.subtree(ExecutedTransaction::EVENTS_FIELD) {
108 self.events = source
109 .events
110 .as_ref()
111 .map(|events| TransactionEvents::merge_from(events, &submask));
112 }
113 }
114}
115
116impl TryFrom<&Checkpoint> for crate::full_checkpoint_content::Checkpoint {
117 type Error = TryFromProtoError;
118
119 fn try_from(checkpoint: &Checkpoint) -> Result<Self, Self::Error> {
120 let summary = checkpoint
121 .summary()
122 .bcs()
123 .deserialize()
124 .map_err(|e| TryFromProtoError::invalid("summary.bcs", e))?;
125
126 let signature =
127 crate::crypto::AuthorityStrongQuorumSignInfo::try_from(checkpoint.signature())?;
128
129 let summary = crate::messages_checkpoint::CertifiedCheckpointSummary::new_from_data_and_sig(
130 summary, signature,
131 );
132
133 let contents: crate::messages_checkpoint::CheckpointContents = checkpoint
134 .contents()
135 .bcs()
136 .deserialize()
137 .map_err(|e| TryFromProtoError::invalid("contents.bcs", e))?;
138
139 let user_signatures: Vec<_> = contents
140 .clone()
141 .into_iter_with_signatures()
142 .map(|(_, user_signatures)| user_signatures)
143 .collect();
144
145 let transactions = checkpoint
146 .transactions()
147 .iter()
148 .zip(user_signatures)
149 .map(|(tx, user_signatures)| {
150 let mut executed_tx: crate::full_checkpoint_content::ExecutedTransaction =
151 tx.try_into()?;
152 executed_tx.signatures = user_signatures;
153 Ok(executed_tx)
154 })
155 .collect::<Result<_, TryFromProtoError>>()?;
156
157 let object_set = checkpoint.objects().try_into()?;
158
159 Ok(Self {
160 summary,
161 contents,
162 transactions,
163 object_set,
164 })
165 }
166}
167
168impl TryFrom<&ExecutedTransaction> for crate::full_checkpoint_content::ExecutedTransaction {
169 type Error = TryFromProtoError;
170
171 fn try_from(value: &ExecutedTransaction) -> Result<Self, Self::Error> {
172 Ok(Self {
173 transaction: value
174 .transaction()
175 .bcs()
176 .deserialize()
177 .map_err(|e| TryFromProtoError::invalid("transaction.bcs", e))?,
178 signatures: value
179 .signatures()
180 .iter()
181 .map(|sig| {
182 crate::signature::GenericSignature::from_bytes(sig.bcs().value())
183 .map_err(|e| TryFromProtoError::invalid("signature.bcs", e))
184 })
185 .collect::<Result<_, _>>()?,
186 effects: value
187 .effects()
188 .bcs()
189 .deserialize()
190 .map_err(|e| TryFromProtoError::invalid("effects.bcs", e))?,
191 events: value
192 .events_opt()
193 .map(|events| {
194 events
195 .bcs()
196 .deserialize()
197 .map_err(|e| TryFromProtoError::invalid("effects.bcs", e))
198 })
199 .transpose()?,
200 unchanged_loaded_runtime_objects: value
201 .effects()
202 .unchanged_loaded_runtime_objects()
203 .iter()
204 .map(TryInto::try_into)
205 .collect::<Result<_, _>>()?,
206 })
207 }
208}
209
210impl TryFrom<&ObjectReference> for crate::storage::ObjectKey {
211 type Error = TryFromProtoError;
212
213 fn try_from(value: &ObjectReference) -> Result<Self, Self::Error> {
214 Ok(Self(
215 value
216 .object_id()
217 .parse()
218 .map_err(|e| TryFromProtoError::invalid("object_id", e))?,
219 value.version().into(),
220 ))
221 }
222}
223
224impl From<crate::messages_checkpoint::CheckpointSummary> for CheckpointSummary {
229 fn from(summary: crate::messages_checkpoint::CheckpointSummary) -> Self {
230 Self::merge_from(summary, &FieldMaskTree::new_wildcard())
231 }
232}
233
234impl Merge<crate::messages_checkpoint::CheckpointSummary> for CheckpointSummary {
235 fn merge(
236 &mut self,
237 source: crate::messages_checkpoint::CheckpointSummary,
238 mask: &FieldMaskTree,
239 ) {
240 if mask.contains(Self::BCS_FIELD) {
241 let mut bcs = Bcs::serialize(&source).unwrap();
242 bcs.name = Some("CheckpointSummary".to_owned());
243 self.bcs = Some(bcs);
244 }
245
246 if mask.contains(Self::DIGEST_FIELD) {
247 self.digest = Some(source.digest().to_string());
248 }
249
250 let crate::messages_checkpoint::CheckpointSummary {
251 epoch,
252 sequence_number,
253 network_total_transactions,
254 content_digest,
255 previous_digest,
256 epoch_rolling_gas_cost_summary,
257 timestamp_ms,
258 checkpoint_commitments,
259 end_of_epoch_data,
260 version_specific_data,
261 } = source;
262
263 if mask.contains(Self::EPOCH_FIELD) {
264 self.epoch = Some(epoch);
265 }
266
267 if mask.contains(Self::SEQUENCE_NUMBER_FIELD) {
268 self.sequence_number = Some(sequence_number);
269 }
270
271 if mask.contains(Self::TOTAL_NETWORK_TRANSACTIONS_FIELD) {
272 self.total_network_transactions = Some(network_total_transactions);
273 }
274
275 if mask.contains(Self::CONTENT_DIGEST_FIELD) {
276 self.content_digest = Some(content_digest.to_string());
277 }
278
279 if mask.contains(Self::PREVIOUS_DIGEST_FIELD) {
280 self.previous_digest = previous_digest.map(|d| d.to_string());
281 }
282
283 if mask.contains(Self::EPOCH_ROLLING_GAS_COST_SUMMARY_FIELD) {
284 self.epoch_rolling_gas_cost_summary = Some(epoch_rolling_gas_cost_summary.into());
285 }
286
287 if mask.contains(Self::TIMESTAMP_FIELD) {
288 self.timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(timestamp_ms));
289 }
290
291 if mask.contains(Self::COMMITMENTS_FIELD) {
292 self.commitments = checkpoint_commitments.into_iter().map(Into::into).collect();
293 }
294
295 if mask.contains(Self::END_OF_EPOCH_DATA_FIELD) {
296 self.end_of_epoch_data = end_of_epoch_data.map(Into::into);
297 }
298
299 if mask.contains(Self::VERSION_SPECIFIC_DATA_FIELD) {
300 self.version_specific_data = Some(version_specific_data.into());
301 }
302 }
303}
304
305impl From<crate::gas::GasCostSummary> for GasCostSummary {
310 fn from(
311 crate::gas::GasCostSummary {
312 computation_cost,
313 storage_cost,
314 storage_rebate,
315 non_refundable_storage_fee,
316 }: crate::gas::GasCostSummary,
317 ) -> Self {
318 let mut message = Self::default();
319 message.computation_cost = Some(computation_cost);
320 message.storage_cost = Some(storage_cost);
321 message.storage_rebate = Some(storage_rebate);
322 message.non_refundable_storage_fee = Some(non_refundable_storage_fee);
323 message
324 }
325}
326
327impl From<crate::messages_checkpoint::CheckpointCommitment> for CheckpointCommitment {
332 fn from(value: crate::messages_checkpoint::CheckpointCommitment) -> Self {
333 use checkpoint_commitment::CheckpointCommitmentKind;
334
335 let mut message = Self::default();
336
337 let kind = match value {
338 crate::messages_checkpoint::CheckpointCommitment::ECMHLiveObjectSetDigest(digest) => {
339 message.digest = Some(digest.digest.to_string());
340 CheckpointCommitmentKind::EcmhLiveObjectSet
341 }
342 crate::messages_checkpoint::CheckpointCommitment::CheckpointArtifactsDigest(digest) => {
343 message.digest = Some(digest.to_string());
344 CheckpointCommitmentKind::CheckpointArtifacts
345 }
346 };
347
348 message.set_kind(kind);
349 message
350 }
351}
352
353impl From<crate::messages_checkpoint::EndOfEpochData> for EndOfEpochData {
358 fn from(
359 crate::messages_checkpoint::EndOfEpochData {
360 next_epoch_committee,
361 next_epoch_protocol_version,
362 epoch_commitments,
363 }: crate::messages_checkpoint::EndOfEpochData,
364 ) -> Self {
365 let mut message = Self::default();
366
367 message.next_epoch_committee = next_epoch_committee
368 .into_iter()
369 .map(|(name, weight)| {
370 let mut member = ValidatorCommitteeMember::default();
371 member.public_key = Some(name.0.to_vec().into());
372 member.weight = Some(weight);
373 member
374 })
375 .collect();
376 message.next_epoch_protocol_version = Some(next_epoch_protocol_version.as_u64());
377 message.epoch_commitments = epoch_commitments.into_iter().map(Into::into).collect();
378
379 message
380 }
381}
382
383impl From<crate::messages_checkpoint::CheckpointContents> for CheckpointContents {
388 fn from(value: crate::messages_checkpoint::CheckpointContents) -> Self {
389 Self::merge_from(value, &FieldMaskTree::new_wildcard())
390 }
391}
392
393impl Merge<crate::messages_checkpoint::CheckpointContents> for CheckpointContents {
394 fn merge(
395 &mut self,
396 source: crate::messages_checkpoint::CheckpointContents,
397 mask: &FieldMaskTree,
398 ) {
399 if mask.contains(Self::BCS_FIELD) {
400 let mut bcs = Bcs::serialize(&source).unwrap();
401 bcs.name = Some("CheckpointContents".to_owned());
402 self.bcs = Some(bcs);
403 }
404
405 if mask.contains(Self::DIGEST_FIELD) {
406 self.digest = Some(source.digest().to_string());
407 }
408
409 if mask.contains(Self::VERSION_FIELD) {
410 self.set_version(match &source {
411 crate::messages_checkpoint::CheckpointContents::V1(_) => 1,
412 crate::messages_checkpoint::CheckpointContents::V2(_) => 2,
413 });
414 }
415
416 if mask.contains(Self::TRANSACTIONS_FIELD) {
417 self.transactions = source
418 .inner()
419 .iter()
420 .map(|(digests, sigs)| {
421 let mut info = CheckpointedTransactionInfo::default();
422 info.transaction = Some(digests.transaction.to_string());
423 info.effects = Some(digests.effects.to_string());
424 let (signatures, versions) = sigs
425 .map(|(s, v)| {
426 (s.into(), {
427 let mut message = AddressAliasesVersion::default();
428 message.version = v.map(Into::into);
429 message
430 })
431 })
432 .unzip();
433 info.signatures = signatures;
434 info.address_aliases_versions = versions;
435 info
436 })
437 .collect();
438 }
439 }
440}
441
442impl Merge<&crate::messages_checkpoint::CheckpointContents> for Checkpoint {
443 fn merge(
444 &mut self,
445 source: &crate::messages_checkpoint::CheckpointContents,
446 mask: &FieldMaskTree,
447 ) {
448 if let Some(submask) = mask.subtree(Self::CONTENTS_FIELD.name) {
449 self.contents = Some(CheckpointContents::merge_from(source.to_owned(), &submask));
450 }
451 }
452}
453
454impl Merge<&crate::messages_checkpoint::CheckpointSummary> for Checkpoint {
459 fn merge(
460 &mut self,
461 source: &crate::messages_checkpoint::CheckpointSummary,
462 mask: &FieldMaskTree,
463 ) {
464 if mask.contains(Self::SEQUENCE_NUMBER_FIELD) {
465 self.sequence_number = Some(source.sequence_number);
466 }
467
468 if mask.contains(Self::DIGEST_FIELD) {
469 self.digest = Some(source.digest().to_string());
470 }
471
472 if let Some(submask) = mask.subtree(Self::SUMMARY_FIELD) {
473 self.summary = Some(CheckpointSummary::merge_from(source.clone(), &submask));
474 }
475 }
476}
477
478impl<const T: bool> Merge<crate::crypto::AuthorityQuorumSignInfo<T>> for Checkpoint {
479 fn merge(&mut self, source: crate::crypto::AuthorityQuorumSignInfo<T>, mask: &FieldMaskTree) {
480 if mask.contains(Self::SIGNATURE_FIELD) {
481 self.signature = Some(source.into());
482 }
483 }
484}
485
486impl Merge<crate::messages_checkpoint::CheckpointContents> for Checkpoint {
487 fn merge(
488 &mut self,
489 source: crate::messages_checkpoint::CheckpointContents,
490 mask: &FieldMaskTree,
491 ) {
492 if let Some(submask) = mask.subtree(Self::CONTENTS_FIELD) {
493 self.contents = Some(CheckpointContents::merge_from(source, &submask));
494 }
495 }
496}
497
498impl From<crate::event::Event> for Event {
503 fn from(value: crate::event::Event) -> Self {
504 Self::merge_from(&value, &FieldMaskTree::new_wildcard())
505 }
506}
507
508impl Merge<&crate::event::Event> for Event {
509 fn merge(&mut self, source: &crate::event::Event, mask: &FieldMaskTree) {
510 if mask.contains(Self::PACKAGE_ID_FIELD) {
511 self.package_id = Some(source.package_id.to_canonical_string(true));
512 }
513
514 if mask.contains(Self::MODULE_FIELD) {
515 self.module = Some(source.transaction_module.to_string());
516 }
517
518 if mask.contains(Self::SENDER_FIELD) {
519 self.sender = Some(source.sender.to_string());
520 }
521
522 if mask.contains(Self::EVENT_TYPE_FIELD) {
523 self.event_type = Some(source.type_.to_canonical_string(true));
524 }
525
526 if mask.contains(Self::CONTENTS_FIELD) {
527 let mut bcs = Bcs::from(source.contents.clone());
528 bcs.name = Some(source.type_.to_canonical_string(true));
529 self.contents = Some(bcs);
530 }
531 }
532}
533
534impl From<crate::effects::TransactionEvents> for TransactionEvents {
539 fn from(value: crate::effects::TransactionEvents) -> Self {
540 Self::merge_from(&value, &FieldMaskTree::new_wildcard())
541 }
542}
543
544impl Merge<&crate::effects::TransactionEvents> for TransactionEvents {
545 fn merge(&mut self, source: &crate::effects::TransactionEvents, mask: &FieldMaskTree) {
546 if mask.contains(Self::BCS_FIELD) {
547 let mut bcs = Bcs::serialize(&source).unwrap();
548 bcs.name = Some("TransactionEvents".to_owned());
549 self.bcs = Some(bcs);
550 }
551
552 if mask.contains(Self::DIGEST_FIELD) {
553 self.digest = Some(source.digest().to_string());
554 }
555
556 if let Some(events_mask) = mask.subtree(Self::EVENTS_FIELD) {
557 self.events = source
558 .data
559 .iter()
560 .map(|event| Event::merge_from(event, &events_mask))
561 .collect();
562 }
563 }
564}
565
566impl From<crate::sui_system_state::SuiSystemState> for SystemState {
571 fn from(value: crate::sui_system_state::SuiSystemState) -> Self {
572 match value {
573 crate::sui_system_state::SuiSystemState::V1(v1) => v1.into(),
574 crate::sui_system_state::SuiSystemState::V2(v2) => v2.into(),
575
576 #[allow(unreachable_patterns)]
577 _ => Self::default(),
578 }
579 }
580}
581
582impl From<crate::sui_system_state::sui_system_state_inner_v1::SuiSystemStateInnerV1>
583 for SystemState
584{
585 fn from(
586 crate::sui_system_state::sui_system_state_inner_v1::SuiSystemStateInnerV1 {
587 epoch,
588 protocol_version,
589 system_state_version,
590 validators,
591 storage_fund,
592 parameters,
593 reference_gas_price,
594 validator_report_records,
595 stake_subsidy,
596 safe_mode,
597 safe_mode_storage_rewards,
598 safe_mode_computation_rewards,
599 safe_mode_storage_rebates,
600 safe_mode_non_refundable_storage_fee,
601 epoch_start_timestamp_ms,
602 extra_fields,
603 }: crate::sui_system_state::sui_system_state_inner_v1::SuiSystemStateInnerV1,
604 ) -> Self {
605 let validator_report_records = validator_report_records
606 .contents
607 .into_iter()
608 .map(|entry| {
609 let mut record = ValidatorReportRecord::default();
610 record.reported = Some(entry.key.to_string());
611 record.reporters = entry
612 .value
613 .contents
614 .iter()
615 .map(ToString::to_string)
616 .collect();
617 record
618 })
619 .collect();
620
621 let mut message = Self::default();
622
623 message.version = Some(system_state_version);
624 message.epoch = Some(epoch);
625 message.protocol_version = Some(protocol_version);
626 message.validators = Some(validators.into());
627 message.storage_fund = Some(storage_fund.into());
628 message.parameters = Some(parameters.into());
629 message.reference_gas_price = Some(reference_gas_price);
630 message.validator_report_records = validator_report_records;
631 message.stake_subsidy = Some(stake_subsidy.into());
632 message.safe_mode = Some(safe_mode);
633 message.safe_mode_storage_rewards = Some(safe_mode_storage_rewards.value());
634 message.safe_mode_computation_rewards = Some(safe_mode_computation_rewards.value());
635 message.safe_mode_storage_rebates = Some(safe_mode_storage_rebates);
636 message.safe_mode_non_refundable_storage_fee = Some(safe_mode_non_refundable_storage_fee);
637 message.epoch_start_timestamp_ms = Some(epoch_start_timestamp_ms);
638 message.extra_fields = Some(extra_fields.into());
639 message
640 }
641}
642
643impl From<crate::sui_system_state::sui_system_state_inner_v2::SuiSystemStateInnerV2>
644 for SystemState
645{
646 fn from(
647 crate::sui_system_state::sui_system_state_inner_v2::SuiSystemStateInnerV2 {
648 epoch,
649 protocol_version,
650 system_state_version,
651 validators,
652 storage_fund,
653 parameters,
654 reference_gas_price,
655 validator_report_records,
656 stake_subsidy,
657 safe_mode,
658 safe_mode_storage_rewards,
659 safe_mode_computation_rewards,
660 safe_mode_storage_rebates,
661 safe_mode_non_refundable_storage_fee,
662 epoch_start_timestamp_ms,
663 extra_fields,
664 }: crate::sui_system_state::sui_system_state_inner_v2::SuiSystemStateInnerV2,
665 ) -> Self {
666 let validator_report_records = validator_report_records
667 .contents
668 .into_iter()
669 .map(|entry| {
670 let mut record = ValidatorReportRecord::default();
671 record.reported = Some(entry.key.to_string());
672 record.reporters = entry
673 .value
674 .contents
675 .iter()
676 .map(ToString::to_string)
677 .collect();
678 record
679 })
680 .collect();
681
682 let mut message = Self::default();
683
684 message.version = Some(system_state_version);
685 message.epoch = Some(epoch);
686 message.protocol_version = Some(protocol_version);
687 message.validators = Some(validators.into());
688 message.storage_fund = Some(storage_fund.into());
689 message.parameters = Some(parameters.into());
690 message.reference_gas_price = Some(reference_gas_price);
691 message.validator_report_records = validator_report_records;
692 message.stake_subsidy = Some(stake_subsidy.into());
693 message.safe_mode = Some(safe_mode);
694 message.safe_mode_storage_rewards = Some(safe_mode_storage_rewards.value());
695 message.safe_mode_computation_rewards = Some(safe_mode_computation_rewards.value());
696 message.safe_mode_storage_rebates = Some(safe_mode_storage_rebates);
697 message.safe_mode_non_refundable_storage_fee = Some(safe_mode_non_refundable_storage_fee);
698 message.epoch_start_timestamp_ms = Some(epoch_start_timestamp_ms);
699 message.extra_fields = Some(extra_fields.into());
700 message
701 }
702}
703
704impl From<crate::collection_types::Bag> for MoveTable {
705 fn from(crate::collection_types::Bag { id, size }: crate::collection_types::Bag) -> Self {
706 let mut message = Self::default();
707 message.id = Some(id.id.bytes.to_canonical_string(true));
708 message.size = Some(size);
709 message
710 }
711}
712
713impl From<crate::collection_types::Table> for MoveTable {
714 fn from(crate::collection_types::Table { id, size }: crate::collection_types::Table) -> Self {
715 let mut message = Self::default();
716 message.id = Some(id.to_canonical_string(true));
717 message.size = Some(size);
718 message
719 }
720}
721
722impl From<crate::collection_types::TableVec> for MoveTable {
723 fn from(value: crate::collection_types::TableVec) -> Self {
724 value.contents.into()
725 }
726}
727
728impl From<crate::sui_system_state::sui_system_state_inner_v1::StakeSubsidyV1> for StakeSubsidy {
729 fn from(
730 crate::sui_system_state::sui_system_state_inner_v1::StakeSubsidyV1 {
731 balance,
732 distribution_counter,
733 current_distribution_amount,
734 stake_subsidy_period_length,
735 stake_subsidy_decrease_rate,
736 extra_fields,
737 }: crate::sui_system_state::sui_system_state_inner_v1::StakeSubsidyV1,
738 ) -> Self {
739 let mut message = Self::default();
740 message.balance = Some(balance.value());
741 message.distribution_counter = Some(distribution_counter);
742 message.current_distribution_amount = Some(current_distribution_amount);
743 message.stake_subsidy_period_length = Some(stake_subsidy_period_length);
744 message.stake_subsidy_decrease_rate = Some(stake_subsidy_decrease_rate.into());
745 message.extra_fields = Some(extra_fields.into());
746 message
747 }
748}
749
750impl From<crate::sui_system_state::sui_system_state_inner_v1::SystemParametersV1>
751 for SystemParameters
752{
753 fn from(
754 crate::sui_system_state::sui_system_state_inner_v1::SystemParametersV1 {
755 epoch_duration_ms,
756 stake_subsidy_start_epoch,
757 max_validator_count,
758 min_validator_joining_stake,
759 validator_low_stake_threshold,
760 validator_very_low_stake_threshold,
761 validator_low_stake_grace_period,
762 extra_fields,
763 }: crate::sui_system_state::sui_system_state_inner_v1::SystemParametersV1,
764 ) -> Self {
765 let mut message = Self::default();
766 message.epoch_duration_ms = Some(epoch_duration_ms);
767 message.stake_subsidy_start_epoch = Some(stake_subsidy_start_epoch);
768 message.min_validator_count = None;
769 message.max_validator_count = Some(max_validator_count);
770 message.min_validator_joining_stake = Some(min_validator_joining_stake);
771 message.validator_low_stake_threshold = Some(validator_low_stake_threshold);
772 message.validator_very_low_stake_threshold = Some(validator_very_low_stake_threshold);
773 message.validator_low_stake_grace_period = Some(validator_low_stake_grace_period);
774 message.extra_fields = Some(extra_fields.into());
775 message
776 }
777}
778
779impl From<crate::sui_system_state::sui_system_state_inner_v2::SystemParametersV2>
780 for SystemParameters
781{
782 fn from(
783 crate::sui_system_state::sui_system_state_inner_v2::SystemParametersV2 {
784 epoch_duration_ms,
785 stake_subsidy_start_epoch,
786 min_validator_count,
787 max_validator_count,
788 min_validator_joining_stake,
789 validator_low_stake_threshold,
790 validator_very_low_stake_threshold,
791 validator_low_stake_grace_period,
792 extra_fields,
793 }: crate::sui_system_state::sui_system_state_inner_v2::SystemParametersV2,
794 ) -> Self {
795 let mut message = Self::default();
796 message.epoch_duration_ms = Some(epoch_duration_ms);
797 message.stake_subsidy_start_epoch = Some(stake_subsidy_start_epoch);
798 message.min_validator_count = Some(min_validator_count);
799 message.max_validator_count = Some(max_validator_count);
800 message.min_validator_joining_stake = Some(min_validator_joining_stake);
801 message.validator_low_stake_threshold = Some(validator_low_stake_threshold);
802 message.validator_very_low_stake_threshold = Some(validator_very_low_stake_threshold);
803 message.validator_low_stake_grace_period = Some(validator_low_stake_grace_period);
804 message.extra_fields = Some(extra_fields.into());
805 message
806 }
807}
808
809impl From<crate::sui_system_state::sui_system_state_inner_v1::StorageFundV1> for StorageFund {
810 fn from(
811 crate::sui_system_state::sui_system_state_inner_v1::StorageFundV1 {
812 total_object_storage_rebates,
813 non_refundable_balance,
814 }: crate::sui_system_state::sui_system_state_inner_v1::StorageFundV1,
815 ) -> Self {
816 let mut message = Self::default();
817 message.total_object_storage_rebates = Some(total_object_storage_rebates.value());
818 message.non_refundable_balance = Some(non_refundable_balance.value());
819 message
820 }
821}
822
823impl From<crate::sui_system_state::sui_system_state_inner_v1::ValidatorSetV1> for ValidatorSet {
824 fn from(
825 crate::sui_system_state::sui_system_state_inner_v1::ValidatorSetV1 {
826 total_stake,
827 active_validators,
828 pending_active_validators,
829 pending_removals,
830 staking_pool_mappings,
831 inactive_validators,
832 validator_candidates,
833 at_risk_validators,
834 extra_fields,
835 }: crate::sui_system_state::sui_system_state_inner_v1::ValidatorSetV1,
836 ) -> Self {
837 let at_risk_validators = at_risk_validators
838 .contents
839 .into_iter()
840 .map(|entry| (entry.key.to_string(), entry.value))
841 .collect();
842
843 let mut message = Self::default();
844 message.total_stake = Some(total_stake);
845 message.active_validators = active_validators.into_iter().map(Into::into).collect();
846 message.pending_active_validators = Some(pending_active_validators.into());
847 message.pending_removals = pending_removals;
848 message.staking_pool_mappings = Some(staking_pool_mappings.into());
849 message.inactive_validators = Some(inactive_validators.into());
850 message.validator_candidates = Some(validator_candidates.into());
851 message.at_risk_validators = at_risk_validators;
852 message.extra_fields = Some(extra_fields.into());
853 message
854 }
855}
856
857impl From<crate::sui_system_state::sui_system_state_inner_v1::StakingPoolV1> for StakingPool {
858 fn from(
859 crate::sui_system_state::sui_system_state_inner_v1::StakingPoolV1 {
860 id,
861 activation_epoch,
862 deactivation_epoch,
863 sui_balance,
864 rewards_pool,
865 pool_token_balance,
866 exchange_rates,
867 pending_stake,
868 pending_total_sui_withdraw,
869 pending_pool_token_withdraw,
870 extra_fields,
871 }: crate::sui_system_state::sui_system_state_inner_v1::StakingPoolV1,
872 ) -> Self {
873 let mut message = Self::default();
874 message.id = Some(id.to_canonical_string(true));
875 message.activation_epoch = activation_epoch;
876 message.deactivation_epoch = deactivation_epoch;
877 message.sui_balance = Some(sui_balance);
878 message.rewards_pool = Some(rewards_pool.value());
879 message.pool_token_balance = Some(pool_token_balance);
880 message.exchange_rates = Some(exchange_rates.into());
881 message.pending_stake = Some(pending_stake);
882 message.pending_total_sui_withdraw = Some(pending_total_sui_withdraw);
883 message.pending_pool_token_withdraw = Some(pending_pool_token_withdraw);
884 message.extra_fields = Some(extra_fields.into());
885 message
886 }
887}
888
889impl From<crate::sui_system_state::sui_system_state_inner_v1::ValidatorV1> for Validator {
890 fn from(
891 crate::sui_system_state::sui_system_state_inner_v1::ValidatorV1 {
892 metadata:
893 crate::sui_system_state::sui_system_state_inner_v1::ValidatorMetadataV1 {
894 sui_address,
895 protocol_pubkey_bytes,
896 network_pubkey_bytes,
897 worker_pubkey_bytes,
898 proof_of_possession_bytes,
899 name,
900 description,
901 image_url,
902 project_url,
903 net_address,
904 p2p_address,
905 primary_address,
906 worker_address,
907 next_epoch_protocol_pubkey_bytes,
908 next_epoch_proof_of_possession,
909 next_epoch_network_pubkey_bytes,
910 next_epoch_worker_pubkey_bytes,
911 next_epoch_net_address,
912 next_epoch_p2p_address,
913 next_epoch_primary_address,
914 next_epoch_worker_address,
915 extra_fields: metadata_extra_fields,
916 },
917 voting_power,
918 operation_cap_id,
919 gas_price,
920 staking_pool,
921 commission_rate,
922 next_epoch_stake,
923 next_epoch_gas_price,
924 next_epoch_commission_rate,
925 extra_fields,
926 ..
927 }: crate::sui_system_state::sui_system_state_inner_v1::ValidatorV1,
928 ) -> Self {
929 let mut message = Self::default();
930 message.name = Some(name);
931 message.address = Some(sui_address.to_string());
932 message.description = Some(description);
933 message.image_url = Some(image_url);
934 message.project_url = Some(project_url);
935 message.protocol_public_key = Some(protocol_pubkey_bytes.into());
936 message.proof_of_possession = Some(proof_of_possession_bytes.into());
937 message.network_public_key = Some(network_pubkey_bytes.into());
938 message.worker_public_key = Some(worker_pubkey_bytes.into());
939 message.network_address = Some(net_address);
940 message.p2p_address = Some(p2p_address);
941 message.primary_address = Some(primary_address);
942 message.worker_address = Some(worker_address);
943 message.next_epoch_protocol_public_key = next_epoch_protocol_pubkey_bytes.map(Into::into);
944 message.next_epoch_proof_of_possession = next_epoch_proof_of_possession.map(Into::into);
945 message.next_epoch_network_public_key = next_epoch_network_pubkey_bytes.map(Into::into);
946 message.next_epoch_worker_public_key = next_epoch_worker_pubkey_bytes.map(Into::into);
947 message.next_epoch_network_address = next_epoch_net_address;
948 message.next_epoch_p2p_address = next_epoch_p2p_address;
949 message.next_epoch_primary_address = next_epoch_primary_address;
950 message.next_epoch_worker_address = next_epoch_worker_address;
951 message.metadata_extra_fields = Some(metadata_extra_fields.into());
952 message.voting_power = Some(voting_power);
953 message.operation_cap_id = Some(operation_cap_id.bytes.to_canonical_string(true));
954 message.gas_price = Some(gas_price);
955 message.staking_pool = Some(staking_pool.into());
956 message.commission_rate = Some(commission_rate);
957 message.next_epoch_stake = Some(next_epoch_stake);
958 message.next_epoch_gas_price = Some(next_epoch_gas_price);
959 message.next_epoch_commission_rate = Some(next_epoch_commission_rate);
960 message.extra_fields = Some(extra_fields.into());
961 message
962 }
963}
964
965impl TryFrom<&SystemState>
966 for crate::sui_system_state::sui_system_state_summary::SuiSystemStateSummary
967{
968 type Error = TryFromProtoError;
969
970 fn try_from(s: &SystemState) -> Result<Self, Self::Error> {
971 Ok(Self {
972 epoch: s.epoch(),
973 protocol_version: s.protocol_version(),
974 system_state_version: s.version(),
975 storage_fund_total_object_storage_rebates: s
976 .storage_fund()
977 .total_object_storage_rebates(),
978 storage_fund_non_refundable_balance: s.storage_fund().non_refundable_balance(),
979 reference_gas_price: s.reference_gas_price(),
980 safe_mode: s.safe_mode(),
981 safe_mode_storage_rewards: s.safe_mode_storage_rewards(),
982 safe_mode_computation_rewards: s.safe_mode_computation_rewards(),
983 safe_mode_storage_rebates: s.safe_mode_storage_rebates(),
984 safe_mode_non_refundable_storage_fee: s.safe_mode_non_refundable_storage_fee(),
985 epoch_start_timestamp_ms: s.epoch_start_timestamp_ms(),
986 epoch_duration_ms: s.parameters().epoch_duration_ms(),
987 stake_subsidy_start_epoch: s.parameters().stake_subsidy_start_epoch(),
988 max_validator_count: s.parameters().max_validator_count(),
989 min_validator_joining_stake: s.parameters().min_validator_joining_stake(),
990 validator_low_stake_threshold: s.parameters().validator_low_stake_threshold(),
991 validator_very_low_stake_threshold: s.parameters().validator_very_low_stake_threshold(),
992 validator_low_stake_grace_period: s.parameters().validator_low_stake_grace_period(),
993 stake_subsidy_balance: s.stake_subsidy().balance(),
994 stake_subsidy_distribution_counter: s.stake_subsidy().distribution_counter(),
995 stake_subsidy_current_distribution_amount: s
996 .stake_subsidy()
997 .current_distribution_amount(),
998 stake_subsidy_period_length: s.stake_subsidy().stake_subsidy_period_length(),
999 stake_subsidy_decrease_rate: s.stake_subsidy().stake_subsidy_decrease_rate() as u16,
1000 total_stake: s.validators().total_stake(),
1001 active_validators: s
1002 .validators()
1003 .active_validators()
1004 .iter()
1005 .map(TryInto::try_into)
1006 .collect::<Result<_, _>>()?,
1007 pending_active_validators_id: s
1008 .validators()
1009 .pending_active_validators()
1010 .id()
1011 .parse()
1012 .map_err(|e| {
1013 TryFromProtoError::invalid("pending_active_validators_id", e)
1014 })?,
1015 pending_active_validators_size: s.validators().pending_active_validators().size(),
1016 pending_removals: s.validators().pending_removals().to_vec(),
1017 staking_pool_mappings_id: s
1018 .validators()
1019 .staking_pool_mappings()
1020 .id()
1021 .parse()
1022 .map_err(|e| TryFromProtoError::invalid("staking_pool_mappings_id", e))?,
1023 staking_pool_mappings_size: s.validators().staking_pool_mappings().size(),
1024 inactive_pools_id: s
1025 .validators()
1026 .inactive_validators()
1027 .id()
1028 .parse()
1029 .map_err(|e| TryFromProtoError::invalid("inactive_pools_id", e))?,
1030 inactive_pools_size: s.validators().inactive_validators().size(),
1031 validator_candidates_id: s
1032 .validators()
1033 .validator_candidates()
1034 .id()
1035 .parse()
1036 .map_err(|e| TryFromProtoError::invalid("validator_candidates", e))?,
1037 validator_candidates_size: s.validators().validator_candidates().size(),
1038 at_risk_validators: s
1039 .validators()
1040 .at_risk_validators()
1041 .iter()
1042 .map(|(address, epoch)| {
1043 address
1044 .parse()
1045 .map(|address| (address, *epoch))
1046 .map_err(|e| TryFromProtoError::invalid("at_risk_validators", e))
1047 })
1048 .collect::<Result<_, _>>()?,
1049 validator_report_records: s
1050 .validator_report_records()
1051 .iter()
1052 .map(|record| {
1053 let reported = record.reported().parse()?;
1054 let reporters = record
1055 .reporters()
1056 .iter()
1057 .map(|address| address.parse())
1058 .collect::<Result<Vec<_>, _>>()?;
1059 Ok((reported, reporters))
1060 })
1061 .collect::<Result<_, anyhow::Error>>()
1062 .map_err(|e| TryFromProtoError::invalid("validator_report_records", e))?,
1063 })
1064 }
1065}
1066
1067impl TryFrom<&Validator>
1068 for crate::sui_system_state::sui_system_state_summary::SuiValidatorSummary
1069{
1070 type Error = TryFromProtoError;
1071
1072 fn try_from(v: &Validator) -> Result<Self, Self::Error> {
1073 Ok(Self {
1074 sui_address: v
1075 .address()
1076 .parse()
1077 .map_err(|e| TryFromProtoError::invalid("address", e))?,
1078 protocol_pubkey_bytes: v.protocol_public_key().into(),
1079 network_pubkey_bytes: v.network_public_key().into(),
1080 worker_pubkey_bytes: v.worker_public_key().into(),
1081 proof_of_possession_bytes: v.proof_of_possession().into(),
1082 name: v.name().into(),
1083 description: v.description().into(),
1084 image_url: v.image_url().into(),
1085 project_url: v.project_url().into(),
1086 net_address: v.network_address().into(),
1087 p2p_address: v.p2p_address().into(),
1088 primary_address: v.primary_address().into(),
1089 worker_address: v.worker_address().into(),
1090 next_epoch_protocol_pubkey_bytes: v
1091 .next_epoch_protocol_public_key_opt()
1092 .map(Into::into),
1093 next_epoch_proof_of_possession: v.next_epoch_proof_of_possession_opt().map(Into::into),
1094 next_epoch_network_pubkey_bytes: v.next_epoch_network_public_key_opt().map(Into::into),
1095 next_epoch_worker_pubkey_bytes: v.next_epoch_worker_public_key_opt().map(Into::into),
1096 next_epoch_net_address: v.next_epoch_network_address_opt().map(Into::into),
1097 next_epoch_p2p_address: v.next_epoch_p2p_address_opt().map(Into::into),
1098 next_epoch_primary_address: v.next_epoch_primary_address_opt().map(Into::into),
1099 next_epoch_worker_address: v.next_epoch_worker_address_opt().map(Into::into),
1100 voting_power: v.voting_power(),
1101 operation_cap_id: v
1102 .operation_cap_id()
1103 .parse()
1104 .map_err(|e| TryFromProtoError::invalid("operation_cap_id", e))?,
1105 gas_price: v.gas_price(),
1106 commission_rate: v.commission_rate(),
1107 next_epoch_stake: v.next_epoch_stake(),
1108 next_epoch_gas_price: v.next_epoch_gas_price(),
1109 next_epoch_commission_rate: v.next_epoch_commission_rate(),
1110 staking_pool_id: v
1111 .staking_pool()
1112 .id()
1113 .parse()
1114 .map_err(|e| TryFromProtoError::invalid("staking_pool_id", e))?,
1115 staking_pool_activation_epoch: v.staking_pool().activation_epoch_opt(),
1116 staking_pool_deactivation_epoch: v.staking_pool().deactivation_epoch_opt(),
1117 staking_pool_sui_balance: v.staking_pool().sui_balance(),
1118 rewards_pool: v.staking_pool().rewards_pool(),
1119 pool_token_balance: v.staking_pool().pool_token_balance(),
1120 pending_stake: v.staking_pool().pending_stake(),
1121 pending_total_sui_withdraw: v.staking_pool().pending_total_sui_withdraw(),
1122 pending_pool_token_withdraw: v.staking_pool().pending_pool_token_withdraw(),
1123 exchange_rates_id: v
1124 .staking_pool()
1125 .exchange_rates()
1126 .id()
1127 .parse()
1128 .map_err(|e| TryFromProtoError::invalid("exchange_rates_id", e))?,
1129 exchange_rates_size: v.staking_pool().exchange_rates().size(),
1130 })
1131 }
1132}
1133
1134impl From<crate::execution_status::ExecutionStatus> for ExecutionStatus {
1139 fn from(value: crate::execution_status::ExecutionStatus) -> Self {
1140 let mut message = Self::default();
1141 match value {
1142 crate::execution_status::ExecutionStatus::Success => {
1143 message.success = Some(true);
1144 }
1145 crate::execution_status::ExecutionStatus::Failure { error, command } => {
1146 let description = if let Some(command) = command {
1147 format!("{error:?} in command {command}")
1148 } else {
1149 format!("{error:?}")
1150 };
1151 let mut error_message = ExecutionError::from(error);
1152 error_message.command = command.map(|i| i as u64);
1153 error_message.description = Some(description);
1154
1155 message.success = Some(false);
1156 message.error = Some(error_message);
1157 }
1158 }
1159
1160 message
1161 }
1162}
1163
1164fn size_error(size: u64, max_size: u64) -> SizeError {
1169 let mut message = SizeError::default();
1170 message.size = Some(size);
1171 message.max_size = Some(max_size);
1172 message
1173}
1174
1175fn index_error(index: u32, secondary_idx: Option<u32>) -> IndexError {
1176 let mut message = IndexError::default();
1177 message.index = Some(index);
1178 message.subresult = secondary_idx;
1179 message
1180}
1181
1182impl From<crate::execution_status::ExecutionFailureStatus> for ExecutionError {
1183 fn from(value: crate::execution_status::ExecutionFailureStatus) -> Self {
1184 use crate::execution_status::ExecutionFailureStatus as E;
1185 use execution_error::ErrorDetails;
1186 use execution_error::ExecutionErrorKind;
1187
1188 let mut message = Self::default();
1189
1190 let kind = match value {
1191 E::InsufficientGas => ExecutionErrorKind::InsufficientGas,
1192 E::InvalidGasObject => ExecutionErrorKind::InvalidGasObject,
1193 E::InvariantViolation => ExecutionErrorKind::InvariantViolation,
1194 E::FeatureNotYetSupported => ExecutionErrorKind::FeatureNotYetSupported,
1195 E::MoveObjectTooBig {
1196 object_size,
1197 max_object_size,
1198 } => {
1199 message.error_details = Some(ErrorDetails::SizeError(size_error(
1200 object_size,
1201 max_object_size,
1202 )));
1203 ExecutionErrorKind::ObjectTooBig
1204 }
1205 E::MovePackageTooBig {
1206 object_size,
1207 max_object_size,
1208 } => {
1209 message.error_details = Some(ErrorDetails::SizeError(size_error(
1210 object_size,
1211 max_object_size,
1212 )));
1213 ExecutionErrorKind::PackageTooBig
1214 }
1215 E::CircularObjectOwnership { object } => {
1216 message.error_details =
1217 Some(ErrorDetails::ObjectId(object.to_canonical_string(true)));
1218 ExecutionErrorKind::CircularObjectOwnership
1219 }
1220 E::InsufficientCoinBalance => ExecutionErrorKind::InsufficientCoinBalance,
1221 E::CoinBalanceOverflow => ExecutionErrorKind::CoinBalanceOverflow,
1222 E::PublishErrorNonZeroAddress => ExecutionErrorKind::PublishErrorNonZeroAddress,
1223 E::SuiMoveVerificationError => ExecutionErrorKind::SuiMoveVerificationError,
1224 E::MovePrimitiveRuntimeError(location) => {
1225 message.error_details = location.0.map(|l| {
1226 let mut abort = MoveAbort::default();
1227 abort.location = Some(l.into());
1228 ErrorDetails::Abort(abort)
1229 });
1230 ExecutionErrorKind::MovePrimitiveRuntimeError
1231 }
1232 E::MoveAbort(location, code) => {
1233 let mut abort = MoveAbort::default();
1234 abort.abort_code = Some(code);
1235 abort.location = Some(location.into());
1236 message.error_details = Some(ErrorDetails::Abort(abort));
1237 ExecutionErrorKind::MoveAbort
1238 }
1239 E::VMVerificationOrDeserializationError => {
1240 ExecutionErrorKind::VmVerificationOrDeserializationError
1241 }
1242 E::VMInvariantViolation => ExecutionErrorKind::VmInvariantViolation,
1243 E::FunctionNotFound => ExecutionErrorKind::FunctionNotFound,
1244 E::ArityMismatch => ExecutionErrorKind::ArityMismatch,
1245 E::TypeArityMismatch => ExecutionErrorKind::TypeArityMismatch,
1246 E::NonEntryFunctionInvoked => ExecutionErrorKind::NonEntryFunctionInvoked,
1247 E::CommandArgumentError { arg_idx, kind } => {
1248 let mut command_argument_error = CommandArgumentError::from(kind);
1249 command_argument_error.argument = Some(arg_idx.into());
1250 message.error_details =
1251 Some(ErrorDetails::CommandArgumentError(command_argument_error));
1252 ExecutionErrorKind::CommandArgumentError
1253 }
1254 E::TypeArgumentError { argument_idx, kind } => {
1255 let mut type_argument_error = TypeArgumentError::default();
1256 type_argument_error.type_argument = Some(argument_idx.into());
1257 type_argument_error.kind =
1258 Some(type_argument_error::TypeArgumentErrorKind::from(kind).into());
1259 message.error_details = Some(ErrorDetails::TypeArgumentError(type_argument_error));
1260 ExecutionErrorKind::TypeArgumentError
1261 }
1262 E::UnusedValueWithoutDrop {
1263 result_idx,
1264 secondary_idx,
1265 } => {
1266 message.error_details = Some(ErrorDetails::IndexError(index_error(
1267 result_idx.into(),
1268 Some(secondary_idx.into()),
1269 )));
1270 ExecutionErrorKind::UnusedValueWithoutDrop
1271 }
1272 E::InvalidPublicFunctionReturnType { idx } => {
1273 message.error_details =
1274 Some(ErrorDetails::IndexError(index_error(idx.into(), None)));
1275 ExecutionErrorKind::InvalidPublicFunctionReturnType
1276 }
1277 E::InvalidTransferObject => ExecutionErrorKind::InvalidTransferObject,
1278 E::EffectsTooLarge {
1279 current_size,
1280 max_size,
1281 } => {
1282 message.error_details =
1283 Some(ErrorDetails::SizeError(size_error(current_size, max_size)));
1284 ExecutionErrorKind::EffectsTooLarge
1285 }
1286 E::PublishUpgradeMissingDependency => {
1287 ExecutionErrorKind::PublishUpgradeMissingDependency
1288 }
1289 E::PublishUpgradeDependencyDowngrade => {
1290 ExecutionErrorKind::PublishUpgradeDependencyDowngrade
1291 }
1292 E::PackageUpgradeError { upgrade_error } => {
1293 message.error_details =
1294 Some(ErrorDetails::PackageUpgradeError(upgrade_error.into()));
1295 ExecutionErrorKind::PackageUpgradeError
1296 }
1297 E::WrittenObjectsTooLarge {
1298 current_size,
1299 max_size,
1300 } => {
1301 message.error_details =
1302 Some(ErrorDetails::SizeError(size_error(current_size, max_size)));
1303
1304 ExecutionErrorKind::WrittenObjectsTooLarge
1305 }
1306 E::CertificateDenied => ExecutionErrorKind::CertificateDenied,
1307 E::SuiMoveVerificationTimedout => ExecutionErrorKind::SuiMoveVerificationTimedout,
1308 E::SharedObjectOperationNotAllowed => {
1309 ExecutionErrorKind::ConsensusObjectOperationNotAllowed
1310 }
1311 E::InputObjectDeleted => ExecutionErrorKind::InputObjectDeleted,
1312 E::ExecutionCancelledDueToSharedObjectCongestion { congested_objects } => {
1313 message.error_details = Some(ErrorDetails::CongestedObjects({
1314 let mut message = CongestedObjects::default();
1315 message.objects = congested_objects
1316 .0
1317 .iter()
1318 .map(|o| o.to_canonical_string(true))
1319 .collect();
1320 message
1321 }));
1322
1323 ExecutionErrorKind::ExecutionCanceledDueToConsensusObjectCongestion
1324 }
1325 E::AddressDeniedForCoin { address, coin_type } => {
1326 message.error_details = Some(ErrorDetails::CoinDenyListError({
1327 let mut message = CoinDenyListError::default();
1328 message.address = Some(address.to_string());
1329 message.coin_type = Some(coin_type);
1330 message
1331 }));
1332 ExecutionErrorKind::AddressDeniedForCoin
1333 }
1334 E::CoinTypeGlobalPause { coin_type } => {
1335 message.error_details = Some(ErrorDetails::CoinDenyListError({
1336 let mut message = CoinDenyListError::default();
1337 message.coin_type = Some(coin_type);
1338 message
1339 }));
1340 ExecutionErrorKind::CoinTypeGlobalPause
1341 }
1342 E::ExecutionCancelledDueToRandomnessUnavailable => {
1343 ExecutionErrorKind::ExecutionCanceledDueToRandomnessUnavailable
1344 }
1345 E::MoveVectorElemTooBig {
1346 value_size,
1347 max_scaled_size,
1348 } => {
1349 message.error_details = Some(ErrorDetails::SizeError(size_error(
1350 value_size,
1351 max_scaled_size,
1352 )));
1353
1354 ExecutionErrorKind::MoveVectorElemTooBig
1355 }
1356 E::MoveRawValueTooBig {
1357 value_size,
1358 max_scaled_size,
1359 } => {
1360 message.error_details = Some(ErrorDetails::SizeError(size_error(
1361 value_size,
1362 max_scaled_size,
1363 )));
1364 ExecutionErrorKind::MoveRawValueTooBig
1365 }
1366 E::InvalidLinkage => ExecutionErrorKind::InvalidLinkage,
1367 E::InsufficientFundsForWithdraw => ExecutionErrorKind::InsufficientFundsForWithdraw,
1368 E::NonExclusiveWriteInputObjectModified { id } => {
1369 message.set_object_id(id.to_canonical_string(true));
1370 ExecutionErrorKind::NonExclusiveWriteInputObjectModified
1371 }
1372 };
1373
1374 message.set_kind(kind);
1375 message
1376 }
1377}
1378
1379impl From<crate::execution_status::CommandArgumentError> for CommandArgumentError {
1384 fn from(value: crate::execution_status::CommandArgumentError) -> Self {
1385 use crate::execution_status::CommandArgumentError as E;
1386 use command_argument_error::CommandArgumentErrorKind;
1387
1388 let mut message = Self::default();
1389
1390 let kind = match value {
1391 E::TypeMismatch => CommandArgumentErrorKind::TypeMismatch,
1392 E::InvalidBCSBytes => CommandArgumentErrorKind::InvalidBcsBytes,
1393 E::InvalidUsageOfPureArg => CommandArgumentErrorKind::InvalidUsageOfPureArgument,
1394 E::InvalidArgumentToPrivateEntryFunction => {
1395 CommandArgumentErrorKind::InvalidArgumentToPrivateEntryFunction
1396 }
1397 E::IndexOutOfBounds { idx } => {
1398 message.index_error = Some(index_error(idx.into(), None));
1399 CommandArgumentErrorKind::IndexOutOfBounds
1400 }
1401 E::SecondaryIndexOutOfBounds {
1402 result_idx,
1403 secondary_idx,
1404 } => {
1405 message.index_error =
1406 Some(index_error(result_idx.into(), Some(secondary_idx.into())));
1407 CommandArgumentErrorKind::SecondaryIndexOutOfBounds
1408 }
1409 E::InvalidResultArity { result_idx } => {
1410 message.index_error = Some(index_error(result_idx.into(), None));
1411 CommandArgumentErrorKind::InvalidResultArity
1412 }
1413 E::InvalidGasCoinUsage => CommandArgumentErrorKind::InvalidGasCoinUsage,
1414 E::InvalidValueUsage => CommandArgumentErrorKind::InvalidValueUsage,
1415 E::InvalidObjectByValue => CommandArgumentErrorKind::InvalidObjectByValue,
1416 E::InvalidObjectByMutRef => CommandArgumentErrorKind::InvalidObjectByMutRef,
1417 E::SharedObjectOperationNotAllowed => {
1418 CommandArgumentErrorKind::ConsensusObjectOperationNotAllowed
1419 }
1420 E::InvalidArgumentArity => CommandArgumentErrorKind::InvalidArgumentArity,
1421
1422 E::InvalidTransferObject => CommandArgumentErrorKind::InvalidTransferObject,
1423 E::InvalidMakeMoveVecNonObjectArgument => {
1424 CommandArgumentErrorKind::InvalidMakeMoveVecNonObjectArgument
1425 }
1426 E::ArgumentWithoutValue => CommandArgumentErrorKind::ArgumentWithoutValue,
1427 E::CannotMoveBorrowedValue => CommandArgumentErrorKind::CannotMoveBorrowedValue,
1428 E::CannotWriteToExtendedReference => {
1429 CommandArgumentErrorKind::CannotWriteToExtendedReference
1430 }
1431 E::InvalidReferenceArgument => CommandArgumentErrorKind::InvalidReferenceArgument,
1432 };
1433
1434 message.set_kind(kind);
1435 message
1436 }
1437}
1438
1439impl From<crate::execution_status::TypeArgumentError>
1444 for type_argument_error::TypeArgumentErrorKind
1445{
1446 fn from(value: crate::execution_status::TypeArgumentError) -> Self {
1447 use crate::execution_status::TypeArgumentError::*;
1448
1449 match value {
1450 TypeNotFound => Self::TypeNotFound,
1451 ConstraintNotSatisfied => Self::ConstraintNotSatisfied,
1452 }
1453 }
1454}
1455
1456impl From<crate::execution_status::PackageUpgradeError> for PackageUpgradeError {
1461 fn from(value: crate::execution_status::PackageUpgradeError) -> Self {
1462 use crate::execution_status::PackageUpgradeError as E;
1463 use package_upgrade_error::PackageUpgradeErrorKind;
1464
1465 let mut message = Self::default();
1466
1467 let kind = match value {
1468 E::UnableToFetchPackage { package_id } => {
1469 message.package_id = Some(package_id.to_canonical_string(true));
1470 PackageUpgradeErrorKind::UnableToFetchPackage
1471 }
1472 E::NotAPackage { object_id } => {
1473 message.package_id = Some(object_id.to_canonical_string(true));
1474 PackageUpgradeErrorKind::NotAPackage
1475 }
1476 E::IncompatibleUpgrade => PackageUpgradeErrorKind::IncompatibleUpgrade,
1477 E::DigestDoesNotMatch { digest } => {
1478 message.digest = crate::digests::Digest::try_from(digest)
1479 .ok()
1480 .map(|d| d.to_string());
1481 PackageUpgradeErrorKind::DigestDoesNotMatch
1482 }
1483 E::UnknownUpgradePolicy { policy } => {
1484 message.policy = Some(policy.into());
1485 PackageUpgradeErrorKind::UnknownUpgradePolicy
1486 }
1487 E::PackageIDDoesNotMatch {
1488 package_id,
1489 ticket_id,
1490 } => {
1491 message.package_id = Some(package_id.to_canonical_string(true));
1492 message.ticket_id = Some(ticket_id.to_canonical_string(true));
1493 PackageUpgradeErrorKind::PackageIdDoesNotMatch
1494 }
1495 };
1496
1497 message.set_kind(kind);
1498 message
1499 }
1500}
1501
1502impl From<crate::execution_status::MoveLocation> for MoveLocation {
1507 fn from(value: crate::execution_status::MoveLocation) -> Self {
1508 let mut message = Self::default();
1509 message.package = Some(value.module.address().to_canonical_string(true));
1510 message.module = Some(value.module.name().to_string());
1511 message.function = Some(value.function.into());
1512 message.instruction = Some(value.instruction.into());
1513 message.function_name = value.function_name.map(|name| name.to_string());
1514 message
1515 }
1516}
1517
1518impl<const T: bool> From<crate::crypto::AuthorityQuorumSignInfo<T>>
1523 for ValidatorAggregatedSignature
1524{
1525 fn from(value: crate::crypto::AuthorityQuorumSignInfo<T>) -> Self {
1526 let mut bitmap = Vec::new();
1527 value.signers_map.serialize_into(&mut bitmap).unwrap();
1528
1529 Self::default()
1530 .with_epoch(value.epoch)
1531 .with_signature(value.signature.as_ref().to_vec())
1532 .with_bitmap(bitmap)
1533 }
1534}
1535
1536impl<const T: bool> TryFrom<&ValidatorAggregatedSignature>
1537 for crate::crypto::AuthorityQuorumSignInfo<T>
1538{
1539 type Error = TryFromProtoError;
1540
1541 fn try_from(value: &ValidatorAggregatedSignature) -> Result<Self, Self::Error> {
1542 Ok(Self {
1543 epoch: value.epoch(),
1544 signature: crate::crypto::AggregateAuthoritySignature::from_bytes(value.signature())
1545 .map_err(|e| TryFromProtoError::invalid("signature", e))?,
1546 signers_map: crate::sui_serde::deserialize_sui_bitmap(value.bitmap())
1547 .map_err(|e| TryFromProtoError::invalid("bitmap", e))?,
1548 })
1549 }
1550}
1551
1552impl From<crate::committee::Committee> for ValidatorCommittee {
1557 fn from(value: crate::committee::Committee) -> Self {
1558 let mut message = Self::default();
1559 message.epoch = Some(value.epoch);
1560 message.members = value
1561 .voting_rights
1562 .into_iter()
1563 .map(|(name, weight)| {
1564 let mut member = ValidatorCommitteeMember::default();
1565 member.public_key = Some(name.0.to_vec().into());
1566 member.weight = Some(weight);
1567 member
1568 })
1569 .collect();
1570 message
1571 }
1572}
1573
1574impl TryFrom<&ValidatorCommittee> for crate::committee::Committee {
1575 type Error = TryFromProtoError;
1576
1577 fn try_from(s: &ValidatorCommittee) -> Result<Self, Self::Error> {
1578 let members = s
1579 .members()
1580 .iter()
1581 .map(|member| {
1582 let public_key =
1583 crate::crypto::AuthorityPublicKeyBytes::from_bytes(member.public_key())
1584 .map_err(|e| TryFromProtoError::invalid("public_key", e))?;
1585 Ok((public_key, member.weight()))
1586 })
1587 .collect::<Result<_, _>>()?;
1588 Ok(Self::new(s.epoch(), members))
1589 }
1590}
1591
1592impl From<&crate::zk_login_authenticator::ZkLoginAuthenticator> for ZkLoginAuthenticator {
1597 fn from(value: &crate::zk_login_authenticator::ZkLoginAuthenticator) -> Self {
1598 let mut inputs = ZkLoginInputs::default();
1600 inputs.address_seed = Some(value.inputs.get_address_seed().to_string());
1601 let mut message = Self::default();
1602 message.inputs = Some(inputs);
1603 message.max_epoch = Some(value.get_max_epoch());
1604 message.signature = Some(value.user_signature.clone().into());
1605
1606 sui_sdk_types::ZkLoginAuthenticator::try_from(value.clone())
1607 .map(Into::into)
1608 .ok()
1609 .unwrap_or(message)
1610 }
1611}
1612
1613impl From<&crate::crypto::ZkLoginPublicIdentifier> for ZkLoginPublicIdentifier {
1618 fn from(value: &crate::crypto::ZkLoginPublicIdentifier) -> Self {
1619 sui_sdk_types::ZkLoginPublicIdentifier::try_from(value.to_owned())
1621 .map(|id| (&id).into())
1622 .ok()
1623 .unwrap_or_default()
1624 }
1625}
1626
1627impl From<crate::crypto::SignatureScheme> for SignatureScheme {
1632 fn from(value: crate::crypto::SignatureScheme) -> Self {
1633 use crate::crypto::SignatureScheme as S;
1634
1635 match value {
1636 S::ED25519 => Self::Ed25519,
1637 S::Secp256k1 => Self::Secp256k1,
1638 S::Secp256r1 => Self::Secp256r1,
1639 S::BLS12381 => Self::Bls12381,
1640 S::MultiSig => Self::Multisig,
1641 S::ZkLoginAuthenticator => Self::Zklogin,
1642 S::PasskeyAuthenticator => Self::Passkey,
1643 }
1644 }
1645}
1646
1647impl From<crate::crypto::Signature> for SimpleSignature {
1652 fn from(value: crate::crypto::Signature) -> Self {
1653 Self::from(&value)
1654 }
1655}
1656
1657impl From<&crate::crypto::Signature> for SimpleSignature {
1658 fn from(value: &crate::crypto::Signature) -> Self {
1659 let scheme: SignatureScheme = value.scheme().into();
1660 let signature = value.signature_bytes();
1661 let public_key = value.public_key_bytes();
1662
1663 let mut message = Self::default();
1664 message.scheme = Some(scheme.into());
1665 message.signature = Some(signature.to_vec().into());
1666 message.public_key = Some(public_key.to_vec().into());
1667 message
1668 }
1669}
1670
1671impl From<&crate::passkey_authenticator::PasskeyAuthenticator> for PasskeyAuthenticator {
1676 fn from(value: &crate::passkey_authenticator::PasskeyAuthenticator) -> Self {
1677 let mut message = Self::default();
1678 message.authenticator_data = Some(value.authenticator_data().to_vec().into());
1679 message.client_data_json = Some(value.client_data_json().to_owned());
1680 message.signature = Some(value.signature().into());
1681 message
1682 }
1683}
1684
1685impl From<&crate::crypto::PublicKey> for MultisigMemberPublicKey {
1690 fn from(value: &crate::crypto::PublicKey) -> Self {
1691 let mut message = Self::default();
1692
1693 match value {
1694 crate::crypto::PublicKey::Ed25519(_)
1695 | crate::crypto::PublicKey::Secp256k1(_)
1696 | crate::crypto::PublicKey::Secp256r1(_)
1697 | crate::crypto::PublicKey::Passkey(_) => {
1698 message.public_key = Some(value.as_ref().to_vec().into());
1699 }
1700 crate::crypto::PublicKey::ZkLogin(z) => {
1701 message.zklogin = Some(z.into());
1702 }
1703 }
1704
1705 message.set_scheme(value.scheme().into());
1706 message
1707 }
1708}
1709
1710impl From<&crate::multisig::MultiSigPublicKey> for MultisigCommittee {
1715 fn from(value: &crate::multisig::MultiSigPublicKey) -> Self {
1716 let mut message = Self::default();
1717 message.members = value
1718 .pubkeys()
1719 .iter()
1720 .map(|(pk, weight)| {
1721 let mut member = MultisigMember::default();
1722 member.public_key = Some(pk.into());
1723 member.weight = Some((*weight).into());
1724 member
1725 })
1726 .collect();
1727 message.threshold = Some((*value.threshold()).into());
1728 message
1729 }
1730}
1731
1732impl From<&crate::multisig_legacy::MultiSigPublicKeyLegacy> for MultisigCommittee {
1733 fn from(value: &crate::multisig_legacy::MultiSigPublicKeyLegacy) -> Self {
1734 let mut message = Self::default();
1735 message.members = value
1736 .pubkeys()
1737 .iter()
1738 .map(|(pk, weight)| {
1739 let mut member = MultisigMember::default();
1740 member.public_key = Some(pk.into());
1741 member.weight = Some((*weight).into());
1742 member
1743 })
1744 .collect();
1745 message.threshold = Some((*value.threshold()).into());
1746 message
1747 }
1748}
1749
1750impl From<&crate::crypto::CompressedSignature> for MultisigMemberSignature {
1755 fn from(value: &crate::crypto::CompressedSignature) -> Self {
1756 let mut message = Self::default();
1757
1758 let scheme = match value {
1759 crate::crypto::CompressedSignature::Ed25519(b) => {
1760 message.signature = Some(b.0.to_vec().into());
1761 SignatureScheme::Ed25519
1762 }
1763 crate::crypto::CompressedSignature::Secp256k1(b) => {
1764 message.signature = Some(b.0.to_vec().into());
1765 SignatureScheme::Secp256k1
1766 }
1767 crate::crypto::CompressedSignature::Secp256r1(b) => {
1768 message.signature = Some(b.0.to_vec().into());
1769 SignatureScheme::Secp256r1
1770 }
1771 crate::crypto::CompressedSignature::ZkLogin(_z) => {
1772 SignatureScheme::Zklogin
1774 }
1775 crate::crypto::CompressedSignature::Passkey(_p) => {
1776 SignatureScheme::Passkey
1778 }
1779 };
1780
1781 message.set_scheme(scheme);
1782 message
1783 }
1784}
1785
1786impl From<&crate::multisig_legacy::MultiSigLegacy> for MultisigAggregatedSignature {
1791 fn from(value: &crate::multisig_legacy::MultiSigLegacy) -> Self {
1792 let mut legacy_bitmap = Vec::new();
1793 value
1794 .get_bitmap()
1795 .serialize_into(&mut legacy_bitmap)
1796 .unwrap();
1797
1798 Self::default()
1799 .with_signatures(value.get_sigs().iter().map(Into::into).collect())
1800 .with_legacy_bitmap(legacy_bitmap)
1801 .with_committee(value.get_pk())
1802 }
1803}
1804
1805impl From<&crate::multisig::MultiSig> for MultisigAggregatedSignature {
1806 fn from(value: &crate::multisig::MultiSig) -> Self {
1807 let mut message = Self::default();
1808 message.signatures = value.get_sigs().iter().map(Into::into).collect();
1809 message.bitmap = Some(value.get_bitmap().into());
1810 message.committee = Some(value.get_pk().into());
1811 message
1812 }
1813}
1814
1815impl From<&crate::signature::GenericSignature> for UserSignature {
1820 fn from(value: &crate::signature::GenericSignature) -> Self {
1821 Self::merge_from(value, &FieldMaskTree::new_wildcard())
1822 }
1823}
1824
1825impl Merge<&crate::signature::GenericSignature> for UserSignature {
1826 fn merge(&mut self, source: &crate::signature::GenericSignature, mask: &FieldMaskTree) {
1827 use user_signature::Signature;
1828
1829 if mask.contains(Self::BCS_FIELD) {
1830 let mut bcs = Bcs::from(source.as_ref().to_vec());
1831 bcs.name = Some("UserSignatureBytes".to_owned());
1832 self.bcs = Some(bcs);
1833 }
1834
1835 let scheme = match source {
1836 crate::signature::GenericSignature::MultiSig(multi_sig) => {
1837 if mask.contains(Self::MULTISIG_FIELD) {
1838 self.signature = Some(Signature::Multisig(multi_sig.into()));
1839 }
1840 SignatureScheme::Multisig
1841 }
1842 crate::signature::GenericSignature::MultiSigLegacy(multi_sig_legacy) => {
1843 if mask.contains(Self::MULTISIG_FIELD) {
1844 self.signature = Some(Signature::Multisig(multi_sig_legacy.into()));
1845 }
1846 SignatureScheme::Multisig
1847 }
1848 crate::signature::GenericSignature::Signature(signature) => {
1849 let scheme = signature.scheme().into();
1850 if mask.contains(Self::SIMPLE_FIELD) {
1851 self.signature = Some(Signature::Simple(signature.into()));
1852 }
1853 scheme
1854 }
1855 crate::signature::GenericSignature::ZkLoginAuthenticator(z) => {
1856 if mask.contains(Self::ZKLOGIN_FIELD) {
1857 self.signature = Some(Signature::Zklogin(z.into()));
1858 }
1859 SignatureScheme::Zklogin
1860 }
1861 crate::signature::GenericSignature::PasskeyAuthenticator(p) => {
1862 if mask.contains(Self::PASSKEY_FIELD) {
1863 self.signature = Some(Signature::Passkey(p.into()));
1864 }
1865 SignatureScheme::Passkey
1866 }
1867 };
1868
1869 if mask.contains(Self::SCHEME_FIELD) {
1870 self.set_scheme(scheme);
1871 }
1872 }
1873}
1874
1875impl From<crate::balance_change::BalanceChange> for BalanceChange {
1880 fn from(value: crate::balance_change::BalanceChange) -> Self {
1881 let mut message = Self::default();
1882 message.address = Some(value.address.to_string());
1883 message.coin_type = Some(value.coin_type.to_canonical_string(true));
1884 message.amount = Some(value.amount.to_string());
1885 message
1886 }
1887}
1888
1889impl TryFrom<&BalanceChange> for crate::balance_change::BalanceChange {
1890 type Error = TryFromProtoError;
1891
1892 fn try_from(value: &BalanceChange) -> Result<Self, Self::Error> {
1893 Ok(Self {
1894 address: value
1895 .address()
1896 .parse()
1897 .map_err(|e| TryFromProtoError::invalid(BalanceChange::ADDRESS_FIELD, e))?,
1898 coin_type: value
1899 .coin_type()
1900 .parse()
1901 .map_err(|e| TryFromProtoError::invalid(BalanceChange::COIN_TYPE_FIELD, e))?,
1902 amount: value
1903 .amount()
1904 .parse()
1905 .map_err(|e| TryFromProtoError::invalid(BalanceChange::AMOUNT_FIELD, e))?,
1906 })
1907 }
1908}
1909
1910pub const PACKAGE_TYPE: &str = "package";
1915
1916impl From<crate::object::Object> for Object {
1917 fn from(value: crate::object::Object) -> Self {
1918 Self::merge_from(&value, &FieldMaskTree::new_wildcard())
1919 }
1920}
1921
1922impl Merge<&crate::object::Object> for Object {
1923 fn merge(&mut self, source: &crate::object::Object, mask: &FieldMaskTree) {
1924 if mask.contains(Self::BCS_FIELD.name) {
1925 let mut bcs = Bcs::serialize(&source).unwrap();
1926 bcs.name = Some("Object".to_owned());
1927 self.bcs = Some(bcs);
1928 }
1929
1930 if mask.contains(Self::DIGEST_FIELD.name) {
1931 self.digest = Some(source.digest().to_string());
1932 }
1933
1934 if mask.contains(Self::OBJECT_ID_FIELD.name) {
1935 self.object_id = Some(source.id().to_canonical_string(true));
1936 }
1937
1938 if mask.contains(Self::VERSION_FIELD.name) {
1939 self.version = Some(source.version().value());
1940 }
1941
1942 if mask.contains(Self::OWNER_FIELD.name) {
1943 self.owner = Some(source.owner().to_owned().into());
1944 }
1945
1946 if mask.contains(Self::PREVIOUS_TRANSACTION_FIELD.name) {
1947 self.previous_transaction = Some(source.previous_transaction.to_string());
1948 }
1949
1950 if mask.contains(Self::STORAGE_REBATE_FIELD.name) {
1951 self.storage_rebate = Some(source.storage_rebate);
1952 }
1953
1954 if mask.contains(Self::BALANCE_FIELD) {
1955 self.balance = source.as_coin_maybe().map(|coin| coin.balance.value());
1956 }
1957
1958 self.merge(&source.data, mask);
1959 }
1960}
1961
1962impl Merge<&crate::object::MoveObject> for Object {
1963 fn merge(&mut self, source: &crate::object::MoveObject, mask: &FieldMaskTree) {
1964 self.object_id = Some(source.id().to_canonical_string(true));
1965 self.version = Some(source.version().value());
1966
1967 if mask.contains(Self::OBJECT_TYPE_FIELD.name) {
1968 self.object_type = Some(source.type_().to_canonical_string(true));
1969 }
1970
1971 if mask.contains(Self::HAS_PUBLIC_TRANSFER_FIELD.name) {
1972 self.has_public_transfer = Some(source.has_public_transfer());
1973 }
1974
1975 if mask.contains(Self::CONTENTS_FIELD.name) {
1976 let mut bcs = Bcs::from(source.contents().to_vec());
1977 bcs.name = Some(source.type_().to_canonical_string(true));
1978 self.contents = Some(bcs);
1979 }
1980 }
1981}
1982
1983impl Merge<&crate::move_package::MovePackage> for Object {
1984 fn merge(&mut self, source: &crate::move_package::MovePackage, mask: &FieldMaskTree) {
1985 self.object_id = Some(source.id().to_canonical_string(true));
1986 self.version = Some(source.version().value());
1987
1988 if mask.contains(Self::OBJECT_TYPE_FIELD.name) {
1989 self.object_type = Some(PACKAGE_TYPE.to_owned());
1990 }
1991
1992 if mask.contains(Self::PACKAGE_FIELD.name) {
1993 let mut package = Package::default();
1994 package.modules = source
1995 .serialized_module_map()
1996 .iter()
1997 .map(|(name, contents)| {
1998 let mut module = Module::default();
1999 module.name = Some(name.to_string());
2000 module.contents = Some(contents.clone().into());
2001 module
2002 })
2003 .collect();
2004 package.type_origins = source
2005 .type_origin_table()
2006 .clone()
2007 .into_iter()
2008 .map(Into::into)
2009 .collect();
2010 package.linkage = source
2011 .linkage_table()
2012 .iter()
2013 .map(
2014 |(
2015 original_id,
2016 crate::move_package::UpgradeInfo {
2017 upgraded_id,
2018 upgraded_version,
2019 },
2020 )| {
2021 let mut linkage = Linkage::default();
2022 linkage.original_id = Some(original_id.to_canonical_string(true));
2023 linkage.upgraded_id = Some(upgraded_id.to_canonical_string(true));
2024 linkage.upgraded_version = Some(upgraded_version.value());
2025 linkage
2026 },
2027 )
2028 .collect();
2029
2030 self.package = Some(package);
2031 }
2032 }
2033}
2034
2035impl Merge<&crate::object::Data> for Object {
2036 fn merge(&mut self, source: &crate::object::Data, mask: &FieldMaskTree) {
2037 match source {
2038 crate::object::Data::Move(object) => self.merge(object, mask),
2039 crate::object::Data::Package(package) => self.merge(package, mask),
2040 }
2041 }
2042}
2043
2044impl From<crate::move_package::TypeOrigin> for TypeOrigin {
2049 fn from(value: crate::move_package::TypeOrigin) -> Self {
2050 let mut message = Self::default();
2051 message.module_name = Some(value.module_name.to_string());
2052 message.datatype_name = Some(value.datatype_name.to_string());
2053 message.package_id = Some(value.package.to_canonical_string(true));
2054 message
2055 }
2056}
2057
2058impl From<crate::transaction::GenesisObject> for Object {
2063 fn from(value: crate::transaction::GenesisObject) -> Self {
2064 let crate::transaction::GenesisObject::RawObject { data, owner } = value;
2065 let mut message = Self::default();
2066 message.owner = Some(owner.into());
2067
2068 message.merge(&data, &FieldMaskTree::new_wildcard());
2069
2070 message
2071 }
2072}
2073
2074pub trait ObjectRefExt {
2079 fn to_proto(self) -> ObjectReference;
2080}
2081
2082pub trait ObjectReferenceExt {
2083 fn try_to_object_ref(&self) -> Result<crate::base_types::ObjectRef, anyhow::Error>;
2084}
2085
2086impl ObjectRefExt for crate::base_types::ObjectRef {
2087 fn to_proto(self) -> ObjectReference {
2088 let (object_id, version, digest) = self;
2089 let mut message = ObjectReference::default();
2090 message.object_id = Some(object_id.to_canonical_string(true));
2091 message.version = Some(version.value());
2092 message.digest = Some(digest.to_string());
2093 message
2094 }
2095}
2096
2097impl ObjectReferenceExt for ObjectReference {
2098 fn try_to_object_ref(&self) -> Result<crate::base_types::ObjectRef, anyhow::Error> {
2099 use anyhow::Context;
2100
2101 let object_id = self
2102 .object_id_opt()
2103 .ok_or_else(|| anyhow::anyhow!("missing object_id"))?;
2104 let object_id = crate::base_types::ObjectID::from_hex_literal(object_id)
2105 .with_context(|| format!("Failed to parse object_id: {}", object_id))?;
2106
2107 let version = self
2108 .version_opt()
2109 .ok_or_else(|| anyhow::anyhow!("missing version"))?;
2110 let version = crate::base_types::SequenceNumber::from(version);
2111
2112 let digest = self
2113 .digest_opt()
2114 .ok_or_else(|| anyhow::anyhow!("missing digest"))?;
2115 let digest = digest
2116 .parse::<crate::digests::ObjectDigest>()
2117 .with_context(|| format!("Failed to parse digest: {}", digest))?;
2118
2119 Ok((object_id, version, digest))
2120 }
2121}
2122
2123impl From<&crate::storage::ObjectKey> for ObjectReference {
2124 fn from(value: &crate::storage::ObjectKey) -> Self {
2125 Self::default()
2126 .with_object_id(value.0.to_canonical_string(true))
2127 .with_version(value.1.value())
2128 }
2129}
2130
2131impl From<crate::object::Owner> for Owner {
2136 fn from(value: crate::object::Owner) -> Self {
2137 use crate::object::Owner as O;
2138 use owner::OwnerKind;
2139
2140 let mut message = Self::default();
2141
2142 let kind = match value {
2143 O::AddressOwner(address) => {
2144 message.address = Some(address.to_string());
2145 OwnerKind::Address
2146 }
2147 O::ObjectOwner(address) => {
2148 message.address = Some(address.to_string());
2149 OwnerKind::Object
2150 }
2151 O::Shared {
2152 initial_shared_version,
2153 } => {
2154 message.version = Some(initial_shared_version.value());
2155 OwnerKind::Shared
2156 }
2157 O::Immutable => OwnerKind::Immutable,
2158 O::ConsensusAddressOwner {
2159 start_version,
2160 owner,
2161 } => {
2162 message.version = Some(start_version.value());
2163 message.address = Some(owner.to_string());
2164 OwnerKind::ConsensusAddress
2165 }
2166 };
2167
2168 message.set_kind(kind);
2169 message
2170 }
2171}
2172
2173impl From<crate::transaction::TransactionData> for Transaction {
2178 fn from(value: crate::transaction::TransactionData) -> Self {
2179 Self::merge_from(&value, &FieldMaskTree::new_wildcard())
2180 }
2181}
2182
2183impl Merge<&crate::transaction::TransactionData> for Transaction {
2184 fn merge(&mut self, source: &crate::transaction::TransactionData, mask: &FieldMaskTree) {
2185 if mask.contains(Self::BCS_FIELD.name) {
2186 let mut bcs = Bcs::serialize(&source).unwrap();
2187 bcs.name = Some("TransactionData".to_owned());
2188 self.bcs = Some(bcs);
2189 }
2190
2191 if mask.contains(Self::DIGEST_FIELD.name) {
2192 self.digest = Some(source.digest().to_string());
2193 }
2194
2195 if mask.contains(Self::VERSION_FIELD.name) {
2196 self.version = Some(1);
2197 }
2198
2199 let crate::transaction::TransactionData::V1(source) = source;
2200
2201 if mask.contains(Self::KIND_FIELD.name) {
2202 self.kind = Some(source.kind.clone().into());
2203 }
2204
2205 if mask.contains(Self::SENDER_FIELD.name) {
2206 self.sender = Some(source.sender.to_string());
2207 }
2208
2209 if mask.contains(Self::GAS_PAYMENT_FIELD.name) {
2210 self.gas_payment = Some((&source.gas_data).into());
2211 }
2212
2213 if mask.contains(Self::EXPIRATION_FIELD.name) {
2214 self.expiration = Some(source.expiration.into());
2215 }
2216 }
2217}
2218
2219impl From<&crate::transaction::GasData> for GasPayment {
2224 fn from(value: &crate::transaction::GasData) -> Self {
2225 let mut message = Self::default();
2226 message.objects = value
2227 .payment
2228 .iter()
2229 .map(|obj_ref| obj_ref.to_proto())
2230 .collect();
2231 message.owner = Some(value.owner.to_string());
2232 message.price = Some(value.price);
2233 message.budget = Some(value.budget);
2234 message
2235 }
2236}
2237
2238impl From<crate::transaction::TransactionExpiration> for TransactionExpiration {
2243 fn from(value: crate::transaction::TransactionExpiration) -> Self {
2244 use crate::transaction::TransactionExpiration as E;
2245 use transaction_expiration::TransactionExpirationKind;
2246
2247 let mut message = Self::default();
2248
2249 let kind = match value {
2250 E::None => TransactionExpirationKind::None,
2251 E::Epoch(epoch) => {
2252 message.epoch = Some(epoch);
2253 TransactionExpirationKind::Epoch
2254 }
2255 E::ValidDuring {
2256 min_epoch,
2257 max_epoch,
2258 min_timestamp,
2259 max_timestamp,
2260 chain,
2261 nonce,
2262 } => {
2263 message.epoch = max_epoch;
2264 message.min_epoch = min_epoch;
2265 message.min_timestamp = min_timestamp.map(ms_to_timestamp);
2266 message.max_timestamp = max_timestamp.map(ms_to_timestamp);
2267 message.set_chain(sui_sdk_types::Digest::new(*chain.as_bytes()));
2268 message.set_nonce(nonce);
2269
2270 TransactionExpirationKind::ValidDuring
2271 }
2272 };
2273
2274 message.set_kind(kind);
2275 message
2276 }
2277}
2278
2279impl TryFrom<&TransactionExpiration> for crate::transaction::TransactionExpiration {
2280 type Error = &'static str;
2281
2282 fn try_from(value: &TransactionExpiration) -> Result<Self, Self::Error> {
2283 use transaction_expiration::TransactionExpirationKind;
2284
2285 Ok(match value.kind() {
2286 TransactionExpirationKind::None => Self::None,
2287 TransactionExpirationKind::Epoch => Self::Epoch(value.epoch()),
2288 TransactionExpirationKind::Unknown | _ => {
2289 return Err("unknown TransactionExpirationKind");
2290 }
2291 })
2292 }
2293}
2294
2295impl From<crate::transaction::TransactionKind> for TransactionKind {
2300 fn from(value: crate::transaction::TransactionKind) -> Self {
2301 use crate::transaction::TransactionKind as K;
2302 use transaction_kind::Kind;
2303
2304 let message = Self::default();
2305
2306 match value {
2307 K::ProgrammableTransaction(ptb) => message
2308 .with_programmable_transaction(ptb)
2309 .with_kind(Kind::ProgrammableTransaction),
2310 K::ChangeEpoch(change_epoch) => message
2311 .with_change_epoch(change_epoch)
2312 .with_kind(Kind::ChangeEpoch),
2313 K::Genesis(genesis) => message.with_genesis(genesis).with_kind(Kind::Genesis),
2314 K::ConsensusCommitPrologue(prologue) => message
2315 .with_consensus_commit_prologue(prologue)
2316 .with_kind(Kind::ConsensusCommitPrologueV1),
2317 K::AuthenticatorStateUpdate(update) => message
2318 .with_authenticator_state_update(update)
2319 .with_kind(Kind::AuthenticatorStateUpdate),
2320 K::EndOfEpochTransaction(transactions) => message
2321 .with_end_of_epoch({
2322 EndOfEpochTransaction::default()
2323 .with_transactions(transactions.into_iter().map(Into::into).collect())
2324 })
2325 .with_kind(Kind::EndOfEpoch),
2326 K::RandomnessStateUpdate(update) => message
2327 .with_randomness_state_update(update)
2328 .with_kind(Kind::RandomnessStateUpdate),
2329 K::ConsensusCommitPrologueV2(prologue) => message
2330 .with_consensus_commit_prologue(prologue)
2331 .with_kind(Kind::ConsensusCommitPrologueV2),
2332 K::ConsensusCommitPrologueV3(prologue) => message
2333 .with_consensus_commit_prologue(prologue)
2334 .with_kind(Kind::ConsensusCommitPrologueV3),
2335 K::ConsensusCommitPrologueV4(prologue) => message
2336 .with_consensus_commit_prologue(prologue)
2337 .with_kind(Kind::ConsensusCommitPrologueV4),
2338 K::ProgrammableSystemTransaction(ptb) => message
2339 .with_programmable_transaction(ptb)
2340 .with_kind(Kind::ProgrammableSystemTransaction),
2341 }
2342 }
2343}
2344
2345impl From<crate::messages_consensus::ConsensusCommitPrologue> for ConsensusCommitPrologue {
2350 fn from(value: crate::messages_consensus::ConsensusCommitPrologue) -> Self {
2351 let mut message = Self::default();
2352 message.epoch = Some(value.epoch);
2353 message.round = Some(value.round);
2354 message.commit_timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(
2355 value.commit_timestamp_ms,
2356 ));
2357 message
2358 }
2359}
2360
2361impl From<crate::messages_consensus::ConsensusCommitPrologueV2> for ConsensusCommitPrologue {
2362 fn from(value: crate::messages_consensus::ConsensusCommitPrologueV2) -> Self {
2363 let mut message = Self::default();
2364 message.epoch = Some(value.epoch);
2365 message.round = Some(value.round);
2366 message.commit_timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(
2367 value.commit_timestamp_ms,
2368 ));
2369 message.consensus_commit_digest = Some(value.consensus_commit_digest.to_string());
2370 message
2371 }
2372}
2373
2374impl From<crate::messages_consensus::ConsensusCommitPrologueV3> for ConsensusCommitPrologue {
2375 fn from(value: crate::messages_consensus::ConsensusCommitPrologueV3) -> Self {
2376 let mut message = Self::default();
2377 message.epoch = Some(value.epoch);
2378 message.round = Some(value.round);
2379 message.commit_timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(
2380 value.commit_timestamp_ms,
2381 ));
2382 message.consensus_commit_digest = Some(value.consensus_commit_digest.to_string());
2383 message.sub_dag_index = value.sub_dag_index;
2384 message.consensus_determined_version_assignments =
2385 Some(value.consensus_determined_version_assignments.into());
2386 message
2387 }
2388}
2389
2390impl From<crate::messages_consensus::ConsensusCommitPrologueV4> for ConsensusCommitPrologue {
2391 fn from(
2392 crate::messages_consensus::ConsensusCommitPrologueV4 {
2393 epoch,
2394 round,
2395 sub_dag_index,
2396 commit_timestamp_ms,
2397 consensus_commit_digest,
2398 consensus_determined_version_assignments,
2399 additional_state_digest,
2400 }: crate::messages_consensus::ConsensusCommitPrologueV4,
2401 ) -> Self {
2402 let mut message = Self::default();
2403 message.epoch = Some(epoch);
2404 message.round = Some(round);
2405 message.commit_timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(commit_timestamp_ms));
2406 message.consensus_commit_digest = Some(consensus_commit_digest.to_string());
2407 message.sub_dag_index = sub_dag_index;
2408 message.consensus_determined_version_assignments =
2409 Some(consensus_determined_version_assignments.into());
2410 message.additional_state_digest = Some(additional_state_digest.to_string());
2411 message
2412 }
2413}
2414
2415impl From<crate::messages_consensus::ConsensusDeterminedVersionAssignments>
2420 for ConsensusDeterminedVersionAssignments
2421{
2422 fn from(value: crate::messages_consensus::ConsensusDeterminedVersionAssignments) -> Self {
2423 use crate::messages_consensus::ConsensusDeterminedVersionAssignments as A;
2424
2425 let mut message = Self::default();
2426
2427 let version = match value {
2428 A::CancelledTransactions(canceled_transactions) => {
2429 message.canceled_transactions = canceled_transactions
2430 .into_iter()
2431 .map(|(tx_digest, assignments)| {
2432 let mut message = CanceledTransaction::default();
2433 message.digest = Some(tx_digest.to_string());
2434 message.version_assignments = assignments
2435 .into_iter()
2436 .map(|(id, version)| {
2437 let mut message = VersionAssignment::default();
2438 message.object_id = Some(id.to_canonical_string(true));
2439 message.version = Some(version.value());
2440 message
2441 })
2442 .collect();
2443 message
2444 })
2445 .collect();
2446 1
2447 }
2448 A::CancelledTransactionsV2(canceled_transactions) => {
2449 message.canceled_transactions = canceled_transactions
2450 .into_iter()
2451 .map(|(tx_digest, assignments)| {
2452 let mut message = CanceledTransaction::default();
2453 message.digest = Some(tx_digest.to_string());
2454 message.version_assignments = assignments
2455 .into_iter()
2456 .map(|((id, start_version), version)| {
2457 let mut message = VersionAssignment::default();
2458 message.object_id = Some(id.to_canonical_string(true));
2459 message.start_version = Some(start_version.value());
2460 message.version = Some(version.value());
2461 message
2462 })
2463 .collect();
2464 message
2465 })
2466 .collect();
2467 2
2468 }
2469 };
2470
2471 message.version = Some(version);
2472 message
2473 }
2474}
2475
2476impl From<crate::transaction::GenesisTransaction> for GenesisTransaction {
2481 fn from(value: crate::transaction::GenesisTransaction) -> Self {
2482 let mut message = Self::default();
2483 message.objects = value.objects.into_iter().map(Into::into).collect();
2484 message
2485 }
2486}
2487
2488impl From<crate::transaction::RandomnessStateUpdate> for RandomnessStateUpdate {
2493 fn from(value: crate::transaction::RandomnessStateUpdate) -> Self {
2494 let mut message = Self::default();
2495 message.epoch = Some(value.epoch);
2496 message.randomness_round = Some(value.randomness_round.0);
2497 message.random_bytes = Some(value.random_bytes.into());
2498 message.randomness_object_initial_shared_version =
2499 Some(value.randomness_obj_initial_shared_version.value());
2500 message
2501 }
2502}
2503
2504impl From<crate::transaction::AuthenticatorStateUpdate> for AuthenticatorStateUpdate {
2509 fn from(value: crate::transaction::AuthenticatorStateUpdate) -> Self {
2510 let mut message = Self::default();
2511 message.epoch = Some(value.epoch);
2512 message.round = Some(value.round);
2513 message.new_active_jwks = value.new_active_jwks.into_iter().map(Into::into).collect();
2514 message.authenticator_object_initial_shared_version =
2515 Some(value.authenticator_obj_initial_shared_version.value());
2516 message
2517 }
2518}
2519
2520impl From<crate::authenticator_state::ActiveJwk> for ActiveJwk {
2525 fn from(value: crate::authenticator_state::ActiveJwk) -> Self {
2526 let mut jwk_id = JwkId::default();
2527 jwk_id.iss = Some(value.jwk_id.iss);
2528 jwk_id.kid = Some(value.jwk_id.kid);
2529
2530 let mut jwk = Jwk::default();
2531 jwk.kty = Some(value.jwk.kty);
2532 jwk.e = Some(value.jwk.e);
2533 jwk.n = Some(value.jwk.n);
2534 jwk.alg = Some(value.jwk.alg);
2535
2536 let mut message = Self::default();
2537 message.id = Some(jwk_id);
2538 message.jwk = Some(jwk);
2539 message.epoch = Some(value.epoch);
2540 message
2541 }
2542}
2543
2544impl From<crate::transaction::ChangeEpoch> for ChangeEpoch {
2549 fn from(value: crate::transaction::ChangeEpoch) -> Self {
2550 let mut message = Self::default();
2551 message.epoch = Some(value.epoch);
2552 message.protocol_version = Some(value.protocol_version.as_u64());
2553 message.storage_charge = Some(value.storage_charge);
2554 message.computation_charge = Some(value.computation_charge);
2555 message.storage_rebate = Some(value.storage_rebate);
2556 message.non_refundable_storage_fee = Some(value.non_refundable_storage_fee);
2557 message.epoch_start_timestamp = Some(sui_rpc::proto::timestamp_ms_to_proto(
2558 value.epoch_start_timestamp_ms,
2559 ));
2560 message.system_packages = value
2561 .system_packages
2562 .into_iter()
2563 .map(|(version, modules, dependencies)| {
2564 let mut message = SystemPackage::default();
2565 message.version = Some(version.value());
2566 message.modules = modules.into_iter().map(Into::into).collect();
2567 message.dependencies = dependencies
2568 .iter()
2569 .map(|d| d.to_canonical_string(true))
2570 .collect();
2571 message
2572 })
2573 .collect();
2574 message
2575 }
2576}
2577
2578impl From<crate::transaction::EndOfEpochTransactionKind> for EndOfEpochTransactionKind {
2583 fn from(value: crate::transaction::EndOfEpochTransactionKind) -> Self {
2584 use crate::transaction::EndOfEpochTransactionKind as K;
2585 use end_of_epoch_transaction_kind::Kind;
2586
2587 let message = Self::default();
2588
2589 match value {
2590 K::ChangeEpoch(change_epoch) => message
2591 .with_change_epoch(change_epoch)
2592 .with_kind(Kind::ChangeEpoch),
2593 K::AuthenticatorStateCreate => message.with_kind(Kind::AuthenticatorStateCreate),
2594 K::AuthenticatorStateExpire(expire) => message
2595 .with_authenticator_state_expire(expire)
2596 .with_kind(Kind::AuthenticatorStateExpire),
2597 K::RandomnessStateCreate => message.with_kind(Kind::RandomnessStateCreate),
2598 K::DenyListStateCreate => message.with_kind(Kind::DenyListStateCreate),
2599 K::BridgeStateCreate(chain_id) => message
2600 .with_bridge_chain_id(chain_id.to_string())
2601 .with_kind(Kind::BridgeStateCreate),
2602 K::BridgeCommitteeInit(bridge_object_version) => message
2603 .with_bridge_object_version(bridge_object_version.into())
2604 .with_kind(Kind::BridgeCommitteeInit),
2605 K::StoreExecutionTimeObservations(observations) => message
2606 .with_execution_time_observations(observations)
2607 .with_kind(Kind::StoreExecutionTimeObservations),
2608 K::AccumulatorRootCreate => message.with_kind(Kind::AccumulatorRootCreate),
2609 K::CoinRegistryCreate => message.with_kind(Kind::CoinRegistryCreate),
2610 K::DisplayRegistryCreate => message.with_kind(Kind::DisplayRegistryCreate),
2611 K::AddressAliasStateCreate => message.with_kind(Kind::AddressAliasStateCreate),
2612 K::WriteAccumulatorStorageCost(storage_cost) => message
2613 .with_kind(Kind::WriteAccumulatorStorageCost)
2614 .with_storage_cost(storage_cost.storage_cost),
2615 }
2616 }
2617}
2618
2619impl From<crate::transaction::AuthenticatorStateExpire> for AuthenticatorStateExpire {
2624 fn from(value: crate::transaction::AuthenticatorStateExpire) -> Self {
2625 let mut message = Self::default();
2626 message.min_epoch = Some(value.min_epoch);
2627 message.authenticator_object_initial_shared_version =
2628 Some(value.authenticator_obj_initial_shared_version.value());
2629 message
2630 }
2631}
2632
2633impl From<crate::transaction::StoredExecutionTimeObservations> for ExecutionTimeObservations {
2636 fn from(value: crate::transaction::StoredExecutionTimeObservations) -> Self {
2637 let mut message = Self::default();
2638 match value {
2639 crate::transaction::StoredExecutionTimeObservations::V1(vec) => {
2640 message.version = Some(1);
2641 message.observations = vec
2642 .into_iter()
2643 .map(|(key, observation)| {
2644 use crate::execution::ExecutionTimeObservationKey as K;
2645 use execution_time_observation::ExecutionTimeObservationKind;
2646
2647 let mut message = ExecutionTimeObservation::default();
2648
2649 let kind = match key {
2650 K::MoveEntryPoint {
2651 package,
2652 module,
2653 function,
2654 type_arguments,
2655 } => {
2656 message.move_entry_point = Some({
2657 let mut message = MoveCall::default();
2658 message.package = Some(package.to_canonical_string(true));
2659 message.module = Some(module);
2660 message.function = Some(function);
2661 message.type_arguments = type_arguments
2662 .into_iter()
2663 .map(|ty| ty.to_canonical_string(true))
2664 .collect();
2665 message
2666 });
2667 ExecutionTimeObservationKind::MoveEntryPoint
2668 }
2669 K::TransferObjects => ExecutionTimeObservationKind::TransferObjects,
2670 K::SplitCoins => ExecutionTimeObservationKind::SplitCoins,
2671 K::MergeCoins => ExecutionTimeObservationKind::MergeCoins,
2672 K::Publish => ExecutionTimeObservationKind::Publish,
2673 K::MakeMoveVec => ExecutionTimeObservationKind::MakeMoveVector,
2674 K::Upgrade => ExecutionTimeObservationKind::Upgrade,
2675 };
2676
2677 message.validator_observations = observation
2678 .into_iter()
2679 .map(|(name, duration)| {
2680 let mut message = ValidatorExecutionTimeObservation::default();
2681 message.validator = Some(name.0.to_vec().into());
2682 message.duration = Some(prost_types::Duration {
2683 seconds: duration.as_secs() as i64,
2684 nanos: duration.subsec_nanos() as i32,
2685 });
2686 message
2687 })
2688 .collect();
2689
2690 message.set_kind(kind);
2691 message
2692 })
2693 .collect();
2694 }
2695 }
2696
2697 message
2698 }
2699}
2700
2701impl From<crate::transaction::ProgrammableTransaction> for ProgrammableTransaction {
2706 fn from(value: crate::transaction::ProgrammableTransaction) -> Self {
2707 let mut message = Self::default();
2708 message.inputs = value.inputs.into_iter().map(Into::into).collect();
2709 message.commands = value.commands.into_iter().map(Into::into).collect();
2710 message
2711 }
2712}
2713
2714impl From<crate::transaction::CallArg> for Input {
2719 fn from(value: crate::transaction::CallArg) -> Self {
2720 use crate::transaction::CallArg as I;
2721 use crate::transaction::ObjectArg as O;
2722 use input::InputKind;
2723 use input::Mutability;
2724
2725 let mut message = Self::default();
2726
2727 let kind = match value {
2728 I::Pure(value) => {
2729 message.pure = Some(value.into());
2730 InputKind::Pure
2731 }
2732 I::Object(o) => match o {
2733 O::ImmOrOwnedObject((id, version, digest)) => {
2734 message.object_id = Some(id.to_canonical_string(true));
2735 message.version = Some(version.value());
2736 message.digest = Some(digest.to_string());
2737 InputKind::ImmutableOrOwned
2738 }
2739 O::SharedObject {
2740 id,
2741 initial_shared_version,
2742 mutability,
2743 } => {
2744 message.object_id = Some(id.to_canonical_string(true));
2745 message.version = Some(initial_shared_version.value());
2746 message.mutable = Some(mutability.is_exclusive());
2747 message.set_mutability(match mutability {
2748 crate::transaction::SharedObjectMutability::Immutable => {
2749 Mutability::Immutable
2750 }
2751 crate::transaction::SharedObjectMutability::Mutable => Mutability::Mutable,
2752 crate::transaction::SharedObjectMutability::NonExclusiveWrite => {
2753 Mutability::NonExclusiveWrite
2754 }
2755 });
2756 InputKind::Shared
2757 }
2758 O::Receiving((id, version, digest)) => {
2759 message.object_id = Some(id.to_canonical_string(true));
2760 message.version = Some(version.value());
2761 message.digest = Some(digest.to_string());
2762 InputKind::Receiving
2763 }
2764 },
2765 I::FundsWithdrawal(withdrawal) => {
2766 message.set_funds_withdrawal(withdrawal);
2767 InputKind::FundsWithdrawal
2768 }
2769 };
2770
2771 message.set_kind(kind);
2772 message
2773 }
2774}
2775
2776impl From<crate::transaction::FundsWithdrawalArg> for FundsWithdrawal {
2777 fn from(value: crate::transaction::FundsWithdrawalArg) -> Self {
2778 use funds_withdrawal::Source;
2779
2780 let mut message = Self::default();
2781
2782 message.amount = match value.reservation {
2783 crate::transaction::Reservation::MaxAmountU64(amount) => Some(amount),
2784 };
2785 let crate::transaction::WithdrawalTypeArg::Balance(coin_type) = value.type_arg;
2786 message.coin_type = Some(coin_type.to_canonical_string(true));
2787 message.set_source(match value.withdraw_from {
2788 crate::transaction::WithdrawFrom::Sender => Source::Sender,
2789 crate::transaction::WithdrawFrom::Sponsor => Source::Sponsor,
2790 });
2791
2792 message
2793 }
2794}
2795
2796impl From<crate::transaction::Argument> for Argument {
2801 fn from(value: crate::transaction::Argument) -> Self {
2802 use crate::transaction::Argument as A;
2803 use argument::ArgumentKind;
2804
2805 let mut message = Self::default();
2806
2807 let kind = match value {
2808 A::GasCoin => ArgumentKind::Gas,
2809 A::Input(input) => {
2810 message.input = Some(input.into());
2811 ArgumentKind::Input
2812 }
2813 A::Result(result) => {
2814 message.result = Some(result.into());
2815 ArgumentKind::Result
2816 }
2817 A::NestedResult(result, subresult) => {
2818 message.result = Some(result.into());
2819 message.subresult = Some(subresult.into());
2820 ArgumentKind::Result
2821 }
2822 };
2823
2824 message.set_kind(kind);
2825 message
2826 }
2827}
2828
2829impl From<crate::transaction::Command> for Command {
2834 fn from(value: crate::transaction::Command) -> Self {
2835 use crate::transaction::Command as C;
2836 use command::Command;
2837
2838 let command = match value {
2839 C::MoveCall(move_call) => Command::MoveCall((*move_call).into()),
2840 C::TransferObjects(objects, address) => Command::TransferObjects({
2841 let mut message = TransferObjects::default();
2842 message.objects = objects.into_iter().map(Into::into).collect();
2843 message.address = Some(address.into());
2844 message
2845 }),
2846 C::SplitCoins(coin, amounts) => Command::SplitCoins({
2847 let mut message = SplitCoins::default();
2848 message.coin = Some(coin.into());
2849 message.amounts = amounts.into_iter().map(Into::into).collect();
2850 message
2851 }),
2852 C::MergeCoins(coin, coins_to_merge) => Command::MergeCoins({
2853 let mut message = MergeCoins::default();
2854 message.coin = Some(coin.into());
2855 message.coins_to_merge = coins_to_merge.into_iter().map(Into::into).collect();
2856 message
2857 }),
2858 C::Publish(modules, dependencies) => Command::Publish({
2859 let mut message = Publish::default();
2860 message.modules = modules.into_iter().map(Into::into).collect();
2861 message.dependencies = dependencies
2862 .iter()
2863 .map(|d| d.to_canonical_string(true))
2864 .collect();
2865 message
2866 }),
2867 C::MakeMoveVec(element_type, elements) => Command::MakeMoveVector({
2868 let mut message = MakeMoveVector::default();
2869 message.element_type = element_type.map(|t| t.to_canonical_string(true));
2870 message.elements = elements.into_iter().map(Into::into).collect();
2871 message
2872 }),
2873 C::Upgrade(modules, dependencies, package, ticket) => Command::Upgrade({
2874 let mut message = Upgrade::default();
2875 message.modules = modules.into_iter().map(Into::into).collect();
2876 message.dependencies = dependencies
2877 .iter()
2878 .map(|d| d.to_canonical_string(true))
2879 .collect();
2880 message.package = Some(package.to_canonical_string(true));
2881 message.ticket = Some(ticket.into());
2882 message
2883 }),
2884 };
2885
2886 let mut message = Self::default();
2887 message.command = Some(command);
2888 message
2889 }
2890}
2891
2892impl From<crate::transaction::ProgrammableMoveCall> for MoveCall {
2897 fn from(value: crate::transaction::ProgrammableMoveCall) -> Self {
2898 let mut message = Self::default();
2899 message.package = Some(value.package.to_canonical_string(true));
2900 message.module = Some(value.module.to_string());
2901 message.function = Some(value.function.to_string());
2902 message.type_arguments = value
2903 .type_arguments
2904 .iter()
2905 .map(|t| t.to_canonical_string(true))
2906 .collect();
2907 message.arguments = value.arguments.into_iter().map(Into::into).collect();
2908 message
2909 }
2910}
2911
2912impl From<crate::effects::TransactionEffects> for TransactionEffects {
2917 fn from(value: crate::effects::TransactionEffects) -> Self {
2918 Self::merge_from(&value, &FieldMaskTree::new_wildcard())
2919 }
2920}
2921
2922impl Merge<&crate::effects::TransactionEffects> for TransactionEffects {
2923 fn merge(&mut self, source: &crate::effects::TransactionEffects, mask: &FieldMaskTree) {
2924 if mask.contains(Self::BCS_FIELD.name) {
2925 let mut bcs = Bcs::serialize(&source).unwrap();
2926 bcs.name = Some("TransactionEffects".to_owned());
2927 self.bcs = Some(bcs);
2928 }
2929
2930 if mask.contains(Self::DIGEST_FIELD.name) {
2931 self.digest = Some(source.digest().to_string());
2932 }
2933
2934 match source {
2935 crate::effects::TransactionEffects::V1(v1) => self.merge(v1, mask),
2936 crate::effects::TransactionEffects::V2(v2) => self.merge(v2, mask),
2937 }
2938 }
2939}
2940
2941impl Merge<&crate::effects::TransactionEffectsV1> for TransactionEffects {
2946 fn merge(&mut self, value: &crate::effects::TransactionEffectsV1, mask: &FieldMaskTree) {
2947 use crate::effects::TransactionEffectsAPI;
2948
2949 if mask.contains(Self::VERSION_FIELD.name) {
2950 self.version = Some(1);
2951 }
2952
2953 if mask.contains(Self::STATUS_FIELD.name) {
2954 self.status = Some(value.status().clone().into());
2955 }
2956
2957 if mask.contains(Self::EPOCH_FIELD.name) {
2958 self.epoch = Some(value.executed_epoch());
2959 }
2960
2961 if mask.contains(Self::GAS_USED_FIELD.name) {
2962 self.gas_used = Some(value.gas_cost_summary().clone().into());
2963 }
2964
2965 if mask.contains(Self::TRANSACTION_DIGEST_FIELD.name) {
2966 self.transaction_digest = Some(value.transaction_digest().to_string());
2967 }
2968
2969 if mask.contains(Self::EVENTS_DIGEST_FIELD.name) {
2970 self.events_digest = value.events_digest().map(|d| d.to_string());
2971 }
2972
2973 if mask.contains(Self::DEPENDENCIES_FIELD.name) {
2974 self.dependencies = value
2975 .dependencies()
2976 .iter()
2977 .map(ToString::to_string)
2978 .collect();
2979 }
2980
2981 if mask.contains(Self::CHANGED_OBJECTS_FIELD.name)
2982 || mask.contains(Self::UNCHANGED_CONSENSUS_OBJECTS_FIELD.name)
2983 || mask.contains(Self::GAS_OBJECT_FIELD.name)
2984 {
2985 let mut changed_objects = Vec::new();
2986 let mut unchanged_consensus_objects = Vec::new();
2987
2988 for ((id, version, digest), owner) in value.created() {
2989 let mut change = ChangedObject::default();
2990 change.object_id = Some(id.to_canonical_string(true));
2991 change.input_state = Some(changed_object::InputObjectState::DoesNotExist.into());
2992 change.output_state = Some(changed_object::OutputObjectState::ObjectWrite.into());
2993 change.output_version = Some(version.value());
2994 change.output_digest = Some(digest.to_string());
2995 change.output_owner = Some(owner.clone().into());
2996 change.id_operation = Some(changed_object::IdOperation::Created.into());
2997
2998 changed_objects.push(change);
2999 }
3000
3001 for ((id, version, digest), owner) in value.mutated() {
3002 let mut change = ChangedObject::default();
3003 change.object_id = Some(id.to_canonical_string(true));
3004 change.input_state = Some(changed_object::InputObjectState::Exists.into());
3005 change.output_state = Some(changed_object::OutputObjectState::ObjectWrite.into());
3006 change.output_version = Some(version.value());
3007 change.output_digest = Some(digest.to_string());
3008 change.output_owner = Some(owner.clone().into());
3009 change.id_operation = Some(changed_object::IdOperation::None.into());
3010
3011 changed_objects.push(change);
3012 }
3013
3014 for ((id, version, digest), owner) in value.unwrapped() {
3015 let mut change = ChangedObject::default();
3016 change.object_id = Some(id.to_canonical_string(true));
3017 change.input_state = Some(changed_object::InputObjectState::DoesNotExist.into());
3018 change.output_state = Some(changed_object::OutputObjectState::ObjectWrite.into());
3019 change.output_version = Some(version.value());
3020 change.output_digest = Some(digest.to_string());
3021 change.output_owner = Some(owner.clone().into());
3022 change.id_operation = Some(changed_object::IdOperation::None.into());
3023
3024 changed_objects.push(change);
3025 }
3026
3027 for (id, version, digest) in value.deleted() {
3028 let mut change = ChangedObject::default();
3029 change.object_id = Some(id.to_canonical_string(true));
3030 change.input_state = Some(changed_object::InputObjectState::Exists.into());
3031 change.output_state = Some(changed_object::OutputObjectState::DoesNotExist.into());
3032 change.output_version = Some(version.value());
3033 change.output_digest = Some(digest.to_string());
3034 change.id_operation = Some(changed_object::IdOperation::Deleted.into());
3035
3036 changed_objects.push(change);
3037 }
3038
3039 for (id, version, digest) in value.unwrapped_then_deleted() {
3040 let mut change = ChangedObject::default();
3041 change.object_id = Some(id.to_canonical_string(true));
3042 change.input_state = Some(changed_object::InputObjectState::DoesNotExist.into());
3043 change.output_state = Some(changed_object::OutputObjectState::DoesNotExist.into());
3044 change.output_version = Some(version.value());
3045 change.output_digest = Some(digest.to_string());
3046 change.id_operation = Some(changed_object::IdOperation::Deleted.into());
3047
3048 changed_objects.push(change);
3049 }
3050
3051 for (id, version, digest) in value.wrapped() {
3052 let mut change = ChangedObject::default();
3053 change.object_id = Some(id.to_canonical_string(true));
3054 change.input_state = Some(changed_object::InputObjectState::Exists.into());
3055 change.output_state = Some(changed_object::OutputObjectState::DoesNotExist.into());
3056 change.output_version = Some(version.value());
3057 change.output_digest = Some(digest.to_string());
3058 change.id_operation = Some(changed_object::IdOperation::Deleted.into());
3059
3060 changed_objects.push(change);
3061 }
3062
3063 for (object_id, version) in value.modified_at_versions() {
3064 let object_id = object_id.to_canonical_string(true);
3065 let version = version.value();
3066 if let Some(changed_object) = changed_objects
3067 .iter_mut()
3068 .find(|object| object.object_id() == object_id)
3069 {
3070 changed_object.input_version = Some(version);
3071 }
3072 }
3073
3074 for (id, version, digest) in value.shared_objects() {
3075 let object_id = id.to_canonical_string(true);
3076 let version = version.value();
3077 let digest = digest.to_string();
3078
3079 if let Some(changed_object) = changed_objects
3080 .iter_mut()
3081 .find(|object| object.object_id() == object_id)
3082 {
3083 changed_object.input_version = Some(version);
3084 changed_object.input_digest = Some(digest);
3085 } else {
3086 let mut unchanged_consensus_object = UnchangedConsensusObject::default();
3087 unchanged_consensus_object.kind = Some(
3088 unchanged_consensus_object::UnchangedConsensusObjectKind::ReadOnlyRoot
3089 .into(),
3090 );
3091 unchanged_consensus_object.object_id = Some(object_id);
3092 unchanged_consensus_object.version = Some(version);
3093 unchanged_consensus_object.digest = Some(digest);
3094
3095 unchanged_consensus_objects.push(unchanged_consensus_object);
3096 }
3097 }
3098
3099 if mask.contains(Self::GAS_OBJECT_FIELD.name) {
3100 let gas_object_id = value.gas_object().0.0.to_canonical_string(true);
3101 self.gas_object = changed_objects
3102 .iter()
3103 .find(|object| object.object_id() == gas_object_id)
3104 .cloned();
3105 }
3106
3107 if mask.contains(Self::CHANGED_OBJECTS_FIELD.name) {
3108 self.changed_objects = changed_objects;
3109 }
3110
3111 if mask.contains(Self::UNCHANGED_CONSENSUS_OBJECTS_FIELD.name) {
3112 self.unchanged_consensus_objects = unchanged_consensus_objects;
3113 }
3114 }
3115 }
3116}
3117
3118impl Merge<&crate::effects::TransactionEffectsV2> for TransactionEffects {
3123 fn merge(
3124 &mut self,
3125 crate::effects::TransactionEffectsV2 {
3126 status,
3127 executed_epoch,
3128 gas_used,
3129 transaction_digest,
3130 gas_object_index,
3131 events_digest,
3132 dependencies,
3133 lamport_version,
3134 changed_objects,
3135 unchanged_consensus_objects,
3136 aux_data_digest,
3137 }: &crate::effects::TransactionEffectsV2,
3138 mask: &FieldMaskTree,
3139 ) {
3140 if mask.contains(Self::VERSION_FIELD.name) {
3141 self.version = Some(2);
3142 }
3143
3144 if mask.contains(Self::STATUS_FIELD.name) {
3145 self.status = Some(status.clone().into());
3146 }
3147
3148 if mask.contains(Self::EPOCH_FIELD.name) {
3149 self.epoch = Some(*executed_epoch);
3150 }
3151
3152 if mask.contains(Self::GAS_USED_FIELD.name) {
3153 self.gas_used = Some(gas_used.clone().into());
3154 }
3155
3156 if mask.contains(Self::TRANSACTION_DIGEST_FIELD.name) {
3157 self.transaction_digest = Some(transaction_digest.to_string());
3158 }
3159
3160 if mask.contains(Self::GAS_OBJECT_FIELD.name) {
3161 self.gas_object = gas_object_index
3162 .map(|index| {
3163 changed_objects
3164 .get(index as usize)
3165 .cloned()
3166 .map(|(id, change)| {
3167 let mut message = ChangedObject::from(change);
3168 message.object_id = Some(id.to_canonical_string(true));
3169 message
3170 })
3171 })
3172 .flatten();
3173 }
3174
3175 if mask.contains(Self::EVENTS_DIGEST_FIELD.name) {
3176 self.events_digest = events_digest.map(|d| d.to_string());
3177 }
3178
3179 if mask.contains(Self::DEPENDENCIES_FIELD.name) {
3180 self.dependencies = dependencies.iter().map(ToString::to_string).collect();
3181 }
3182
3183 if mask.contains(Self::LAMPORT_VERSION_FIELD.name) {
3184 self.lamport_version = Some(lamport_version.value());
3185 }
3186
3187 if mask.contains(Self::CHANGED_OBJECTS_FIELD.name) {
3188 self.changed_objects = changed_objects
3189 .clone()
3190 .into_iter()
3191 .map(|(id, change)| {
3192 let mut message = ChangedObject::from(change);
3193 message.object_id = Some(id.to_canonical_string(true));
3194 message
3195 })
3196 .collect();
3197 }
3198
3199 for object in self.changed_objects.iter_mut().chain(&mut self.gas_object) {
3200 if object.output_digest.is_some() && object.output_version.is_none() {
3201 object.output_version = Some(lamport_version.value());
3202 }
3203 }
3204
3205 if mask.contains(Self::UNCHANGED_CONSENSUS_OBJECTS_FIELD.name) {
3206 self.unchanged_consensus_objects = unchanged_consensus_objects
3207 .clone()
3208 .into_iter()
3209 .map(|(id, unchanged)| {
3210 let mut message = UnchangedConsensusObject::from(unchanged);
3211 message.object_id = Some(id.to_canonical_string(true));
3212 message
3213 })
3214 .collect();
3215 }
3216
3217 if mask.contains(Self::AUXILIARY_DATA_DIGEST_FIELD.name) {
3218 self.auxiliary_data_digest = aux_data_digest.map(|d| d.to_string());
3219 }
3220 }
3221}
3222
3223impl From<crate::effects::EffectsObjectChange> for ChangedObject {
3228 fn from(value: crate::effects::EffectsObjectChange) -> Self {
3229 use crate::effects::ObjectIn;
3230 use crate::effects::ObjectOut;
3231 use changed_object::InputObjectState;
3232 use changed_object::OutputObjectState;
3233
3234 let mut message = Self::default();
3235
3236 let input_state = match value.input_state {
3238 ObjectIn::NotExist => InputObjectState::DoesNotExist,
3239 ObjectIn::Exist(((version, digest), owner)) => {
3240 message.input_version = Some(version.value());
3241 message.input_digest = Some(digest.to_string());
3242 message.input_owner = Some(owner.into());
3243 InputObjectState::Exists
3244 }
3245 };
3246 message.set_input_state(input_state);
3247
3248 let output_state = match value.output_state {
3250 ObjectOut::NotExist => OutputObjectState::DoesNotExist,
3251 ObjectOut::ObjectWrite((digest, owner)) => {
3252 message.output_digest = Some(digest.to_string());
3253 message.output_owner = Some(owner.into());
3254 OutputObjectState::ObjectWrite
3255 }
3256 ObjectOut::PackageWrite((version, digest)) => {
3257 message.output_version = Some(version.value());
3258 message.output_digest = Some(digest.to_string());
3259 OutputObjectState::PackageWrite
3260 }
3261 ObjectOut::AccumulatorWriteV1(accumulator_write) => {
3262 message.set_accumulator_write(accumulator_write);
3263 OutputObjectState::AccumulatorWrite
3264 }
3265 };
3266 message.set_output_state(output_state);
3267
3268 message.set_id_operation(value.id_operation.into());
3269 message
3270 }
3271}
3272
3273impl From<crate::effects::AccumulatorWriteV1> for AccumulatorWrite {
3274 fn from(value: crate::effects::AccumulatorWriteV1) -> Self {
3275 use accumulator_write::AccumulatorOperation;
3276
3277 let mut message = Self::default();
3278
3279 message.set_address(value.address.address.to_string());
3280 message.set_accumulator_type(value.address.ty.to_canonical_string(true));
3281 message.set_operation(match value.operation {
3282 crate::effects::AccumulatorOperation::Merge => AccumulatorOperation::Merge,
3283 crate::effects::AccumulatorOperation::Split => AccumulatorOperation::Split,
3284 });
3285 match value.value {
3286 crate::effects::AccumulatorValue::Integer(value) => message.set_value(value),
3287 crate::effects::AccumulatorValue::IntegerTuple(_, _)
3289 | crate::effects::AccumulatorValue::EventDigest(_) => {}
3290 }
3291
3292 message
3293 }
3294}
3295
3296impl From<crate::effects::IDOperation> for changed_object::IdOperation {
3301 fn from(value: crate::effects::IDOperation) -> Self {
3302 use crate::effects::IDOperation as I;
3303
3304 match value {
3305 I::None => Self::None,
3306 I::Created => Self::Created,
3307 I::Deleted => Self::Deleted,
3308 }
3309 }
3310}
3311
3312impl From<crate::effects::UnchangedConsensusKind> for UnchangedConsensusObject {
3317 fn from(value: crate::effects::UnchangedConsensusKind) -> Self {
3318 use crate::effects::UnchangedConsensusKind as K;
3319 use unchanged_consensus_object::UnchangedConsensusObjectKind;
3320
3321 let mut message = Self::default();
3322
3323 let kind = match value {
3324 K::ReadOnlyRoot((version, digest)) => {
3325 message.version = Some(version.value());
3326 message.digest = Some(digest.to_string());
3327 UnchangedConsensusObjectKind::ReadOnlyRoot
3328 }
3329 K::MutateConsensusStreamEnded(version) => {
3330 message.version = Some(version.value());
3331 UnchangedConsensusObjectKind::MutateConsensusStreamEnded
3332 }
3333 K::ReadConsensusStreamEnded(version) => {
3334 message.version = Some(version.value());
3335 UnchangedConsensusObjectKind::ReadConsensusStreamEnded
3336 }
3337 K::Cancelled(version) => {
3338 message.version = Some(version.value());
3339 UnchangedConsensusObjectKind::Canceled
3340 }
3341 K::PerEpochConfig => UnchangedConsensusObjectKind::PerEpochConfig,
3342 };
3347
3348 message.set_kind(kind);
3349 message
3350 }
3351}
3352
3353impl From<simulate_transaction_request::TransactionChecks>
3358 for crate::transaction_executor::TransactionChecks
3359{
3360 fn from(value: simulate_transaction_request::TransactionChecks) -> Self {
3361 match value {
3362 simulate_transaction_request::TransactionChecks::Enabled => Self::Enabled,
3363 simulate_transaction_request::TransactionChecks::Disabled => Self::Disabled,
3364 _ => Self::Enabled,
3366 }
3367 }
3368}
3369
3370impl From<crate::coin_registry::MetadataCapState> for coin_metadata::MetadataCapState {
3375 fn from(value: crate::coin_registry::MetadataCapState) -> Self {
3376 match value {
3377 crate::coin_registry::MetadataCapState::Claimed(_) => {
3378 coin_metadata::MetadataCapState::Claimed
3379 }
3380 crate::coin_registry::MetadataCapState::Unclaimed => {
3381 coin_metadata::MetadataCapState::Unclaimed
3382 }
3383 crate::coin_registry::MetadataCapState::Deleted => {
3384 coin_metadata::MetadataCapState::Deleted
3385 }
3386 }
3387 }
3388}
3389
3390impl From<&crate::coin_registry::Currency> for CoinMetadata {
3391 fn from(value: &crate::coin_registry::Currency) -> Self {
3392 let mut metadata = CoinMetadata::default();
3393 metadata.id = Some(sui_sdk_types::Address::from(value.id.into_bytes()).to_string());
3394 metadata.decimals = Some(value.decimals.into());
3395 metadata.name = Some(value.name.clone());
3396 metadata.symbol = Some(value.symbol.clone());
3397 metadata.description = Some(value.description.clone());
3398 metadata.icon_url = Some(value.icon_url.clone());
3399
3400 match &value.metadata_cap_id {
3401 crate::coin_registry::MetadataCapState::Claimed(id) => {
3402 metadata.metadata_cap_state = Some(coin_metadata::MetadataCapState::Claimed as i32);
3403 metadata.metadata_cap_id = Some(sui_sdk_types::Address::from(*id).to_string());
3404 }
3405 crate::coin_registry::MetadataCapState::Unclaimed => {
3406 metadata.metadata_cap_state =
3407 Some(coin_metadata::MetadataCapState::Unclaimed as i32);
3408 }
3409 crate::coin_registry::MetadataCapState::Deleted => {
3410 metadata.metadata_cap_state = Some(coin_metadata::MetadataCapState::Deleted as i32);
3411 }
3412 }
3413
3414 metadata
3415 }
3416}
3417
3418impl From<crate::coin::CoinMetadata> for CoinMetadata {
3419 fn from(value: crate::coin::CoinMetadata) -> Self {
3420 let mut metadata = CoinMetadata::default();
3421 metadata.id = Some(sui_sdk_types::Address::from(value.id.id.bytes).to_string());
3422 metadata.decimals = Some(value.decimals.into());
3423 metadata.name = Some(value.name);
3424 metadata.symbol = Some(value.symbol);
3425 metadata.description = Some(value.description);
3426 metadata.icon_url = value.icon_url;
3427 metadata
3428 }
3429}
3430
3431impl From<crate::coin_registry::SupplyState> for coin_treasury::SupplyState {
3432 fn from(value: crate::coin_registry::SupplyState) -> Self {
3433 match value {
3434 crate::coin_registry::SupplyState::Fixed(_) => coin_treasury::SupplyState::Fixed,
3435 crate::coin_registry::SupplyState::BurnOnly(_) => coin_treasury::SupplyState::BurnOnly,
3436 crate::coin_registry::SupplyState::Unknown => coin_treasury::SupplyState::Unknown,
3437 }
3438 }
3439}
3440
3441impl From<crate::coin::TreasuryCap> for CoinTreasury {
3442 fn from(value: crate::coin::TreasuryCap) -> Self {
3443 let mut treasury = CoinTreasury::default();
3444 treasury.id = Some(sui_sdk_types::Address::from(value.id.id.bytes).to_string());
3445 treasury.total_supply = Some(value.total_supply.value);
3446 treasury
3447 }
3448}
3449
3450impl From<&crate::coin_registry::RegulatedState> for RegulatedCoinMetadata {
3451 fn from(value: &crate::coin_registry::RegulatedState) -> Self {
3452 let mut regulated = RegulatedCoinMetadata::default();
3453
3454 match value {
3455 crate::coin_registry::RegulatedState::Regulated {
3456 cap,
3457 allow_global_pause,
3458 variant,
3459 } => {
3460 regulated.deny_cap_object = Some(sui_sdk_types::Address::from(*cap).to_string());
3461 regulated.allow_global_pause = *allow_global_pause;
3462 regulated.variant = Some(*variant as u32);
3463 regulated.coin_regulated_state =
3464 Some(regulated_coin_metadata::CoinRegulatedState::Regulated as i32);
3465 }
3466 crate::coin_registry::RegulatedState::Unregulated => {
3467 regulated.coin_regulated_state =
3468 Some(regulated_coin_metadata::CoinRegulatedState::Unregulated as i32);
3469 }
3470 crate::coin_registry::RegulatedState::Unknown => {
3471 regulated.coin_regulated_state =
3472 Some(regulated_coin_metadata::CoinRegulatedState::Unknown as i32);
3473 }
3474 }
3475
3476 regulated
3477 }
3478}
3479
3480impl From<crate::coin_registry::RegulatedState> for RegulatedCoinMetadata {
3481 fn from(value: crate::coin_registry::RegulatedState) -> Self {
3482 (&value).into()
3483 }
3484}
3485
3486impl From<crate::coin::RegulatedCoinMetadata> for RegulatedCoinMetadata {
3487 fn from(value: crate::coin::RegulatedCoinMetadata) -> Self {
3488 let mut message = RegulatedCoinMetadata::default();
3489 message.id = Some(sui_sdk_types::Address::from(value.id.id.bytes).to_string());
3490 message.coin_metadata_object =
3491 Some(sui_sdk_types::Address::from(value.coin_metadata_object.bytes).to_string());
3492 message.deny_cap_object =
3493 Some(sui_sdk_types::Address::from(value.deny_cap_object.bytes).to_string());
3494 message.coin_regulated_state =
3495 Some(regulated_coin_metadata::CoinRegulatedState::Regulated as i32);
3496 message
3497 }
3498}
3499
3500impl TryFrom<&ObjectSet> for crate::full_checkpoint_content::ObjectSet {
3501 type Error = TryFromProtoError;
3502
3503 fn try_from(value: &ObjectSet) -> Result<Self, Self::Error> {
3504 let mut objects = Self::default();
3505
3506 for o in value.objects() {
3507 objects.insert(
3508 o.bcs()
3509 .deserialize()
3510 .map_err(|e| TryFromProtoError::invalid("object.bcs", e))?,
3511 );
3512 }
3513
3514 Ok(objects)
3515 }
3516}