subxt 0.50.0

Interact with Substrate based chains on the Polkadot Network
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

// Copyright 2019-2026 Parity Technologies (UK) Ltd.
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
// see LICENSE for license details.

use crate::config::{Config, HashFor};
use crate::error::TransactionExtensionError;
use crate::metadata::ArcMetadata;
use scale_decode::DecodeAsType;
use scale_info::PortableRegistry;

/// A set of [`TransactionExtensions`]. This:
/// - Implements [`frame_decode::extrinsics::TransactionExtensions`], meaning that it
///   can be encoded to value or implicit bytes.
/// - Accepts custom params on construction, allowing user configuration to be provided.
/// - Can have an account ID and signature injected (useful for V5 transaction extensions).
pub trait TransactionExtensions<T: Config>:
    frame_decode::extrinsics::TransactionExtensions<PortableRegistry> + Sized
{
    /// These parameters can be provided to the constructor along with
    /// some default parameters that Subxt understands.
    type Params: Params<T>;

    /// Construct a new instance of our [`TransactionExtensions`].
    fn new(
        client: &ClientState<T>,
        params: Self::Params,
    ) -> Result<Self, TransactionExtensionError>;

    /// Set the signature and account ID for any transaction extensions that care.
    fn inject_signature(&mut self, account_id: &T::AccountId, signature: &T::Signature);
}

/// A single transaction extension.
pub trait TransactionExtension<T: Config>:
    frame_decode::extrinsics::TransactionExtension<PortableRegistry> + Sized
{
    /// The type representing the `extra` / value bytes of a transaction extension.
    /// Decoding from this type should be symmetrical to the respective
    /// [`frame_decode::extrinsics::TransactionExtension::encode_value_to()`] implementation
    /// for this transaction extension.
    type Decoded: DecodeAsType;

    /// These parameters can be provided to the constructor along with
    /// some default parameters that Subxt understands.
    type Params: Params<T>;

    /// Construct a new instance of our [`TransactionExtension`].
    fn new(
        client: &ClientState<T>,
        params: Self::Params,
    ) -> Result<Self, TransactionExtensionError>;

    /// Set the signature and accountID for this transaction extension. Defaults to doing nothing.
    fn inject_signature(&mut self, _account_id: &T::AccountId, _signature: &T::Signature) {}
}

/// This provides access to some relevant client state in transaction extensions,
/// and is just a combination of some of the available properties.
#[derive(Clone, Debug)]
pub struct ClientState<T: Config> {
    /// Genesis hash.
    pub genesis_hash: HashFor<T>,
    /// Spec version.
    pub spec_version: u32,
    /// Transaction version.
    pub transaction_version: u32,
    /// Metadata.
    pub metadata: ArcMetadata,
}

/// The parameters (ie [`TransactionExtensions::Params`]) can also have data injected into them,
/// allowing Subxt to retrieve data from the chain and amend the parameters with it when
/// online.
pub trait Params<T: Config> {
    /// Set the account nonce.
    fn inject_account_nonce(&mut self, _nonce: u64) {}
    /// Set the current block.
    fn inject_block(&mut self, _number: u64, _hash: HashFor<T>) {}
}

// empty tuples impl Params and do nothing.
impl<T: Config> Params<T> for () {}

// tuples of Params are also valid Params.
macro_rules! impl_params_tuple {
    ($($ident:ident $index:tt),+) => {
        impl <Conf: Config, $($ident : Params<Conf>),+> Params<Conf> for ($($ident,)+) {
            fn inject_account_nonce(&mut self, nonce: u64) {
                $(self.$index.inject_account_nonce(nonce);)+
            }

            fn inject_block(&mut self, number: u64, hash: HashFor<Conf>) {
                $(self.$index.inject_block(number, hash);)+
            }
        }
    }
}

#[rustfmt::skip]
const _: () = {
    impl_params_tuple!(A 0);
    impl_params_tuple!(A 0, B 1);
    impl_params_tuple!(A 0, B 1, C 2);
    impl_params_tuple!(A 0, B 1, C 2, D 3);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23, Y 24);
    impl_params_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23, Y 24, Z 25);
};

// tuples of TransactionExtension types are automatically TransactionExtensions.
macro_rules! impl_extensions_tuple {
    ($($ident:ident $index:tt),+) => {
        impl<Conf: Config, $($ident: TransactionExtension<Conf>),+>
            TransactionExtensions<Conf> for ($($ident,)+)
        where
            ($($ident::Params,)+): Params<Conf>,
        {
            type Params = ($($ident::Params,)+);

            fn new(client: &ClientState<Conf>, params: Self::Params) -> Result<Self, TransactionExtensionError> {
                Ok((
                    $($ident::new(client, params.$index)?,)+
                ))
            }

            fn inject_signature(&mut self, account_id: &Conf::AccountId, signature: &Conf::Signature) {
                $(self.$index.inject_signature(account_id, signature);)+
            }
        }
    }
}

#[rustfmt::skip]
const _: () = {
    impl_extensions_tuple!(A 0);
    impl_extensions_tuple!(A 0, B 1);
    impl_extensions_tuple!(A 0, B 1, C 2);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23, Y 24);
    impl_extensions_tuple!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, T 19, U 20, V 21, W 22, X 23, Y 24, Z 25);
};