nym-validator-client 1.21.4

Client for interacting with Nyx Cosmos SDK blockchain
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

// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0

use crate::signing::AccountData;
pub use cosmrs::crypto::secp256k1::Signature;
use cosmrs::tx::SignDoc;
use cosmrs::{tx, AccountId};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum SigningError {
    #[error("the requested signing type: {typ:?} is not supported by this signer.")]
    UnsupportedSigningType { typ: SignerType },

    #[error("account {account} was not found within this signer")]
    AccountNotFound { account: AccountId },

    #[error("failed to sign the requested message: {source}")]
    SigningFailure { source: eyre::Report },

    #[error("failed to construct the sign doc: {source}")]
    SignDocFailure { source: eyre::Report },
}

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum SignerType {
    Amino,
    Direct,
}

// TODO: check if this trait needs to be async
// (I guess it depends on future ledger requirements)
pub trait OfflineSigner {
    type Error: From<SigningError>;

    fn signer_addresses(&self) -> Vec<AccountId> {
        self.get_accounts()
            .iter()
            .map(|account| account.address.clone())
            .collect()
    }

    fn get_accounts(&self) -> &[AccountData];

    fn find_account(&self, signer_address: &AccountId) -> Result<&AccountData, Self::Error> {
        self.get_accounts()
            .iter()
            .find(|account| &account.address == signer_address)
            .ok_or_else(|| {
                SigningError::AccountNotFound {
                    account: signer_address.clone(),
                }
                .into()
            })
    }

    fn sign_raw_with_account<M: AsRef<[u8]>>(
        &self,
        signer: &AccountData,
        message: M,
    ) -> Result<Signature, Self::Error> {
        signer
            .private_key
            .sign(message.as_ref())
            .map_err(|source| SigningError::SigningFailure { source }.into())
    }

    fn sign_raw<M: AsRef<[u8]>>(
        &self,
        signer_address: &AccountId,
        message: M,
    ) -> Result<Signature, Self::Error> {
        let signer = self.find_account(signer_address)?;
        self.sign_raw_with_account(signer, message)
    }

    fn sign_direct(
        &self,
        signer_address: &AccountId,
        sign_doc: SignDoc,
    ) -> Result<tx::Raw, Self::Error> {
        let signer = self.find_account(signer_address)?;
        self.sign_direct_with_account(signer, sign_doc)
    }

    // unless explicitly defined, each signing method is unsupported
    fn sign_direct_with_account(
        &self,
        _signer: &AccountData,
        _sign_doc: SignDoc,
    ) -> Result<tx::Raw, Self::Error> {
        Err(SigningError::UnsupportedSigningType {
            typ: SignerType::Direct,
        }
        .into())
    }

    // fn sign_amino(&self, signer_address: &AccountId, sign_doc: AminoSignDoc) -> Result<tx::Raw, Self::Error>;

    // fn sign_amino_with_account(&self, signer: &AccountData, sign_doc: AminoSignDoc) -> Result<tx::Raw, Self::Error>;
}

#[derive(Debug, Default, Copy, Clone)]
pub struct NoSigner;

// #[derive(Debug, Copy, Clone, Error)]
// #[error("no signer is available")]
// struct SignerUnavailable;
//
// // trait bound requirements
// impl From<SigningError> for SignerUnavailable {
//     fn from(_: SigningError) -> Self {
//         SignerUnavailable
//     }
// }
//
// impl OfflineSigner for NoSigner {
//     type Error = SignerUnavailable;
//
//     fn get_accounts(&self) -> &[AccountData] {
//         return Err(SignerUnavailable);
//     }
// }