referrerpolicy=no-referrer-when-downgrade

pallet_node_authorization/
lib.rs

1// This file is part of Substrate.
2
3// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: Apache-2.0
5
6// 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.
17
18//! # 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.
36
37// Ensure we're `no_std` when compiling for Wasm.
38#![cfg_attr(not(feature = "std"), no_std)]
39
40#[cfg(test)]
41// We do not declare all features used by `construct_runtime`
42#[allow(unexpected_cfgs)]
43mod mock;
44#[cfg(test)]
45mod tests;
46
47pub mod weights;
48
49extern crate alloc;
50
51use 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;
58
59type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
60
61#[frame::pallet]
62pub mod pallet {
63	use super::*;
64
65	#[pallet::pallet]
66	#[pallet::without_storage_info]
67	pub struct Pallet<T>(_);
68
69	/// The module configuration trait
70	#[pallet::config]
71	pub trait Config: frame_system::Config {
72		/// The overarching event type.
73		#[allow(deprecated)]
74		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
75
76		/// The maximum number of well known nodes that are allowed to set
77		#[pallet::constant]
78		type MaxWellKnownNodes: Get<u32>;
79
80		/// The maximum length in bytes of PeerId
81		#[pallet::constant]
82		type MaxPeerIdLength: Get<u32>;
83
84		/// The origin which can add a well known node.
85		type AddOrigin: EnsureOrigin<Self::RuntimeOrigin>;
86
87		/// The origin which can remove a well known node.
88		type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
89
90		/// The origin which can swap the well known nodes.
91		type SwapOrigin: EnsureOrigin<Self::RuntimeOrigin>;
92
93		/// The origin which can reset the well known nodes.
94		type ResetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
95
96		/// Weight information for extrinsics in this pallet.
97		type WeightInfo: WeightInfo;
98	}
99
100	/// The set of well known nodes. This is stored sorted (just by value).
101	#[pallet::storage]
102	#[pallet::getter(fn well_known_nodes)]
103	pub type WellKnownNodes<T> = StorageValue<_, BTreeSet<PeerId>, ValueQuery>;
104
105	/// A map that maintains the ownership of each node.
106	#[pallet::storage]
107	#[pallet::getter(fn owners)]
108	pub type Owners<T: Config> = StorageMap<_, Blake2_128Concat, PeerId, T::AccountId>;
109
110	/// The additional adaptive connections of each node.
111	#[pallet::storage]
112	#[pallet::getter(fn additional_connection)]
113	pub type AdditionalConnections<T> =
114		StorageMap<_, Blake2_128Concat, PeerId, BTreeSet<PeerId>, ValueQuery>;
115
116	#[pallet::genesis_config]
117	#[derive(DefaultNoBound)]
118	pub struct GenesisConfig<T: Config> {
119		pub nodes: Vec<(PeerId, T::AccountId)>,
120	}
121
122	#[pallet::genesis_build]
123	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
124		fn build(&self) {
125			Pallet::<T>::initialize_nodes(&self.nodes);
126		}
127	}
128
129	#[pallet::event]
130	#[pallet::generate_deposit(pub(super) fn deposit_event)]
131	pub enum Event<T: Config> {
132		/// The given well known node was added.
133		NodeAdded { peer_id: PeerId, who: T::AccountId },
134		/// The given well known node was removed.
135		NodeRemoved { peer_id: PeerId },
136		/// The given well known node was swapped; first item was removed,
137		/// the latter was added.
138		NodeSwapped { removed: PeerId, added: PeerId },
139		/// The given well known nodes were reset.
140		NodesReset { nodes: Vec<(PeerId, T::AccountId)> },
141		/// The given node was claimed by a user.
142		NodeClaimed { peer_id: PeerId, who: T::AccountId },
143		/// The given claim was removed by its owner.
144		ClaimRemoved { peer_id: PeerId, who: T::AccountId },
145		/// The node was transferred to another account.
146		NodeTransferred { peer_id: PeerId, target: T::AccountId },
147		/// The allowed connections were added to a node.
148		ConnectionsAdded { peer_id: PeerId, allowed_connections: Vec<PeerId> },
149		/// The allowed connections were removed from a node.
150		ConnectionsRemoved { peer_id: PeerId, allowed_connections: Vec<PeerId> },
151	}
152
153	#[pallet::error]
154	pub enum Error<T> {
155		/// The PeerId is too long.
156		PeerIdTooLong,
157		/// Too many well known nodes.
158		TooManyNodes,
159		/// The node is already joined in the list.
160		AlreadyJoined,
161		/// The node doesn't exist in the list.
162		NotExist,
163		/// The node is already claimed by a user.
164		AlreadyClaimed,
165		/// The node hasn't been claimed yet.
166		NotClaimed,
167		/// You are not the owner of the node.
168		NotOwner,
169		/// No permission to perform specific operation.
170		PermissionDenied,
171	}
172
173	#[pallet::hooks]
174	impl<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.
177		fn offchain_worker(now: BlockNumberFor<T>) {
178			let network_state = sp_io::offchain::network_state();
179			match network_state {
180				Err(_) => log::error!(
181					target: "runtime::node-authorization",
182					"Error: failed to get network state of node at {:?}",
183					now,
184				),
185				Ok(state) => {
186					let encoded_peer = state.peer_id.0;
187					match Decode::decode(&mut &encoded_peer[..]) {
188						Err(_) => log::error!(
189							target: "runtime::node-authorization",
190							"Error: failed to decode PeerId at {:?}",
191							now,
192						),
193						Ok(node) => sp_io::offchain::set_authorized_nodes(
194							Self::get_authorized_nodes(&PeerId(node)),
195							true,
196						),
197					}
198				},
199			}
200		}
201	}
202
203	#[pallet::call]
204	impl<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))]
213		pub fn add_well_known_node(
214			origin: OriginFor<T>,
215			node: PeerId,
216			owner: AccountIdLookupOf<T>,
217		) -> DispatchResult {
218			T::AddOrigin::ensure_origin(origin)?;
219			let owner = T::Lookup::lookup(owner)?;
220			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
221
222			let mut nodes = WellKnownNodes::<T>::get();
223			ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
224			ensure!(!nodes.contains(&node), Error::<T>::AlreadyJoined);
225
226			nodes.insert(node.clone());
227
228			WellKnownNodes::<T>::put(&nodes);
229			<Owners<T>>::insert(&node, &owner);
230
231			Self::deposit_event(Event::NodeAdded { peer_id: node, who: owner });
232			Ok(())
233		}
234
235		/// 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))]
243		pub fn remove_well_known_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
244			T::RemoveOrigin::ensure_origin(origin)?;
245			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
246
247			let mut nodes = WellKnownNodes::<T>::get();
248			ensure!(nodes.contains(&node), Error::<T>::NotExist);
249
250			nodes.remove(&node);
251
252			WellKnownNodes::<T>::put(&nodes);
253			<Owners<T>>::remove(&node);
254			AdditionalConnections::<T>::remove(&node);
255
256			Self::deposit_event(Event::NodeRemoved { peer_id: node });
257			Ok(())
258		}
259
260		/// 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))]
269		pub fn swap_well_known_node(
270			origin: OriginFor<T>,
271			remove: PeerId,
272			add: PeerId,
273		) -> DispatchResult {
274			T::SwapOrigin::ensure_origin(origin)?;
275			ensure!(remove.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
276			ensure!(add.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
277
278			if remove == add {
279				return Ok(())
280			}
281
282			let mut nodes = WellKnownNodes::<T>::get();
283			ensure!(nodes.contains(&remove), Error::<T>::NotExist);
284			ensure!(!nodes.contains(&add), Error::<T>::AlreadyJoined);
285
286			nodes.remove(&remove);
287			nodes.insert(add.clone());
288
289			WellKnownNodes::<T>::put(&nodes);
290			Owners::<T>::swap(&remove, &add);
291			AdditionalConnections::<T>::swap(&remove, &add);
292
293			Self::deposit_event(Event::NodeSwapped { removed: remove, added: add });
294			Ok(())
295		}
296
297		/// 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))]
306		pub fn reset_well_known_nodes(
307			origin: OriginFor<T>,
308			nodes: Vec<(PeerId, T::AccountId)>,
309		) -> DispatchResult {
310			T::ResetOrigin::ensure_origin(origin)?;
311			ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
312
313			Self::initialize_nodes(&nodes);
314
315			Self::deposit_event(Event::NodesReset { nodes });
316			Ok(())
317		}
318
319		/// 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())]
325		pub fn claim_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
326			let sender = ensure_signed(origin)?;
327
328			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
329			ensure!(!Owners::<T>::contains_key(&node), Error::<T>::AlreadyClaimed);
330
331			Owners::<T>::insert(&node, &sender);
332			Self::deposit_event(Event::NodeClaimed { peer_id: node, who: sender });
333			Ok(())
334		}
335
336		/// 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())]
343		pub fn remove_claim(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
344			let sender = ensure_signed(origin)?;
345
346			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
347			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
348			ensure!(owner == sender, Error::<T>::NotOwner);
349			ensure!(!WellKnownNodes::<T>::get().contains(&node), Error::<T>::PermissionDenied);
350
351			Owners::<T>::remove(&node);
352			AdditionalConnections::<T>::remove(&node);
353
354			Self::deposit_event(Event::ClaimRemoved { peer_id: node, who: sender });
355			Ok(())
356		}
357
358		/// 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())]
364		pub fn transfer_node(
365			origin: OriginFor<T>,
366			node: PeerId,
367			owner: AccountIdLookupOf<T>,
368		) -> DispatchResult {
369			let sender = ensure_signed(origin)?;
370			let owner = T::Lookup::lookup(owner)?;
371
372			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
373			let pre_owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
374			ensure!(pre_owner == sender, Error::<T>::NotOwner);
375
376			Owners::<T>::insert(&node, &owner);
377
378			Self::deposit_event(Event::NodeTransferred { peer_id: node, target: owner });
379			Ok(())
380		}
381
382		/// 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())]
388		pub fn add_connections(
389			origin: OriginFor<T>,
390			node: PeerId,
391			connections: Vec<PeerId>,
392		) -> DispatchResult {
393			let sender = ensure_signed(origin)?;
394
395			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
396			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
397			ensure!(owner == sender, Error::<T>::NotOwner);
398
399			let mut nodes = AdditionalConnections::<T>::get(&node);
400
401			for add_node in connections.iter() {
402				if *add_node == node {
403					continue
404				}
405				nodes.insert(add_node.clone());
406			}
407
408			AdditionalConnections::<T>::insert(&node, nodes);
409
410			Self::deposit_event(Event::ConnectionsAdded {
411				peer_id: node,
412				allowed_connections: connections,
413			});
414			Ok(())
415		}
416
417		/// 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())]
423		pub fn remove_connections(
424			origin: OriginFor<T>,
425			node: PeerId,
426			connections: Vec<PeerId>,
427		) -> DispatchResult {
428			let sender = ensure_signed(origin)?;
429
430			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
431			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
432			ensure!(owner == sender, Error::<T>::NotOwner);
433
434			let mut nodes = AdditionalConnections::<T>::get(&node);
435
436			for remove_node in connections.iter() {
437				nodes.remove(remove_node);
438			}
439
440			AdditionalConnections::<T>::insert(&node, nodes);
441
442			Self::deposit_event(Event::ConnectionsRemoved {
443				peer_id: node,
444				allowed_connections: connections,
445			});
446			Ok(())
447		}
448	}
449}
450
451impl<T: Config> Pallet<T> {
452	fn initialize_nodes(nodes: &Vec<(PeerId, T::AccountId)>) {
453		let peer_ids = nodes.iter().map(|item| item.0.clone()).collect::<BTreeSet<PeerId>>();
454		WellKnownNodes::<T>::put(&peer_ids);
455
456		for (node, who) in nodes.iter() {
457			Owners::<T>::insert(node, who);
458		}
459	}
460
461	fn get_authorized_nodes(node: &PeerId) -> Vec<PeerId> {
462		let mut nodes = AdditionalConnections::<T>::get(node);
463
464		let mut well_known_nodes = WellKnownNodes::<T>::get();
465		if well_known_nodes.contains(node) {
466			well_known_nodes.remove(node);
467			nodes.extend(well_known_nodes);
468		}
469
470		Vec::from_iter(nodes)
471	}
472}