gsigner 2.0.0

Universal cryptographic signer supporting secp256k1 (Ethereum), ed25519, and sr25519 (Substrate)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// Copyright (C) Gear Technologies Inc.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

//! Secp256k1-specific signer extensions.

use super::{
    Address, ContractSignature, Digest, PrivateKey, PublicKey, Secp256k1, Signature, SignedData,
    SignedMessage,
};
use crate::{
    Signer,
    error::{Result, SignerError},
};

/// Extension trait for Secp256k1 signers.
pub trait Secp256k1SignerExt {
    /// Get private key, optionally decrypting with password.
    fn get_private_key(&self, public_key: PublicKey, password: Option<&str>) -> Result<PrivateKey>;

    /// Create a recoverable ECDSA signature.
    fn sign_recoverable(
        &self,
        public_key: PublicKey,
        data: &[u8],
        password: Option<&str>,
    ) -> Result<Signature>;

    /// Create a recoverable ECDSA signature from a precomputed digest.
    fn sign_digest(
        &self,
        public_key: PublicKey,
        digest: Digest,
        password: Option<&str>,
    ) -> Result<Signature>;

    /// Create signed data (signature + data).
    fn signed_data<T>(
        &self,
        public_key: PublicKey,
        data: T,
        password: Option<&str>,
    ) -> Result<SignedData<T>>
    where
        T: super::ToDigest;

    /// Create a signed EIP-191 message with recovered address.
    fn signed_message<T>(
        &self,
        public_key: PublicKey,
        data: T,
        password: Option<&str>,
    ) -> Result<SignedMessage<T>>
    where
        for<'a> Digest: From<&'a T>;

    /// Create a contract-specific signature (EIP-191).
    fn sign_for_contract(
        &self,
        contract_address: Address,
        public_key: PublicKey,
        data: &[u8],
        password: Option<&str>,
    ) -> Result<ContractSignature>;

    /// Create a contract-specific signature from a precomputed digest.
    fn sign_for_contract_digest(
        &self,
        contract_address: Address,
        public_key: PublicKey,
        digest: Digest,
        password: Option<&str>,
    ) -> Result<ContractSignature>;
}

impl Secp256k1SignerExt for Signer<Secp256k1> {
    fn get_private_key(&self, public_key: PublicKey, password: Option<&str>) -> Result<PrivateKey> {
        match password {
            Some(pwd) => self.private_key_encrypted(public_key, pwd),
            None => self.private_key(public_key),
        }
    }

    fn sign_recoverable(
        &self,
        public_key: PublicKey,
        data: &[u8],
        password: Option<&str>,
    ) -> Result<Signature> {
        let private_key = self.get_private_key(public_key, password)?;
        Signature::create(&private_key, data)
            .map_err(|e| SignerError::Crypto(format!("Signature creation failed: {e}")))
    }

    fn sign_digest(
        &self,
        public_key: PublicKey,
        digest: Digest,
        password: Option<&str>,
    ) -> Result<Signature> {
        let private_key = self.get_private_key(public_key, password)?;
        Signature::create_from_digest(&private_key, digest)
            .map_err(|e| SignerError::Crypto(format!("Signature creation failed: {e}")))
    }

    fn signed_data<T>(
        &self,
        public_key: PublicKey,
        data: T,
        password: Option<&str>,
    ) -> Result<SignedData<T>>
    where
        T: super::ToDigest,
    {
        let private_key = self.get_private_key(public_key, password)?;
        SignedData::create(&private_key, data)
            .map_err(|e| SignerError::Crypto(format!("SignedData creation failed: {e}")))
    }

    fn signed_message<T>(
        &self,
        public_key: PublicKey,
        data: T,
        password: Option<&str>,
    ) -> Result<SignedMessage<T>>
    where
        for<'a> Digest: From<&'a T>,
    {
        let private_key = self.get_private_key(public_key, password)?;
        SignedMessage::create(private_key, data)
            .map_err(|e| SignerError::Crypto(format!("SignedMessage creation failed: {e}")))
    }

    fn sign_for_contract(
        &self,
        contract_address: Address,
        public_key: PublicKey,
        data: &[u8],
        password: Option<&str>,
    ) -> Result<ContractSignature> {
        let private_key = self.get_private_key(public_key, password)?;
        ContractSignature::create(contract_address, &private_key, data)
            .map_err(|e| SignerError::Crypto(format!("Contract signature creation failed: {e}")))
    }

    fn sign_for_contract_digest(
        &self,
        contract_address: Address,
        public_key: PublicKey,
        digest: Digest,
        password: Option<&str>,
    ) -> Result<ContractSignature> {
        let private_key = self.get_private_key(public_key, password)?;
        ContractSignature::create_from_digest(contract_address, &private_key, digest)
            .map_err(|e| SignerError::Crypto(format!("Contract signature creation failed: {e}")))
    }
}