Getting started

use std::sync::Arc;
use eyre::Result;
use rrelayer::{
    AdminRelayerClient, AdminRelayerClientConfig, AdminRelayerClientAuth,
    RelayerSigner, TransactionSpeed, RelayerId
};
use dotenvy::dotenv;
use std::env;
 
pub async fn create_relayer_signer() -> Result<RelayerSigner> {
    dotenv().ok();
 
    let username = env::var("RRELAYER_AUTH_USERNAME")
        .expect("RRELAYER_AUTH_USERNAME must be set");
 
    let password = env::var("RRELAYER_AUTH_PASSWORD")
        .expect("RRELAYER_AUTH_PASSWORD must be set");
 
    let config = AdminRelayerClientConfig {
        server_url: "http://localhost:8000".to_string(),
        provider_url: "https://eth.llamarpc.com".to_string(),
        relayer_id: RelayerId::from_str("94afb207-bb47-4392-9229-ba87e4d783cb")?,
        auth: CreateClientAuth {
            username,
            password,
        },
        // This is optional it defaults to fast and is a fallback
        // You can override this with the transaction request
        speed: Some(TransactionSpeed::FAST),
    };
 
    let client = Arc::new(AdminRelayerClient::new(config));
 
    // Auto-fetch address from relayer
    let signer = RelayerSigner::from_admin_client_auto_address(
        client,
        Some(1), // mainnet chain ID
    ).await?;
 
    Ok(signer)
}

use alloy::{
    primitives::{Address, U256},
    providers::{ProviderBuilder, Provider},
    rpc::types::TransactionRequest,
    network::TransactionBuilder,
};
use rrelayer::with_relayer;
use std::str::FromStr;
use eyre::Result;
 
#[tokio::main]
async fn main() -> Result<()> {
    let signer = create_relayer_signer().await?;
 
    // Create HTTP provider for reading blockchain state
    let rpc_url = "https://eth.llamarpc.com".parse()?;
    let http_provider = ProviderBuilder::new().on_http(rpc_url);
 
    // Wrap provider with relayer functionality for transactions
    let relayer_provider = with_relayer(http_provider, signer.clone());
 
    // Build transaction using standard Alloy patterns
    let to = Address::from_str("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")?;
    let value = U256::from(1000000000000000000u64); // 1 ETH
 
    // Get current gas price from the network
    let gas_price = relayer_provider.inner().get_gas_price().await?;
 
    // Get nonce for the signer
    let nonce = relayer_provider.inner()
        .get_transaction_count(signer.address())
        .await?;
 
    // Build complete transaction request
    let tx_request = TransactionRequest::default()
        .with_from(signer.address())
        .with_to(to)
        .with_value(value)
        .with_gas_limit(21000) // Standard ETH transfer
        .with_gas_price(gas_price)
        .with_nonce(nonce);
 
    println!("📋 Transaction Details:");
    println!("   From: {}", signer.address());
    println!("   To: {}", to);
    println!("   Value: {} ETH", value / U256::from(10u64.pow(18)));
    println!("   Gas Limit: {:?}", tx_request.gas_limit);
    println!("   Gas Price: {} gwei", gas_price / U256::from(1_000_000_000u64));
    println!("   Nonce: {}", nonce);
 
    // Send transaction via relayer using standard Alloy TransactionRequest
    let tx_id = relayer_provider
        .send_transaction(&tx_request)
        .await?;
 
    println!("✅ Transaction sent via relayer!");
    println!("   Transaction ID: {}", tx_id);
 
    Ok(())
}

use alloy::{
    primitives::{Address, U256},
    providers::{ProviderBuilder, Provider},
    sol,
};
use rrelayer::with_relayer;
use std::str::FromStr;
use eyre::Result;
 
// Define contract ABI using Alloy's sol! macro
sol!(
    #[allow(missing_docs)]
    #[sol(rpc)]
    ERC20,
    "abi/ERC20.json"
);
 
#[tokio::main]
async fn main() -> Result<()> {
    let signer = create_relayer_signer().await?;
    let rpc_url = "https://eth.llamarpc.com".parse()?;
    let provider = ProviderBuilder::new().on_http(rpc_url);
 
    // Wrap provider with relayer
    let relayer_provider = with_relayer(provider, signer.clone());
 
    let contract_address = Address::from_str("0xA0b86a33E6417Efc5a1b1C0e9F6f12C1C9E5e5dA")?;
    let contract = ERC20::new(contract_address, &relayer_provider);
 
    let recipient = Address::from_str("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")?;
    let amount = U256::from(1000000000000000000u64); // 1 token
 
    // Note: Full contract integration requires implementing the Provider trait
    // For now, you can build the transaction manually and use send_transaction()
 
    // Build transaction manually for now
    let call = contract.transfer(recipient, amount);
    let tx_request = call.into_transaction_request();
 
    // Send via relayer
    let tx_id = relayer_provider.send_transaction(&tx_request).await?;
 
    println!("✅ Contract transaction sent via relayer: {}", tx_id);
 
    Ok(())
}