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

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