Struct serai_processor::networks::ethereum::Ethereum

pub struct Ethereum<D: Db> { /* private fields */ }

Implementations

impl<D: Db> Ethereum<D>

pub async fn new(db: D, daemon_url: String, relayer_url: String) -> Self

pub async fn router(&self) -> RwLockReadGuard<'_, Option<Router>>

Trait Implementations

impl<D: Db> Block<Ethereum<D>> for Epoch

type Id = [u8; 32]

fn id(&self) -> [u8; 32]

fn parent(&self) -> [u8; 32]

fn time<'life0, 'life1, 'async_trait>( &'life0 self, _: &'life1 Ethereum<D>, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>

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

The monotonic network time at this block.

impl<D: Clone + Db> Clone for Ethereum<D>

fn clone(&self) -> Ethereum<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Db> Debug for Ethereum<D>

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

Formats the value using the given formatter.

impl<D: Db> Network for Ethereum<D>

type Curve = Secp256k1

The elliptic curve used for this network.

type Transaction = Transaction

The type representing the transaction for this network.

type Block = Epoch

The type representing the block for this network.

type Output = InInstruction

The type containing all information on a scanned output.

type SignableTransaction = RouterCommand

The type containing all information on a planned transaction, waiting to be signed.

type Eventuality = Eventuality

The type containing all information to check if a plan was completed.

type TransactionMachine = RouterCommandMachine

The FROST machine to sign a transaction.

type Scheduler = Scheduler<Ethereum<D>>

The scheduler for this network.

type Address = Address

The type representing an address.

const NETWORK: ExternalNetworkId = ExternalNetworkId::Ethereum

Network ID for this network.

const ID: &'static str = "Ethereum"

String ID for this network.

const ESTIMATED_BLOCK_TIME_IN_SECONDS: usize = 384usize

The estimated amount of time a block will take.

const CONFIRMATIONS: usize = 1usize

The amount of confirmations required to consider a block ‘final’.

const DUST: u64 = 0u64

Minimum output value which will be handled.

const COST_TO_AGGREGATE: u64 = 0u64

The cost to perform input aggregation with a 2-input 1-output TX.

const MAX_OUTPUTS: usize = 256usize

The maximum amount of outputs which will fit in a TX. This should be equal to MAX_INPUTS unless one is specifically limited. A TX with MAX_INPUTS and MAX_OUTPUTS must not exceed the max size.

fn tweak_keys(keys: &mut ThresholdKeys<Self::Curve>)

Tweak keys for this network.

fn branch_address(_key: <Secp256k1 as Ciphersuite>::G) -> Option<Address>

Address for the given group key to use for scheduled branches.

fn change_address(_key: <Secp256k1 as Ciphersuite>::G) -> Option<Address>

Address for the given group key to use for change.

fn forward_address(_key: <Secp256k1 as Ciphersuite>::G) -> Option<Address>

Address for forwarded outputs from prior multisigs.

fn get_latest_block_number<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, NetworkError>> + Send + 'async_trait>>

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

Get the latest block’s number.

fn get_block<'life0, 'async_trait>( &'life0 self, number: usize, ) -> Pin<Box<dyn Future<Output = Result<Self::Block, NetworkError>> + Send + 'async_trait>>

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

Get a block by its number.

fn get_outputs<'life0, 'life1, 'async_trait>( &'life0 self, block: &'life1 Self::Block, __arg2: <Secp256k1 as Ciphersuite>::G, ) -> Pin<Box<dyn Future<Output = Vec<Self::Output>> + Send + 'async_trait>>

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

Get the outputs within a block for a specific key.

fn get_eventuality_completions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, eventualities: &'life1 mut EventualitiesTracker<Self::Eventuality>, block: &'life2 Self::Block, ) -> Pin<Box<dyn Future<Output = HashMap<[u8; 32], (usize, <Self::Transaction as TransactionTrait<Self>>::Id, <Self::Eventuality as EventualityTrait>::Completion)>> + Send + 'async_trait>>

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

Get the registered eventualities completed within this block, and any prior blocks which registered eventualities may have been completed in.

fn needed_fee<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _block_number: usize, inputs: &'life1 [Self::Output], _payments: &'life2 [Payment<Self>], _change: &'life3 Option<Self::Address>, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, NetworkError>> + Send + 'async_trait>>

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

Returns the needed fee to fulfill this Plan at this fee rate.

fn signable_transaction<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, _block_number: usize, _plan_id: &'life1 [u8; 32], key: <Self::Curve as Ciphersuite>::G, inputs: &'life2 [Self::Output], payments: &'life3 [Payment<Self>], change: &'life4 Option<Self::Address>, scheduler_addendum: &'life5 <Self::Scheduler as SchedulerTrait<Self>>::Addendum, ) -> Pin<Box<dyn Future<Output = Result<Option<(Self::SignableTransaction, Self::Eventuality)>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Create a SignableTransaction for the given Plan.

fn attempt_sign<'life0, 'async_trait>( &'life0 self, keys: ThresholdKeys<Self::Curve>, transaction: Self::SignableTransaction, ) -> Pin<Box<dyn Future<Output = Result<Self::TransactionMachine, NetworkError>> + Send + 'async_trait>>

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

Attempt to sign a SignableTransaction.

fn publish_completion<'life0, 'life1, 'async_trait>( &'life0 self, completion: &'life1 <Self::Eventuality as EventualityTrait>::Completion, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

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

Publish a completion.

fn confirm_completion<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, eventuality: &'life1 Self::Eventuality, claim: &'life2 <Self::Eventuality as EventualityTrait>::Claim, ) -> Pin<Box<dyn Future<Output = Result<Option<<Self::Eventuality as EventualityTrait>::Completion>, NetworkError>> + Send + 'async_trait>>

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

Confirm a plan was completed by the specified transaction, per our bounds.

fn get_latest_block_number_with_retries<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = usize> + Send + 'async_trait>>

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

Get the latest block’s number, retrying until success.

fn get_block_with_retries<'life0, 'async_trait>( &'life0 self, block_number: usize, ) -> Pin<Box<dyn Future<Output = Self::Block> + Send + 'async_trait>>

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

Get a block, retrying until success.

fn prepare_send<'life0, 'async_trait>( &'life0 self, block_number: usize, plan: Plan<Self>, operating_costs: u64, ) -> Pin<Box<dyn Future<Output = Result<PreparedSend<Self>, NetworkError>> + Send + 'async_trait>>

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

Prepare a SignableTransaction for a transaction.

impl<D: Db> Output<Ethereum<D>> for InInstruction

type Id = [u8; 32]

fn kind(&self) -> OutputType

fn id(&self) -> Self::Id

fn tx_id(&self) -> [u8; 32]

fn key(&self) -> <Secp256k1 as Ciphersuite>::G

fn presumed_origin(&self) -> Option<Address>

fn balance(&self) -> ExternalBalance

fn data(&self) -> &[u8]

fn write<W: Write>(&self, writer: &mut W) -> Result<()>

fn read<R: Read>(reader: &mut R) -> Result<Self>

impl<D: Db> PartialEq for Ethereum<D>

fn eq(&self, _other: &Ethereum<D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: Db> Transaction<Ethereum<D>> for Transaction

type Id = [u8; 32]

fn id(&self) -> Self::Id