Struct AnyOf 

pub struct AnyOf<T, Params> { /* private fields */ }

This accepts a tuple of TransactionExtensions, and will dynamically make use of whichever ones are actually required for the chain in the correct order, ignoring the rest. This is a sensible default, and allows for a single configuration to work across multiple chains.

Trait Implementations

impl<T, A> ExtrinsicParams<T> for AnyOf<T, (A,)>

where T: Config, A: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params,)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B> ExtrinsicParams<T> for AnyOf<T, (A, B)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C> ExtrinsicParams<T> for AnyOf<T, (A, B, C)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params, <Q as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params, <Q as ExtrinsicParams<T>>::Params, <R as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params, <Q as ExtrinsicParams<T>>::Params, <R as ExtrinsicParams<T>>::Params, <S as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>, U: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params, <Q as ExtrinsicParams<T>>::Params, <R as ExtrinsicParams<T>>::Params, <S as ExtrinsicParams<T>>::Params, <U as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V> ExtrinsicParams<T> for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>, U: TransactionExtension<T>, V: TransactionExtension<T>,

type Params = (<A as ExtrinsicParams<T>>::Params, <B as ExtrinsicParams<T>>::Params, <C as ExtrinsicParams<T>>::Params, <D as ExtrinsicParams<T>>::Params, <E as ExtrinsicParams<T>>::Params, <F as ExtrinsicParams<T>>::Params, <G as ExtrinsicParams<T>>::Params, <H as ExtrinsicParams<T>>::Params, <I as ExtrinsicParams<T>>::Params, <J as ExtrinsicParams<T>>::Params, <K as ExtrinsicParams<T>>::Params, <L as ExtrinsicParams<T>>::Params, <M as ExtrinsicParams<T>>::Params, <N as ExtrinsicParams<T>>::Params, <O as ExtrinsicParams<T>>::Params, <P as ExtrinsicParams<T>>::Params, <Q as ExtrinsicParams<T>>::Params, <R as ExtrinsicParams<T>>::Params, <S as ExtrinsicParams<T>>::Params, <U as ExtrinsicParams<T>>::Params, <V as ExtrinsicParams<T>>::Params)

These parameters can be provided to the constructor along with some default parameters that subxt understands, in order to help construct your ExtrinsicParams object.

fn new( client: &ClientState<T>, params: Self::Params, ) -> Result<Self, ExtrinsicParamsError>

Construct a new instance of our ExtrinsicParams.

impl<T, A> ExtrinsicParamsEncoder for AnyOf<T, (A,)>

where T: Config, A: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B> ExtrinsicParamsEncoder for AnyOf<T, (A, B)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>, U: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V> ExtrinsicParamsEncoder for AnyOf<T, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V)>

where T: Config, A: TransactionExtension<T>, B: TransactionExtension<T>, C: TransactionExtension<T>, D: TransactionExtension<T>, E: TransactionExtension<T>, F: TransactionExtension<T>, G: TransactionExtension<T>, H: TransactionExtension<T>, I: TransactionExtension<T>, J: TransactionExtension<T>, K: TransactionExtension<T>, L: TransactionExtension<T>, M: TransactionExtension<T>, N: TransactionExtension<T>, O: TransactionExtension<T>, P: TransactionExtension<T>, Q: TransactionExtension<T>, R: TransactionExtension<T>, S: TransactionExtension<T>, U: TransactionExtension<T>, V: TransactionExtension<T>,

fn encode_value_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the transaction extension data to some buffer that has been provided. This data is attached to the transaction and also (by default) attached to the signer payload which is signed to provide a signature for the transaction.

fn encode_signer_payload_value_to(&self, v: &mut Vec<u8>)

See ExtrinsicParamsEncoder::encode_value_to. This defaults to calling that method, but if implemented will dictate what is encoded to the signer payload.

fn encode_implicit_to(&self, v: &mut Vec<u8>)

This is expected to SCALE encode the “implicit” (formally “additional”) parameters to some buffer that has been provided. These parameters are not sent along with the transaction, but are taken into account when signing it, meaning the client and node must agree on their values.

fn inject_signature(&mut self, account_id: &dyn Any, signature: &dyn Any)

Set the signature. This happens after we have constructed the extrinsic params, and so is defined here rather than on the params, below. We need to use &dyn Any to keep this trait object safe, but can downcast in the impls.