Skip to content

registration cooldown modulo removed #13

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Mar 11, 2025
Merged

registration cooldown modulo removed #13

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
3672db8
registration periods
hayotensor Mar 11, 2025
e64689d
Merge pull request #2 from hayotensor/uid
hayotensor Mar 11, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
114 changes: 63 additions & 51 deletions pallets/network/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -306,6 +306,8 @@ pub mod pallet {
InvalidSubnetId,

/// Maximum amount of subnet entries surpassed, see subnet `entry_interval` for more information
MaxSubnetEntryIntervalReached,
/// Maximum `entry_interval` parameter entered during subnet registration
MaxSubnetEntryInterval,

DelegateStakeTransferPeriodExceeded,
Expand Down Expand Up @@ -904,7 +906,7 @@ pub mod pallet {
100
}
#[pallet::type_value]
pub fn DefaultMaxLastSubnetEntry() -> u64 {
pub fn DefaultMaxSubnetEntryInterval() -> u64 {
// 1 week based on 6s blocks
100800
}
Expand All @@ -924,7 +926,7 @@ pub mod pallet {
pub type SubnetsData<T: Config> = StorageMap<_, Blake2_128Concat, u32, SubnetData>;

#[pallet::storage] // subnet_id => block_interval
pub type MaxLastSubnetEntry<T: Config> = StorageValue<_, u64, ValueQuery, DefaultMaxLastSubnetEntry>;
pub type MaxSubnetEntryInterval<T: Config> = StorageValue<_, u64, ValueQuery, DefaultMaxSubnetEntryInterval>;

/// The maximum a single node can enter a subnet per blocks interval
#[pallet::storage] // subnet_id => block
Expand Down Expand Up @@ -2896,6 +2898,11 @@ pub mod pallet {
Error::<T>::MaxSubnetMemory
);

ensure!(
subnet_data.entry_interval <= MaxSubnetEntryInterval::<T>::get(),
Error::<T>::MaxSubnetEntryInterval
);

let block: u64 = Self::get_current_block_as_u64();
let subnet_fee: u128 = Self::registration_cost(epoch);

Expand Down Expand Up @@ -3114,7 +3121,7 @@ pub mod pallet {
let block: u64 = Self::get_current_block_as_u64();
ensure!(
block >= LastSubnetEntry::<T>::get(subnet_id) + subnet.entry_interval,
Error::<T>::MaxSubnetEntryInterval
Error::<T>::MaxSubnetEntryIntervalReached
);

// Ensure hotkey either has no owner or is the origins hotkey
Expand Down Expand Up @@ -3605,61 +3612,66 @@ pub mod pallet {
return
}

let subnet_id = 1;
// let subnet_id = 1;

let base_node_memory: u128 = BaseSubnetNodeMemoryMB::<T>::get();
// let base_node_memory: u128 = BaseSubnetNodeMemoryMB::<T>::get();

// --- Get min nodes based on default memory settings
let real_min_subnet_nodes: u128 = self.memory_mb.clone() / base_node_memory;
let mut min_subnet_nodes: u32 = MinSubnetNodes::<T>::get();
if real_min_subnet_nodes as u32 > min_subnet_nodes {
min_subnet_nodes = real_min_subnet_nodes as u32;
}
// // --- Get min nodes based on default memory settings
// let real_min_subnet_nodes: u128 = self.memory_mb.clone() / base_node_memory;
// let mut min_subnet_nodes: u32 = MinSubnetNodes::<T>::get();
// if real_min_subnet_nodes as u32 > min_subnet_nodes {
// min_subnet_nodes = real_min_subnet_nodes as u32;
// }

let target_subnet_nodes: u32 = (min_subnet_nodes as u128).saturating_mul(TargetSubnetNodesMultiplier::<T>::get()).saturating_div(1000000000) as u32 + min_subnet_nodes;

let subnet_data = SubnetData {
id: subnet_id,
path: self.subnet_path.clone(),
min_nodes: min_subnet_nodes,
target_nodes: target_subnet_nodes,
memory_mb: self.memory_mb.clone(),
registration_blocks: MinSubnetRegistrationBlocks::<T>::get(),
initialized: 1,
activated: 0,
entry_interval: 0,
};
// let target_subnet_nodes: u32 = (min_subnet_nodes as u128).saturating_mul(TargetSubnetNodesMultiplier::<T>::get()).saturating_div(1000000000) as u32 + min_subnet_nodes;

// let subnet_data = SubnetData {
// id: subnet_id,
// path: self.subnet_path.clone(),
// min_nodes: min_subnet_nodes,
// target_nodes: target_subnet_nodes,
// memory_mb: self.memory_mb.clone(),
// registration_blocks: MinSubnetRegistrationBlocks::<T>::get(),
// initialized: 1,
// activated: 0,
// entry_interval: 0,
// };

// Increase total subnet memory
TotalSubnetMemoryMB::<T>::mutate(|n: &mut u128| *n += subnet_data.memory_mb);
// Store unique path
SubnetPaths::<T>::insert(self.subnet_path.clone(), subnet_id);
// Store subnet data
SubnetsData::<T>::insert(subnet_id, subnet_data.clone());
// Increase total subnets count
TotalSubnets::<T>::mutate(|n: &mut u32| *n += 1);
// // Increase total subnet memory
// TotalSubnetMemoryMB::<T>::mutate(|n: &mut u128| *n += subnet_data.memory_mb);
// // Store unique path
// SubnetPaths::<T>::insert(self.subnet_path.clone(), subnet_id);
// // Store subnet data
// SubnetsData::<T>::insert(subnet_id, subnet_data.clone());
// // Increase total subnets count
// TotalSubnets::<T>::mutate(|n: &mut u32| *n += 1);

// // Increase delegate stake to allow activation of subnet model
// let min_stake_balance = MinStakeBalance::<T>::get();
// // --- Get minimum subnet stake balance
// let min_subnet_stake_balance = min_stake_balance * min_subnet_nodes as u128;
// // --- Get required delegate stake balance for a subnet to have to stay live
// let mut min_subnet_delegate_stake_balance = (min_subnet_stake_balance as u128).saturating_mul(MinSubnetDelegateStakePercentage::<T>::get()).saturating_div(1000000000);

// // --- Get absolute minimum required subnet delegate stake balance
// let min_subnet_delegate_stake = MinSubnetDelegateStake::<T>::get();
// // --- Return here if the absolute minimum required subnet delegate stake balance is greater
// // than the calculated minimum requirement
// if min_subnet_delegate_stake > min_subnet_delegate_stake_balance {
// min_subnet_delegate_stake_balance = min_subnet_delegate_stake
// }
// TotalSubnetDelegateStakeBalance::<T>::insert(subnet_id, min_subnet_delegate_stake_balance);

// // --- Initialize subnet nodes
// // Only initialize to test using subnet nodes
// // If testing using subnet nodes in a subnet, comment out the ``for`` loop

// Increase delegate stake to allow activation of subnet model
let min_stake_balance = MinStakeBalance::<T>::get();
// --- Get minimum subnet stake balance
let min_subnet_stake_balance = min_stake_balance * min_subnet_nodes as u128;
// --- Get required delegate stake balance for a subnet to have to stay live
let mut min_subnet_delegate_stake_balance = (min_subnet_stake_balance as u128).saturating_mul(MinSubnetDelegateStakePercentage::<T>::get()).saturating_div(1000000000);

// --- Get absolute minimum required subnet delegate stake balance
let min_subnet_delegate_stake = MinSubnetDelegateStake::<T>::get();
// --- Return here if the absolute minimum required subnet delegate stake balance is greater
// than the calculated minimum requirement
if min_subnet_delegate_stake > min_subnet_delegate_stake_balance {
min_subnet_delegate_stake_balance = min_subnet_delegate_stake
}
TotalSubnetDelegateStakeBalance::<T>::insert(subnet_id, min_subnet_delegate_stake_balance);
// let mut stake_amount: u128 = MinStakeBalance::<T>::get();

// --- Initialize subnet nodes
// Only initialize to test using subnet nodes
// If testing using subnet nodes in a subnet, comment out the ``for`` loop

let mut stake_amount: u128 = MinStakeBalance::<T>::get();
//
//
//

// let mut count = 0;
// for (account_id, peer_id) in &self.subnet_nodes {
Expand Down
2 changes: 0 additions & 2 deletions pallets/network/src/stake/node_delegate_staking.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -142,8 +142,6 @@ impl<T: Config> Pallet<T> {
total_node_delegated_stake_balance
);

log::error!("delegate_stake_to_be_removed {:?}", delegate_stake_to_be_removed);

// --- Ensure that we can convert this u128 to a balance.
// Redunant
let delegate_stake_to_be_added_as_currency = Self::u128_to_balance(delegate_stake_to_be_removed);
Expand Down
4 changes: 2 additions & 2 deletions pallets/network/src/tests/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
mod test_utils;
mod mock;
mod test_utils;
mod subnet;
mod subnet_node;
mod staking;
Expand All @@ -9,5 +9,5 @@ mod incentives_protocol;
mod proposals;
mod math;
mod randomization;
mod steps;
mod utils;
mod steps;
111 changes: 85 additions & 26 deletions pallets/network/src/tests/node_delegate_staking.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -130,34 +130,31 @@ fn test_remove_node_delegate_stake() {
let account_node_delegate_stake_shares = AccountNodeDelegateStakeShares::<Test>::get((account(total_subnet_nodes+1), subnet_id, 0));
let total_node_delegate_stake_balance = TotalNodeDelegateStakeBalance::<Test>::get(subnet_id, 0);
let total_node_delegate_stake_shares = TotalNodeDelegateStakeShares::<Test>::get(subnet_id, 0);
log::error!("account_node_delegate_stake_shares {:?}", account_node_delegate_stake_shares);
log::error!("total_node_delegate_stake_balance {:?}", total_node_delegate_stake_balance);
log::error!("total_node_delegate_stake_shares {:?}", total_node_delegate_stake_shares);

let account_node_delegate_stake_balance = Network::convert_to_balance(
account_node_delegate_stake_shares,
total_node_delegate_stake_shares,
total_node_delegate_stake_balance
);
log::error!("account_node_delegate_stake_balance {:?}", account_node_delegate_stake_balance);

assert!(
(account_node_delegate_stake_balance >= Network::percent_mul(amount, 9999)) &&
(account_node_delegate_stake_balance <= amount)
);

let account_node_delegate_stake_shares_to_be_removed = account_node_delegate_stake_shares / 2;
log::error!("account_node_delegate_stake_shares_to_be_removed {:?}", account_node_delegate_stake_shares_to_be_removed);

let expected_balance_to_be_removed = Network::convert_to_balance(
account_node_delegate_stake_shares_to_be_removed,
total_node_delegate_stake_shares,
total_node_delegate_stake_balance
);
log::error!("expected_balance_to_be_removed {:?}", expected_balance_to_be_removed);

let expected_post_balance = account_node_delegate_stake_balance - expected_balance_to_be_removed;
log::error!("expected_post_balance {:?}", expected_post_balance);
let expected_post_balance = Network::convert_to_balance(
account_node_delegate_stake_shares_to_be_removed,
total_node_delegate_stake_shares - account_node_delegate_stake_shares_to_be_removed,
total_node_delegate_stake_balance - expected_balance_to_be_removed
);

assert_ok!(
Network::remove_node_delegate_stake(
Expand All @@ -171,9 +168,6 @@ fn test_remove_node_delegate_stake() {
let account_node_delegate_stake_shares = AccountNodeDelegateStakeShares::<Test>::get((account(total_subnet_nodes+1), subnet_id, 0));
let total_node_delegate_stake_balance = TotalNodeDelegateStakeBalance::<Test>::get(subnet_id, 0);
let total_node_delegate_stake_shares = TotalNodeDelegateStakeShares::<Test>::get(subnet_id, 0);
log::error!("post account_node_delegate_stake_shares {:?}", account_node_delegate_stake_shares);
log::error!("post total_node_delegate_stake_balance {:?}", total_node_delegate_stake_balance);
log::error!("post total_node_delegate_stake_shares {:?}", total_node_delegate_stake_shares);

assert_eq!(account_node_delegate_stake_shares, account_node_delegate_stake_shares_to_be_removed);

Expand All @@ -182,25 +176,90 @@ fn test_remove_node_delegate_stake() {
total_node_delegate_stake_shares,
total_node_delegate_stake_balance
);
log::error!("post_account_node_delegate_stake_balance {:?}", post_account_node_delegate_stake_balance);

// assert_eq!(expected_post_balance, post_account_node_delegate_stake_balance);

// let expected_balance = Network::percent_mul(account_node_delegate_stake_balance/2, 9999);
// log::error!("expected_balance {:?}", expected_balance);

// assert!(
// post_account_node_delegate_stake_balance >= expected_balance
// );

// assert!(
// (post_account_node_delegate_stake_balance >= expected_balance) &&
// (post_account_node_delegate_stake_balance <= (account_node_delegate_stake_balance/2))
// );

assert_eq!(expected_post_balance, post_account_node_delegate_stake_balance);
})
}

// #[test]
// fn test_transfer_node_delegate_stake() {
// new_test_ext().execute_with(|| {
// let subnet_path: Vec<u8> = "petals-team/StableBeluga2".into();
// let deposit_amount: u128 = 10000000000000000000000;
// let amount: u128 = 1000000000000000000000;

// build_activated_subnet_with_delegator_rewards(
// subnet_path.clone(),
// 0,
// 16,
// deposit_amount,
// amount,
// DEFAULT_DELEGATE_REWARD_RATE,
// );

// let from_subnet_id = SubnetPaths::<Test>::get(subnet_path.clone()).unwrap();
// let total_from_subnet_nodes = TotalSubnetNodes::<Test>::get(from_subnet_id);

// let to_subnet_path: Vec<u8> = "petals-team/StableBeluga3".into();

// build_activated_subnet_with_delegator_rewards(
// to_subnet_path.clone(),
// 0,
// 16,
// deposit_amount,
// amount,
// DEFAULT_DELEGATE_REWARD_RATE,
// );

// let to_subnet_id = SubnetPaths::<Test>::get(to_subnet_path.clone()).unwrap();

// let _ = Balances::deposit_creating(&account(total_from_subnet_nodes+1), amount+500);

// assert_ok!(
// Network::add_to_node_delegate_stake(
// RuntimeOrigin::signed(account(total_from_subnet_nodes+1)),
// from_subnet_id,
// 0,
// amount,
// )
// );

// let account_node_delegate_stake_shares = AccountNodeDelegateStakeShares::<Test>::get((account(total_from_subnet_nodes+1), from_subnet_id, 0));
// let total_node_delegate_stake_balance = TotalNodeDelegateStakeBalance::<Test>::get(from_subnet_id, 0);
// let total_node_delegate_stake_shares = TotalNodeDelegateStakeShares::<Test>::get(from_subnet_id, 0);

// let account_node_delegate_stake_balance = Network::convert_to_balance(
// account_node_delegate_stake_shares,
// total_node_delegate_stake_shares,
// total_node_delegate_stake_balance
// );

// assert!(
// (account_node_delegate_stake_balance >= Network::percent_mul(amount, 9999)) &&
// (account_node_delegate_stake_balance <= amount)
// );

// let account_node_delegate_stake_shares_to_be_removed = account_node_delegate_stake_shares / 2;

// let expected_balance_to_be_removed = Network::convert_to_balance(
// account_node_delegate_stake_shares_to_be_removed,
// total_node_delegate_stake_shares,
// total_node_delegate_stake_balance
// );

// assert_ok!(
// Network::transfer_node_delegate_stake(
// RuntimeOrigin::signed(account(total_from_subnet_nodes+1)),
// from_subnet_id,
// 0,
// to_subnet_id,
// 0,
// account_node_delegate_stake_shares_to_be_removed,
// )
// );
// })
// }

#[test]
fn test_validate_with_delegate_rewards_rate() {
new_test_ext().execute_with(|| {
Expand Down
Loading
Loading