938 lines
41 KiB
Rust
938 lines
41 KiB
Rust
use mock::{
|
|
ExtBuilder, System, RegistererAccount, UpdaterAccount, RemoverAccount,
|
|
RandomAccount, GhostNetworks, Test, RuntimeEvent, RuntimeOrigin, RewardCurve,
|
|
};
|
|
use frame_support::{assert_err, assert_ok};
|
|
use sp_runtime::DispatchError;
|
|
use pallet_staking::EraPayout;
|
|
use super::*;
|
|
|
|
fn prepare_network_data() -> (u32, NetworkData) {
|
|
(1u32, NetworkData {
|
|
chain_name: "Ethereum".into(),
|
|
default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
|
|
finality_delay: Some(69),
|
|
release_delay: Some(69),
|
|
network_type: NetworkType::Evm,
|
|
gatekeeper: b"0x1234567891234567891234567891234567891234".to_vec(),
|
|
topic_name: b"0x12345678912345678912345678912345678912345678912345678912345678".to_vec(),
|
|
incoming_fee: 0,
|
|
outgoing_fee: 0,
|
|
})
|
|
}
|
|
|
|
fn register_and_check_network(chain_id: u32, network: NetworkData) {
|
|
assert_ok!(GhostNetworks::register_network(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id,
|
|
network.clone()));
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network.clone()));
|
|
}
|
|
|
|
#[test]
|
|
fn could_add_network_from_authority() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_ok!(GhostNetworks::register_network(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id,
|
|
network.clone(),
|
|
));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkRegistered {
|
|
chain_id, network: network.clone()
|
|
}));
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_add_network_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::register_network(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id,
|
|
network.clone(),
|
|
), DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::register_network(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id,
|
|
network.clone(),
|
|
), DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::register_network(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id,
|
|
network,
|
|
), DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_name_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_name = b"Polygon".to_vec();
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_name(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_name.clone()));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkNameUpdated {
|
|
chain_id,
|
|
chain_name: new_name.clone() }));
|
|
let mut final_network = network.clone();
|
|
final_network.chain_name = new_name;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_endpoint_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_endpoint = b"https:://google.com".to_vec();
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_endpoint(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_endpoint.clone()));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkEndpointUpdated {
|
|
chain_id,
|
|
default_endpoint: new_endpoint.clone() }));
|
|
let mut final_network = network.clone();
|
|
final_network.default_endpoint = new_endpoint;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_finality_delay_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_finality_delay = Some(1337);
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_finality_delay(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_finality_delay));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkFinalityDelayUpdated {
|
|
chain_id,
|
|
finality_delay: new_finality_delay }));
|
|
let mut final_network = network.clone();
|
|
final_network.finality_delay = new_finality_delay;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_release_delay_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_release_delay = Some(1337);
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_release_delay(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_release_delay));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkReleaseDelayUpdated {
|
|
chain_id,
|
|
release_delay: new_release_delay }));
|
|
let mut final_network = network.clone();
|
|
final_network.release_delay = new_release_delay;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_type_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_type = NetworkType::Utxo;
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_type(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_type.clone()));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkTypeUpdated {
|
|
chain_id,
|
|
network_type: new_type.clone() }));
|
|
let mut final_network = network.clone();
|
|
final_network.network_type = new_type;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_gatekeeper_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_gatekeeper = b"0x9876543219876543219876543219876543219876".to_vec();
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_gatekeeper(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_gatekeeper.clone()));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkGatekeeperUpdated {
|
|
chain_id,
|
|
gatekeeper: new_gatekeeper.clone() }));
|
|
let mut final_network = network.clone();
|
|
final_network.gatekeeper = new_gatekeeper;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_network_topic_name_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_topic_name = b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec();
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_network_topic_name(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_topic_name.clone()));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkTopicNameUpdated {
|
|
chain_id,
|
|
topic_name: new_topic_name.clone() }));
|
|
let mut final_network = network.clone();
|
|
final_network.topic_name = new_topic_name;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_incoming_network_fee_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_incoming_fee = 69;
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_incoming_network_fee(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_incoming_fee));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkIncomingFeeUpdated {
|
|
chain_id,
|
|
incoming_fee: new_incoming_fee }));
|
|
let mut final_network = network.clone();
|
|
final_network.incoming_fee = new_incoming_fee;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_update_outgoing_network_fee_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let new_outgoing_fee = 69;
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::update_outgoing_network_fee(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, new_outgoing_fee));
|
|
System::assert_last_event(RuntimeEvent::GhostNetworks(
|
|
crate::Event::NetworkOutgoingFeeUpdated {
|
|
chain_id,
|
|
outgoing_fee: new_outgoing_fee }));
|
|
let mut final_network = network.clone();
|
|
final_network.outgoing_fee = new_outgoing_fee;
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
|
|
assert_ne!(network, final_network);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_name_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_name(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, "Binance".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_name(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, "Binance".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_name(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, "Binance".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_endpoint_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_endpoint(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, "https:://google.com".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_endpoint(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, "https:://google.com".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_endpoint(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, "https:://google.com".into()),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_finality_delay_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_finality_delay(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_finality_delay(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_finality_delay(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_release_delay_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_release_delay(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_release_delay(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_release_delay(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, Some(1337)),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_type_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_type(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, NetworkType::Utxo),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_type(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, NetworkType::Utxo),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_type(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, NetworkType::Utxo),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_gatekeeper_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_gatekeeper(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_gatekeeper(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_gatekeeper(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_topic_name_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_network_topic_name(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_topic_name(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_network_topic_name(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec()),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_incoming_fee_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_incoming_network_fee(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_incoming_network_fee(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_incoming_network_fee(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_network_outgoing_fee_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::update_outgoing_network_fee(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_outgoing_network_fee(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::update_outgoing_network_fee(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id, 69),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_name_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_name(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, "Binance".into()),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_endpoint_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_endpoint(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, "https:://google.com".into()),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_finality_delay_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_finality_delay(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, Some(1337)),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_release_delay_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_release_delay(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, Some(1337)),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_type_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_type(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, NetworkType::Utxo),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_gatekeeper_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_gatekeeper(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876".to_vec()),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_topic_name_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_network_topic_name(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec()),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_incoming_fee_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_incoming_network_fee(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, 1337),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_update_outgoing_fee_for_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::update_outgoing_network_fee(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id, 1337),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_remove_network_from_authority_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_ok!(GhostNetworks::remove_network(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id,
|
|
));
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_remove_network_from_random_account() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let (chain_id, network) = prepare_network_data();
|
|
register_and_check_network(chain_id, network.clone());
|
|
assert_err!(GhostNetworks::remove_network(
|
|
RuntimeOrigin::signed(RegistererAccount::get()),
|
|
chain_id),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::remove_network(
|
|
RuntimeOrigin::signed(UpdaterAccount::get()),
|
|
chain_id),
|
|
DispatchError::BadOrigin);
|
|
assert_err!(GhostNetworks::remove_network(
|
|
RuntimeOrigin::signed(RandomAccount::get()),
|
|
chain_id),
|
|
DispatchError::BadOrigin);
|
|
assert_eq!(Networks::<Test>::get(chain_id), Some(network));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn could_not_remove_non_existent_network() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
assert_err!(GhostNetworks::remove_network(
|
|
RuntimeOrigin::signed(RemoverAccount::get()),
|
|
chain_id),
|
|
crate::Error::<Test>::NetworkDoesNotExist);
|
|
assert_eq!(Networks::<Test>::get(chain_id), None);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn bridge_storage_is_empty_by_default() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
|
|
assert_eq!(BridgedImbalance::<Test>::get(),
|
|
BridgeAdjustment::default());
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn gatekeeper_amount_changes_correctly() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
let amount_in: u128 = 420;
|
|
let amount_out: u128 = 69;
|
|
let result = amount_in - 3 * amount_out;
|
|
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
|
|
assert_eq!(BridgedImbalance::<Test>::get(),
|
|
BridgeAdjustment::default());
|
|
|
|
assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount_in));
|
|
assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
|
|
assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
|
|
assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
|
|
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), result);
|
|
assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
|
|
bridged_out: 3 * amount_out,
|
|
bridged_in: amount_in });
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn commission_accumulation_is_correct() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let commission_first: u128 = 420;
|
|
let commission_second: u128 = 69;
|
|
let result = commission_first + commission_second;
|
|
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
|
|
assert_ok!(GhostNetworks::accumulate_commission(&commission_first));
|
|
assert_ok!(GhostNetworks::accumulate_commission(&commission_second));
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), result);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn commission_overflow_and_underflow_emits_error() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let commission: u128 = u128::MAX - 69;
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
|
|
assert_ok!(GhostNetworks::accumulate_commission(&commission));
|
|
assert_err!(GhostNetworks::accumulate_commission(&commission), ());
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), commission);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn gatekeeper_amount_overflow_and_underflow_emits_error() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
let commission: u128 = u128::MAX - 69;
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
|
|
assert_ok!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id,
|
|
&commission,
|
|
), (commission, commission));
|
|
assert_err!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id,
|
|
&commission,
|
|
), ());
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), commission);
|
|
assert_ok!(GhostNetworks::decrease_gatekeeper_amount(
|
|
&chain_id,
|
|
&commission,
|
|
), (0, commission));
|
|
assert_err!(GhostNetworks::decrease_gatekeeper_amount(
|
|
&chain_id,
|
|
&commission,
|
|
), ());
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
|
|
assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
|
|
bridged_out: commission,
|
|
bridged_in: commission,
|
|
});
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn bridged_amount_overflow_and_underflow_emits_error() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id_first: u32 = 1;
|
|
let chain_id_second: u32 = 2;
|
|
let commission: u128 = u128::MAX - 69;
|
|
assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
|
|
bridged_out: 0,
|
|
bridged_in: 0,
|
|
});
|
|
assert_ok!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id_first,
|
|
&commission,
|
|
), (commission, commission));
|
|
assert_err!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id_second,
|
|
&commission,
|
|
), ());
|
|
assert_err!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id_first,
|
|
&u128::MAX,
|
|
), ());
|
|
assert_err!(GhostNetworks::increase_gatekeeper_amount(
|
|
&chain_id_first,
|
|
&commission,
|
|
), ());
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_first), commission);
|
|
assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_second), 0);
|
|
assert_err!(GhostNetworks::decrease_gatekeeper_amount(
|
|
&chain_id_second,
|
|
&commission,
|
|
), ());
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn accumulated_commission_could_be_nullified() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let commission_first: u128 = 420;
|
|
let commission_second: u128 = 69;
|
|
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
|
|
assert_ok!(GhostNetworks::accumulate_commission(
|
|
&commission_first
|
|
), commission_first);
|
|
assert_ok!(GhostNetworks::accumulate_commission(
|
|
&commission_second,
|
|
), commission_first + commission_second);
|
|
assert_eq!(AccumulatedCommission::<Test>::get(),
|
|
commission_first + commission_second);
|
|
GhostNetworks::nullify_commission();
|
|
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn bridged_inlation_reward_works() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
let amount: u128 = 1337 * 1_000_000_000;
|
|
let commission: u128 = amount / 100; // 1% commission
|
|
let total_staked_ideal: u128 = 69;
|
|
let total_staked_not_ideal: u128 = 68;
|
|
let total_issuance: u128 = 100;
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000,
|
|
total_issuance * 1_000,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000,
|
|
0), (0, 0));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000,
|
|
total_issuance * 1_000,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000,
|
|
0), (0, 0));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000, 0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000, 0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000_000_000_000_000, 0), (0, 0));
|
|
|
|
assert_ok!(GhostNetworks::accumulate_commission(&commission));
|
|
assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000,
|
|
total_issuance * 1_000 + amount,
|
|
0), (commission, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000 + amount,
|
|
0), (commission, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
|
|
0), (commission, 0));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000,
|
|
total_issuance * 1_000 + amount,
|
|
0), (13177472000, 192528000));
|
|
assert_eq!(13177472000 + 192528000, commission);
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000 + amount,
|
|
0), (13177568884, 192431116));
|
|
assert_eq!(13177568884 + 192431116, commission);
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
|
|
0), (13177568884, 192431116));
|
|
assert_eq!(13177568884 + 192431116, commission);
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000 + amount, 0),
|
|
(92386700, 13277613300));
|
|
assert_eq!(92386700 + 13277613300, commission);
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000 + amount, 0),
|
|
(92253000, 13277747000));
|
|
assert_eq!(92253000 + 13277747000, commission);
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0),
|
|
(92253000, 13277747000));
|
|
assert_eq!(92253000 + 13277747000, commission);
|
|
|
|
GhostNetworks::nullify_commission();
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000,
|
|
total_issuance * 1_000 + amount,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000 + amount,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
|
|
0), (0, 0));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000,
|
|
total_issuance * 1_000 + amount,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000 + amount,
|
|
0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
|
|
total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
|
|
0), (0, 0));
|
|
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000 + amount, 0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000 + amount, 0), (0, 0));
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0), (0, 0));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn bridged_inflation_era_payout_triggers_need_of_nullification() {
|
|
ExtBuilder::build()
|
|
.execute_with(|| {
|
|
let chain_id: u32 = 1;
|
|
let amount: u128 = 1337 * 1_000_000_000;
|
|
let commission: u128 = amount / 100; // 1% commission
|
|
let total_staked_ideal: u128 = 69;
|
|
let total_issuance: u128 = 100;
|
|
|
|
assert_ok!(GhostNetworks::accumulate_commission(&commission));
|
|
assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount));
|
|
assert_eq!(NullifyNeeded::<Test>::get(), false);
|
|
assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
|
|
total_staked_ideal * 1_000,
|
|
total_issuance * 1_000 + amount,
|
|
0), (commission, 0));
|
|
assert_eq!(NullifyNeeded::<Test>::get(), true);
|
|
GhostNetworks::on_finalize(69);
|
|
assert_eq!(NullifyNeeded::<Test>::get(), false);
|
|
});
|
|
}
|