Struct gekko::runtime::kusama::extrinsics::auctions::Bid

pub struct Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode,  {
    pub para: A,
    pub auction_index: B,
    pub first_slot: C,
    pub last_slot: D,
    pub amount: E,
}

Make a new bid from an account (including a parachain account) for deploying a new

Documentation (provided by the runtime metadata)

Make a new bid from an account (including a parachain account) for deploying a new parachain.

Multiple simultaneous bids from the same bidder are allowed only as long as all active bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.

• sub is the sub-bidder ID, allowing for multiple competing bids to be made by (and funded by) the same account.
• auction_index is the index of the auction to bid on. Should just be the present value of AuctionCounter.
• first_slot is the first lease period index of the range to bid on. This is the absolute lease period index value, not an auction-specific offset.
• last_slot is the last lease period index of the range to bid on. This is the absolute lease period index value, not an auction-specific offset.
• amount is the amount to bid to be held as deposit for the parachain should the bid win. This amount is held throughout the range.

Type Disclaimer

This library makes no assumptions about parameter types and must be specified manually as generic types. Each field contains a type description which can serve as a hint on what type is being expected, as provided by the runtime meatadata. See the common module for common types which can be used.

Fields

para: A

Type description: Compact<ParaId>

auction_index: B

Type description: Compact<AuctionIndex>

first_slot: C

Type description: Compact<LeasePeriodOf<T>>

last_slot: D

Type description: Compact<LeasePeriodOf<T>>

amount: E

Type description: Compact<BalanceOf<T>>

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone> Clone for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

fn clone(&self) -> Bid<A, B, C, D, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug> Debug for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

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

Formats the value using the given formatter.

impl<A, B, C, D, E> Decode for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

fn decode<SI: Input>(input: &mut SI) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<A, B, C, D, E> Encode for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

fn using_encoded<SR, SF: FnOnce(&[u8]) -> SR>(&self, f: SF) -> SR

Convert self to a slice and then invoke the given closure with it.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<T>(&self, dest: &mut T) where
    T: Output + ?Sized, 

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq> PartialEq<Bid<A, B, C, D, E>> for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

fn eq(&self, other: &Bid<A, B, C, D, E>) -> bool

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

fn ne(&self, other: &Bid<A, B, C, D, E>) -> bool

This method tests for !=.

impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

impl<A, B, C, D, E> StructuralEq for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode, 

impl<A, B, C, D, E> StructuralPartialEq for Bid<A, B, C, D, E> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,
    E: Encode + Decode,