Struct pallet_circuit::SFXBid

pub struct SFXBid<AccountId, BalanceOf, AssetId> {
    pub amount: BalanceOf,
    pub insurance: BalanceOf,
    pub reserved_bond: Option<BalanceOf>,
    pub reward_asset_id: Option<AssetId>,
    pub executor: AccountId,
    pub requester: AccountId,
}

All Executors from the active set can bid for SFX executions in order to claim the rewards (max_fee) set by users, ultimately competing against one another on the open market rules. In case bid goes on Optimistic SFX, Executor will also have their bonded stake reserve to insure other Optimistic Executors co-executing given Xtx with their bonded collateral (reserved_bond) Their balance

Fields

amount: BalanceOf

Bid amount - always below SFX::max_fee requested by a user

insurance: BalanceOf

Insurance in case of optimistic FSX

reserved_bond: Option<BalanceOf>

Optional reserved bond in case of optimistic FSX

reward_asset_id: Option<AssetId>

Optional reserved asset id in case execution on foreign assets

executor: AccountId

Bidding Executor belonging to the active set

requester: AccountId

Requester - subject ordering SFX

Implementations

impl<AccountId, BalanceOf, AssetId> SFXBid<AccountId, BalanceOf, AssetId>where AccountId: Encode,

pub fn new_none_optimistic( bid: BalanceOf, insurance: BalanceOf, executor: AccountId, requester: AccountId, reward_asset_id: Option<AssetId> ) -> SFXBid<AccountId, BalanceOf, AssetId>

pub fn expect_reserved_bond(&self) -> &BalanceOf

pub fn get_reserved_bond(&self) -> &Option<BalanceOf>

pub fn get_insurance(&self) -> &BalanceOf

pub fn generate_id<Hasher, T>( &self, sfx_id: <T as Config>::Hash ) -> <Hasher as Hasher>::Outwhere Hasher: Hasher, T: Config,

Generate BID id as a hash of the SFX id and the executor account id bytes

Trait Implementations

impl<AccountId, BalanceOf, AssetId> Clone for SFXBid<AccountId, BalanceOf, AssetId>where AccountId: Clone, BalanceOf: Clone, AssetId: Clone,

fn clone(&self) -> SFXBid<AccountId, BalanceOf, AssetId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AccountId, BalanceOf, AssetId> Debug for SFXBid<AccountId, BalanceOf, AssetId>where AccountId: Debug, BalanceOf: Debug, AssetId: Debug,

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

Formats the value using the given formatter.

impl<AccountId, BalanceOf, AssetId> Decode for SFXBid<AccountId, BalanceOf, AssetId>where BalanceOf: Decode, Option<BalanceOf>: Decode, Option<AssetId>: Decode, AccountId: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<SFXBid<AccountId, BalanceOf, AssetId>, Error>where __CodecInputEdqy: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

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<AccountId, BalanceOf, AssetId> Default for SFXBid<AccountId, BalanceOf, AssetId>where AccountId: Default, BalanceOf: Default, AssetId: Default,

fn default() -> SFXBid<AccountId, BalanceOf, AssetId>

Returns the “default value” for a type.

impl<AccountId, BalanceOf, AssetId> Encode for SFXBid<AccountId, BalanceOf, AssetId>where BalanceOf: Encode, Option<BalanceOf>: Encode, Option<AssetId>: Encode, AccountId: Encode,

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )where __CodecOutputEdqy: 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 using_encoded<R, F>(&self, f: F) -> Rwhere 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<AccountId, BalanceOf, AssetId> PartialEq<SFXBid<AccountId, BalanceOf, AssetId>> for SFXBid<AccountId, BalanceOf, AssetId>where AccountId: PartialEq<AccountId>, BalanceOf: PartialEq<BalanceOf>, AssetId: PartialEq<AssetId>,

fn eq(&self, other: &SFXBid<AccountId, BalanceOf, AssetId>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<AccountId, BalanceOf, AssetId> TypeInfo for SFXBid<AccountId, BalanceOf, AssetId>where BalanceOf: TypeInfo + 'static, Option<BalanceOf>: TypeInfo + 'static, Option<AssetId>: TypeInfo + 'static, AccountId: TypeInfo + 'static, AssetId: TypeInfo + 'static,

type Identity = SFXBid<AccountId, BalanceOf, AssetId>

The type identifying for which type info is provided.

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.

impl<AccountId, BalanceOf, AssetId> EncodeLike<SFXBid<AccountId, BalanceOf, AssetId>> for SFXBid<AccountId, BalanceOf, AssetId>where BalanceOf: Encode, Option<BalanceOf>: Encode, Option<AssetId>: Encode, AccountId: Encode,

impl<AccountId, BalanceOf, AssetId> Eq for SFXBid<AccountId, BalanceOf, AssetId>where AccountId: Eq, BalanceOf: Eq, AssetId: Eq,

impl<AccountId, BalanceOf, AssetId> StructuralEq for SFXBid<AccountId, BalanceOf, AssetId>

impl<AccountId, BalanceOf, AssetId> StructuralPartialEq for SFXBid<AccountId, BalanceOf, AssetId>