Struct RelayerSigner 

pub struct RelayerSigner { /* private fields */ }

A signer that routes all signing through your relayer service.

This is a drop-in replacement for Alloy signers like PrivateKeySigner that works with existing Alloy code but routes all operations through your relayer infrastructure.

Examples

use alloy::signers::Signer;
use alloy::primitives::Address;
use alloy::dyn_abi::TypedData;
use rrelayer::{RelayerSigner, RelayerClient, RelayerClientConfig, RelayerClientAuth, RelayerId};
use std::{sync::Arc, str::FromStr};

// Create RelayerClient
let relayer_id = RelayerId::from_str("94afb207-bb47-4392-9229-ba87e4d783cb")?;
let config = RelayerClientConfig {
    server_url: "http://localhost:8000".to_string(),
    relayer_id: relayer_id.clone(),
    auth: RelayerClientAuth::ApiKey { api_key: "your-key".to_string() },
    fallback_speed: None,
};
let relayer_client = Arc::new(RelayerClient::new(config));
let address = Address::from_str("0x742d35cc6634c0532925a3b8d67e8000c942b1b5")?;

// Create from RelayerClient
let signer = RelayerSigner::from_relayer_client(
    relayer_client,
    address,
    Some(1), // mainnet
);

// Sign messages (routes through relayer.sign().text())
let signature = signer.sign_message(b"hello").await?;

Implementations

impl RelayerSigner

pub fn from_relayer_client( client: Arc<RelayerClient>, address: Address, chain_id: Option<ChainId>, ) -> Self

Create a RelayerSigner from a RelayerClient.

Arguments

• client - The RelayerClient to use for signing operations
• address - The Ethereum address this signer represents
• chain_id - Optional chain ID for EIP-155 replay protection

pub fn from_admin_client( client: Arc<AdminRelayerClient>, address: Address, chain_id: Option<ChainId>, ) -> Self

Create a RelayerSigner from an AdminRelayerClient.

Arguments

• client - The AdminRelayerClient to use for signing operations
• address - The Ethereum address this signer represents
• chain_id - Optional chain ID for EIP-155 replay protection

pub async fn from_relayer_client_auto_address( client: Arc<RelayerClient>, chain_id: Option<ChainId>, ) -> Result<Self, RelayerSignerError>

Convenience constructor that automatically fetches the address from the relayer.

Arguments

• client - The RelayerClient to use
• chain_id - Optional chain ID for EIP-155 replay protection

pub async fn from_admin_client_auto_address( client: Arc<AdminRelayerClient>, chain_id: Option<ChainId>, ) -> Result<Self, RelayerSignerError>

Convenience constructor that automatically fetches the address from the admin client.

Arguments

• client - The AdminRelayerClient to use
• chain_id - Optional chain ID for EIP-155 replay protection

pub fn relayer_id(&self) -> &RelayerId

Get the relayer ID associated with this signer.

pub fn client(&self) -> &RelayerClientType

Get access to the underlying client for advanced operations.

pub fn address(&self) -> &Address

Get address of relayer

Trait Implementations

impl Clone for RelayerSigner

fn clone(&self) -> RelayerSigner

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RelayerSigner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Signer for RelayerSigner

fn address(&self) -> Address

Get the signer’s Ethereum address.

fn chain_id(&self) -> Option<ChainId>

Get the chain ID for EIP-155 replay protection.

fn set_chain_id(&mut self, chain_id: Option<ChainId>)

Set the chain ID for EIP-155 replay protection.

fn sign_hash<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 B256, ) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sign a hash using the relayer service.

This routes the signing request through relayer.sign().text().

fn sign_dynamic_typed_data<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 TypedData, ) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sign dynamic typed data using the relayer service.

This routes the signing request through relayer.sign().typed_data().

fn sign_message<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Sig, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Signs the hash of the provided message after prefixing it, as specified in EIP-191.

fn sign_typed_data<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, payload: &'life1 T, domain: &'life2 Eip712Domain, ) -> Pin<Box<dyn Future<Output = Result<Sig, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sized + Sync + 'async_trait, T: 'async_trait + SolStruct + Send + Sync,

Encodes and signs the typed data according to EIP-712.

fn with_chain_id(self, chain_id: Option<u64>) -> Self

where Self: Sized,

Sets the signer’s chain ID and returns self.