Enum Funder

pub enum Funder<T: Config> {
    Direct(Backer<T>),
    Index {
        digest: IndexDigest<T>,
        backer: Backer<T>,
    },
    Pool {
        digest: PoolDigest<T>,
        backer: Backer<T>,
    },
}

Represents the entity responsible for backing or funding an Author role.

A Funder abstracts away different possible funding sources - individual accounts, indexed commitments, or pooled backing mechanisms - allowing the runtime to treat all funders uniformly.

Design Rationale

The Funder type enables composable funding logic by decoupling the origin of funds from their operational treatment.
Whether funds come directly from an account, a collective pool, or an indexing mechanism, they can all be processed consistently by the same logic.

Transparency

• Funding is open to multiple origins, encouraging decentralized capital flow.
• Digest-based identifiers ensure verifiable commitment integrity without requiring central registries.

Variants

Direct(Backer<T>)

A direct account-based funder (standard single backer).

Index

An indexed commitment-based funder. Contains the index’s digest and the account through which it is backed.

Fields

digest: IndexDigest<T>

Index Digest

backer: Backer<T>

Index’s Backer/Funder

Pool

A pool funder, representing collective or group-backed collateral. Contains the pool’s digest and the account through which it is backed.

Fields

digest: PoolDigest<T>

Pool Digest

backer: Backer<T>

Pool’s Backer/Funder

Trait Implementations

impl<T: Clone + Config> Clone for Funder<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

where Backer<T>: Decode, IndexDigest<T>: Decode, PoolDigest<T>: Decode,

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

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<T: Config> Encode for Funder<T>

where Backer<T>: Encode, IndexDigest<T>: Encode, PoolDigest<T>: Encode,

fn size_hint(&self) -> usize

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

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

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

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

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> MaxEncodedLen for Funder<T>

where Backer<T>: MaxEncodedLen, IndexDigest<T>: MaxEncodedLen, PoolDigest<T>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: Config> Ord for Funder<T>

BackingElectionWeight tuple only takes the other element AuthorAsset for ordering.

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + Config> PartialEq for Funder<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config> PartialOrd for Funder<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> TypeInfo for Funder<T>

where Backer<T>: TypeInfo + 'static, IndexDigest<T>: TypeInfo + 'static, PoolDigest<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = Funder<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> DecodeWithMemTracking for Funder<T>

where Backer<T>: DecodeWithMemTracking, IndexDigest<T>: DecodeWithMemTracking, PoolDigest<T>: DecodeWithMemTracking,

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

where Backer<T>: Encode, IndexDigest<T>: Encode, PoolDigest<T>: Encode,

impl<T: Eq + Config> Eq for Funder<T>

impl<T: Config> StructuralPartialEq for Funder<T>