Struct ChainActions

pub struct ChainActions<Db>
where
    Db: Clone + Debug,
{ /* private fields */ }

Contains all actions that a node can execute on-chain.

Implementations

impl<Db> ChainActions<Db>

where Db: Clone + Debug,

pub fn new(me: &ChainKeypair, db: Db, tx_sender: ActionSender) -> Self

Creates new instance.

pub fn self_address(&self) -> Address

On-chain address of this node

Trait Implementations

impl<Db> ChannelActions for ChainActions<Db>

where Db: HoprDbAllOperations + Clone + Send + Sync + Debug + 'static,

fn open_channel<'life0, 'async_trait>( &'life0 self, destination: Address, amount: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Opens a channel to the given destination with the given amount staked.

fn fund_channel<'life0, 'async_trait>( &'life0 self, channel_id: Hash, amount: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Funds the given channel with the given amount

fn close_channel<'life0, 'async_trait>( &'life0 self, counterparty: Address, direction: ChannelDirection, redeem_before_close: bool, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Closes the channel to counterparty in the given direction. Optionally can issue redeeming of all tickets in that channel, in case the direction is [ChannelDirection::Incoming].

impl<Db> Clone for ChainActions<Db>

where Db: Clone + Debug + Clone,

fn clone(&self) -> ChainActions<Db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Db> Debug for ChainActions<Db>

where Db: Clone + Debug + Debug,

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

Formats the value using the given formatter.

impl<Db> NodeActions for ChainActions<Db>

where Db: HoprDbAccountOperations + Clone + Send + Sync + Debug,

fn withdraw<'life0, 'async_trait>( &'life0 self, recipient: Address, amount: HoprBalance, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Withdraws the specified amount of tokens to the given recipient.

fn withdraw_native<'life0, 'async_trait>( &'life0 self, recipient: Address, amount: XDaiBalance, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Withdraws the specified amount of native coins to the given recipient.

fn announce<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, multiaddrs: &'life1 [Multiaddr], offchain_key: &'life2 OffchainKeypair, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Announces node on-chain with key binding. The operation should also check if such an announcement has not been already made on-chain.

fn register_safe_by_node<'life0, 'async_trait>( &'life0 self, safe_address: Address, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Registers the safe address with the node

impl<Db> TicketRedeemActions for ChainActions<Db>

where Db: HoprDbChannelOperations + HoprDbTicketOperations + HoprDbInfoOperations + Clone + Send + Sync + Debug,

fn redeem_all_tickets<'life0, 'async_trait>( &'life0 self, only_aggregated: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingAction>>> + Send + 'async_trait>>

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

Redeems all redeemable tickets in all channels.

fn redeem_tickets_with_counterparty<'life0, 'life1, 'async_trait>( &'life0 self, counterparty: &'life1 Address, only_aggregated: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingAction>>> + Send + 'async_trait>>

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

Redeems all redeemable tickets in the incoming channel from the given counterparty.

fn redeem_tickets_in_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel: &'life1 ChannelEntry, only_aggregated: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingAction>>> + Send + 'async_trait>>

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

Redeems all redeemable tickets in the given channel.

fn redeem_tickets<'life0, 'async_trait>( &'life0 self, selector: TicketSelector, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingAction>>> + Send + 'async_trait>>

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

Redeems all tickets based on the given [TicketSelector].

fn redeem_ticket<'life0, 'async_trait>( &'life0 self, ack_ticket: AcknowledgedTicket, ) -> Pin<Box<dyn Future<Output = Result<PendingAction>> + Send + 'async_trait>>

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

Tries to redeem the given ticket. If the ticket is not redeemable, returns an error. Otherwise, the transaction hash of the on-chain redemption is returned.