Struct orml_oracle::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn raw_values<KArg1, KArg2>(
    k1: KArg1,
    k2: KArg2
) -> Option<TimestampedValueOf<T>> where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<T::OracleKey>, 

pub fn is_updated<K: EncodeLike<T::OracleKey>>(key: K) -> bool

True if Self::values(key) is up to date, otherwise the value is stale

pub fn values<K: EncodeLike<T::OracleKey>>(
    key: K
) -> Option<TimestampedValueOf<T>>

Combined value, may not be up to date

pub fn members() -> OrderedSet<T::AccountId>

The current members of the collective. This is stored sorted (just by value).

pub fn session_keys<K: EncodeLike<T::AccountId>>(
    key: K
) -> Option<T::AuthorityId>

Session key for oracle operators

pub fn nonces<K: EncodeLike<T::AccountId>>(key: K) -> u32

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn feed_values(
    origin: T::Origin,
    values: Vec<(T::OracleKey, T::OracleValue)>,
    index: u32,
    _signature: <T::AuthorityId as RuntimeAppPublic>::Signature
) -> DispatchResult

pub fn set_session_key(origin: T::Origin, key: T::AuthorityId) -> DispatchResult

impl<T: Trait> Module<T>

pub fn read_raw_values(key: &T::OracleKey) -> Vec<TimestampedValueOf<T>>

pub fn get(key: &T::OracleKey) -> Option<TimestampedValueOf<T>>

Returns fresh combined value if has update, or latest combined value.

Note this will update values storage if has update.

pub fn get_no_op(key: &T::OracleKey) -> Option<TimestampedValueOf<T>>

Returns fresh combined value if has update, or latest combined value.

This is a no-op function which would not change storage.

pub fn get_all_values() -> Vec<(T::OracleKey, Option<TimestampedValueOf<T>>)>

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Trait> ChangeMembers<<T as Trait>::AccountId> for Module<T>

fn change_members_sorted(
    _incoming: &[T::AccountId],
    outgoing: &[T::AccountId],
    new: &[T::AccountId]
)

A number of members _incoming just joined the set and replaced some _outgoing ones. The new set is thus given by sorted_new and must be sorted.

fn set_prime(_prime: Option<T::AccountId>)

Set the prime member.

fn change_members(
    incoming: &[AccountId],
    outgoing: &[AccountId],
    new: Vec<AccountId>
)

A number of members incoming just joined the set and replaced some outgoing ones. The new set is given by new, and need not be sorted.

fn set_members_sorted(new_members: &[AccountId], old_members: &[AccountId])

Set the new members; they must already be sorted. This will compute the diff and use it to call change_members_sorted.

fn compute_members_diff(
    new_members: &[AccountId],
    old_members: &[AccountId]
) -> (Vec<AccountId>, Vec<AccountId>)

Set the new members; they must already be sorted. This will compute the diff and use it to call change_members_sorted.

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> DataProvider<<T as Trait>::OracleKey, <T as Trait>::OracleValue> for Module<T>

fn get(key: &T::OracleKey) -> Option<T::OracleValue>

impl<T: Trait> DataProviderExtended<<T as Trait>::OracleKey, <T as Trait>::OracleValue, <T as Trait>::AccountId> for Module<T>

fn feed_value(
    who: T::AccountId,
    key: T::OracleKey,
    value: T::OracleValue
) -> DispatchResult

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> InitializeMembers<<T as Trait>::AccountId> for Module<T>

fn initialize_members(members: &[T::AccountId])

Initialize the members to the given members.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: T::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

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

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>

impl<T: Trait> ValidateUnsigned for Module<T>

type Call = Call<T>

The call to validate

fn validate_unsigned(
    _source: TransactionSource,
    call: &Self::Call
) -> TransactionValidity

Return the validity of the call

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch.