1// This file is part of Substrate.
23// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: Apache-2.0
56// Licensed under the Apache License, Version 2.0 (the "License");
7// you may not use this file except in compliance with the License.
8// You may obtain a copy of the License at
9//
10// http://www.apache.org/licenses/LICENSE-2.0
11//
12// Unless required by applicable law or agreed to in writing, software
13// distributed under the License is distributed on an "AS IS" BASIS,
14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15// See the License for the specific language governing permissions and
16// limitations under the License.
1718//! # Node authorization pallet
19//!
20//! This pallet manages a configurable set of nodes for a permissioned network.
21//! Each node is identified by a PeerId (i.e. `Vec<u8>`). It provides two ways to
22//! authorize a node,
23//!
24//! - a set of well known nodes across different organizations in which the
25//! connections are allowed.
26//! - users can claim the ownership for each node, then manage the connections of
27//! the node.
28//!
29//! A node must have an owner. The owner can additionally change the connections
30//! for the node. Only one user is allowed to claim a specific node. To eliminate
31//! false claim, the maintainer of the node should claim it before even starting the
32//! node. This pallet uses offchain worker to set reserved nodes, if the node is not
33//! an authority, make sure to enable offchain worker with the right CLI flag. The
34//! node can be lagged with the latest block, in this case you need to disable offchain
35//! worker and manually set reserved nodes when starting it.
3637// Ensure we're `no_std` when compiling for Wasm.
38#![cfg_attr(not(feature = "std"), no_std)]
3940#[cfg(test)]
41// We do not declare all features used by `construct_runtime`
42#[allow(unexpected_cfgs)]
43mod mock;
44#[cfg(test)]
45mod tests;
4647pub mod weights;
4849extern crate alloc;
5051use alloc::{collections::btree_set::BTreeSet, vec::Vec};
52use frame::{
53 deps::{sp_core::OpaquePeerId as PeerId, sp_io},
54 prelude::*,
55};
56pub use pallet::*;
57pub use weights::WeightInfo;
5859type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
6061#[frame::pallet]
62pub mod pallet {
63use super::*;
6465#[pallet::pallet]
66 #[pallet::without_storage_info]
67pub struct Pallet<T>(_);
6869/// The module configuration trait
70#[pallet::config]
71pub trait Config: frame_system::Config {
72/// The overarching event type.
73#[allow(deprecated)]
74type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
7576/// The maximum number of well known nodes that are allowed to set
77#[pallet::constant]
78type MaxWellKnownNodes: Get<u32>;
7980/// The maximum length in bytes of PeerId
81#[pallet::constant]
82type MaxPeerIdLength: Get<u32>;
8384/// The origin which can add a well known node.
85type AddOrigin: EnsureOrigin<Self::RuntimeOrigin>;
8687/// The origin which can remove a well known node.
88type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
8990/// The origin which can swap the well known nodes.
91type SwapOrigin: EnsureOrigin<Self::RuntimeOrigin>;
9293/// The origin which can reset the well known nodes.
94type ResetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
9596/// Weight information for extrinsics in this pallet.
97type WeightInfo: WeightInfo;
98 }
99100/// The set of well known nodes. This is stored sorted (just by value).
101#[pallet::storage]
102 #[pallet::getter(fn well_known_nodes)]
103pub type WellKnownNodes<T> = StorageValue<_, BTreeSet<PeerId>, ValueQuery>;
104105/// A map that maintains the ownership of each node.
106#[pallet::storage]
107 #[pallet::getter(fn owners)]
108pub type Owners<T: Config> = StorageMap<_, Blake2_128Concat, PeerId, T::AccountId>;
109110/// The additional adaptive connections of each node.
111#[pallet::storage]
112 #[pallet::getter(fn additional_connection)]
113pub type AdditionalConnections<T> =
114 StorageMap<_, Blake2_128Concat, PeerId, BTreeSet<PeerId>, ValueQuery>;
115116#[pallet::genesis_config]
117 #[derive(DefaultNoBound)]
118pub struct GenesisConfig<T: Config> {
119pub nodes: Vec<(PeerId, T::AccountId)>,
120 }
121122#[pallet::genesis_build]
123impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
124fn build(&self) {
125 Pallet::<T>::initialize_nodes(&self.nodes);
126 }
127 }
128129#[pallet::event]
130 #[pallet::generate_deposit(pub(super) fn deposit_event)]
131pub enum Event<T: Config> {
132/// The given well known node was added.
133NodeAdded { peer_id: PeerId, who: T::AccountId },
134/// The given well known node was removed.
135NodeRemoved { peer_id: PeerId },
136/// The given well known node was swapped; first item was removed,
137 /// the latter was added.
138NodeSwapped { removed: PeerId, added: PeerId },
139/// The given well known nodes were reset.
140NodesReset { nodes: Vec<(PeerId, T::AccountId)> },
141/// The given node was claimed by a user.
142NodeClaimed { peer_id: PeerId, who: T::AccountId },
143/// The given claim was removed by its owner.
144ClaimRemoved { peer_id: PeerId, who: T::AccountId },
145/// The node was transferred to another account.
146NodeTransferred { peer_id: PeerId, target: T::AccountId },
147/// The allowed connections were added to a node.
148ConnectionsAdded { peer_id: PeerId, allowed_connections: Vec<PeerId> },
149/// The allowed connections were removed from a node.
150ConnectionsRemoved { peer_id: PeerId, allowed_connections: Vec<PeerId> },
151 }
152153#[pallet::error]
154pub enum Error<T> {
155/// The PeerId is too long.
156PeerIdTooLong,
157/// Too many well known nodes.
158TooManyNodes,
159/// The node is already joined in the list.
160AlreadyJoined,
161/// The node doesn't exist in the list.
162NotExist,
163/// The node is already claimed by a user.
164AlreadyClaimed,
165/// The node hasn't been claimed yet.
166NotClaimed,
167/// You are not the owner of the node.
168NotOwner,
169/// No permission to perform specific operation.
170PermissionDenied,
171 }
172173#[pallet::hooks]
174impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
175/// Set reserved node every block. It may not be enabled depends on the offchain
176 /// worker settings when starting the node.
177fn offchain_worker(now: BlockNumberFor<T>) {
178let network_state = sp_io::offchain::network_state();
179match network_state {
180Err(_) => log::error!(
181 target: "runtime::node-authorization",
182"Error: failed to get network state of node at {:?}",
183 now,
184 ),
185Ok(state) => {
186let encoded_peer = state.peer_id.0;
187match Decode::decode(&mut &encoded_peer[..]) {
188Err(_) => log::error!(
189 target: "runtime::node-authorization",
190"Error: failed to decode PeerId at {:?}",
191 now,
192 ),
193Ok(node) => sp_io::offchain::set_authorized_nodes(
194Self::get_authorized_nodes(&PeerId(node)),
195true,
196 ),
197 }
198 },
199 }
200 }
201 }
202203#[pallet::call]
204impl<T: Config> Pallet<T> {
205/// Add a node to the set of well known nodes. If the node is already claimed, the owner
206 /// will be updated and keep the existing additional connection unchanged.
207 ///
208 /// May only be called from `T::AddOrigin`.
209 ///
210 /// - `node`: identifier of the node.
211#[pallet::call_index(0)]
212 #[pallet::weight((T::WeightInfo::add_well_known_node(), DispatchClass::Operational))]
213pub fn add_well_known_node(
214 origin: OriginFor<T>,
215 node: PeerId,
216 owner: AccountIdLookupOf<T>,
217 ) -> DispatchResult {
218 T::AddOrigin::ensure_origin(origin)?;
219let owner = T::Lookup::lookup(owner)?;
220ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
221222let mut nodes = WellKnownNodes::<T>::get();
223ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
224ensure!(!nodes.contains(&node), Error::<T>::AlreadyJoined);
225226 nodes.insert(node.clone());
227228 WellKnownNodes::<T>::put(&nodes);
229 <Owners<T>>::insert(&node, &owner);
230231Self::deposit_event(Event::NodeAdded { peer_id: node, who: owner });
232Ok(())
233 }
234235/// Remove a node from the set of well known nodes. The ownership and additional
236 /// connections of the node will also be removed.
237 ///
238 /// May only be called from `T::RemoveOrigin`.
239 ///
240 /// - `node`: identifier of the node.
241#[pallet::call_index(1)]
242 #[pallet::weight((T::WeightInfo::remove_well_known_node(), DispatchClass::Operational))]
243pub fn remove_well_known_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
244 T::RemoveOrigin::ensure_origin(origin)?;
245ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
246247let mut nodes = WellKnownNodes::<T>::get();
248ensure!(nodes.contains(&node), Error::<T>::NotExist);
249250 nodes.remove(&node);
251252 WellKnownNodes::<T>::put(&nodes);
253 <Owners<T>>::remove(&node);
254 AdditionalConnections::<T>::remove(&node);
255256Self::deposit_event(Event::NodeRemoved { peer_id: node });
257Ok(())
258 }
259260/// Swap a well known node to another. Both the ownership and additional connections
261 /// stay untouched.
262 ///
263 /// May only be called from `T::SwapOrigin`.
264 ///
265 /// - `remove`: the node which will be moved out from the list.
266 /// - `add`: the node which will be put in the list.
267#[pallet::call_index(2)]
268 #[pallet::weight((T::WeightInfo::swap_well_known_node(), DispatchClass::Operational))]
269pub fn swap_well_known_node(
270 origin: OriginFor<T>,
271 remove: PeerId,
272 add: PeerId,
273 ) -> DispatchResult {
274 T::SwapOrigin::ensure_origin(origin)?;
275ensure!(remove.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
276ensure!(add.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
277278if remove == add {
279return Ok(())
280 }
281282let mut nodes = WellKnownNodes::<T>::get();
283ensure!(nodes.contains(&remove), Error::<T>::NotExist);
284ensure!(!nodes.contains(&add), Error::<T>::AlreadyJoined);
285286 nodes.remove(&remove);
287 nodes.insert(add.clone());
288289 WellKnownNodes::<T>::put(&nodes);
290 Owners::<T>::swap(&remove, &add);
291 AdditionalConnections::<T>::swap(&remove, &add);
292293Self::deposit_event(Event::NodeSwapped { removed: remove, added: add });
294Ok(())
295 }
296297/// Reset all the well known nodes. This will not remove the ownership and additional
298 /// connections for the removed nodes. The node owner can perform further cleaning if
299 /// they decide to leave the network.
300 ///
301 /// May only be called from `T::ResetOrigin`.
302 ///
303 /// - `nodes`: the new nodes for the allow list.
304#[pallet::call_index(3)]
305 #[pallet::weight((T::WeightInfo::reset_well_known_nodes(), DispatchClass::Operational))]
306pub fn reset_well_known_nodes(
307 origin: OriginFor<T>,
308 nodes: Vec<(PeerId, T::AccountId)>,
309 ) -> DispatchResult {
310 T::ResetOrigin::ensure_origin(origin)?;
311ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
312313Self::initialize_nodes(&nodes);
314315Self::deposit_event(Event::NodesReset { nodes });
316Ok(())
317 }
318319/// A given node can be claimed by anyone. The owner should be the first to know its
320 /// PeerId, so claim it right away!
321 ///
322 /// - `node`: identifier of the node.
323#[pallet::call_index(4)]
324 #[pallet::weight(T::WeightInfo::claim_node())]
325pub fn claim_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
326let sender = ensure_signed(origin)?;
327328ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
329ensure!(!Owners::<T>::contains_key(&node), Error::<T>::AlreadyClaimed);
330331 Owners::<T>::insert(&node, &sender);
332Self::deposit_event(Event::NodeClaimed { peer_id: node, who: sender });
333Ok(())
334 }
335336/// A claim can be removed by its owner and get back the reservation. The additional
337 /// connections are also removed. You can't remove a claim on well known nodes, as it
338 /// needs to reach consensus among the network participants.
339 ///
340 /// - `node`: identifier of the node.
341#[pallet::call_index(5)]
342 #[pallet::weight(T::WeightInfo::remove_claim())]
343pub fn remove_claim(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
344let sender = ensure_signed(origin)?;
345346ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
347let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
348ensure!(owner == sender, Error::<T>::NotOwner);
349ensure!(!WellKnownNodes::<T>::get().contains(&node), Error::<T>::PermissionDenied);
350351 Owners::<T>::remove(&node);
352 AdditionalConnections::<T>::remove(&node);
353354Self::deposit_event(Event::ClaimRemoved { peer_id: node, who: sender });
355Ok(())
356 }
357358/// A node can be transferred to a new owner.
359 ///
360 /// - `node`: identifier of the node.
361 /// - `owner`: new owner of the node.
362#[pallet::call_index(6)]
363 #[pallet::weight(T::WeightInfo::transfer_node())]
364pub fn transfer_node(
365 origin: OriginFor<T>,
366 node: PeerId,
367 owner: AccountIdLookupOf<T>,
368 ) -> DispatchResult {
369let sender = ensure_signed(origin)?;
370let owner = T::Lookup::lookup(owner)?;
371372ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
373let pre_owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
374ensure!(pre_owner == sender, Error::<T>::NotOwner);
375376 Owners::<T>::insert(&node, &owner);
377378Self::deposit_event(Event::NodeTransferred { peer_id: node, target: owner });
379Ok(())
380 }
381382/// Add additional connections to a given node.
383 ///
384 /// - `node`: identifier of the node.
385 /// - `connections`: additional nodes from which the connections are allowed.
386#[pallet::call_index(7)]
387 #[pallet::weight(T::WeightInfo::add_connections())]
388pub fn add_connections(
389 origin: OriginFor<T>,
390 node: PeerId,
391 connections: Vec<PeerId>,
392 ) -> DispatchResult {
393let sender = ensure_signed(origin)?;
394395ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
396let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
397ensure!(owner == sender, Error::<T>::NotOwner);
398399let mut nodes = AdditionalConnections::<T>::get(&node);
400401for add_node in connections.iter() {
402if *add_node == node {
403continue
404}
405 nodes.insert(add_node.clone());
406 }
407408 AdditionalConnections::<T>::insert(&node, nodes);
409410Self::deposit_event(Event::ConnectionsAdded {
411 peer_id: node,
412 allowed_connections: connections,
413 });
414Ok(())
415 }
416417/// Remove additional connections of a given node.
418 ///
419 /// - `node`: identifier of the node.
420 /// - `connections`: additional nodes from which the connections are not allowed anymore.
421#[pallet::call_index(8)]
422 #[pallet::weight(T::WeightInfo::remove_connections())]
423pub fn remove_connections(
424 origin: OriginFor<T>,
425 node: PeerId,
426 connections: Vec<PeerId>,
427 ) -> DispatchResult {
428let sender = ensure_signed(origin)?;
429430ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
431let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
432ensure!(owner == sender, Error::<T>::NotOwner);
433434let mut nodes = AdditionalConnections::<T>::get(&node);
435436for remove_node in connections.iter() {
437 nodes.remove(remove_node);
438 }
439440 AdditionalConnections::<T>::insert(&node, nodes);
441442Self::deposit_event(Event::ConnectionsRemoved {
443 peer_id: node,
444 allowed_connections: connections,
445 });
446Ok(())
447 }
448 }
449}
450451impl<T: Config> Pallet<T> {
452fn initialize_nodes(nodes: &Vec<(PeerId, T::AccountId)>) {
453let peer_ids = nodes.iter().map(|item| item.0.clone()).collect::<BTreeSet<PeerId>>();
454 WellKnownNodes::<T>::put(&peer_ids);
455456for (node, who) in nodes.iter() {
457 Owners::<T>::insert(node, who);
458 }
459 }
460461fn get_authorized_nodes(node: &PeerId) -> Vec<PeerId> {
462let mut nodes = AdditionalConnections::<T>::get(node);
463464let mut well_known_nodes = WellKnownNodes::<T>::get();
465if well_known_nodes.contains(node) {
466 well_known_nodes.remove(node);
467 nodes.extend(well_known_nodes);
468 }
469470 Vec::from_iter(nodes)
471 }
472}