Enum polkadot_runtime_common::auctions::pallet::Call[−][src]

pub enum Call<T: Config> {
    new_auction {
        duration: T::BlockNumber,
        lease_period_index: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod,
    },
    bid {
        para: ParaId,
        auction_index: AuctionIndex,
        first_slot: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod,
        last_slot: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod,
        amount: <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    cancel_auction {},
    // some variants omitted
}

Expand description

Contains one variant per dispatchable that can be called by an extrinsic.

Variants

new_auction

Create a new auction.

This can only happen when there isn’t already an auction in progress and may only be called by the root origin. Accepts the duration of this auction and the lease_period_index of the initial lease period of the four that are to be auctioned.

Fields of new_auction

duration: T::BlockNumberlease_period_index: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod

bid

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.

Fields of bid

para: ParaIdauction_index: AuctionIndexfirst_slot: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriodlast_slot: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod

amount: <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance

cancel_auction

Cancel an in-progress auction.

Can only be called by Root origin.

Enum polkadot_runtime_common::auctions::pallet::Call[−][src]

Variants

Fields of new_auction

Fields of bid

Fields of cancel_auction

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_new_auction( duration: T::BlockNumber, lease_period_index: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod) -> Self

pub fn new_call_variant_cancel_auction() -> Self

Trait Implementations

impl<T: Config> Clone for Call<T>

fn clone(&self) -> Self

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

impl<T: Config> Debug for Call<T>

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

impl<T: Config> Decode for Call<T>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<Self, Error>

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

fn encoded_fixed_size() -> Option<usize>

impl<T: Config> Encode for Call<T>

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy)

fn size_hint(&self) -> usize

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

fn using_encoded<R, F>(&self, f: F) -> R where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

fn get_call_names() -> &'static [&'static str]

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

impl<T: Config> PartialEq<Call<T>> for Call<T>

fn eq(&self, other: &Self) -> bool

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

type Identity = Self

fn type_info() -> Type

impl<T: Config> UnfilteredDispatchable for Call<T>

type Origin = OriginFor<T>

fn dispatch_bypass_filter( self, origin: Self::Origin) -> DispatchResultWithPostInfo

impl<T: Config> EncodeLike<Call<T>> for Call<T>

impl<T: Config> Eq for Call<T>

Auto Trait Implementations

impl<T> RefUnwindSafe for Call<T> where T: RefUnwindSafe, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: RefUnwindSafe, <T as Config>::BlockNumber: RefUnwindSafe,

impl<T> Send for Call<T> where T: Send, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Send,

impl<T> Sync for Call<T> where T: Sync, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Sync,

impl<T> Unpin for Call<T> where T: Unpin, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Unpin, <T as Config>::BlockNumber: Unpin,

impl<T> UnwindSafe for Call<T> where T: UnwindSafe, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: UnwindSafe, <T as Config>::BlockNumber: UnwindSafe,

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

pub 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) -> T where Self: Into<T>,

impl<T> Conv for T

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

impl<T> DecodeAll for T where T: Decode,

pub fn decode_all(input: &[u8]) -> Result<T, Error>

impl<T> DecodeLimit for T where T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

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

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

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

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

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

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

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<T> EncodeAs<T> for T where T: Encode,

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

impl<Q, K> Equivalent<K> for Q where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

pub fn equivalent(&self, key: &K) -> bool

impl<T> FmtForward for T

pub fn new_call_variant_new_auction(
duration: T::BlockNumber,
lease_period_index: <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod
) -> Self

fn decode<CodecInputEdqy: Input>(
codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

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

fn encode_to<CodecOutputEdqy: Output + ?Sized>(
&self,
codec_dest_edqy: &mut __CodecOutputEdqy
)

fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8 ]) -> R,

fn get_call_names() -> &'static [&'static str ]

fn dispatch_bypass_filter(
self,
origin: Self::Origin
) -> DispatchResultWithPostInfo

impl<T> RefUnwindSafe for Call<T> where
T: RefUnwindSafe,
<<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: RefUnwindSafe,
<T as Config>::BlockNumber: RefUnwindSafe,

impl<T> Send for Call<T> where
T: Send,
<<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Send,

impl<T> Sync for Call<T> where
T: Sync,
<<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Sync,

impl<T> Unpin for Call<T> where
T: Unpin,
<<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Unpin,
<T as Config>::BlockNumber: Unpin,

impl<T> UnwindSafe for Call<T> where
T: UnwindSafe,
<<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: UnwindSafe,
<T as Config>::BlockNumber: UnwindSafe,

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

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

impl<T> BorrowMut<T> for T where
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) -> T where
Self: Into<T>,

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

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

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

impl<T> DynClone for T where
T: Clone,

impl<T> EncodeAs<T> for T where
T: Encode,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

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,

impl<T> FullLeaf for T where
T: Encode + Decode + Clone + PartialEq<T> + Debug,

pub fn using_encoded<R, F>(&self, f: F, _compact: bool) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

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

pub fn twox_128(&self) -> [u8 ; 16]

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

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

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

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

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

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

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

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
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
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
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) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
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
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

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

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