Struct thor::FragmentSender

pub struct FragmentSender<'a, S: SyncNode + Send> {
    block0_hash: Hash,
    fees: LinearFee,
    setup: FragmentSenderSetup<'a, S>,
    expiry_generator: BlockDateGenerator,
    witness_mode: WitnessMode,
}

Fields

block0_hash: Hash

fees: LinearFee

setup: FragmentSenderSetup<'a, S>

expiry_generator: BlockDateGenerator

witness_mode: WitnessMode

Implementations

impl<'a, S: SyncNode + Send> FragmentSender<'a, S>

pub fn try_from_with_setup( jormungandr: &JormungandrProcess, block: BlockDate, setup: FragmentSenderSetup<'a, S> ) -> Result<Self, RestError>

impl<'a, S: SyncNode + Send> FragmentSender<'a, S>

pub fn from_settings_with_setup( settings: &SettingsDto, setup: FragmentSenderSetup<'a, S> ) -> Self

impl<'a, S: SyncNode + Send> FragmentSender<'a, S>

pub fn from_settings( settings: &SettingsDto, generator: BlockDateGenerator, setup: FragmentSenderSetup<'a, S> ) -> Self

impl<'a, S: SyncNode + Send> FragmentSender<'a, S>

pub fn from_with_setup( block0_configuration: &Block0Configuration, setup: FragmentSenderSetup<'a, S> ) -> Self

pub fn new( block0_hash: Hash, fees: LinearFee, expiry_generator: BlockDateGenerator, setup: FragmentSenderSetup<'a, S> ) -> Self

pub fn block0_hash(&self) -> Hash

pub fn fees(&self) -> LinearFee

pub fn date(&self) -> BlockDate

pub fn witness_mode(self, witness_mode: WitnessMode) -> Self

pub fn set_valid_until(self, valid_until: BlockDate) -> Self

pub fn clone_with_setup<U: SyncNode + Send>( &self, setup: FragmentSenderSetup<'a, U> ) -> FragmentSender<'a, U>

pub fn send_batch_fragments<A: FragmentNode + SyncNode + Sized + Send>( &self, fragments: Vec<Fragment>, fail_fast: bool, node: &A ) -> Result<FragmentsProcessingSummary, FragmentSenderError>

pub fn send_batch_fragments_in_chunks<A: FragmentNode + SyncNode + Sized + Send>( &self, fragments: Vec<Fragment>, chunks_size: usize, fail_fast: bool, node: &A ) -> Result<FragmentsProcessingSummary, FragmentSenderError>

pub fn send_transaction<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &Wallet, via: &A, value: Value ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_transaction_to_address<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: Address, via: &A, value: Value ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_transaction_with_witness_mode<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: Address, via: &A, value: Value, witness_mode: WitnessMode ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_transaction_to_many<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &[Wallet], via: &A, value: Value ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_full_delegation<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &StakePool, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_split_delegation<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, distribution: &[(&StakePool, u8)], via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_owner_delegation<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &StakePool, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_pool_registration<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &StakePool, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_pool_update<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &StakePool, update_stake_pool: &StakePool, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_pool_retire<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, to: &StakePool, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_vote_plan<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_vote_cast_with_witness_mode<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, proposal_index: u8, choice: &Choice, via: &A, witness_mode: WitnessMode ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_vote_cast<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, proposal_index: u8, choice: &Choice, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_public_vote_tally<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_update_proposal<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, bft_secret: &SecretKey<Ed25519>, update_proposal: UpdateProposal, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_update_vote<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, bft_secret: &SecretKey<Ed25519>, update_vote: UpdateVote, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_private_vote_tally<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, inner: DecryptedPrivateTally, via: &A ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_vote_tally<A: FragmentNode + SyncNode + Sized + Send>( &self, from: &mut Wallet, vote_plan: &VotePlan, via: &A, tally_type: VoteTallyPayload ) -> Result<MemPoolCheck, FragmentSenderError>

pub fn send_transactions<A: FragmentNode + SyncNode + Sized + Send>( &self, n: u32, wallet1: &mut Wallet, wallet2: &Wallet, node: &A, value: Value ) -> Result<(), FragmentSenderError>

pub fn send_transactions_with_iteration_delay<A: FragmentNode + SyncNode + Sized + Send>( &self, n: u32, wallet1: &mut Wallet, wallet2: &mut Wallet, node: &A, value: Value, duration: Duration ) -> Result<(), FragmentSenderError>

pub fn send_transactions_round_trip<A: FragmentNode + SyncNode + Sized + Send>( &self, n: u32, wallet1: &mut Wallet, wallet2: &mut Wallet, node: &A, value: Value ) -> Result<(), FragmentSenderError>

pub fn verify<A: FragmentNode + SyncNode + Sized + Send>( &self, check: &MemPoolCheck, node: &A ) -> Result<(), FragmentSenderError>

fn dump_fragment_if_enabled( &self, sender: &Wallet, fragment: &Fragment, via: &dyn FragmentNode ) -> Result<(), FragmentSenderError>

fn dump_fragments_if_enabled( &self, fragments: &[Fragment], via: &dyn FragmentNode ) -> Result<(), FragmentSenderError>

pub fn send_fragment<A: FragmentNode + SyncNode + Sized + Send>( &self, sender: &mut Wallet, fragment: Fragment, node: &A ) -> Result<MemPoolCheck, FragmentSenderError>

fn confirm_transaction_if_enabled(&self, sender: &mut Wallet)

fn wait_for_node_sync_if_enabled<A: FragmentNode + SyncNode + Sized + Send>( &self, node: &A ) -> Result<(), SyncNodeError>

Trait Implementations

impl<'a, S: Clone + SyncNode + Send> Clone for FragmentSender<'a, S>

fn clone(&self) -> FragmentSender<'a, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> From<&Block0Configuration> for FragmentSender<'a, DummySyncNode>

fn from(block0: &Block0Configuration) -> Self

Converts to this type from the input type.

impl<'a> From<&SettingsDto> for FragmentSender<'a, DummySyncNode>

fn from(settings: &SettingsDto) -> Self

Converts to this type from the input type.

impl<'a> TryFrom<&JormungandrProcess> for FragmentSender<'a, DummySyncNode>

type Error = RestError

The type returned in the event of a conversion error.

fn try_from(jormungandr: &JormungandrProcess) -> Result<Self, Self::Error>

Performs the conversion.