#![cfg_attr(not(feature = "std"), no_std)]
use tet_core::OpaquePeerId as PeerId;
use tetcore_std::{
collections::btree_set::BTreeSet,
iter::FromIterator,
prelude::*,
};
use codec::Decode;
use fabric_support::{
decl_module, decl_storage, decl_event, decl_error,
debug, ensure,
weights::{DispatchClass, Weight},
traits::{Get, EnsureOrigin},
};
use fabric_system::ensure_signed;
pub trait WeightInfo {
fn add_well_known_node() -> Weight;
fn remove_well_known_node() -> Weight;
fn swap_well_known_node() -> Weight;
fn reset_well_known_nodes() -> Weight;
fn claim_node() -> Weight;
fn remove_claim() -> Weight;
fn transfer_node() -> Weight;
fn add_connections() -> Weight;
fn remove_connections() -> Weight;
}
impl WeightInfo for () {
fn add_well_known_node() -> Weight { 50_000_000 }
fn remove_well_known_node() -> Weight { 50_000_000 }
fn swap_well_known_node() -> Weight { 50_000_000 }
fn reset_well_known_nodes() -> Weight { 50_000_000 }
fn claim_node() -> Weight { 50_000_000 }
fn remove_claim() -> Weight { 50_000_000 }
fn transfer_node() -> Weight { 50_000_000 }
fn add_connections() -> Weight { 50_000_000 }
fn remove_connections() -> Weight { 50_000_000 }
}
pub trait Config: fabric_system::Config {
type Event: From<Event<Self>> + Into<<Self as fabric_system::Config>::Event>;
type MaxWellKnownNodes: Get<u32>;
type MaxPeerIdLength: Get<u32>;
type AddOrigin: EnsureOrigin<Self::Origin>;
type RemoveOrigin: EnsureOrigin<Self::Origin>;
type SwapOrigin: EnsureOrigin<Self::Origin>;
type ResetOrigin: EnsureOrigin<Self::Origin>;
type WeightInfo: WeightInfo;
}
decl_storage! {
trait Store for Module<T: Config> as NodeAuthorization {
pub WellKnownNodes get(fn well_known_nodes): BTreeSet<PeerId>;
pub Owners get(fn owners):
map hasher(blake2_128_concat) PeerId => T::AccountId;
pub AdditionalConnections get(fn additional_connection):
map hasher(blake2_128_concat) PeerId => BTreeSet<PeerId>;
}
add_extra_genesis {
config(nodes): Vec<(PeerId, T::AccountId)>;
build(|config: &GenesisConfig<T>| {
<Module<T>>::initialize_nodes(&config.nodes)
})
}
}
decl_event! {
pub enum Event<T> where
<T as fabric_system::Config>::AccountId,
{
NodeAdded(PeerId, AccountId),
NodeRemoved(PeerId),
NodeSwapped(PeerId, PeerId),
NodesReset(Vec<(PeerId, AccountId)>),
NodeClaimed(PeerId, AccountId),
ClaimRemoved(PeerId, AccountId),
NodeTransferred(PeerId, AccountId),
ConnectionsAdded(PeerId, Vec<PeerId>),
ConnectionsRemoved(PeerId, Vec<PeerId>),
}
}
decl_error! {
pub enum Error for Module<T: Config> {
PeerIdTooLong,
TooManyNodes,
AlreadyJoined,
NotExist,
AlreadyClaimed,
NotClaimed,
NotOwner,
PermissionDenied,
}
}
decl_module! {
pub struct Module<T: Config> for enum Call where origin: T::Origin {
const MaxWellKnownNodes: u32 = T::MaxWellKnownNodes::get();
const MaxPeerIdLength: u32 = T::MaxPeerIdLength::get();
type Error = Error<T>;
fn deposit_event() = default;
#[weight = (T::WeightInfo::add_well_known_node(), DispatchClass::Operational)]
pub fn add_well_known_node(origin, node: PeerId, owner: T::AccountId) {
T::AddOrigin::ensure_origin(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
let mut nodes = WellKnownNodes::get();
ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
ensure!(!nodes.contains(&node), Error::<T>::AlreadyJoined);
nodes.insert(node.clone());
WellKnownNodes::put(&nodes);
<Owners<T>>::insert(&node, &owner);
Self::deposit_event(RawEvent::NodeAdded(node, owner));
}
#[weight = (T::WeightInfo::remove_well_known_node(), DispatchClass::Operational)]
pub fn remove_well_known_node(origin, node: PeerId) {
T::RemoveOrigin::ensure_origin(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
let mut nodes = WellKnownNodes::get();
ensure!(nodes.contains(&node), Error::<T>::NotExist);
nodes.remove(&node);
WellKnownNodes::put(&nodes);
<Owners<T>>::remove(&node);
AdditionalConnections::remove(&node);
Self::deposit_event(RawEvent::NodeRemoved(node));
}
#[weight = (T::WeightInfo::swap_well_known_node(), DispatchClass::Operational)]
pub fn swap_well_known_node(origin, remove: PeerId, add: PeerId) {
T::SwapOrigin::ensure_origin(origin)?;
ensure!(remove.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(add.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
if remove == add { return Ok(()) }
let mut nodes = WellKnownNodes::get();
ensure!(nodes.contains(&remove), Error::<T>::NotExist);
ensure!(!nodes.contains(&add), Error::<T>::AlreadyJoined);
nodes.remove(&remove);
nodes.insert(add.clone());
WellKnownNodes::put(&nodes);
Owners::<T>::swap(&remove, &add);
AdditionalConnections::swap(&remove, &add);
Self::deposit_event(RawEvent::NodeSwapped(remove, add));
}
#[weight = (T::WeightInfo::reset_well_known_nodes(), DispatchClass::Operational)]
pub fn reset_well_known_nodes(origin, nodes: Vec<(PeerId, T::AccountId)>) {
T::ResetOrigin::ensure_origin(origin)?;
ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
Self::initialize_nodes(&nodes);
Self::deposit_event(RawEvent::NodesReset(nodes));
}
#[weight = T::WeightInfo::claim_node()]
pub fn claim_node(origin, node: PeerId) {
let sender = ensure_signed(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(!Owners::<T>::contains_key(&node),Error::<T>::AlreadyClaimed);
Owners::<T>::insert(&node, &sender);
Self::deposit_event(RawEvent::NodeClaimed(node, sender));
}
#[weight = T::WeightInfo::remove_claim()]
pub fn remove_claim(origin, node: PeerId) {
let sender = ensure_signed(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(Owners::<T>::contains_key(&node), Error::<T>::NotClaimed);
ensure!(Owners::<T>::get(&node) == sender, Error::<T>::NotOwner);
ensure!(!WellKnownNodes::get().contains(&node), Error::<T>::PermissionDenied);
Owners::<T>::remove(&node);
AdditionalConnections::remove(&node);
Self::deposit_event(RawEvent::ClaimRemoved(node, sender));
}
#[weight = T::WeightInfo::transfer_node()]
pub fn transfer_node(origin, node: PeerId, owner: T::AccountId) {
let sender = ensure_signed(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(Owners::<T>::contains_key(&node), Error::<T>::NotClaimed);
ensure!(Owners::<T>::get(&node) == sender, Error::<T>::NotOwner);
Owners::<T>::insert(&node, &owner);
Self::deposit_event(RawEvent::NodeTransferred(node, owner));
}
#[weight = T::WeightInfo::add_connections()]
pub fn add_connections(
origin,
node: PeerId,
connections: Vec<PeerId>
) {
let sender = ensure_signed(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(Owners::<T>::contains_key(&node), Error::<T>::NotClaimed);
ensure!(Owners::<T>::get(&node) == sender, Error::<T>::NotOwner);
let mut nodes = AdditionalConnections::get(&node);
for add_node in connections.iter() {
if *add_node == node {
continue;
}
nodes.insert(add_node.clone());
}
AdditionalConnections::insert(&node, nodes);
Self::deposit_event(RawEvent::ConnectionsAdded(node, connections));
}
#[weight = T::WeightInfo::remove_connections()]
pub fn remove_connections(
origin,
node: PeerId,
connections: Vec<PeerId>
) {
let sender = ensure_signed(origin)?;
ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
ensure!(Owners::<T>::contains_key(&node), Error::<T>::NotClaimed);
ensure!(Owners::<T>::get(&node) == sender, Error::<T>::NotOwner);
let mut nodes = AdditionalConnections::get(&node);
for remove_node in connections.iter() {
nodes.remove(remove_node);
}
AdditionalConnections::insert(&node, nodes);
Self::deposit_event(RawEvent::ConnectionsRemoved(node, connections));
}
fn offchain_worker(now: T::BlockNumber) {
let network_state = tet_io::offchain::network_state();
match network_state {
Err(_) => debug::error!("Error: failed to get network state of node at {:?}", now),
Ok(state) => {
let encoded_peer = state.peer_id.0;
match Decode::decode(&mut &encoded_peer[..]) {
Err(_) => debug::error!("Error: failed to decode PeerId at {:?}", now),
Ok(node) => tet_io::offchain::set_authorized_nodes(
Self::get_authorized_nodes(&PeerId(node)),
true
)
}
}
}
}
}
}
impl<T: Config> Module<T> {
fn initialize_nodes(nodes: &Vec<(PeerId, T::AccountId)>) {
let peer_ids = nodes.iter()
.map(|item| item.0.clone())
.collect::<BTreeSet<PeerId>>();
WellKnownNodes::put(&peer_ids);
for (node, who) in nodes.iter() {
Owners::<T>::insert(node, who);
}
}
fn get_authorized_nodes(node: &PeerId) -> Vec<PeerId> {
let mut nodes = AdditionalConnections::get(node);
let mut well_known_nodes = WellKnownNodes::get();
if well_known_nodes.contains(node) {
well_known_nodes.remove(node);
nodes.extend(well_known_nodes);
}
Vec::from_iter(nodes)
}
}
#[cfg(test)]
mod tests {
use super::*;
use fabric_support::{
assert_ok, assert_noop, impl_outer_origin,
parameter_types, ord_parameter_types,
};
use fabric_system::EnsureSignedBy;
use tet_core::H256;
use tp_runtime::{traits::{BlakeTwo256, IdentityLookup, BadOrigin}, testing::Header};
impl_outer_origin! {
pub enum Origin for Test where system = fabric_system {}
}
#[derive(Clone, Eq, PartialEq)]
pub struct Test;
parameter_types! {
pub const BlockHashCount: u64 = 250;
}
impl fabric_system::Config for Test {
type BaseCallFilter = ();
type DbWeight = ();
type BlockWeights = ();
type BlockLength = ();
type Origin = Origin;
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
type Call = ();
type Hashing = BlakeTwo256;
type AccountId = u64;
type Lookup = IdentityLookup<Self::AccountId>;
type Header = Header;
type Event = ();
type BlockHashCount = BlockHashCount;
type Version = ();
type NobleInfo = ();
type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
type SystemWeightInfo = ();
type SS58Prefix = ();
}
ord_parameter_types! {
pub const One: u64 = 1;
pub const Two: u64 = 2;
pub const Three: u64 = 3;
pub const Four: u64 = 4;
}
parameter_types! {
pub const MaxWellKnownNodes: u32 = 4;
pub const MaxPeerIdLength: u32 = 2;
}
impl Config for Test {
type Event = ();
type MaxWellKnownNodes = MaxWellKnownNodes;
type MaxPeerIdLength = MaxPeerIdLength;
type AddOrigin = EnsureSignedBy<One, u64>;
type RemoveOrigin = EnsureSignedBy<Two, u64>;
type SwapOrigin = EnsureSignedBy<Three, u64>;
type ResetOrigin = EnsureSignedBy<Four, u64>;
type WeightInfo = ();
}
type NodeAuthorization = Module<Test>;
fn test_node(id: u8) -> PeerId {
PeerId(vec![id])
}
fn new_test_ext() -> tet_io::TestExternalities {
let mut t = fabric_system::GenesisConfig::default().build_storage::<Test>().unwrap();
GenesisConfig::<Test> {
nodes: vec![(test_node(10), 10), (test_node(20), 20), (test_node(30), 30)],
}.assimilate_storage(&mut t).unwrap();
t.into()
}
#[test]
fn add_well_known_node_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::add_well_known_node(Origin::signed(2), test_node(15), 15),
BadOrigin
);
assert_noop!(
NodeAuthorization::add_well_known_node(Origin::signed(1), PeerId(vec![1, 2, 3]), 15),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::add_well_known_node(Origin::signed(1), test_node(20), 20),
Error::<Test>::AlreadyJoined
);
assert_ok!(
NodeAuthorization::add_well_known_node(Origin::signed(1), test_node(15), 15)
);
assert_eq!(
WellKnownNodes::get(),
BTreeSet::from_iter(vec![test_node(10), test_node(15), test_node(20), test_node(30)])
);
assert_eq!(Owners::<Test>::get(test_node(10)), 10);
assert_eq!(Owners::<Test>::get(test_node(20)), 20);
assert_eq!(Owners::<Test>::get(test_node(30)), 30);
assert_eq!(Owners::<Test>::get(test_node(15)), 15);
assert_noop!(
NodeAuthorization::add_well_known_node(Origin::signed(1), test_node(25), 25),
Error::<Test>::TooManyNodes
);
});
}
#[test]
fn remove_well_known_node_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::remove_well_known_node(Origin::signed(3), test_node(20)),
BadOrigin
);
assert_noop!(
NodeAuthorization::remove_well_known_node(Origin::signed(2), PeerId(vec![1, 2, 3])),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::remove_well_known_node(Origin::signed(2), test_node(40)),
Error::<Test>::NotExist
);
AdditionalConnections::insert(
test_node(20),
BTreeSet::from_iter(vec![test_node(40)])
);
assert!(AdditionalConnections::contains_key(test_node(20)));
assert_ok!(
NodeAuthorization::remove_well_known_node(Origin::signed(2), test_node(20))
);
assert_eq!(
WellKnownNodes::get(),
BTreeSet::from_iter(vec![test_node(10), test_node(30)])
);
assert!(!Owners::<Test>::contains_key(test_node(20)));
assert!(!AdditionalConnections::contains_key(test_node(20)));
});
}
#[test]
fn swap_well_known_node_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::swap_well_known_node(
Origin::signed(4), test_node(20), test_node(5)
),
BadOrigin
);
assert_noop!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), PeerId(vec![1, 2, 3]), test_node(20)
),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), test_node(20), PeerId(vec![1, 2, 3])
),
Error::<Test>::PeerIdTooLong
);
assert_ok!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), test_node(20), test_node(20)
)
);
assert_eq!(
WellKnownNodes::get(),
BTreeSet::from_iter(vec![test_node(10), test_node(20), test_node(30)])
);
assert_noop!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), test_node(15), test_node(5)
),
Error::<Test>::NotExist
);
assert_noop!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), test_node(20), test_node(30)
),
Error::<Test>::AlreadyJoined
);
AdditionalConnections::insert(
test_node(20),
BTreeSet::from_iter(vec![test_node(15)])
);
assert_ok!(
NodeAuthorization::swap_well_known_node(
Origin::signed(3), test_node(20), test_node(5)
)
);
assert_eq!(
WellKnownNodes::get(),
BTreeSet::from_iter(vec![test_node(5), test_node(10), test_node(30)])
);
assert!(!Owners::<Test>::contains_key(test_node(20)));
assert_eq!(Owners::<Test>::get(test_node(5)), 20);
assert!(!AdditionalConnections::contains_key(test_node(20)));
assert_eq!(
AdditionalConnections::get(test_node(5)),
BTreeSet::from_iter(vec![test_node(15)])
);
});
}
#[test]
fn reset_well_known_nodes_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::reset_well_known_nodes(
Origin::signed(3),
vec![(test_node(15), 15), (test_node(5), 5), (test_node(20), 20)]
),
BadOrigin
);
assert_noop!(
NodeAuthorization::reset_well_known_nodes(
Origin::signed(4),
vec![
(test_node(15), 15),
(test_node(5), 5),
(test_node(20), 20),
(test_node(25), 25),
]
),
Error::<Test>::TooManyNodes
);
assert_ok!(
NodeAuthorization::reset_well_known_nodes(
Origin::signed(4),
vec![(test_node(15), 15), (test_node(5), 5), (test_node(20), 20)]
)
);
assert_eq!(
WellKnownNodes::get(),
BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(20)])
);
assert_eq!(Owners::<Test>::get(test_node(5)), 5);
assert_eq!(Owners::<Test>::get(test_node(15)), 15);
assert_eq!(Owners::<Test>::get(test_node(20)), 20);
});
}
#[test]
fn claim_node_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::claim_node(Origin::signed(1), PeerId(vec![1, 2, 3])),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::claim_node(Origin::signed(1), test_node(20)),
Error::<Test>::AlreadyClaimed
);
assert_ok!(NodeAuthorization::claim_node(Origin::signed(15), test_node(15)));
assert_eq!(Owners::<Test>::get(test_node(15)), 15);
});
}
#[test]
fn remove_claim_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::remove_claim(Origin::signed(15), PeerId(vec![1, 2, 3])),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::remove_claim(Origin::signed(15), test_node(15)),
Error::<Test>::NotClaimed
);
assert_noop!(
NodeAuthorization::remove_claim(Origin::signed(15), test_node(20)),
Error::<Test>::NotOwner
);
assert_noop!(
NodeAuthorization::remove_claim(Origin::signed(20), test_node(20)),
Error::<Test>::PermissionDenied
);
Owners::<Test>::insert(test_node(15), 15);
AdditionalConnections::insert(
test_node(15),
BTreeSet::from_iter(vec![test_node(20)])
);
assert_ok!(NodeAuthorization::remove_claim(Origin::signed(15), test_node(15)));
assert!(!Owners::<Test>::contains_key(test_node(15)));
assert!(!AdditionalConnections::contains_key(test_node(15)));
});
}
#[test]
fn transfer_node_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::transfer_node(Origin::signed(15), PeerId(vec![1, 2, 3]), 10),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::transfer_node(Origin::signed(15), test_node(15), 10),
Error::<Test>::NotClaimed
);
assert_noop!(
NodeAuthorization::transfer_node(Origin::signed(15), test_node(20), 10),
Error::<Test>::NotOwner
);
assert_ok!(NodeAuthorization::transfer_node(Origin::signed(20), test_node(20), 15));
assert_eq!(Owners::<Test>::get(test_node(20)), 15);
});
}
#[test]
fn add_connections_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::add_connections(
Origin::signed(15), PeerId(vec![1, 2, 3]), vec![test_node(5)]
),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::add_connections(
Origin::signed(15), test_node(15), vec![test_node(5)]
),
Error::<Test>::NotClaimed
);
assert_noop!(
NodeAuthorization::add_connections(
Origin::signed(15), test_node(20), vec![test_node(5)]
),
Error::<Test>::NotOwner
);
assert_ok!(
NodeAuthorization::add_connections(
Origin::signed(20),
test_node(20),
vec![test_node(15), test_node(5), test_node(25), test_node(20)]
)
);
assert_eq!(
AdditionalConnections::get(test_node(20)),
BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)])
);
});
}
#[test]
fn remove_connections_works() {
new_test_ext().execute_with(|| {
assert_noop!(
NodeAuthorization::remove_connections(
Origin::signed(15), PeerId(vec![1, 2, 3]), vec![test_node(5)]
),
Error::<Test>::PeerIdTooLong
);
assert_noop!(
NodeAuthorization::remove_connections(
Origin::signed(15), test_node(15), vec![test_node(5)]
),
Error::<Test>::NotClaimed
);
assert_noop!(
NodeAuthorization::remove_connections(
Origin::signed(15), test_node(20), vec![test_node(5)]
),
Error::<Test>::NotOwner
);
AdditionalConnections::insert(
test_node(20),
BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)])
);
assert_ok!(
NodeAuthorization::remove_connections(
Origin::signed(20),
test_node(20),
vec![test_node(15), test_node(5)]
)
);
assert_eq!(
AdditionalConnections::get(test_node(20)),
BTreeSet::from_iter(vec![test_node(25)])
);
});
}
#[test]
fn get_authorized_nodes_works() {
new_test_ext().execute_with(|| {
AdditionalConnections::insert(
test_node(20),
BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)])
);
let mut authorized_nodes = Module::<Test>::get_authorized_nodes(&test_node(20));
authorized_nodes.sort();
assert_eq!(
authorized_nodes,
vec![test_node(5), test_node(10), test_node(15), test_node(25), test_node(30)]
);
});
}
}