substrate-subxt 0.12.0

Submit extrinsics (transactions) to a substrate node via RPC
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

// Copyright 2019-2020 Parity Technologies (UK) Ltd.
// This file is part of substrate-subxt.
//
// subxt is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// subxt is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.

//! Implements support for built-in runtime modules.

use crate::{
    events::EventsDecoder,
    metadata::{
        Metadata,
        MetadataError,
    },
};
use codec::{
    Decode,
    Encode,
};
use sp_core::storage::StorageKey;

pub mod balances;
pub mod contracts;
pub mod sudo;
pub mod system;

/// Store trait.
pub trait Store<T>: Encode {
    /// Module name.
    const MODULE: &'static str;
    /// Field name.
    const FIELD: &'static str;
    /// Return type.
    type Returns: Decode;
    /// Returns the key prefix for storage maps
    fn prefix(metadata: &Metadata) -> Result<StorageKey, MetadataError>;
    /// Returns the `StorageKey`.
    fn key(&self, metadata: &Metadata) -> Result<StorageKey, MetadataError>;
    /// Returns the default value.
    fn default(&self, metadata: &Metadata) -> Result<Self::Returns, MetadataError> {
        Ok(metadata
            .module(Self::MODULE)?
            .storage(Self::FIELD)?
            .default()?)
    }
}

/// Call trait.
pub trait Call<T>: Encode {
    /// Module name.
    const MODULE: &'static str;
    /// Function name.
    const FUNCTION: &'static str;
    /// Load event decoder.
    fn events_decoder(_decoder: &mut EventsDecoder<T>) {}
}

/// Event trait.
pub trait Event<T>: Decode {
    /// Module name.
    const MODULE: &'static str;
    /// Event name.
    const EVENT: &'static str;
}