accumulate_client/generated/
signatures.rs

1//! GENERATED FILE - DO NOT EDIT
2//! Source: protocol/signatures.yml | Generated: 2025-10-03 20:47:50
3
4#![allow(missing_docs)]
5
6use serde::{Serialize, Deserialize};
7use hex;
8
9// Helper module for optional hex serialization
10mod hex_option {
11    use serde::{Deserialize, Deserializer, Serialize, Serializer};
12
13    pub fn serialize<S>(value: &Option<[u8; 32]>, serializer: S) -> Result<S::Ok, S::Error>
14    where
15        S: Serializer,
16    {
17        match value {
18            Some(bytes) => hex::encode(bytes).serialize(serializer),
19            None => serializer.serialize_none(),
20        }
21    }
22
23    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<[u8; 32]>, D::Error>
24    where
25        D: Deserializer<'de>,
26    {
27        let opt: Option<String> = Option::deserialize(deserializer)?;
28        match opt {
29            Some(hex_str) => {
30                let bytes = hex::decode(&hex_str).map_err(serde::de::Error::custom)?;
31                if bytes.len() != 32 {
32                    return Err(serde::de::Error::custom("Hash must be 32 bytes"));
33                }
34                let mut hash = [0u8; 32];
35                hash.copy_from_slice(&bytes);
36                Ok(Some(hash))
37            },
38            None => Ok(None),
39        }
40    }
41}
42
43// Helper module for optional bytes hex serialization
44mod hex_option_vec {
45    use serde::{Deserialize, Deserializer, Serialize, Serializer};
46
47    pub fn serialize<S>(value: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
48    where
49        S: Serializer,
50    {
51        match value {
52            Some(bytes) => hex::encode(bytes).serialize(serializer),
53            None => serializer.serialize_none(),
54        }
55    }
56
57    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
58    where
59        D: Deserializer<'de>,
60    {
61        let opt: Option<String> = Option::deserialize(deserializer)?;
62        match opt {
63            Some(hex_str) => {
64                let bytes = hex::decode(&hex_str).map_err(serde::de::Error::custom)?;
65                Ok(Some(bytes))
66            },
67            None => Ok(None),
68        }
69    }
70}
71
72// Helper module for vector of hashes hex serialization
73mod hex_vec_hash {
74    use serde::{Deserialize, Deserializer, Serialize, Serializer};
75
76    pub fn serialize<S>(value: &Vec<[u8; 32]>, serializer: S) -> Result<S::Ok, S::Error>
77    where
78        S: Serializer,
79    {
80        let hex_strings: Vec<String> = value.iter().map(|hash| hex::encode(hash)).collect();
81        hex_strings.serialize(serializer)
82    }
83
84    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<[u8; 32]>, D::Error>
85    where
86        D: Deserializer<'de>,
87    {
88        let hex_strings: Vec<String> = Vec::deserialize(deserializer)?;
89        let mut result = Vec::new();
90        for hex_str in hex_strings {
91            let bytes = hex::decode(&hex_str).map_err(serde::de::Error::custom)?;
92            if bytes.len() != 32 {
93                return Err(serde::de::Error::custom("Hash must be 32 bytes"));
94            }
95            let mut hash = [0u8; 32];
96            hash.copy_from_slice(&bytes);
97            result.push(hash);
98        }
99        Ok(result)
100    }
101}
102
103// Helper module for vector of bytes hex serialization
104// Kept for potential future use with Vec<Vec<u8>> fields
105#[allow(dead_code)]
106mod hex_vec_bytes {
107    use serde::{Deserialize, Deserializer, Serialize, Serializer};
108
109    pub fn serialize<S>(value: &Vec<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
110    where
111        S: Serializer,
112    {
113        let hex_strings: Vec<String> = value.iter().map(|bytes| hex::encode(bytes)).collect();
114        hex_strings.serialize(serializer)
115    }
116
117    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Vec<u8>>, D::Error>
118    where
119        D: Deserializer<'de>,
120    {
121        let hex_strings: Vec<String> = Vec::deserialize(deserializer)?;
122        let mut result = Vec::new();
123        for hex_str in hex_strings {
124            let bytes = hex::decode(&hex_str).map_err(serde::de::Error::custom)?;
125            result.push(bytes);
126        }
127        Ok(result)
128    }
129}
130
131/// Error type for signature operations
132#[derive(Debug, thiserror::Error)]
133pub enum SignatureError {
134    #[error("Invalid signature format")]
135    InvalidFormat,
136    #[error("Verification failed: {0}")]
137    VerificationFailed(String),
138    #[error("Unsupported signature type")]
139    UnsupportedType,
140}
141
142/// Main signature trait for verification
143pub trait AccSignature {
144    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error>;
145    fn sig_type(&self) -> &'static str;
146}
147
148/// LegacyED25519Signature signature
149#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
150#[serde(rename_all = "camelCase")]
151pub struct LegacyED25519Signature {
152    #[serde(rename = "Timestamp")]
153    pub timestamp: u64,
154    #[serde(rename = "PublicKey", with = "hex::serde")]
155    pub public_key: Vec<u8>,
156    #[serde(rename = "Signature", with = "hex::serde")]
157    pub signature: Vec<u8>,
158    #[serde(rename = "Signer")]
159    pub signer: String,
160    #[serde(rename = "SignerVersion")]
161    pub signer_version: u64,
162    #[serde(rename = "Vote")]
163    pub vote: Option<crate::generated::enums::VoteType>,
164    #[serde(rename = "TransactionHash", with = "hex_option")]
165    pub transaction_hash: Option<[u8; 32]>,
166}
167
168/// RCD1Signature signature
169#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
170#[serde(rename_all = "camelCase")]
171pub struct RCD1Signature {
172    #[serde(rename = "PublicKey", with = "hex::serde")]
173    pub public_key: Vec<u8>,
174    #[serde(rename = "Signature", with = "hex::serde")]
175    pub signature: Vec<u8>,
176    #[serde(rename = "Signer")]
177    pub signer: String,
178    #[serde(rename = "SignerVersion")]
179    pub signer_version: u64,
180    #[serde(rename = "Timestamp")]
181    pub timestamp: Option<u64>,
182    #[serde(rename = "Vote")]
183    pub vote: Option<crate::generated::enums::VoteType>,
184    #[serde(rename = "TransactionHash", with = "hex_option")]
185    pub transaction_hash: Option<[u8; 32]>,
186    #[serde(rename = "Memo")]
187    pub memo: Option<String>,
188    #[serde(rename = "Data", with = "hex_option_vec")]
189    pub data: Option<Vec<u8>>,
190}
191
192/// ED25519Signature signature
193#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
194#[serde(rename_all = "camelCase")]
195pub struct ED25519Signature {
196    #[serde(rename = "PublicKey", with = "hex::serde")]
197    pub public_key: Vec<u8>,
198    #[serde(rename = "Signature", with = "hex::serde")]
199    pub signature: Vec<u8>,
200    #[serde(rename = "Signer")]
201    pub signer: String,
202    #[serde(rename = "SignerVersion")]
203    pub signer_version: u64,
204    #[serde(rename = "Timestamp")]
205    pub timestamp: Option<u64>,
206    #[serde(rename = "Vote")]
207    pub vote: Option<crate::generated::enums::VoteType>,
208    #[serde(rename = "TransactionHash", with = "hex_option")]
209    pub transaction_hash: Option<[u8; 32]>,
210    #[serde(rename = "Memo")]
211    pub memo: Option<String>,
212    #[serde(rename = "Data", with = "hex_option_vec")]
213    pub data: Option<Vec<u8>>,
214}
215
216/// BTCSignature signature
217#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
218#[serde(rename_all = "camelCase")]
219pub struct BTCSignature {
220    #[serde(rename = "PublicKey", with = "hex::serde")]
221    pub public_key: Vec<u8>,
222    #[serde(rename = "Signature", with = "hex::serde")]
223    pub signature: Vec<u8>,
224    #[serde(rename = "Signer")]
225    pub signer: String,
226    #[serde(rename = "SignerVersion")]
227    pub signer_version: u64,
228    #[serde(rename = "Timestamp")]
229    pub timestamp: Option<u64>,
230    #[serde(rename = "Vote")]
231    pub vote: Option<crate::generated::enums::VoteType>,
232    #[serde(rename = "TransactionHash", with = "hex_option")]
233    pub transaction_hash: Option<[u8; 32]>,
234    #[serde(rename = "Memo")]
235    pub memo: Option<String>,
236    #[serde(rename = "Data", with = "hex_option_vec")]
237    pub data: Option<Vec<u8>>,
238}
239
240/// BTCLegacySignature signature
241#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
242#[serde(rename_all = "camelCase")]
243pub struct BTCLegacySignature {
244    #[serde(rename = "PublicKey", with = "hex::serde")]
245    pub public_key: Vec<u8>,
246    #[serde(rename = "Signature", with = "hex::serde")]
247    pub signature: Vec<u8>,
248    #[serde(rename = "Signer")]
249    pub signer: String,
250    #[serde(rename = "SignerVersion")]
251    pub signer_version: u64,
252    #[serde(rename = "Timestamp")]
253    pub timestamp: Option<u64>,
254    #[serde(rename = "Vote")]
255    pub vote: Option<crate::generated::enums::VoteType>,
256    #[serde(rename = "TransactionHash", with = "hex_option")]
257    pub transaction_hash: Option<[u8; 32]>,
258    #[serde(rename = "Memo")]
259    pub memo: Option<String>,
260    #[serde(rename = "Data", with = "hex_option_vec")]
261    pub data: Option<Vec<u8>>,
262}
263
264/// ETHSignature signature
265#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
266#[serde(rename_all = "camelCase")]
267pub struct ETHSignature {
268    #[serde(rename = "PublicKey", with = "hex::serde")]
269    pub public_key: Vec<u8>,
270    #[serde(rename = "Signature", with = "hex::serde")]
271    pub signature: Vec<u8>,
272    #[serde(rename = "Signer")]
273    pub signer: String,
274    #[serde(rename = "SignerVersion")]
275    pub signer_version: u64,
276    #[serde(rename = "Timestamp")]
277    pub timestamp: Option<u64>,
278    #[serde(rename = "Vote")]
279    pub vote: Option<crate::generated::enums::VoteType>,
280    #[serde(rename = "TransactionHash", with = "hex_option")]
281    pub transaction_hash: Option<[u8; 32]>,
282    #[serde(rename = "Memo")]
283    pub memo: Option<String>,
284    #[serde(rename = "Data", with = "hex_option_vec")]
285    pub data: Option<Vec<u8>>,
286}
287
288/// RsaSha256Signature signature
289#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
290#[serde(rename_all = "camelCase")]
291pub struct RsaSha256Signature {
292    #[serde(rename = "PublicKey", with = "hex::serde")]
293    pub public_key: Vec<u8>,
294    #[serde(rename = "Signature", with = "hex::serde")]
295    pub signature: Vec<u8>,
296    #[serde(rename = "Signer")]
297    pub signer: String,
298    #[serde(rename = "SignerVersion")]
299    pub signer_version: u64,
300    #[serde(rename = "Timestamp")]
301    pub timestamp: Option<u64>,
302    #[serde(rename = "Vote")]
303    pub vote: Option<crate::generated::enums::VoteType>,
304    #[serde(rename = "TransactionHash", with = "hex_option")]
305    pub transaction_hash: Option<[u8; 32]>,
306    #[serde(rename = "Memo")]
307    pub memo: Option<String>,
308    #[serde(rename = "Data", with = "hex_option_vec")]
309    pub data: Option<Vec<u8>>,
310}
311
312/// EcdsaSha256Signature signature
313#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
314#[serde(rename_all = "camelCase")]
315pub struct EcdsaSha256Signature {
316    #[serde(rename = "PublicKey", with = "hex::serde")]
317    pub public_key: Vec<u8>,
318    #[serde(rename = "Signature", with = "hex::serde")]
319    pub signature: Vec<u8>,
320    #[serde(rename = "Signer")]
321    pub signer: String,
322    #[serde(rename = "SignerVersion")]
323    pub signer_version: u64,
324    #[serde(rename = "Timestamp")]
325    pub timestamp: Option<u64>,
326    #[serde(rename = "Vote")]
327    pub vote: Option<crate::generated::enums::VoteType>,
328    #[serde(rename = "TransactionHash", with = "hex_option")]
329    pub transaction_hash: Option<[u8; 32]>,
330    #[serde(rename = "Memo")]
331    pub memo: Option<String>,
332    #[serde(rename = "Data", with = "hex_option_vec")]
333    pub data: Option<Vec<u8>>,
334}
335
336/// TypedDataSignature signature
337#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
338#[serde(rename_all = "camelCase")]
339pub struct TypedDataSignature {
340    #[serde(rename = "PublicKey", with = "hex::serde")]
341    pub public_key: Vec<u8>,
342    #[serde(rename = "Signature", with = "hex::serde")]
343    pub signature: Vec<u8>,
344    #[serde(rename = "Signer")]
345    pub signer: String,
346    #[serde(rename = "SignerVersion")]
347    pub signer_version: u64,
348    #[serde(rename = "Timestamp")]
349    pub timestamp: Option<u64>,
350    #[serde(rename = "Vote")]
351    pub vote: Option<crate::generated::enums::VoteType>,
352    #[serde(rename = "TransactionHash", with = "hex_option")]
353    pub transaction_hash: Option<[u8; 32]>,
354    #[serde(rename = "Memo")]
355    pub memo: Option<String>,
356    #[serde(rename = "Data", with = "hex_option_vec")]
357    pub data: Option<Vec<u8>>,
358    #[serde(rename = "ChainID")]
359    pub chain_i_d: String,
360}
361
362/// ReceiptSignature signature
363#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
364#[serde(rename_all = "camelCase")]
365pub struct ReceiptSignature {
366    #[serde(rename = "SourceNetwork")]
367    pub source_network: String,
368    #[serde(rename = "Proof")]
369    pub proof: crate::types::MerkleReceipt,
370    #[serde(rename = "TransactionHash", with = "hex_option")]
371    pub transaction_hash: Option<[u8; 32]>,
372}
373
374/// PartitionSignature signature
375#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
376#[serde(rename_all = "camelCase")]
377pub struct PartitionSignature {
378    #[serde(rename = "SourceNetwork")]
379    pub source_network: String,
380    #[serde(rename = "DestinationNetwork")]
381    pub destination_network: String,
382    #[serde(rename = "SequenceNumber")]
383    pub sequence_number: u64,
384    #[serde(rename = "TransactionHash", with = "hex_option")]
385    pub transaction_hash: Option<[u8; 32]>,
386}
387
388/// SignatureSet signature
389#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
390#[serde(rename_all = "camelCase")]
391pub struct SignatureSet {
392    #[serde(rename = "Vote")]
393    pub vote: Option<crate::generated::enums::VoteType>,
394    #[serde(rename = "Signer")]
395    pub signer: String,
396    #[serde(rename = "TransactionHash", with = "hex_option")]
397    pub transaction_hash: Option<[u8; 32]>,
398    #[serde(rename = "Signatures")]
399    pub signatures: Vec<Box<crate::generated::signatures::Signature>>,
400    #[serde(rename = "Authority")]
401    pub authority: String,
402}
403
404/// RemoteSignature signature
405#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
406#[serde(rename_all = "camelCase")]
407pub struct RemoteSignature {
408    #[serde(rename = "Destination")]
409    pub destination: String,
410    #[serde(rename = "Signature")]
411    pub signature: Box<crate::generated::signatures::Signature>,
412    #[serde(rename = "Cause", with = "hex_vec_hash")]
413    pub cause: Vec<[u8; 32]>,
414}
415
416/// DelegatedSignature signature
417#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
418#[serde(rename_all = "camelCase")]
419pub struct DelegatedSignature {
420    #[serde(rename = "Signature")]
421    pub signature: Box<crate::generated::signatures::Signature>,
422    #[serde(rename = "Delegator")]
423    pub delegator: String,
424}
425
426/// InternalSignature signature
427#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
428#[serde(rename_all = "camelCase")]
429pub struct InternalSignature {
430    #[serde(rename = "Cause", with = "hex::serde")]
431    pub cause: [u8; 32],
432    #[serde(rename = "TransactionHash", with = "hex::serde")]
433    pub transaction_hash: [u8; 32],
434}
435
436/// AuthoritySignature signature
437#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
438#[serde(rename_all = "camelCase")]
439pub struct AuthoritySignature {
440    #[serde(rename = "Origin")]
441    pub origin: String,
442    #[serde(rename = "Authority")]
443    pub authority: String,
444    #[serde(rename = "Vote")]
445    pub vote: Option<crate::generated::enums::VoteType>,
446    #[serde(rename = "TxID")]
447    pub tx_i_d: String,
448    #[serde(rename = "Cause")]
449    pub cause: String,
450    #[serde(rename = "Delegator")]
451    pub delegator: Vec<String>,
452    #[serde(rename = "Memo")]
453    pub memo: Option<String>,
454}
455
456/// Main signature dispatch enum
457#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
458#[serde(tag = "type")]
459pub enum Signature {
460    #[serde(rename = "legacyED25519")]
461    LegacyED25519(LegacyED25519Signature),
462    #[serde(rename = "rcd1")]
463    RCD1(RCD1Signature),
464    #[serde(rename = "ed25519")]
465    ED25519(ED25519Signature),
466    #[serde(rename = "btc")]
467    BTC(BTCSignature),
468    #[serde(rename = "btcLegacy")]
469    BTCLegacy(BTCLegacySignature),
470    #[serde(rename = "eth")]
471    ETH(ETHSignature),
472    #[serde(rename = "rsaSha256")]
473    RsaSha256(RsaSha256Signature),
474    #[serde(rename = "ecdsaSha256")]
475    EcdsaSha256(EcdsaSha256Signature),
476    #[serde(rename = "typedData")]
477    TypedData(TypedDataSignature),
478    #[serde(rename = "receipt")]
479    Receipt(ReceiptSignature),
480    #[serde(rename = "partition")]
481    Partition(PartitionSignature),
482    #[serde(rename = "signatureSet")]
483    Set(SignatureSet),
484    #[serde(rename = "remote")]
485    Remote(RemoteSignature),
486    #[serde(rename = "delegated")]
487    Delegated(DelegatedSignature),
488    #[serde(rename = "internal")]
489    Internal(InternalSignature),
490    #[serde(rename = "authority")]
491    Authority(AuthoritySignature),
492}
493
494impl Signature {
495    pub fn wire_tag(&self) -> &'static str {
496        match self {
497            Signature::LegacyED25519(_) => "legacyED25519",
498            Signature::RCD1(_) => "rcd1",
499            Signature::ED25519(_) => "ed25519",
500            Signature::BTC(_) => "btc",
501            Signature::BTCLegacy(_) => "btcLegacy",
502            Signature::ETH(_) => "eth",
503            Signature::RsaSha256(_) => "rsaSha256",
504            Signature::EcdsaSha256(_) => "ecdsaSha256",
505            Signature::TypedData(_) => "typedData",
506            Signature::Receipt(_) => "receipt",
507            Signature::Partition(_) => "partition",
508            Signature::Set(_) => "signatureSet",
509            Signature::Remote(_) => "remote",
510            Signature::Delegated(_) => "delegated",
511            Signature::Internal(_) => "internal",
512            Signature::Authority(_) => "authority",
513        }
514    }
515
516    /// Get the vote from this signature
517    /// Returns VoteType::Accept for signatures that don't have a vote field
518    pub fn get_vote(&self) -> crate::generated::enums::VoteType {
519        use crate::generated::enums::VoteType;
520        match self {
521            Signature::LegacyED25519(s) => s.vote.unwrap_or(VoteType::Accept),
522            Signature::RCD1(s) => s.vote.unwrap_or(VoteType::Accept),
523            Signature::ED25519(s) => s.vote.unwrap_or(VoteType::Accept),
524            Signature::BTC(s) => s.vote.unwrap_or(VoteType::Accept),
525            Signature::BTCLegacy(s) => s.vote.unwrap_or(VoteType::Accept),
526            Signature::ETH(s) => s.vote.unwrap_or(VoteType::Accept),
527            Signature::RsaSha256(s) => s.vote.unwrap_or(VoteType::Accept),
528            Signature::EcdsaSha256(s) => s.vote.unwrap_or(VoteType::Accept),
529            Signature::TypedData(s) => s.vote.unwrap_or(VoteType::Accept),
530            // System signatures always vote Accept
531            Signature::Receipt(_) => VoteType::Accept,
532            Signature::Partition(_) => VoteType::Accept,
533            Signature::Internal(_) => VoteType::Accept,
534            // SignatureSet has its own vote
535            Signature::Set(s) => s.vote.unwrap_or(VoteType::Accept),
536            // Wrapper signatures delegate to inner (signature is Box<Signature>, not Option)
537            Signature::Remote(s) => s.signature.get_vote(),
538            Signature::Delegated(s) => s.signature.get_vote(),
539            Signature::Authority(s) => s.vote.unwrap_or(VoteType::Accept),
540        }
541    }
542
543    /// Check if this signature votes to accept
544    pub fn votes_accept(&self) -> bool {
545        self.get_vote().is_approval()
546    }
547
548    /// Check if this signature votes to reject
549    pub fn votes_reject(&self) -> bool {
550        self.get_vote().is_rejection()
551    }
552
553    /// Check if this signature abstains
554    pub fn votes_abstain(&self) -> bool {
555        self.get_vote().is_abstention()
556    }
557
558    /// Tally votes from multiple signatures
559    pub fn tally_votes(signatures: &[Signature]) -> crate::generated::enums::VoteTally {
560        let mut tally = crate::generated::enums::VoteTally::new();
561        for sig in signatures {
562            tally.add_vote(sig.get_vote());
563        }
564        tally
565    }
566
567    /// Tally votes from multiple signatures (nested - includes nested signatures in sets)
568    pub fn tally_votes_nested(signatures: &[Signature]) -> crate::generated::enums::VoteTally {
569        let mut tally = crate::generated::enums::VoteTally::new();
570        for sig in signatures {
571            match sig {
572                Signature::Set(s) => {
573                    // For SignatureSet, use its vote field
574                    tally.add_vote(s.vote.unwrap_or(crate::generated::enums::VoteType::Accept));
575                }
576                Signature::Remote(s) => {
577                    // signature is Box<Signature>, not Option
578                    tally.add_vote(s.signature.get_vote());
579                }
580                Signature::Delegated(s) => {
581                    // signature is Box<Signature>, not Option
582                    tally.add_vote(s.signature.get_vote());
583                }
584                _ => {
585                    tally.add_vote(sig.get_vote());
586                }
587            }
588        }
589        tally
590    }
591}
592
593impl AccSignature for LegacyED25519Signature {
594    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
595        // Updated for ed25519-dalek v2.x API
596        // Legacy Ed25519 - use same verification as ED25519Signature
597        use ed25519_dalek::{Signature as Ed25519Sig, VerifyingKey, Verifier};
598
599        if self.public_key.len() != 32 || self.signature.len() != 64 {
600            return Ok(false);
601        }
602
603        let mut pub_key_bytes = [0u8; 32];
604        pub_key_bytes.copy_from_slice(&self.public_key);
605
606        let mut sig_bytes = [0u8; 64];
607        sig_bytes.copy_from_slice(&self.signature);
608
609        match VerifyingKey::from_bytes(&pub_key_bytes) {
610            Ok(verifying_key) => {
611                let signature = Ed25519Sig::from_bytes(&sig_bytes);
612                Ok(verifying_key.verify(message, &signature).is_ok())
613            },
614            Err(_) => Ok(false),
615        }
616    }
617
618    fn sig_type(&self) -> &'static str {
619        "legacyED25519"
620    }
621}
622
623impl AccSignature for RCD1Signature {
624    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
625        // Updated for ed25519-dalek v2.x API
626        // RCD1 uses ED25519 internally (Factom RCD1 format)
627        // The public key format is the same as ED25519
628        use ed25519_dalek::{Signature as Ed25519Sig, VerifyingKey, Verifier};
629
630        if self.public_key.len() != 32 || self.signature.len() != 64 {
631            return Ok(false);
632        }
633
634        let mut pub_key_bytes = [0u8; 32];
635        pub_key_bytes.copy_from_slice(&self.public_key);
636
637        let mut sig_bytes = [0u8; 64];
638        sig_bytes.copy_from_slice(&self.signature);
639
640        match VerifyingKey::from_bytes(&pub_key_bytes) {
641            Ok(verifying_key) => {
642                let signature = Ed25519Sig::from_bytes(&sig_bytes);
643                Ok(verifying_key.verify(message, &signature).is_ok())
644            },
645            Err(_) => Ok(false),
646        }
647    }
648
649    fn sig_type(&self) -> &'static str {
650        "rcd1"
651    }
652}
653
654impl AccSignature for ED25519Signature {
655    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
656        // Updated for ed25519-dalek v2.x API
657        use ed25519_dalek::{Signature as Ed25519Sig, VerifyingKey, Verifier};
658
659        if self.public_key.len() != 32 || self.signature.len() != 64 {
660            return Ok(false);
661        }
662
663        let mut pub_key_bytes = [0u8; 32];
664        pub_key_bytes.copy_from_slice(&self.public_key);
665
666        let mut sig_bytes = [0u8; 64];
667        sig_bytes.copy_from_slice(&self.signature);
668
669        match VerifyingKey::from_bytes(&pub_key_bytes) {
670            Ok(verifying_key) => {
671                // In v2, Signature::from_bytes is infallible
672                let signature = Ed25519Sig::from_bytes(&sig_bytes);
673                Ok(verifying_key.verify(message, &signature).is_ok())
674            },
675            Err(_) => Ok(false),
676        }
677    }
678
679    fn sig_type(&self) -> &'static str {
680        "ed25519"
681    }
682}
683
684impl AccSignature for BTCSignature {
685    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
686        // BTC uses secp256k1 ECDSA with DER-encoded signatures
687        use k256::ecdsa::{Signature as K256Signature, VerifyingKey, signature::Verifier};
688        use sha2::{Sha256, Digest};
689
690        if self.public_key.is_empty() || self.signature.is_empty() {
691            return Ok(false);
692        }
693
694        // Hash the message with SHA256 (Bitcoin double-SHA256 for transaction signing)
695        let mut hasher = Sha256::new();
696        hasher.update(message);
697        let hash = hasher.finalize();
698
699        // Parse the public key (compressed or uncompressed SEC1 format)
700        let verifying_key = match VerifyingKey::from_sec1_bytes(&self.public_key) {
701            Ok(key) => key,
702            Err(_) => return Ok(false),
703        };
704
705        // Try to parse signature as DER format first, then as raw r||s format
706        let signature = if let Ok(sig) = K256Signature::from_der(&self.signature) {
707            sig
708        } else if self.signature.len() == 64 {
709            // Raw r||s format (32 bytes each)
710            match K256Signature::from_slice(&self.signature) {
711                Ok(sig) => sig,
712                Err(_) => return Ok(false),
713            }
714        } else {
715            return Ok(false);
716        };
717
718        Ok(verifying_key.verify(&hash, &signature).is_ok())
719    }
720
721    fn sig_type(&self) -> &'static str {
722        "btc"
723    }
724}
725
726impl AccSignature for BTCLegacySignature {
727    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
728        // BTCLegacy uses same secp256k1 ECDSA as BTC
729        use k256::ecdsa::{Signature as K256Signature, VerifyingKey, signature::Verifier};
730        use sha2::{Sha256, Digest};
731
732        if self.public_key.is_empty() || self.signature.is_empty() {
733            return Ok(false);
734        }
735
736        // Hash the message with SHA256
737        let mut hasher = Sha256::new();
738        hasher.update(message);
739        let hash = hasher.finalize();
740
741        // Parse the public key (compressed or uncompressed SEC1 format)
742        let verifying_key = match VerifyingKey::from_sec1_bytes(&self.public_key) {
743            Ok(key) => key,
744            Err(_) => return Ok(false),
745        };
746
747        // Try to parse signature as DER format first, then as raw r||s format
748        let signature = if let Ok(sig) = K256Signature::from_der(&self.signature) {
749            sig
750        } else if self.signature.len() == 64 {
751            match K256Signature::from_slice(&self.signature) {
752                Ok(sig) => sig,
753                Err(_) => return Ok(false),
754            }
755        } else {
756            return Ok(false);
757        };
758
759        Ok(verifying_key.verify(&hash, &signature).is_ok())
760    }
761
762    fn sig_type(&self) -> &'static str {
763        "btcLegacy"
764    }
765}
766
767impl AccSignature for ETHSignature {
768    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
769        // Ethereum uses secp256k1 ECDSA with keccak256 hash
770        // Signature format: r (32 bytes) || s (32 bytes) || v (1 byte recovery id)
771        use k256::ecdsa::{Signature as K256Signature, VerifyingKey, RecoveryId, signature::Verifier};
772        use sha3::{Keccak256, Digest};
773
774        if self.public_key.is_empty() || self.signature.is_empty() {
775            return Ok(false);
776        }
777
778        // Hash the message with Keccak256 (Ethereum style)
779        let mut hasher = Keccak256::new();
780        hasher.update(message);
781        let hash = hasher.finalize();
782
783        // Parse the public key (compressed or uncompressed SEC1 format)
784        let expected_key = match VerifyingKey::from_sec1_bytes(&self.public_key) {
785            Ok(key) => key,
786            Err(_) => return Ok(false),
787        };
788
789        // ETH signatures are typically 65 bytes (r || s || v) or 64 bytes (r || s)
790        if self.signature.len() == 65 {
791            // Extract r, s, and recovery id
792            let recovery_id = match RecoveryId::try_from(self.signature[64] % 4) {
793                Ok(id) => id,
794                Err(_) => return Ok(false),
795            };
796
797            let sig = match K256Signature::from_slice(&self.signature[..64]) {
798                Ok(s) => s,
799                Err(_) => return Ok(false),
800            };
801
802            // Recover the public key and compare
803            match VerifyingKey::recover_from_prehash(&hash, &sig, recovery_id) {
804                Ok(recovered_key) => {
805                    Ok(recovered_key == expected_key)
806                },
807                Err(_) => Ok(false),
808            }
809        } else if self.signature.len() == 64 {
810            // Standard ECDSA without recovery - verify directly
811            let signature = match K256Signature::from_slice(&self.signature) {
812                Ok(sig) => sig,
813                Err(_) => return Ok(false),
814            };
815            Ok(expected_key.verify(&hash, &signature).is_ok())
816        } else {
817            Ok(false)
818        }
819    }
820
821    fn sig_type(&self) -> &'static str {
822        "eth"
823    }
824}
825
826impl AccSignature for RsaSha256Signature {
827    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
828        // RSA PKCS#1 v1.5 with SHA-256
829        use rsa::{RsaPublicKey, pkcs1::DecodeRsaPublicKey, pkcs8::DecodePublicKey};
830        use rsa::signature::Verifier;
831        use rsa::pkcs1v15::{Signature, VerifyingKey};
832        use sha2::Sha256;
833
834        if self.signature.is_empty() || self.public_key.is_empty() {
835            return Ok(false);
836        }
837
838        // Try to parse the public key in different formats
839        // First try PKCS#1 DER format, then PKCS#8 DER format
840        let public_key = if let Ok(key) = RsaPublicKey::from_pkcs1_der(&self.public_key) {
841            key
842        } else if let Ok(key) = RsaPublicKey::from_public_key_der(&self.public_key) {
843            key
844        } else {
845            return Ok(false);
846        };
847
848        // Create verifying key with SHA256
849        let verifying_key: VerifyingKey<Sha256> = VerifyingKey::new(public_key);
850
851        // Parse the signature
852        let signature = match Signature::try_from(self.signature.as_slice()) {
853            Ok(sig) => sig,
854            Err(_) => return Ok(false),
855        };
856
857        // Verify the signature
858        Ok(verifying_key.verify(message, &signature).is_ok())
859    }
860
861    fn sig_type(&self) -> &'static str {
862        "rsaSha256"
863    }
864}
865
866impl AccSignature for EcdsaSha256Signature {
867    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
868        // ECDSA secp256k1 with SHA-256 hash
869        use k256::ecdsa::{Signature as K256Signature, VerifyingKey, signature::Verifier};
870        use sha2::{Sha256, Digest};
871
872        if self.signature.is_empty() || self.public_key.is_empty() {
873            return Ok(false);
874        }
875
876        // Hash the message with SHA256
877        let mut hasher = Sha256::new();
878        hasher.update(message);
879        let hash = hasher.finalize();
880
881        // Parse the public key (compressed or uncompressed SEC1 format)
882        let verifying_key = match VerifyingKey::from_sec1_bytes(&self.public_key) {
883            Ok(key) => key,
884            Err(_) => return Ok(false),
885        };
886
887        // Try to parse signature as DER format first, then as raw r||s format
888        let signature = if let Ok(sig) = K256Signature::from_der(&self.signature) {
889            sig
890        } else if self.signature.len() == 64 {
891            match K256Signature::from_slice(&self.signature) {
892                Ok(sig) => sig,
893                Err(_) => return Ok(false),
894            }
895        } else {
896            return Ok(false);
897        };
898
899        Ok(verifying_key.verify(&hash, &signature).is_ok())
900    }
901
902    fn sig_type(&self) -> &'static str {
903        "ecdsaSha256"
904    }
905}
906
907impl AccSignature for TypedDataSignature {
908    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
909        // EIP-712 TypedData signature - uses keccak256 and secp256k1 with recovery
910        // Similar to ETHSignature but the message is already the EIP-712 typed data hash
911        use k256::ecdsa::{Signature as K256Signature, VerifyingKey, RecoveryId, signature::Verifier};
912        use sha3::{Keccak256, Digest};
913
914        if self.public_key.is_empty() || self.signature.is_empty() {
915            return Ok(false);
916        }
917
918        // For EIP-712, the message should already be the structured data hash
919        // We hash it with keccak256 for final signing
920        let mut hasher = Keccak256::new();
921        hasher.update(message);
922        let hash = hasher.finalize();
923
924        // Parse the public key
925        let expected_key = match VerifyingKey::from_sec1_bytes(&self.public_key) {
926            Ok(key) => key,
927            Err(_) => return Ok(false),
928        };
929
930        // ETH-style signatures are typically 65 bytes (r || s || v)
931        if self.signature.len() == 65 {
932            let recovery_id = match RecoveryId::try_from(self.signature[64] % 4) {
933                Ok(id) => id,
934                Err(_) => return Ok(false),
935            };
936
937            let sig = match K256Signature::from_slice(&self.signature[..64]) {
938                Ok(s) => s,
939                Err(_) => return Ok(false),
940            };
941
942            match VerifyingKey::recover_from_prehash(&hash, &sig, recovery_id) {
943                Ok(recovered_key) => Ok(recovered_key == expected_key),
944                Err(_) => Ok(false),
945            }
946        } else if self.signature.len() == 64 {
947            let signature = match K256Signature::from_slice(&self.signature) {
948                Ok(sig) => sig,
949                Err(_) => return Ok(false),
950            };
951            Ok(expected_key.verify(&hash, &signature).is_ok())
952        } else {
953            Ok(false)
954        }
955    }
956
957    fn sig_type(&self) -> &'static str {
958        "typedData"
959    }
960}
961
962impl AccSignature for ReceiptSignature {
963    fn verify(&self, _message: &[u8]) -> Result<bool, crate::errors::Error> {
964        // Receipt signatures verify Merkle proofs from anchors
965        // The proof field contains the Merkle receipt that proves inclusion
966        // For now, we validate structure - full Merkle verification requires the anchor root
967
968        // Basic structural validation
969        if self.source_network.is_empty() {
970            return Ok(false);
971        }
972
973        // Receipt validation would require access to the anchor chain
974        // to verify the Merkle root. For SDK purposes, we trust well-formed receipts.
975        // Full validation happens on the validator nodes.
976        Ok(true)
977    }
978
979    fn sig_type(&self) -> &'static str {
980        "receipt"
981    }
982}
983
984impl AccSignature for PartitionSignature {
985    fn verify(&self, _message: &[u8]) -> Result<bool, crate::errors::Error> {
986        // Partition signatures are used for cross-partition communication
987        // They are produced by validators and verify routing between partitions
988
989        // Basic structural validation
990        if self.source_network.is_empty() || self.destination_network.is_empty() {
991            return Ok(false);
992        }
993
994        // Partition signatures are trusted when coming from validators
995        // Full validation requires access to validator sets
996        Ok(true)
997    }
998
999    fn sig_type(&self) -> &'static str {
1000        "partition"
1001    }
1002}
1003
1004impl AccSignature for SignatureSet {
1005    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
1006        // SignatureSet is a multi-signature container
1007        // All inner signatures must verify for the set to be valid
1008
1009        if self.signatures.is_empty() {
1010            return Ok(false);
1011        }
1012
1013        // Verify each signature in the set
1014        for sig in &self.signatures {
1015            let result = match sig.as_ref() {
1016                Signature::LegacyED25519(s) => s.verify(message),
1017                Signature::RCD1(s) => s.verify(message),
1018                Signature::ED25519(s) => s.verify(message),
1019                Signature::BTC(s) => s.verify(message),
1020                Signature::BTCLegacy(s) => s.verify(message),
1021                Signature::ETH(s) => s.verify(message),
1022                Signature::RsaSha256(s) => s.verify(message),
1023                Signature::EcdsaSha256(s) => s.verify(message),
1024                Signature::TypedData(s) => s.verify(message),
1025                Signature::Receipt(s) => s.verify(message),
1026                Signature::Partition(s) => s.verify(message),
1027                Signature::Set(s) => s.verify(message),
1028                Signature::Remote(s) => s.verify(message),
1029                Signature::Delegated(s) => s.verify(message),
1030                Signature::Internal(s) => s.verify(message),
1031                Signature::Authority(s) => s.verify(message),
1032            };
1033
1034            match result {
1035                Ok(true) => continue,
1036                Ok(false) => return Ok(false),
1037                Err(e) => return Err(e),
1038            }
1039        }
1040
1041        Ok(true)
1042    }
1043
1044    fn sig_type(&self) -> &'static str {
1045        "signatureSet"
1046    }
1047}
1048
1049impl AccSignature for RemoteSignature {
1050    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
1051        // RemoteSignature wraps another signature for cross-partition routing
1052        // Delegate verification to the inner signature
1053
1054        if self.destination.is_empty() {
1055            return Ok(false);
1056        }
1057
1058        // Verify the wrapped signature
1059        match self.signature.as_ref() {
1060            Signature::LegacyED25519(s) => s.verify(message),
1061            Signature::RCD1(s) => s.verify(message),
1062            Signature::ED25519(s) => s.verify(message),
1063            Signature::BTC(s) => s.verify(message),
1064            Signature::BTCLegacy(s) => s.verify(message),
1065            Signature::ETH(s) => s.verify(message),
1066            Signature::RsaSha256(s) => s.verify(message),
1067            Signature::EcdsaSha256(s) => s.verify(message),
1068            Signature::TypedData(s) => s.verify(message),
1069            Signature::Receipt(s) => s.verify(message),
1070            Signature::Partition(s) => s.verify(message),
1071            Signature::Set(s) => s.verify(message),
1072            Signature::Remote(s) => s.verify(message),
1073            Signature::Delegated(s) => s.verify(message),
1074            Signature::Internal(s) => s.verify(message),
1075            Signature::Authority(s) => s.verify(message),
1076        }
1077    }
1078
1079    fn sig_type(&self) -> &'static str {
1080        "remote"
1081    }
1082}
1083
1084impl AccSignature for DelegatedSignature {
1085    fn verify(&self, message: &[u8]) -> Result<bool, crate::errors::Error> {
1086        // DelegatedSignature wraps a signature from a delegated authority
1087        // Delegate verification to the inner signature
1088
1089        if self.delegator.is_empty() {
1090            return Ok(false);
1091        }
1092
1093        // Verify the wrapped signature
1094        match self.signature.as_ref() {
1095            Signature::LegacyED25519(s) => s.verify(message),
1096            Signature::RCD1(s) => s.verify(message),
1097            Signature::ED25519(s) => s.verify(message),
1098            Signature::BTC(s) => s.verify(message),
1099            Signature::BTCLegacy(s) => s.verify(message),
1100            Signature::ETH(s) => s.verify(message),
1101            Signature::RsaSha256(s) => s.verify(message),
1102            Signature::EcdsaSha256(s) => s.verify(message),
1103            Signature::TypedData(s) => s.verify(message),
1104            Signature::Receipt(s) => s.verify(message),
1105            Signature::Partition(s) => s.verify(message),
1106            Signature::Set(s) => s.verify(message),
1107            Signature::Remote(s) => s.verify(message),
1108            Signature::Delegated(s) => s.verify(message),
1109            Signature::Internal(s) => s.verify(message),
1110            Signature::Authority(s) => s.verify(message),
1111        }
1112    }
1113
1114    fn sig_type(&self) -> &'static str {
1115        "delegated"
1116    }
1117}
1118
1119impl AccSignature for InternalSignature {
1120    fn verify(&self, _message: &[u8]) -> Result<bool, crate::errors::Error> {
1121        // InternalSignature is used for system-generated transactions
1122        // It contains cause and transaction hash references
1123
1124        // Internal signatures are valid if they have proper hash references
1125        // They are generated by the system, not user signatures
1126        let zero_hash = [0u8; 32];
1127        if self.cause == zero_hash || self.transaction_hash == zero_hash {
1128            return Ok(false);
1129        }
1130
1131        // Internal signatures are trusted - they come from the validator
1132        Ok(true)
1133    }
1134
1135    fn sig_type(&self) -> &'static str {
1136        "internal"
1137    }
1138}
1139
1140impl AccSignature for AuthoritySignature {
1141    fn verify(&self, _message: &[u8]) -> Result<bool, crate::errors::Error> {
1142        // AuthoritySignature represents approval from an authority (key book/key page)
1143        // It's a structural signature that tracks authority approval chains
1144
1145        // Basic structural validation
1146        if self.origin.is_empty() || self.authority.is_empty() {
1147            return Ok(false);
1148        }
1149
1150        if self.tx_i_d.is_empty() || self.cause.is_empty() {
1151            return Ok(false);
1152        }
1153
1154        // Authority signatures are valid if they have proper structure
1155        // The actual authorization check is done by the validator
1156        Ok(true)
1157    }
1158
1159    fn sig_type(&self) -> &'static str {
1160        "authority"
1161    }
1162}
accumulate_client/generated/signatures.rs

accumulate_client/generated/
signatures.rs
