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

// 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.

//! Construct addresses to access constants with.

use derive_where::derive_where;
use scale_decode::DecodeAsType;
use std::borrow::Cow;

/// This represents a constant address. Anything implementing this trait
/// can be used to fetch constants.
pub trait Address {
    /// The target type of the value that lives at this address.
    type Target: DecodeAsType;

    /// The name of the pallet that the constant lives under.
    fn pallet_name(&self) -> &str;

    /// The name of the constant in a given pallet.
    fn constant_name(&self) -> &str;

    /// An optional hash which, if present, will be checked against
    /// the node metadata to confirm that the return type matches what
    /// we are expecting.
    fn validation_hash(&self) -> Option<[u8; 32]> {
        None
    }
}

// Any reference to an address is a valid address.
impl<A: Address + ?Sized> Address for &'_ A {
    type Target = A::Target;

    fn pallet_name(&self) -> &str {
        A::pallet_name(*self)
    }

    fn constant_name(&self) -> &str {
        A::constant_name(*self)
    }

    fn validation_hash(&self) -> Option<[u8; 32]> {
        A::validation_hash(*self)
    }
}

// (str, str) and similar are valid addresses.
impl<A: AsRef<str>, B: AsRef<str>> Address for (A, B) {
    type Target = scale_value::Value;

    fn pallet_name(&self) -> &str {
        self.0.as_ref()
    }

    fn constant_name(&self) -> &str {
        self.1.as_ref()
    }

    fn validation_hash(&self) -> Option<[u8; 32]> {
        None
    }
}

/// This represents the address of a constant.
#[derive_where(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
pub struct StaticAddress<ReturnTy> {
    pallet_name: Cow<'static, str>,
    constant_name: Cow<'static, str>,
    constant_hash: Option<[u8; 32]>,
    _marker: core::marker::PhantomData<ReturnTy>,
}

/// A dynamic lookup address to access a constant.
pub type DynamicAddress<ReturnTy> = StaticAddress<ReturnTy>;

impl<ReturnTy> StaticAddress<ReturnTy> {
    /// Create a new [`StaticAddress`] to use to look up a constant.
    pub fn new(pallet_name: impl Into<String>, constant_name: impl Into<String>) -> Self {
        Self {
            pallet_name: Cow::Owned(pallet_name.into()),
            constant_name: Cow::Owned(constant_name.into()),
            constant_hash: None,
            _marker: core::marker::PhantomData,
        }
    }

    /// Create a new [`StaticAddress`] that will be validated
    /// against node metadata using the hash given.
    #[doc(hidden)]
    pub fn new_static(
        pallet_name: &'static str,
        constant_name: &'static str,
        hash: [u8; 32],
    ) -> Self {
        Self {
            pallet_name: Cow::Borrowed(pallet_name),
            constant_name: Cow::Borrowed(constant_name),
            constant_hash: Some(hash),
            _marker: core::marker::PhantomData,
        }
    }

    /// Do not validate this constant prior to accessing it.
    pub fn unvalidated(self) -> Self {
        Self {
            pallet_name: self.pallet_name,
            constant_name: self.constant_name,
            constant_hash: None,
            _marker: self._marker,
        }
    }
}

impl<ReturnTy: DecodeAsType> Address for StaticAddress<ReturnTy> {
    type Target = ReturnTy;

    fn pallet_name(&self) -> &str {
        &self.pallet_name
    }

    fn constant_name(&self) -> &str {
        &self.constant_name
    }

    fn validation_hash(&self) -> Option<[u8; 32]> {
        self.constant_hash
    }
}

/// Construct a new dynamic constant lookup.
pub fn dynamic<ReturnTy: DecodeAsType>(
    pallet_name: impl Into<String>,
    constant_name: impl Into<String>,
) -> DynamicAddress<ReturnTy> {
    DynamicAddress::new(pallet_name, constant_name)
}