sui_rpc/proto/sui/rpc/v2beta2/
signatures.rs

1use super::*;
2use crate::field::FieldMaskTree;
3use crate::merge::Merge;
4use crate::proto::TryFromProtoError;
5use tap::Pipe;
6
7//
8// ValidatorAggregatedSignature
9//
10
11impl From<sui_sdk_types::ValidatorAggregatedSignature> for ValidatorAggregatedSignature {
12    fn from(value: sui_sdk_types::ValidatorAggregatedSignature) -> Self {
13        Self {
14            epoch: Some(value.epoch),
15            signature: Some(value.signature.as_bytes().to_vec().into()),
16            bitmap: value.bitmap.iter().collect(),
17        }
18    }
19}
20
21impl TryFrom<&ValidatorAggregatedSignature> for sui_sdk_types::ValidatorAggregatedSignature {
22    type Error = TryFromProtoError;
23
24    fn try_from(value: &ValidatorAggregatedSignature) -> Result<Self, Self::Error> {
25        let epoch = value
26            .epoch
27            .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
28        let signature = value
29            .signature
30            .as_ref()
31            .ok_or_else(|| TryFromProtoError::missing("signature"))?
32            .as_ref()
33            .pipe(sui_sdk_types::Bls12381Signature::from_bytes)
34            .map_err(|e| {
35                TryFromProtoError::invalid(ValidatorAggregatedSignature::SIGNATURE_FIELD, e)
36            })?;
37        let bitmap = value.bitmap.iter().copied().collect();
38
39        Ok(Self {
40            epoch,
41            signature,
42            bitmap,
43        })
44    }
45}
46
47//
48// ValidatorCommitteeMember
49//
50
51impl From<sui_sdk_types::ValidatorCommitteeMember> for ValidatorCommitteeMember {
52    fn from(value: sui_sdk_types::ValidatorCommitteeMember) -> Self {
53        Self {
54            public_key: Some(value.public_key.as_bytes().to_vec().into()),
55            weight: Some(value.stake),
56        }
57    }
58}
59
60impl TryFrom<&ValidatorCommitteeMember> for sui_sdk_types::ValidatorCommitteeMember {
61    type Error = TryFromProtoError;
62
63    fn try_from(
64        ValidatorCommitteeMember { public_key, weight }: &ValidatorCommitteeMember,
65    ) -> Result<Self, Self::Error> {
66        let public_key = public_key
67            .as_ref()
68            .ok_or_else(|| TryFromProtoError::missing("public_key"))?
69            .as_ref()
70            .pipe(sui_sdk_types::Bls12381PublicKey::from_bytes)
71            .map_err(|e| {
72                TryFromProtoError::invalid(ValidatorCommitteeMember::PUBLIC_KEY_FIELD, e)
73            })?;
74        let stake = weight.ok_or_else(|| TryFromProtoError::missing("weight"))?;
75        Ok(Self { public_key, stake })
76    }
77}
78
79//
80// ValidatorCommittee
81//
82
83impl From<sui_sdk_types::ValidatorCommittee> for ValidatorCommittee {
84    fn from(value: sui_sdk_types::ValidatorCommittee) -> Self {
85        Self {
86            epoch: Some(value.epoch),
87            members: value.members.into_iter().map(Into::into).collect(),
88        }
89    }
90}
91
92impl TryFrom<&ValidatorCommittee> for sui_sdk_types::ValidatorCommittee {
93    type Error = TryFromProtoError;
94
95    fn try_from(value: &ValidatorCommittee) -> Result<Self, Self::Error> {
96        let epoch = value
97            .epoch
98            .ok_or_else(|| TryFromProtoError::missing("epoch"))?;
99        Ok(Self {
100            epoch,
101            members: value
102                .members
103                .iter()
104                .map(TryInto::try_into)
105                .collect::<Result<_, _>>()?,
106        })
107    }
108}
109
110//
111// CircomG1
112//
113
114impl From<sui_sdk_types::CircomG1> for CircomG1 {
115    fn from(value: sui_sdk_types::CircomG1) -> Self {
116        let [e0, e1, e2] = value.0;
117
118        Self {
119            e0: Some(e0.to_string()),
120            e1: Some(e1.to_string()),
121            e2: Some(e2.to_string()),
122        }
123    }
124}
125
126impl TryFrom<&CircomG1> for sui_sdk_types::CircomG1 {
127    type Error = TryFromProtoError;
128
129    fn try_from(value: &CircomG1) -> Result<Self, Self::Error> {
130        let e0 = value
131            .e0
132            .as_ref()
133            .ok_or_else(|| TryFromProtoError::missing("e0"))?
134            .parse()
135            .map_err(|e| TryFromProtoError::invalid(CircomG1::E0_FIELD, e))?;
136        let e1 = value
137            .e1
138            .as_ref()
139            .ok_or_else(|| TryFromProtoError::missing("e1"))?
140            .parse()
141            .map_err(|e| TryFromProtoError::invalid(CircomG1::E1_FIELD, e))?;
142        let e2 = value
143            .e2
144            .as_ref()
145            .ok_or_else(|| TryFromProtoError::missing("e2"))?
146            .parse()
147            .map_err(|e| TryFromProtoError::invalid(CircomG1::E2_FIELD, e))?;
148
149        Ok(Self([e0, e1, e2]))
150    }
151}
152
153//
154// CircomG2
155//
156
157impl From<sui_sdk_types::CircomG2> for CircomG2 {
158    fn from(value: sui_sdk_types::CircomG2) -> Self {
159        let [[e00, e01], [e10, e11], [e20, e21]] = value.0;
160
161        Self {
162            e00: Some(e00.to_string()),
163            e01: Some(e01.to_string()),
164            e10: Some(e10.to_string()),
165            e11: Some(e11.to_string()),
166            e20: Some(e20.to_string()),
167            e21: Some(e21.to_string()),
168        }
169    }
170}
171
172impl TryFrom<&CircomG2> for sui_sdk_types::CircomG2 {
173    type Error = TryFromProtoError;
174
175    fn try_from(value: &CircomG2) -> Result<Self, Self::Error> {
176        let e00 = value
177            .e00
178            .as_ref()
179            .ok_or_else(|| TryFromProtoError::missing("e00"))?
180            .parse()
181            .map_err(|e| TryFromProtoError::invalid(CircomG2::E00_FIELD, e))?;
182        let e01 = value
183            .e01
184            .as_ref()
185            .ok_or_else(|| TryFromProtoError::missing("e01"))?
186            .parse()
187            .map_err(|e| TryFromProtoError::invalid(CircomG2::E01_FIELD, e))?;
188
189        let e10 = value
190            .e10
191            .as_ref()
192            .ok_or_else(|| TryFromProtoError::missing("e10"))?
193            .parse()
194            .map_err(|e| TryFromProtoError::invalid(CircomG2::E10_FIELD, e))?;
195        let e11 = value
196            .e11
197            .as_ref()
198            .ok_or_else(|| TryFromProtoError::missing("e11"))?
199            .parse()
200            .map_err(|e| TryFromProtoError::invalid(CircomG2::E11_FIELD, e))?;
201
202        let e20 = value
203            .e20
204            .as_ref()
205            .ok_or_else(|| TryFromProtoError::missing("e20"))?
206            .parse()
207            .map_err(|e| TryFromProtoError::invalid(CircomG2::E20_FIELD, e))?;
208        let e21 = value
209            .e21
210            .as_ref()
211            .ok_or_else(|| TryFromProtoError::missing("e21"))?
212            .parse()
213            .map_err(|e| TryFromProtoError::invalid(CircomG2::E21_FIELD, e))?;
214
215        Ok(Self([[e00, e01], [e10, e11], [e20, e21]]))
216    }
217}
218
219//
220// ZkLoginClaim
221//
222
223impl From<sui_sdk_types::ZkLoginClaim> for ZkLoginClaim {
224    fn from(
225        sui_sdk_types::ZkLoginClaim { value, index_mod_4 }: sui_sdk_types::ZkLoginClaim,
226    ) -> Self {
227        Self {
228            value: Some(value),
229            index_mod_4: Some(index_mod_4.into()),
230        }
231    }
232}
233
234impl TryFrom<&ZkLoginClaim> for sui_sdk_types::ZkLoginClaim {
235    type Error = TryFromProtoError;
236
237    fn try_from(ZkLoginClaim { value, index_mod_4 }: &ZkLoginClaim) -> Result<Self, Self::Error> {
238        let value = value
239            .as_ref()
240            .ok_or_else(|| TryFromProtoError::missing("value"))?
241            .into();
242        let index_mod_4 = index_mod_4
243            .ok_or_else(|| TryFromProtoError::missing("index_mod_4"))?
244            .try_into()
245            .map_err(|e| TryFromProtoError::invalid(ZkLoginClaim::INDEX_MOD_4_FIELD, e))?;
246
247        Ok(Self { value, index_mod_4 })
248    }
249}
250
251//
252// ZkLoginProof
253//
254
255impl From<sui_sdk_types::ZkLoginProof> for ZkLoginProof {
256    fn from(value: sui_sdk_types::ZkLoginProof) -> Self {
257        Self {
258            a: Some(value.a.into()),
259            b: Some(value.b.into()),
260            c: Some(value.c.into()),
261        }
262    }
263}
264
265impl TryFrom<&ZkLoginProof> for sui_sdk_types::ZkLoginProof {
266    type Error = TryFromProtoError;
267
268    fn try_from(value: &ZkLoginProof) -> Result<Self, Self::Error> {
269        let a = value
270            .a
271            .as_ref()
272            .ok_or_else(|| TryFromProtoError::missing("a"))?
273            .try_into()?;
274        let b = value
275            .b
276            .as_ref()
277            .ok_or_else(|| TryFromProtoError::missing("b"))?
278            .try_into()?;
279        let c = value
280            .c
281            .as_ref()
282            .ok_or_else(|| TryFromProtoError::missing("c"))?
283            .try_into()?;
284
285        Ok(Self { a, b, c })
286    }
287}
288
289//
290// ZkLoginInputs
291//
292
293impl From<sui_sdk_types::ZkLoginInputs> for ZkLoginInputs {
294    fn from(value: sui_sdk_types::ZkLoginInputs) -> Self {
295        Self {
296            proof_points: Some(value.proof_points().clone().into()),
297            iss_base64_details: Some(value.iss_base64_details().clone().into()),
298            header_base64: Some(value.header_base64().into()),
299            address_seed: Some(value.address_seed().to_string()),
300        }
301    }
302}
303
304impl TryFrom<&ZkLoginInputs> for sui_sdk_types::ZkLoginInputs {
305    type Error = TryFromProtoError;
306
307    fn try_from(value: &ZkLoginInputs) -> Result<Self, Self::Error> {
308        let proof_points = value
309            .proof_points
310            .as_ref()
311            .ok_or_else(|| TryFromProtoError::missing("proof_points"))?
312            .try_into()?;
313        let iss_base64_details = value
314            .iss_base64_details
315            .as_ref()
316            .ok_or_else(|| TryFromProtoError::missing("iss_base64_details"))?
317            .try_into()?;
318        let header_base64 = value
319            .header_base64
320            .as_ref()
321            .ok_or_else(|| TryFromProtoError::missing("header_base64"))?
322            .into();
323        let address_seed = value
324            .address_seed
325            .as_ref()
326            .ok_or_else(|| TryFromProtoError::missing("address_seed"))?
327            .parse()
328            .map_err(|e| TryFromProtoError::invalid(ZkLoginInputs::ADDRESS_SEED_FIELD, e))?;
329
330        Self::new(
331            proof_points,
332            iss_base64_details,
333            header_base64,
334            address_seed,
335        )
336        .map_err(|e| TryFromProtoError::invalid("inputs", e))
337    }
338}
339
340//
341// ZkLoginAuthenticator
342//
343
344impl From<sui_sdk_types::ZkLoginAuthenticator> for ZkLoginAuthenticator {
345    fn from(value: sui_sdk_types::ZkLoginAuthenticator) -> Self {
346        Self {
347            inputs: Some(value.inputs.into()),
348            max_epoch: Some(value.max_epoch),
349            signature: Some(value.signature.into()),
350        }
351    }
352}
353
354impl TryFrom<&ZkLoginAuthenticator> for sui_sdk_types::ZkLoginAuthenticator {
355    type Error = TryFromProtoError;
356
357    fn try_from(value: &ZkLoginAuthenticator) -> Result<Self, Self::Error> {
358        let inputs = value
359            .inputs
360            .as_ref()
361            .ok_or_else(|| TryFromProtoError::missing("inputs"))?
362            .try_into()?;
363        let max_epoch = value
364            .max_epoch
365            .ok_or_else(|| TryFromProtoError::missing("max_epoch"))?;
366        let signature = value
367            .signature
368            .as_ref()
369            .ok_or_else(|| TryFromProtoError::missing("signature"))?
370            .try_into()?;
371
372        Ok(Self {
373            inputs,
374            max_epoch,
375            signature,
376        })
377    }
378}
379
380//
381// ZkLoginPublicIdentifier
382//
383
384impl From<&sui_sdk_types::ZkLoginPublicIdentifier> for ZkLoginPublicIdentifier {
385    fn from(value: &sui_sdk_types::ZkLoginPublicIdentifier) -> Self {
386        Self {
387            iss: Some(value.iss().to_owned()),
388            address_seed: Some(value.address_seed().to_string()),
389        }
390    }
391}
392
393impl TryFrom<&ZkLoginPublicIdentifier> for sui_sdk_types::ZkLoginPublicIdentifier {
394    type Error = TryFromProtoError;
395
396    fn try_from(value: &ZkLoginPublicIdentifier) -> Result<Self, Self::Error> {
397        let iss = value
398            .iss
399            .as_ref()
400            .ok_or_else(|| TryFromProtoError::missing("iss"))?
401            .into();
402        let address_seed = value
403            .address_seed
404            .as_ref()
405            .ok_or_else(|| TryFromProtoError::missing("address_seed"))?
406            .parse()
407            .map_err(|e| {
408                TryFromProtoError::invalid(ZkLoginPublicIdentifier::ADDRESS_SEED_FIELD, e)
409            })?;
410
411        Self::new(iss, address_seed)
412            .ok_or_else(|| {
413                TryFromProtoError::invalid(ZkLoginPublicIdentifier::ISS_FIELD, "invalid iss")
414            })?
415            .pipe(Ok)
416    }
417}
418
419//
420// SignatureScheme
421//
422
423impl TryFrom<&SignatureScheme> for sui_sdk_types::SignatureScheme {
424    type Error = TryFromProtoError;
425
426    fn try_from(value: &SignatureScheme) -> Result<Self, Self::Error> {
427        use SignatureScheme::*;
428
429        match value {
430            Ed25519 => Self::Ed25519,
431            Secp256k1 => Self::Secp256k1,
432            Secp256r1 => Self::Secp256r1,
433            Multisig => Self::Multisig,
434            Bls12381 => Self::Bls12381,
435            Zklogin => Self::ZkLogin,
436            Passkey => Self::Passkey,
437        }
438        .pipe(Ok)
439    }
440}
441
442//
443// SimpleSignature
444//
445
446impl From<sui_sdk_types::SimpleSignature> for SimpleSignature {
447    fn from(value: sui_sdk_types::SimpleSignature) -> Self {
448        let (signature, public_key) = match &value {
449            sui_sdk_types::SimpleSignature::Ed25519 {
450                signature,
451                public_key,
452            } => (signature.as_bytes(), public_key.as_bytes()),
453            sui_sdk_types::SimpleSignature::Secp256k1 {
454                signature,
455                public_key,
456            } => (signature.as_bytes(), public_key.as_bytes()),
457            sui_sdk_types::SimpleSignature::Secp256r1 {
458                signature,
459                public_key,
460            } => (signature.as_bytes(), public_key.as_bytes()),
461            _ => return Self::default(),
462        };
463
464        Self {
465            scheme: Some(value.scheme().to_u8().into()),
466            signature: Some(signature.to_vec().into()),
467            public_key: Some(public_key.to_vec().into()),
468        }
469    }
470}
471
472impl TryFrom<&SimpleSignature> for sui_sdk_types::SimpleSignature {
473    type Error = TryFromProtoError;
474
475    fn try_from(value: &SimpleSignature) -> Result<Self, Self::Error> {
476        use sui_sdk_types::Ed25519PublicKey;
477        use sui_sdk_types::Ed25519Signature;
478        use sui_sdk_types::Secp256k1PublicKey;
479        use sui_sdk_types::Secp256k1Signature;
480        use sui_sdk_types::Secp256r1PublicKey;
481        use sui_sdk_types::Secp256r1Signature;
482        use SignatureScheme;
483
484        let scheme = value
485            .scheme
486            .ok_or_else(|| TryFromProtoError::missing("scheme"))?
487            .pipe(SignatureScheme::try_from)
488            .map_err(|e| TryFromProtoError::invalid(SimpleSignature::SCHEME_FIELD, e))?;
489        let signature = value
490            .signature
491            .as_ref()
492            .ok_or_else(|| TryFromProtoError::missing("signature"))?;
493        let public_key = value
494            .public_key
495            .as_ref()
496            .ok_or_else(|| TryFromProtoError::missing("public_key"))?;
497
498        match scheme {
499            SignatureScheme::Ed25519 => Self::Ed25519 {
500                signature: Ed25519Signature::from_bytes(signature)
501                    .map_err(|e| TryFromProtoError::invalid(SimpleSignature::SIGNATURE_FIELD, e))?,
502                public_key: Ed25519PublicKey::from_bytes(public_key).map_err(|e| {
503                    TryFromProtoError::invalid(SimpleSignature::PUBLIC_KEY_FIELD, e)
504                })?,
505            },
506            SignatureScheme::Secp256k1 => Self::Secp256k1 {
507                signature: Secp256k1Signature::from_bytes(signature)
508                    .map_err(|e| TryFromProtoError::invalid(SimpleSignature::SIGNATURE_FIELD, e))?,
509                public_key: Secp256k1PublicKey::from_bytes(public_key).map_err(|e| {
510                    TryFromProtoError::invalid(SimpleSignature::PUBLIC_KEY_FIELD, e)
511                })?,
512            },
513            SignatureScheme::Secp256r1 => Self::Secp256r1 {
514                signature: Secp256r1Signature::from_bytes(signature)
515                    .map_err(|e| TryFromProtoError::invalid(SimpleSignature::SIGNATURE_FIELD, e))?,
516                public_key: Secp256r1PublicKey::from_bytes(public_key).map_err(|e| {
517                    TryFromProtoError::invalid(SimpleSignature::PUBLIC_KEY_FIELD, e)
518                })?,
519            },
520            SignatureScheme::Multisig
521            | SignatureScheme::Bls12381
522            | SignatureScheme::Zklogin
523            | SignatureScheme::Passkey => {
524                return Err(TryFromProtoError::invalid(
525                    SimpleSignature::SCHEME_FIELD,
526                    "invalid or unknown signature scheme",
527                ))
528            }
529        }
530        .pipe(Ok)
531    }
532}
533
534//
535// PasskeyAuthenticator
536//
537
538impl From<sui_sdk_types::PasskeyAuthenticator> for PasskeyAuthenticator {
539    fn from(value: sui_sdk_types::PasskeyAuthenticator) -> Self {
540        Self {
541            authenticator_data: Some(value.authenticator_data().to_vec().into()),
542            client_data_json: Some(value.client_data_json().to_owned()),
543            signature: Some(value.signature().into()),
544        }
545    }
546}
547
548impl TryFrom<&PasskeyAuthenticator> for sui_sdk_types::PasskeyAuthenticator {
549    type Error = TryFromProtoError;
550
551    fn try_from(value: &PasskeyAuthenticator) -> Result<Self, Self::Error> {
552        let authenticator_data = value
553            .authenticator_data
554            .as_ref()
555            .ok_or_else(|| TryFromProtoError::missing("authenticator_data"))?
556            .to_vec();
557        let client_data_json = value
558            .client_data_json
559            .as_ref()
560            .ok_or_else(|| TryFromProtoError::missing("client_data_json"))?
561            .into();
562
563        let signature = value
564            .signature
565            .as_ref()
566            .ok_or_else(|| TryFromProtoError::missing("signature"))?
567            .try_into()?;
568
569        Self::new(authenticator_data, client_data_json, signature).ok_or_else(|| {
570            TryFromProtoError::invalid(
571                PasskeyAuthenticator::CLIENT_DATA_JSON_FIELD,
572                "invalid passkey",
573            )
574        })
575    }
576}
577
578//
579// MultisigMemberPublicKey
580//
581
582impl From<&sui_sdk_types::MultisigMemberPublicKey> for MultisigMemberPublicKey {
583    fn from(value: &sui_sdk_types::MultisigMemberPublicKey) -> Self {
584        use sui_sdk_types::MultisigMemberPublicKey::*;
585
586        let mut message = Self::default();
587
588        let scheme = match value {
589            Ed25519(public_key) => {
590                message.public_key = Some(public_key.as_bytes().to_vec().into());
591                SignatureScheme::Ed25519
592            }
593            Secp256k1(public_key) => {
594                message.public_key = Some(public_key.as_bytes().to_vec().into());
595                SignatureScheme::Secp256k1
596            }
597            Secp256r1(public_key) => {
598                message.public_key = Some(public_key.as_bytes().to_vec().into());
599                SignatureScheme::Secp256r1
600            }
601            ZkLogin(zklogin_id) => {
602                message.zklogin = Some(zklogin_id.into());
603                SignatureScheme::Zklogin
604            }
605            Passkey(public_key) => {
606                message.public_key = Some(public_key.inner().as_bytes().to_vec().into());
607                SignatureScheme::Passkey
608            }
609            _ => return Self::default(),
610        };
611
612        message.set_scheme(scheme);
613        message
614    }
615}
616
617impl TryFrom<&MultisigMemberPublicKey> for sui_sdk_types::MultisigMemberPublicKey {
618    type Error = TryFromProtoError;
619
620    fn try_from(value: &MultisigMemberPublicKey) -> Result<Self, Self::Error> {
621        use sui_sdk_types::Ed25519PublicKey;
622        use sui_sdk_types::Secp256k1PublicKey;
623        use sui_sdk_types::Secp256r1PublicKey;
624
625        match value.scheme() {
626            SignatureScheme::Ed25519 => Self::Ed25519(
627                Ed25519PublicKey::from_bytes(value.public_key()).map_err(|e| {
628                    TryFromProtoError::invalid(MultisigMemberPublicKey::PUBLIC_KEY_FIELD, e)
629                })?,
630            ),
631            SignatureScheme::Secp256k1 => {
632                Self::Secp256k1(Secp256k1PublicKey::from_bytes(value.public_key()).map_err(
633                    |e| TryFromProtoError::invalid(MultisigMemberPublicKey::PUBLIC_KEY_FIELD, e),
634                )?)
635            }
636            SignatureScheme::Secp256r1 => {
637                Self::Secp256r1(Secp256r1PublicKey::from_bytes(value.public_key()).map_err(
638                    |e| TryFromProtoError::invalid(MultisigMemberPublicKey::PUBLIC_KEY_FIELD, e),
639                )?)
640            }
641            SignatureScheme::Zklogin => Self::ZkLogin(
642                value
643                    .zklogin
644                    .as_ref()
645                    .ok_or_else(|| TryFromProtoError::missing("zklogin"))?
646                    .try_into()?,
647            ),
648            SignatureScheme::Passkey => Self::Passkey(sui_sdk_types::PasskeyPublicKey::new(
649                Secp256r1PublicKey::from_bytes(value.public_key()).map_err(|e| {
650                    TryFromProtoError::invalid(MultisigMemberPublicKey::PUBLIC_KEY_FIELD, e)
651                })?,
652            )),
653            SignatureScheme::Multisig | SignatureScheme::Bls12381 => {
654                return Err(TryFromProtoError::invalid(
655                    MultisigMemberPublicKey::SCHEME_FIELD,
656                    "invalid MultisigMemberPublicKey scheme",
657                ))
658            }
659        }
660        .pipe(Ok)
661    }
662}
663
664//
665// MultisigMember
666//
667
668impl From<&sui_sdk_types::MultisigMember> for MultisigMember {
669    fn from(value: &sui_sdk_types::MultisigMember) -> Self {
670        Self {
671            public_key: Some(value.public_key().into()),
672            weight: Some(value.weight().into()),
673        }
674    }
675}
676
677impl TryFrom<&MultisigMember> for sui_sdk_types::MultisigMember {
678    type Error = TryFromProtoError;
679
680    fn try_from(value: &MultisigMember) -> Result<Self, Self::Error> {
681        let public_key = value
682            .public_key
683            .as_ref()
684            .ok_or_else(|| TryFromProtoError::missing("public_key"))?
685            .try_into()?;
686        let weight = value
687            .weight
688            .ok_or_else(|| TryFromProtoError::missing("weight"))?
689            .try_into()
690            .map_err(|e| TryFromProtoError::invalid(MultisigMember::WEIGHT_FIELD, e))?;
691
692        Ok(Self::new(public_key, weight))
693    }
694}
695
696//
697// MultisigCommittee
698//
699
700impl From<&sui_sdk_types::MultisigCommittee> for MultisigCommittee {
701    fn from(value: &sui_sdk_types::MultisigCommittee) -> Self {
702        Self {
703            members: value.members().iter().map(Into::into).collect(),
704            threshold: Some(value.threshold().into()),
705        }
706    }
707}
708
709impl TryFrom<&MultisigCommittee> for sui_sdk_types::MultisigCommittee {
710    type Error = TryFromProtoError;
711
712    fn try_from(value: &MultisigCommittee) -> Result<Self, Self::Error> {
713        let members = value
714            .members
715            .iter()
716            .map(TryInto::try_into)
717            .collect::<Result<_, _>>()?;
718        let threshold = value
719            .threshold
720            .ok_or_else(|| TryFromProtoError::missing("threshold"))?
721            .try_into()
722            .map_err(|e| TryFromProtoError::invalid(MultisigCommittee::THRESHOLD_FIELD, e))?;
723
724        Ok(Self::new(members, threshold))
725    }
726}
727
728//
729// MultisigMemberSignature
730//
731
732impl From<&sui_sdk_types::MultisigMemberSignature> for MultisigMemberSignature {
733    fn from(value: &sui_sdk_types::MultisigMemberSignature) -> Self {
734        use sui_sdk_types::MultisigMemberSignature::*;
735
736        let mut message = Self::default();
737
738        let scheme = match value {
739            Ed25519(signature) => {
740                message.signature = Some(signature.as_bytes().to_vec().into());
741                SignatureScheme::Ed25519
742            }
743            Secp256k1(signature) => {
744                message.signature = Some(signature.as_bytes().to_vec().into());
745                SignatureScheme::Secp256k1
746            }
747            Secp256r1(signature) => {
748                message.signature = Some(signature.as_bytes().to_vec().into());
749                SignatureScheme::Secp256r1
750            }
751            ZkLogin(zklogin_id) => {
752                message.zklogin = Some((**zklogin_id).clone().into());
753                SignatureScheme::Zklogin
754            }
755            Passkey(p) => {
756                message.passkey = Some(p.clone().into());
757                SignatureScheme::Passkey
758            }
759            _ => return Self::default(),
760        };
761
762        message.set_scheme(scheme);
763        message
764    }
765}
766
767impl TryFrom<&MultisigMemberSignature> for sui_sdk_types::MultisigMemberSignature {
768    type Error = TryFromProtoError;
769
770    fn try_from(value: &MultisigMemberSignature) -> Result<Self, Self::Error> {
771        use sui_sdk_types::Ed25519Signature;
772        use sui_sdk_types::Secp256k1Signature;
773        use sui_sdk_types::Secp256r1Signature;
774
775        match value.scheme() {
776            SignatureScheme::Ed25519 => Self::Ed25519(
777                Ed25519Signature::from_bytes(value.signature()).map_err(|e| {
778                    TryFromProtoError::invalid(MultisigMemberSignature::SIGNATURE_FIELD, e)
779                })?,
780            ),
781            SignatureScheme::Secp256k1 => Self::Secp256k1(
782                Secp256k1Signature::from_bytes(value.signature()).map_err(|e| {
783                    TryFromProtoError::invalid(MultisigMemberSignature::SIGNATURE_FIELD, e)
784                })?,
785            ),
786            SignatureScheme::Secp256r1 => Self::Secp256r1(
787                Secp256r1Signature::from_bytes(value.signature()).map_err(|e| {
788                    TryFromProtoError::invalid(MultisigMemberSignature::SIGNATURE_FIELD, e)
789                })?,
790            ),
791            SignatureScheme::Zklogin => Self::ZkLogin(Box::new(
792                value
793                    .zklogin
794                    .as_ref()
795                    .ok_or_else(|| TryFromProtoError::missing("zklogin"))?
796                    .try_into()?,
797            )),
798            SignatureScheme::Passkey => Self::Passkey(
799                value
800                    .passkey
801                    .as_ref()
802                    .ok_or_else(|| TryFromProtoError::missing("passkey"))?
803                    .try_into()?,
804            ),
805            SignatureScheme::Multisig | SignatureScheme::Bls12381 => {
806                return Err(TryFromProtoError::invalid(
807                    MultisigMemberSignature::SCHEME_FIELD,
808                    "invalid MultisigMemberSignature scheme",
809                ))
810            }
811        }
812        .pipe(Ok)
813    }
814}
815
816//
817// MultisigAggregatedSignature
818//
819
820impl From<&sui_sdk_types::MultisigAggregatedSignature> for MultisigAggregatedSignature {
821    fn from(value: &sui_sdk_types::MultisigAggregatedSignature) -> Self {
822        Self {
823            signatures: value.signatures().iter().map(Into::into).collect(),
824            bitmap: Some(value.bitmap().into()),
825            legacy_bitmap: value
826                .legacy_bitmap()
827                .map(|roaring| roaring.iter().collect())
828                .unwrap_or_default(),
829            committee: Some(value.committee().into()),
830        }
831    }
832}
833
834impl TryFrom<&MultisigAggregatedSignature> for sui_sdk_types::MultisigAggregatedSignature {
835    type Error = TryFromProtoError;
836
837    fn try_from(value: &MultisigAggregatedSignature) -> Result<Self, Self::Error> {
838        let signatures = value
839            .signatures
840            .iter()
841            .map(TryInto::try_into)
842            .collect::<Result<_, _>>()?;
843        let bitmap = value
844            .bitmap
845            .ok_or_else(|| TryFromProtoError::missing("bitmap"))?
846            .try_into()
847            .map_err(|e| {
848                TryFromProtoError::invalid(MultisigAggregatedSignature::BITMAP_FIELD, e)
849            })?;
850        let committee = value
851            .committee
852            .as_ref()
853            .ok_or_else(|| TryFromProtoError::missing("committee"))?
854            .try_into()?;
855
856        let mut signature = Self::new(committee, signatures, bitmap);
857
858        if !value.legacy_bitmap.is_empty() {
859            let legacy_bitmap = value
860                .legacy_bitmap
861                .iter()
862                .copied()
863                .collect::<sui_sdk_types::Bitmap>();
864            signature.with_legacy_bitmap(legacy_bitmap);
865        }
866
867        Ok(signature)
868    }
869}
870
871//
872// UserSignature
873//
874
875impl From<sui_sdk_types::UserSignature> for UserSignature {
876    fn from(value: sui_sdk_types::UserSignature) -> Self {
877        Self::merge_from(value, &FieldMaskTree::new_wildcard())
878    }
879}
880
881impl Merge<sui_sdk_types::UserSignature> for UserSignature {
882    fn merge(&mut self, source: sui_sdk_types::UserSignature, mask: &FieldMaskTree) {
883        use sui_sdk_types::UserSignature::*;
884        use user_signature::Signature;
885
886        if mask.contains(Self::BCS_FIELD.name) {
887            self.bcs = Some(Bcs {
888                name: Some("UserSignatureBytes".to_owned()),
889                value: Some(source.to_bytes().into()),
890            });
891        }
892
893        if mask.contains(Self::SCHEME_FIELD.name) {
894            self.scheme = Some(source.scheme().to_u8().into());
895        }
896
897        match source {
898            Simple(simple) => {
899                if mask.contains(Self::SIMPLE_FIELD.name) {
900                    self.signature = Some(Signature::Simple(simple.into()));
901                }
902            }
903            Multisig(ref multisig) => {
904                if mask.contains(Self::MULTISIG_FIELD.name) {
905                    self.signature = Some(Signature::Multisig(multisig.into()));
906                }
907            }
908            ZkLogin(zklogin) => {
909                if mask.contains(Self::ZKLOGIN_FIELD.name) {
910                    self.signature = Some(Signature::Zklogin((*zklogin).into()));
911                }
912            }
913            Passkey(passkey) => {
914                if mask.contains(Self::PASSKEY_FIELD.name) {
915                    self.signature = Some(Signature::Passkey(passkey.into()));
916                }
917            }
918            _ => {}
919        }
920    }
921}
922
923impl Merge<&UserSignature> for UserSignature {
924    fn merge(&mut self, source: &UserSignature, mask: &FieldMaskTree) {
925        use user_signature::Signature;
926
927        let UserSignature {
928            bcs,
929            scheme,
930            signature,
931        } = source;
932
933        if mask.contains(Self::BCS_FIELD.name) {
934            self.bcs = bcs.clone();
935        }
936
937        if mask.contains(Self::SCHEME_FIELD.name) {
938            self.scheme = *scheme;
939        }
940
941        if matches!(signature, Some(Signature::Simple(_))) && mask.contains(Self::SIMPLE_FIELD.name)
942            || matches!(signature, Some(Signature::Multisig(_)))
943                && mask.contains(Self::MULTISIG_FIELD.name)
944            || matches!(signature, Some(Signature::Zklogin(_)))
945                && mask.contains(Self::ZKLOGIN_FIELD.name)
946            || matches!(signature, Some(Signature::Passkey(_)))
947                && mask.contains(Self::PASSKEY_FIELD.name)
948        {
949            self.signature = signature.clone();
950        }
951    }
952}
953
954impl TryFrom<&UserSignature> for sui_sdk_types::UserSignature {
955    type Error = TryFromProtoError;
956
957    fn try_from(value: &UserSignature) -> Result<Self, Self::Error> {
958        use user_signature::Signature;
959
960        if let Some(bcs) = &value.bcs {
961            if let Ok(sig) = Self::from_bytes(bcs.value()) {
962                return Ok(sig);
963            } else {
964                return bcs
965                    .deserialize()
966                    .map_err(|e| TryFromProtoError::invalid(UserSignature::BCS_FIELD, e));
967            }
968        }
969
970        let _scheme = value
971            .scheme
972            .ok_or_else(|| TryFromProtoError::missing("scheme"))?
973            .pipe(SignatureScheme::try_from)
974            .map_err(|e| TryFromProtoError::invalid(UserSignature::SCHEME_FIELD, e));
975
976        match &value.signature {
977            Some(Signature::Simple(simple)) => Self::Simple(simple.try_into()?),
978            Some(Signature::Multisig(multisig)) => Self::Multisig(multisig.try_into()?),
979            Some(Signature::Zklogin(zklogin)) => Self::ZkLogin(Box::new(zklogin.try_into()?)),
980            Some(Signature::Passkey(passkey)) => Self::Passkey(passkey.try_into()?),
981            None => {
982                return Err(TryFromProtoError::invalid(
983                    "signature",
984                    "invalid or unknown signature scheme",
985                ))
986            }
987        }
988        .pipe(Ok)
989    }
990}
sui_rpc/proto/sui/rpc/v2beta2/signatures.rs

sui_rpc/proto/sui/rpc/v2beta2/
signatures.rs
