kona-sources 0.1.2

Data source types and utilities for the kona-node
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

//! Signer utilities for the Kona node.
//!
//! We currently support two types of block signers:
//!
//! 1. A local block signer that is used to sign blocks with a locally available private key.
//! 2. A remote block signer that is used to sign blocks with a remote private key.

use alloy_primitives::{Address, ChainId};
use alloy_signer::{Signature, SignerSync};
use derive_more::From;
use op_alloy_rpc_types_engine::PayloadHash;
use std::fmt::Debug;

mod remote;
pub use remote::{
    CertificateError, ClientCert, RemoteSigner, RemoteSignerError, RemoteSignerHandler,
    RemoteSignerStartError,
};

/// A builder for a block signer.
#[derive(Debug, Clone, From)]
pub enum BlockSigner {
    /// A local block signer that is used to sign blocks with a locally available private key.
    Local(#[from] alloy_signer_local::PrivateKeySigner),
    /// A remote block signer that is used to sign blocks with a remote private key.
    Remote(#[from] RemoteSigner),
}

/// A handler for a block signer.
#[derive(Debug)]
pub enum BlockSignerHandler {
    /// A local block signer that is used to sign blocks with a locally available private key.
    Local(alloy_signer_local::PrivateKeySigner),
    /// A remote block signer that is used to sign blocks with a remote private key.
    Remote(RemoteSignerHandler),
}

/// Errors that can occur when starting a block signer.
#[derive(Debug, thiserror::Error)]
pub enum BlockSignerStartError {
    /// An error that can occur when signing a block with a local signer.
    #[error(transparent)]
    Local(#[from] alloy_signer::Error),
    /// An error that can occur when signing a block with a remote signer.
    #[error(transparent)]
    Remote(#[from] RemoteSignerStartError),
}

/// Errors that can occur when signing a block.
#[derive(Debug, thiserror::Error)]
pub enum BlockSignerError {
    /// An error that can occur when signing a block with a local signer.
    #[error(transparent)]
    Local(#[from] alloy_signer::Error),
    /// An error that can occur when signing a block with a remote signer.
    #[error(transparent)]
    Remote(#[from] RemoteSignerError),
}

impl BlockSigner {
    /// Starts a block signer.
    pub async fn start(self) -> Result<BlockSignerHandler, BlockSignerStartError> {
        match self {
            Self::Local(signer) => Ok(BlockSignerHandler::Local(signer)),
            Self::Remote(signer) => Ok(BlockSignerHandler::Remote(signer.start().await?)),
        }
    }
}

impl BlockSignerHandler {
    /// Signs a payload with the signer.
    pub async fn sign_block(
        &self,
        payload_hash: PayloadHash,
        chain_id: ChainId,
        sender_address: Address,
    ) -> Result<Signature, BlockSignerError> {
        let signature = match self {
            Self::Local(signer) => {
                signer.sign_hash_sync(&payload_hash.signature_message(chain_id))?
            }
            Self::Remote(signer) => {
                signer.sign_block_v1(payload_hash, chain_id, sender_address).await?
            }
        };

        Ok(signature)
    }
}