Enum pallet_chainlink_feed::pallet::Call

pub enum Call<T: Config> {
    create_feed {
        payment: BalanceOf<T>,
        timeout: T::BlockNumber,
        submission_value_bounds: (T::Value, T::Value),
        min_submissions: u32,
        decimals: u8,
        description: Vec<u8>,
        restart_delay: u32,
        oracles: Vec<(T::AccountId, T::AccountId)>,
        pruning_window: Option<u32>,
        max_debt: Option<BalanceOf<T>>,
    },
    transfer_ownership {
        feed_id: T::FeedId,
        new_owner: T::AccountId,
    },
    cancel_ownership_transfer {
        feed_id: T::FeedId,
    },
    accept_ownership {
        feed_id: T::FeedId,
    },
    set_pruning_window {
        feed_id: T::FeedId,
        pruning_window: u32,
    },
    submit {
        feed_id: T::FeedId,
        round_id: RoundId,
        submission: T::Value,
    },
    change_oracles {
        feed_id: T::FeedId,
        to_disable: Vec<T::AccountId>,
        to_add: Vec<(T::AccountId, T::AccountId)>,
    },
    update_future_rounds {
        feed_id: T::FeedId,
        payment: BalanceOf<T>,
        submission_count_bounds: (u32, u32),
        restart_delay: u32,
        timeout: T::BlockNumber,
    },
    set_requester {
        feed_id: T::FeedId,
        requester: T::AccountId,
        delay: RoundId,
    },
    remove_requester {
        feed_id: T::FeedId,
        requester: T::AccountId,
    },
    request_new_round {
        feed_id: T::FeedId,
    },
    withdraw_payment {
        oracle: T::AccountId,
        recipient: T::AccountId,
        amount: BalanceOf<T>,
    },
    transfer_admin {
        oracle: T::AccountId,
        new_admin: T::AccountId,
    },
    cancel_admin_transfer {
        oracle: T::AccountId,
    },
    accept_admin {
        oracle: T::AccountId,
    },
    withdraw_funds {
        recipient: T::AccountId,
        amount: BalanceOf<T>,
    },
    reduce_debt {
        feed_id: T::FeedId,
        amount: BalanceOf<T>,
    },
    force_set_pallet_admin {
        new_pallet_admin: T::AccountId,
    },
    transfer_pallet_admin {
        new_pallet_admin: T::AccountId,
    },
    cancel_pallet_admin_transfer {},
    accept_pallet_admin {},
    set_feed_creator {
        new_creator: T::AccountId,
    },
    remove_feed_creator {
        creator: T::AccountId,
    },
    // some variants omitted
}

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

Variants

create_feed

Create a new oracle feed with the given config values.

This will issue the next available feed ID (FeedCounter) and assign it to the new feed.

Limited to feed creator accounts that where granted permission by the pallet admin to create feeds via set_feed_creator.

Parameters:

• payment: The amount of funds an oracle should received per valid round submission.
• timeout: The timeout in blocks, after which a started round is timed out. If a round started in block n and the feed’s timeout is 10, then the round is timed out if n + 10 < current_block.
• submission_value_bounds: The value bounds of oracle submissions that are considered valid.
• min_submissions: Determines the lower end of the feed’s submission_count_bounds where the maximum number of submissions a round records is the number of configured oracles and the lower end is the minimum amount of submissions a round needs to update an answer via AnswerUpdated event.
• decimals: Metadata that represents the number of decimals with which the feed is configured.
• description: A user friendly name or ticker of this feed. Limited in length by StringLimit.
• restart_delay: The number of rounds that must elapse before a new round can be initiated by the same oracle again. Therefore this must be lower than the number of provided oracles.
• oracles: A list of the oracle accounts together with their admin account (oracle, admin) that will be registered as oracles for the feed. If the oracle account is already tracked (for another feed for example), then the provided admin must match the already tracked oracle’s admin (see Oracles). At least one (oracle, admin) pair is required.
• pruning_window: This specifies the number of rounds to keep in storage for this feed. A None ensures that no past rounds are ever deleted from the chain’s storage. A value of Some(n) ensures that n rounds are kept in storage after the total number of rounds has exceeded n. This means that starting with the n+1 round, the oldest round is purged from storage.
• max_debt: With Some(n) the feed is allowed to accumulate a less or equal than n amount of debt to the oracles. This means that oracles can submit values even if the feed’s fund is dry, and essentially receive an IOU that they can cash in once the feed is refunded.

Emits FeedCreated event when successful.

Fields of create_feed

payment: BalanceOf<T>timeout: T::BlockNumbersubmission_value_bounds: (T::Value, T::Value)min_submissions: u32decimals: u8description: Vec<u8>restart_delay: u32oracles: Vec<(T::AccountId, T::AccountId)>pruning_window: Option<u32>max_debt: Option<BalanceOf<T>>

transfer_ownership

Initiate the transfer of the feed to new_owner. Limited to the current owner of the feed.

This is a noop if the requested new_owner is the sender itself and the sender is already the owner.

Fields of transfer_ownership

feed_id: T::FeedIdnew_owner: T::AccountId

cancel_ownership_transfer

Cancels a previously with transfer_ownership initiated transfer of ownership if it’s still pending.

This will fail if the pending_owner already accepted the transfer with accept_ownership..

Fields of cancel_ownership_transfer

feed_id: T::FeedId

accept_ownership

Accept the transfer of feed ownership.

Fields of accept_ownership

feed_id: T::FeedId

set_pruning_window

Updates the pruning window of an existing feed

• Will prune rounds if the given window is smaller than the existing one.

Fields of set_pruning_window

feed_id: T::FeedIdpruning_window: u32

submit

Submit a new value to the given feed and round.

• Will start a new round if there is no round for the id, yet, and a round can be started (at this time by this oracle).
• Will update the round answer if minimum number of submissions has been reached.
• Records the rewards incurred by the oracle.
• Removes the details for the previous round if it was superseded.

Limited to the oracles of a feed.

Fields of submit

feed_id: T::FeedIdround_id: RoundIdsubmission: T::Value

change_oracles

Disable and add oracles for the given feed. Limited to the owner of a feed.

Fields of change_oracles

feed_id: T::FeedIdto_disable: Vec<T::AccountId>to_add: Vec<(T::AccountId, T::AccountId)>

update_future_rounds

Update the configuration for future oracle rounds. Limited to the owner of a feed.

Fields of update_future_rounds

feed_id: T::FeedIdpayment: BalanceOf<T>submission_count_bounds: (u32, u32)restart_delay: u32timeout: T::BlockNumber

set_requester

Set requester permissions for requester. Limited to the feed owner.

Fields of set_requester

feed_id: T::FeedIdrequester: T::AccountIddelay: RoundId

remove_requester

Remove requester permissions for requester. Limited to the feed owner.

Fields of remove_requester

feed_id: T::FeedIdrequester: T::AccountId

request_new_round

Request the start of a new oracle round. Limited to accounts with “requester” permission.

Fields of request_new_round

feed_id: T::FeedId

withdraw_payment

Withdraw amount payment of the given oracle to recipient. Limited to the oracle admin.

Fields of withdraw_payment

oracle: T::AccountIdrecipient: T::AccountIdamount: BalanceOf<T>

transfer_admin

Initiate an admin transfer for the given oracle. Limited to the oracle admin account.

This is a noop if the requested new_admin is the sender itself and the sender is already the oracle admin.

Fields of transfer_admin

oracle: T::AccountIdnew_admin: T::AccountId

cancel_admin_transfer

Cancels a previously with transfer_admin initiated transfer of admin ownership for the given oracle, if the transfer is still pending.

This will fail if the pending_admin already accepted the transfer with accept_admin..

Fields of cancel_admin_transfer

oracle: T::AccountId

accept_admin

Complete an admin transfer for the given oracle. Limited to the pending oracle admin account.

Fields of accept_admin

oracle: T::AccountId

withdraw_funds

Withdraw amount funds to recipient. Limited to the pallet admin.

Fields of withdraw_funds

recipient: T::AccountIdamount: BalanceOf<T>

reduce_debt

Reduce the amount of debt in the pallet by moving funds from the free balance to the reserved so oracles can be payed out. Limited to the pallet admin.

Fields of reduce_debt

feed_id: T::FeedIdamount: BalanceOf<T>

force_set_pallet_admin

Sets the pallet admin account.

The dispatch origin for this call must be Root.

Unlike transfer_pallet_admin, the new_pallet_admin is not required to accept the transfer, instead the PalletAdmin is forcibly set and the eventual pending transfer is aborted.

Fields of force_set_pallet_admin

new_pallet_admin: T::AccountId

transfer_pallet_admin

Initiate an admin transfer for the pallet. Limited to the pallet admin account.

This is a noop if the requested new_pallet_admin is the sender itself and the sender is already the pallet admin.

Fields of transfer_pallet_admin

new_pallet_admin: T::AccountId

cancel_pallet_admin_transfer

Cancels a previously with transfer_pallet_admin initiated transfer of the pallet admin ownership, if the transfer is still pending.

This will fail if the PendingPalletAdmin already accepted the transfer with accept_pallet_admin.

Fields of cancel_pallet_admin_transfer

accept_pallet_admin

Complete an admin transfer for the pallet. Limited to the pending pallet admin account.

Fields of accept_pallet_admin

set_feed_creator

Allow the given account to create oracle feeds. Limited to the pallet admin account.

Fields of set_feed_creator

new_creator: T::AccountId

remove_feed_creator

Disallow the given account to create oracle feeds. Limited to the pallet admin account.

Fields of remove_feed_creator

creator: T::AccountId

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_create_feed(
    payment: BalanceOf<T>,
    timeout: T::BlockNumber,
    submission_value_bounds: (T::Value, T::Value),
    min_submissions: u32,
    decimals: u8,
    description: Vec<u8>,
    restart_delay: u32,
    oracles: Vec<(T::AccountId, T::AccountId)>,
    pruning_window: Option<u32>,
    max_debt: Option<BalanceOf<T>>
) -> Self

Create a call with the variant create_feed.

pub fn new_call_variant_transfer_ownership(
    feed_id: T::FeedId,
    new_owner: T::AccountId
) -> Self

Create a call with the variant transfer_ownership.

pub fn new_call_variant_cancel_ownership_transfer(feed_id: T::FeedId) -> Self

Create a call with the variant cancel_ownership_transfer.

pub fn new_call_variant_accept_ownership(feed_id: T::FeedId) -> Self

Create a call with the variant accept_ownership.

pub fn new_call_variant_set_pruning_window(
    feed_id: T::FeedId,
    pruning_window: u32
) -> Self

Create a call with the variant set_pruning_window.

pub fn new_call_variant_submit(
    feed_id: T::FeedId,
    round_id: RoundId,
    submission: T::Value
) -> Self

Create a call with the variant submit.

pub fn new_call_variant_change_oracles(
    feed_id: T::FeedId,
    to_disable: Vec<T::AccountId>,
    to_add: Vec<(T::AccountId, T::AccountId)>
) -> Self

Create a call with the variant change_oracles.

pub fn new_call_variant_update_future_rounds(
    feed_id: T::FeedId,
    payment: BalanceOf<T>,
    submission_count_bounds: (u32, u32),
    restart_delay: u32,
    timeout: T::BlockNumber
) -> Self

Create a call with the variant update_future_rounds.

pub fn new_call_variant_set_requester(
    feed_id: T::FeedId,
    requester: T::AccountId,
    delay: RoundId
) -> Self

Create a call with the variant set_requester.

pub fn new_call_variant_remove_requester(
    feed_id: T::FeedId,
    requester: T::AccountId
) -> Self

Create a call with the variant remove_requester.

pub fn new_call_variant_request_new_round(feed_id: T::FeedId) -> Self

Create a call with the variant request_new_round.

pub fn new_call_variant_withdraw_payment(
    oracle: T::AccountId,
    recipient: T::AccountId,
    amount: BalanceOf<T>
) -> Self

Create a call with the variant withdraw_payment.

pub fn new_call_variant_transfer_admin(
    oracle: T::AccountId,
    new_admin: T::AccountId
) -> Self

Create a call with the variant transfer_admin.

pub fn new_call_variant_cancel_admin_transfer(oracle: T::AccountId) -> Self

Create a call with the variant cancel_admin_transfer.

pub fn new_call_variant_accept_admin(oracle: T::AccountId) -> Self

Create a call with the variant accept_admin.

pub fn new_call_variant_withdraw_funds(
    recipient: T::AccountId,
    amount: BalanceOf<T>
) -> Self

Create a call with the variant withdraw_funds.

pub fn new_call_variant_reduce_debt(
    feed_id: T::FeedId,
    amount: BalanceOf<T>
) -> Self

Create a call with the variant reduce_debt.

pub fn new_call_variant_force_set_pallet_admin(
    new_pallet_admin: T::AccountId
) -> Self

Create a call with the variant force_set_pallet_admin.

pub fn new_call_variant_transfer_pallet_admin(
    new_pallet_admin: T::AccountId
) -> Self

Create a call with the variant transfer_pallet_admin.

pub fn new_call_variant_cancel_pallet_admin_transfer() -> Self

Create a call with the variant cancel_pallet_admin_transfer.

pub fn new_call_variant_accept_pallet_admin() -> Self

Create a call with the variant accept_pallet_admin.

pub fn new_call_variant_set_feed_creator(new_creator: T::AccountId) -> Self

Create a call with the variant set_feed_creator.

pub fn new_call_variant_remove_feed_creator(creator: T::AccountId) -> Self

Create a call with the variant remove_feed_creator.

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> 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<T: Config> Encode for Call<T>

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

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

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

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

fn encoded_size(&self) -> usize

Calculates the encoded size.

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

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

Return the function name of the Call.

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

Return all function names.

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

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

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

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

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

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

This method tests for !=.

impl<T: Config> TypeInfo for Call<T> where
    PhantomData<(T,)>: TypeInfo + 'static,
    BalanceOf<T>: TypeInfo + 'static,
    T::BlockNumber: TypeInfo + 'static,
    (T::Value, T::Value): TypeInfo + 'static,
    Vec<(T::AccountId, T::AccountId)>: TypeInfo + 'static,
    Option<BalanceOf<T>>: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::FeedId: HasCompact,
    T::Value: HasCompact,
    T::FeedId: TypeInfo + 'static,
    Vec<T::AccountId>: TypeInfo + 'static,
    Vec<(T::AccountId, T::AccountId)>: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    BalanceOf<T>: TypeInfo + 'static,
    T::BlockNumber: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    BalanceOf<T>: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    BalanceOf<T>: TypeInfo + 'static,
    T::FeedId: TypeInfo + 'static,
    BalanceOf<T>: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T: Config + 'static, 

type Identity = Self

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

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

type Origin = OriginFor<T>

The origin type of the runtime, (i.e. frame_system::Config::Origin).

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

Dispatch this call but do not check the filter in origin.

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

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