Struct sc_consensus_babe::BabeParams

source ·

pub struct BabeParams<B: BlockT, C, SC, E, I, SO, L, CIDP, BS, CAW> {Show 15 fields
    pub keystore: SyncCryptoStorePtr,
    pub client: Arc<C>,
    pub select_chain: SC,
    pub env: E,
    pub block_import: I,
    pub sync_oracle: SO,
    pub justification_sync_link: L,
    pub create_inherent_data_providers: CIDP,
    pub force_authoring: bool,
    pub backoff_authoring_blocks: Option<BS>,
    pub babe_link: BabeLink<B>,
    pub can_author_with: CAW,
    pub block_proposal_slot_portion: SlotProportion,
    pub max_block_proposal_slot_portion: Option<SlotProportion>,
    pub telemetry: Option<TelemetryHandle>,
}

Expand description

Parameters for BABE.

Fields§

§keystore: SyncCryptoStorePtr

The keystore that manages the keys of the node.

§client: Arc<C>

The client to use

§select_chain: SC

The SelectChain Strategy

§env: E

The environment we are producing blocks for.

§block_import: I

The underlying block-import object to supply our produced blocks to. This must be a BabeBlockImport or a wrapper of it, otherwise critical consensus logic will be omitted.

§sync_oracle: SO

A sync oracle

§justification_sync_link: L

Hook into the sync module to control the justification sync process.

§create_inherent_data_providers: CIDP

Something that can create the inherent data providers.

§force_authoring: bool

Force authoring of blocks even if we are offline

§backoff_authoring_blocks: Option<BS>

Strategy and parameters for backing off block production.

§babe_link: BabeLink

The source of timestamps for relative slots

§can_author_with: CAW

Checks if the current native implementation can author with a runtime at a given block.

§block_proposal_slot_portion: SlotProportion

The proportion of the slot dedicated to proposing.

The block proposing will be limited to this proportion of the slot from the starting of the slot. However, the proposing can still take longer when there is some lenience factor applied, because there were no blocks produced for some slots.

§max_block_proposal_slot_portion: Option<SlotProportion>

The maximum proportion of the slot dedicated to proposing with any lenience factor applied due to no blocks being produced.

§telemetry: Option<TelemetryHandle>

Handle use to report telemetries.

Auto Trait Implementations§

§

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> !RefUnwindSafe for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>

§

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Send for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where
 BS: Send,
 C: Send + Sync,
 CAW: Send,
 CIDP: Send,
 E: Send,
 I: Send,
 L: Send,
 SC: Send,
 SO: Send,

§

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Sync for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where
 BS: Sync,
 C: Send + Sync,
 CAW: Sync,
 CIDP: Sync,
 E: Sync,
 I: Sync,
 L: Sync,
 SC: Sync,
 SO: Sync,

§

Struct sc_consensus_babe::BabeParams

Fields§

Auto Trait Implementations§

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> !RefUnwindSafe for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Send for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where BS: Send, C: Send + Sync, CAW: Send, CIDP: Send, E: Send, I: Send, L: Send, SC: Send, SO: Send,

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Sync for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where BS: Sync, C: Send + Sync, CAW: Sync, CIDP: Sync, E: Sync, I: Sync, L: Sync, SC: Sync, SO: Sync,

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Unpin for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where BS: Unpin, CAW: Unpin, CIDP: Unpin, E: Unpin, I: Unpin, L: Unpin, SC: Unpin, SO: Unpin,

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> !UnwindSafe for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T>where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, Outer> IsWrappedBy<Outer> for Twhere Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

fn from_mut(outer: &mut Outer) -> &mut T

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same<T> for T

type Output = T

impl<T> SaturatedConversion for T

fn saturated_from<T>(t: T) -> Selfwhere Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> Twhere Self: UniqueSaturatedInto<T>,

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Send for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where
BS: Send,
C: Send + Sync,
CAW: Send,
CIDP: Send,
E: Send,
I: Send,
L: Send,
SC: Send,
SO: Send,

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Sync for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where
BS: Sync,
C: Send + Sync,
CAW: Sync,
CIDP: Sync,
E: Sync,
I: Sync,
L: Sync,
SC: Sync,
SO: Sync,

impl<B, C, SC, E, I, SO, L, CIDP, BS, CAW> Unpin for BabeParams<B, C, SC, E, I, SO, L, CIDP, BS, CAW>where
BS: Unpin,
CAW: Unpin,
CIDP: Unpin,
E: Unpin,
I: Unpin,
L: Unpin,
SC: Unpin,
SO: Unpin,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,

fn conv<T>(self) -> Twhere
Self: Into<T>,

impl<T> Downcast for Twhere
T: Any,

impl<T> DowncastSync for Twhere
T: Any + Send + Sync,

fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> Pipe for Twhere
T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> Rwhere
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn try_conv<T>(self) -> Result<T, Self::Error>where
Self: TryInto<T>,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,

impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,