From baa16587af39c5ce8bec19e7b709eceaf028cefa Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 2 Jun 2026 14:29:23 -0400 Subject: [PATCH 01/48] Implement custom dust collection type in subtensor --- pallets/subtensor/src/coinbase/tao.rs | 18 +----- pallets/subtensor/src/lib.rs | 15 +++++ .../migrate_fix_total_issuance_evm_fees.rs | 29 +++++---- pallets/subtensor/src/tests/migration.rs | 18 +++++- pallets/subtensor/src/tests/mock.rs | 2 +- pallets/subtensor/src/tests/mock_high_ed.rs | 2 +- runtime/src/lib.rs | 2 +- runtime/tests/balances_dust.rs | 60 +++++++++++++++++++ 8 files changed, 115 insertions(+), 31 deletions(-) create mode 100644 runtime/tests/balances_dust.rs diff --git a/pallets/subtensor/src/coinbase/tao.rs b/pallets/subtensor/src/coinbase/tao.rs index 33dbda57fb..b605407763 100644 --- a/pallets/subtensor/src/coinbase/tao.rs +++ b/pallets/subtensor/src/coinbase/tao.rs @@ -33,18 +33,14 @@ impl Pallet { SubnetTAO::::get(netuid) } - /// Internal function that transfers and updates subtensor pallet total issuance - /// in case of dust collection. + /// Internal function that transfers TAO and allows the origin account to be reaped. + /// + /// Dust collection is handled by the runtime's Balances `DustRemoval` implementation. fn transfer_allow_death_update_ti( origin_coldkey: &T::AccountId, destination_coldkey: &T::AccountId, amount: BalanceOf, ) -> DispatchResult { - // If account balance remainder drops below ED, then account is killed, balance - // is lost, and we need to reduce total issuance in subtensor pallet. Measure - // balance TI before and after to detect the dust. - let balances_ti_before = ::Currency::total_issuance(); - ::Currency::transfer( origin_coldkey, destination_coldkey, @@ -52,14 +48,6 @@ impl Pallet { Preservation::Expendable, )?; - let balances_ti_after = ::Currency::total_issuance(); - if balances_ti_after < balances_ti_before { - let burned = balances_ti_before.saturating_sub(balances_ti_after); - TotalIssuance::::mutate(|total| { - *total = total.saturating_sub(burned); - }); - } - Ok(()) } diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs index d5aee84243..641c816e3c 100644 --- a/pallets/subtensor/src/lib.rs +++ b/pallets/subtensor/src/lib.rs @@ -69,6 +69,21 @@ pub const MAX_SUBNET_CLAIMS: usize = 5; pub const MAX_ROOT_CLAIM_THRESHOLD: u64 = 10_000_000; +pub struct SubtensorDustRemoval(PhantomData); +impl frame_support::traits::OnUnbalanced> + for SubtensorDustRemoval +where + T: Config + pallet_balances::Config, + ::Balance: Into + Copy, +{ + fn on_nonzero_unbalanced(dust: pallet_balances::CreditOf) { + let amount: TaoBalance = frame_support::traits::Imbalance::peek(&dust).into(); + TotalIssuance::::mutate(|total| { + *total = total.saturating_sub(amount); + }); + } +} + #[allow(deprecated)] #[deny(missing_docs)] #[import_section(errors::errors)] diff --git a/pallets/subtensor/src/migrations/migrate_fix_total_issuance_evm_fees.rs b/pallets/subtensor/src/migrations/migrate_fix_total_issuance_evm_fees.rs index b4851745cb..476a9d8b4f 100644 --- a/pallets/subtensor/src/migrations/migrate_fix_total_issuance_evm_fees.rs +++ b/pallets/subtensor/src/migrations/migrate_fix_total_issuance_evm_fees.rs @@ -3,24 +3,31 @@ use frame_support::traits::fungible::Inspect; use frame_support::weights::Weight; pub fn migrate_fix_total_issuance_evm_fees() -> Weight { - let migration_name = b"migrate_fix_total_issuance_evm_fees".to_vec(); - let mut weight = T::DbWeight::get().reads(1); - - if HasMigrationRun::::get(&migration_name) { - log::info!( - "Migration '{:?}' has already run. Skipping.", - String::from_utf8_lossy(&migration_name) - ); + let migration_names: [&[u8]; 2] = [ + // Fix testnet TotalIssuance after the earlier EVM fees issue caused the + // Subtensor pallet's accounting to diverge from the balances pallet. + b"migrate_fix_total_issuance_evm_fees", + // Fix Subtensor TotalIssuance after dust collection caused accounting drift. + b"migrate_fix_total_issuance_after_dust_collection", + ]; + let mut weight = T::DbWeight::get().reads(migration_names.len() as u64); + + let Some(migration_name) = migration_names + .iter() + .map(|name| name.to_vec()) + .find(|name| !HasMigrationRun::::get(name)) + else { + log::info!("All total issuance fix migrations have already run. Skipping."); return weight; - } + }; log::info!( "Running migration '{}'", String::from_utf8_lossy(&migration_name) ); - // Fix testnet TotalIssuance after the earlier EVM fees issue caused the - // Subtensor pallet's accounting to diverge from the balances pallet. + // All migration instances reset Subtensor TotalIssuance to the authoritative + // Balances pallet total issuance. let balances_total_issuance = ::Currency::total_issuance(); let subtensor_total_issuance_before = TotalIssuance::::get(); TotalIssuance::::put(balances_total_issuance); diff --git a/pallets/subtensor/src/tests/migration.rs b/pallets/subtensor/src/tests/migration.rs index f13c2ae186..a68f02d250 100644 --- a/pallets/subtensor/src/tests/migration.rs +++ b/pallets/subtensor/src/tests/migration.rs @@ -4362,6 +4362,7 @@ fn test_migrate_subnet_balances() { fn test_migrate_fix_total_issuance_evm_fees() { new_test_ext(1).execute_with(|| { const MIGRATION_NAME: &[u8] = b"migrate_fix_total_issuance_evm_fees"; + const DUST_MIGRATION_NAME: &[u8] = b"migrate_fix_total_issuance_after_dust_collection"; let account = U256::from(42); let balances_total_issuance = TaoBalance::from(123_456_789_u64); @@ -4382,16 +4383,29 @@ fn test_migrate_fix_total_issuance_evm_fees() { assert!(!weight.is_zero(), "weight must be non-zero"); assert_eq!(TotalIssuance::::get(), balances_total_issuance); assert!(HasMigrationRun::::get(MIGRATION_NAME.to_vec())); + assert!(!HasMigrationRun::::get( + DUST_MIGRATION_NAME.to_vec() + )); let second_wrong_value = TaoBalance::from(555_u64); TotalIssuance::::put(second_wrong_value); crate::migrations::migrate_fix_total_issuance_evm_fees::migrate_fix_total_issuance_evm_fees::(); + assert_eq!(TotalIssuance::::get(), balances_total_issuance); + assert!(HasMigrationRun::::get( + DUST_MIGRATION_NAME.to_vec() + )); + + let third_wrong_value = TaoBalance::from(777_u64); + TotalIssuance::::put(third_wrong_value); + + crate::migrations::migrate_fix_total_issuance_evm_fees::migrate_fix_total_issuance_evm_fees::(); + assert_eq!( TotalIssuance::::get(), - second_wrong_value, - "migration must not run more than once" + third_wrong_value, + "migration must not run after all known migration keys have run" ); }); } diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs index 277162dde4..0d07251f13 100644 --- a/pallets/subtensor/src/tests/mock.rs +++ b/pallets/subtensor/src/tests/mock.rs @@ -88,7 +88,7 @@ pub type BlockNumber = u64; impl pallet_balances::Config for Test { type Balance = Balance; type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); + type DustRemoval = crate::SubtensorDustRemoval; type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; type MaxLocks = (); diff --git a/pallets/subtensor/src/tests/mock_high_ed.rs b/pallets/subtensor/src/tests/mock_high_ed.rs index 5f19edf455..00cdc5c2bb 100644 --- a/pallets/subtensor/src/tests/mock_high_ed.rs +++ b/pallets/subtensor/src/tests/mock_high_ed.rs @@ -70,7 +70,7 @@ pub type BlockNumber = u64; impl pallet_balances::Config for Test { type Balance = Balance; type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); + type DustRemoval = crate::SubtensorDustRemoval; type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; type MaxLocks = (); diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 207997d7df..999a64fbc8 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -519,7 +519,7 @@ impl pallet_balances::Config for Runtime { type Balance = Balance; // The ubiquitous event type. type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); + type DustRemoval = pallet_subtensor::SubtensorDustRemoval; type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; type WeightInfo = pallet_balances::weights::SubstrateWeight; diff --git a/runtime/tests/balances_dust.rs b/runtime/tests/balances_dust.rs new file mode 100644 index 0000000000..b56ada26bc --- /dev/null +++ b/runtime/tests/balances_dust.rs @@ -0,0 +1,60 @@ +#![allow(clippy::unwrap_used)] + +use frame_support::traits::fungible::{Inspect, Mutate}; +use frame_support::traits::tokens::Preservation; +use node_subtensor_runtime::{Balances, BuildStorage, Runtime, RuntimeGenesisConfig}; +use sp_core::crypto::AccountId32; +use subtensor_runtime_common::TaoBalance; + +fn new_test_ext() -> sp_io::TestExternalities { + let mut ext: sp_io::TestExternalities = RuntimeGenesisConfig { + ..Default::default() + } + .build_storage() + .unwrap() + .into(); + ext.execute_with(|| frame_system::Pallet::::set_block_number(1)); + ext +} + +fn add_balance_to_account(account: &AccountId32, tao: TaoBalance) { + let credit = pallet_subtensor::Pallet::::mint_tao(tao); + let _ = pallet_subtensor::Pallet::::spend_tao(account, credit, tao).unwrap(); +} + +#[test] +fn balances_dust_removal_updates_subtensor_total_issuance() { + new_test_ext().execute_with(|| { + let origin = AccountId32::new([1u8; 32]); + let destination = AccountId32::new([2u8; 32]); + let existential_deposit = TaoBalance::from(500u64); + let dust = TaoBalance::from(1u64); + let transfer_amount = existential_deposit; + + add_balance_to_account(&origin, transfer_amount + dust); + + let balances_issuance_before = Balances::total_issuance(); + let subtensor_issuance_before = pallet_subtensor::Pallet::::get_total_issuance(); + assert_eq!(balances_issuance_before, subtensor_issuance_before); + + >::transfer( + &origin, + &destination, + transfer_amount, + Preservation::Expendable, + ) + .unwrap(); + + assert_eq!(Balances::total_balance(&origin), 0u64.into()); + assert_eq!(Balances::total_balance(&destination), transfer_amount); + assert_eq!(balances_issuance_before - Balances::total_issuance(), dust); + assert_eq!( + subtensor_issuance_before - pallet_subtensor::Pallet::::get_total_issuance(), + dust + ); + assert_eq!( + Balances::total_issuance(), + pallet_subtensor::Pallet::::get_total_issuance() + ); + }); +} From 60e462e2cbfeb4445ae1aa84f1fc020329949157 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 9 Jun 2026 12:12:18 -0400 Subject: [PATCH 02/48] Add min_childkey_take_per_subnet hyperparameter --- pallets/subtensor/src/rpc_info/subnet_info.rs | 5 +++++ pallets/subtensor/src/tests/subnet_info.rs | 6 ++++++ 2 files changed, 11 insertions(+) diff --git a/pallets/subtensor/src/rpc_info/subnet_info.rs b/pallets/subtensor/src/rpc_info/subnet_info.rs index 00c3f1b18f..dc0b819404 100644 --- a/pallets/subtensor/src/rpc_info/subnet_info.rs +++ b/pallets/subtensor/src/rpc_info/subnet_info.rs @@ -617,6 +617,11 @@ impl Pallet { HyperparamValue::Bool(Self::get_owner_cut_auto_lock_enabled(netuid)), ) .into(), + ( + "min_childkey_take_per_subnet", + HyperparamValue::U16(Self::get_effective_min_childkey_take(netuid).into()), + ) + .into(), ]) } } diff --git a/pallets/subtensor/src/tests/subnet_info.rs b/pallets/subtensor/src/tests/subnet_info.rs index fcf597f4ff..a867ea645f 100644 --- a/pallets/subtensor/src/tests/subnet_info.rs +++ b/pallets/subtensor/src/tests/subnet_info.rs @@ -43,6 +43,7 @@ const EXPECTED_V3_NAMES: &[&[u8]] = &[ b"user_liquidity_enabled", b"owner_cut_enabled", b"owner_cut_auto_lock_enabled", + b"min_childkey_take_per_subnet", ]; fn find<'a>(params: &'a [HyperparamEntry], name: &[u8]) -> &'a HyperparamValue { @@ -121,6 +122,7 @@ fn test_get_subnet_hyperparams_v3_values_reflect_storage() { SubtensorModule::set_bonds_reset(netuid, true); SubtensorModule::set_owner_cut_enabled_flag(netuid, true); SubtensorModule::set_owner_cut_auto_lock_enabled(netuid, true); + SubtensorModule::set_min_childkey_take_for_subnet(netuid, 31); let result = SubtensorModule::get_subnet_hyperparams_v3(netuid).unwrap(); let p = &result; @@ -180,6 +182,10 @@ fn test_get_subnet_hyperparams_v3_values_reflect_storage() { &HyperparamValue::U16(Compact(30)) ); assert_eq!(find(p, b"yuma_version"), &HyperparamValue::U16(Compact(3))); + assert_eq!( + find(p, b"min_childkey_take_per_subnet"), + &HyperparamValue::U16(Compact(31)) + ); // U64 variants assert_eq!( From fce9aa908d6f11012acbbde6f05632bf729523e6 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 8 Jun 2026 12:53:41 -0400 Subject: [PATCH 03/48] Fix hotkey swap conviction locks --- pallets/subtensor/src/macros/hooks.rs | 4 +- .../migrate_fix_subnet_hotkey_lock_swaps.rs | 348 ++++++++++++++++++ pallets/subtensor/src/migrations/mod.rs | 1 + pallets/subtensor/src/swap/swap_hotkey.rs | 10 +- pallets/subtensor/src/tests/locks.rs | 105 ++++++ pallets/subtensor/src/tests/migration.rs | 137 +++++++ 6 files changed, 601 insertions(+), 4 deletions(-) create mode 100644 pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs diff --git a/pallets/subtensor/src/macros/hooks.rs b/pallets/subtensor/src/macros/hooks.rs index fa7fbb3b16..4639dc2e91 100644 --- a/pallets/subtensor/src/macros/hooks.rs +++ b/pallets/subtensor/src/macros/hooks.rs @@ -171,7 +171,9 @@ mod hooks { // Reset testnet conviction lock storage before deploying the current design. .saturating_add(migrations::migrate_reset_tnet_conviction_locks::migrate_reset_tnet_conviction_locks::()) // Capture the runtime-upgrade block for TAO-in refund cutover. - .saturating_add(migrations::migrate_tao_in_refund_deployment_block::migrate_tao_in_refund_deployment_block::()); + .saturating_add(migrations::migrate_tao_in_refund_deployment_block::migrate_tao_in_refund_deployment_block::()) + // Fix lock state left behind by subnet-scoped hotkey swaps. + .saturating_add(migrations::migrate_fix_subnet_hotkey_lock_swaps::migrate_fix_subnet_hotkey_lock_swaps::()); weight } diff --git a/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs new file mode 100644 index 0000000000..be437fd212 --- /dev/null +++ b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs @@ -0,0 +1,348 @@ +use super::*; +use crate::staking::lock::LockState; +use frame_support::weights::Weight; +use scale_info::prelude::string::String; +use sp_core::crypto::Ss58Codec; +use sp_runtime::AccountId32; +use substrate_fixed::types::U64F64; + +struct HotkeySwapLockFix { + coldkey: Option<&'static str>, + netuid: u16, + old_hotkey: &'static str, + new_hotkey: &'static str, +} + +const HOTKEY_SWAP_LOCK_FIXES: &[HotkeySwapLockFix] = &[ + HotkeySwapLockFix { + coldkey: None, + netuid: 28, + old_hotkey: "5Ca8L8PkbqXUtzohKtSM3i1naGQxANGLx51kJsEPNB14Admz", + new_hotkey: "5Evgh9QTXJLxYLusVy3tcY5S6Z3GgRSNDb9AzXUchX5dco3P", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 97, + old_hotkey: "5EU83xGi9piVeTEQsjAod1Jrog7bFKuHRVQekM4LURwXqNdJ", + new_hotkey: "5DSEX7ww3K5i2rpCuv6cyvQ2nVn1qi7b5Ur86Vqop3muxXcC", + }, + HotkeySwapLockFix { + coldkey: Some("5C53wCYowihKwAxwTKd7ZA8hyzBkZJ1Qqa3Ry7v75Ed6eRNP"), + netuid: 97, + old_hotkey: "5F1dKAbbJNtf4Yce8ostaU5e1iPfrL6q8cjqH1KUGbBzmees", + new_hotkey: "5CtNXpjaK79SX9QC1GqRbS3C4KNETT7jh6GgZDrmCxvYrAdJ", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 97, + old_hotkey: "5DAGsDentUAs6Uh9SYJ2uLEQvYRWu1Euqai97AHF3A7RiGoT", + new_hotkey: "5GsqcuatjJtgSwJuaZWpPV8QWcQ4aHcPkF8DG7oqMNJLoN93", + }, + HotkeySwapLockFix { + coldkey: Some("5C53wCYowihKwAxwTKd7ZA8hyzBkZJ1Qqa3Ry7v75Ed6eRNP"), + netuid: 97, + old_hotkey: "5CtNXpjaK79SX9QC1GqRbS3C4KNETT7jh6GgZDrmCxvYrAdJ", + new_hotkey: "5DMN2AnnbUqbnSvbHkXHF7A8JUKBT8vxJJhKkDKG1GCwGDwf", + }, + HotkeySwapLockFix { + coldkey: Some("5D2n9CKP4KQ1FMf1ybm2psFsQSMKkCiCFMRchcvo3EUECFro"), + netuid: 120, + old_hotkey: "5GCN5Bo2djDGQ6aqVjgdfMzWbLuqhcN5pyNmrbkkJ4n7jZpQ", + new_hotkey: "5GRaijFsfTR723LeofVrjrq8kNAdyucmT9TPPGdiyrxckwGg", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 120, + old_hotkey: "5EU83xGi9piVeTEQsjAod1Jrog7bFKuHRVQekM4LURwXqNdJ", + new_hotkey: "5DAGsDentUAs6Uh9SYJ2uLEQvYRWu1Euqai97AHF3A7RiGoT", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 97, + old_hotkey: "5H3Kuy7L7DBSy7BS2c9EBayJYGkHV1pzWtnJm3iXvThT4VUJ", + new_hotkey: "5CSiRF3sMKt1c3MT4KsRLBWENGkymVE7wA2zUDPsYy6JtpGE", + }, + HotkeySwapLockFix { + coldkey: Some("5C53wCYowihKwAxwTKd7ZA8hyzBkZJ1Qqa3Ry7v75Ed6eRNP"), + netuid: 97, + old_hotkey: "5Cm7DPowNeA2b8b2ET4EkyqgviZUnsTUqQuqAnGp1SfXuPSw", + new_hotkey: "5GbMdbCdt4TJ94JUbf22uWGRvf17u99DdKpHuJGyMiexuCKx", + }, + HotkeySwapLockFix { + coldkey: Some("5D2n9CKP4KQ1FMf1ybm2psFsQSMKkCiCFMRchcvo3EUECFro"), + netuid: 120, + old_hotkey: "5GRaijFsfTR723LeofVrjrq8kNAdyucmT9TPPGdiyrxckwGg", + new_hotkey: "5CAkU49aHNYcDVLKKYSHnBuuymWr1A7aoAiAhK8FZpNYF6YH", + }, + HotkeySwapLockFix { + coldkey: Some("5DywxdtESjskgPZrDXL86qV44SpPgJuqs9X6noyJJwX9PaSD"), + netuid: 128, + old_hotkey: "5GRViDgqddpH3qB9A6nqPgMepgum51ZUZ199ksXQuCFsn128", + new_hotkey: "5Gq2gs4ft5dhhjbHabvVbAhjMCV2RgKmVJKAFCUWiirbRT21", + }, + HotkeySwapLockFix { + coldkey: Some("5D2n9CKP4KQ1FMf1ybm2psFsQSMKkCiCFMRchcvo3EUECFro"), + netuid: 120, + old_hotkey: "5CAkU49aHNYcDVLKKYSHnBuuymWr1A7aoAiAhK8FZpNYF6YH", + new_hotkey: "5HbgNXyw4mCMQWLL6Hb7inA2qQ81A8pqw1GFxpcshpKu11Aj", + }, + HotkeySwapLockFix { + coldkey: Some("5C53wCYowihKwAxwTKd7ZA8hyzBkZJ1Qqa3Ry7v75Ed6eRNP"), + netuid: 97, + old_hotkey: "5CfXcxCex4Up1S2SjP4MhBPM55qioPd8dCt2SEMC94m4M5Md", + new_hotkey: "5EWk5uun4rdLHfst1DXiU6e4QqTXSNpdkCtGVBGjEkDoorfN", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 97, + old_hotkey: "5HVyG7q3AiMLvG4GvkXTCfarerA3GnJ6a3r8pSVVeUiSLTng", + new_hotkey: "5GWJ5cdmEAiCL8V9sopDvntQjKtw5ciHy8urPh9AMLkpmtEw", + }, + HotkeySwapLockFix { + coldkey: Some("5C8SMSqb1i3tFao2vwdAnFWM6KA38y5UFCwBCLVr5a48tXtz"), + netuid: 97, + old_hotkey: "5GCFXhD1E7aY1Eq9hDWe24fXwRe4gqJ4nxw7XcV19SwTgtoq", + new_hotkey: "5FCXQcqNd8W5CJuTgNvPjR2R82N5TMJ66sPmWPhEDs3GkgZQ", + }, + HotkeySwapLockFix { + coldkey: Some("5EZWeiJunm2PCdsyUCv6UvckY5daLKGrxzRu1K9QHBAYiVhm"), + netuid: 120, + old_hotkey: "5ECiTKuujAHqf29cUDvsiEPwtAC6Yg3cT8aHJ4riAp41p1bS", + new_hotkey: "5CMFnjWR72kCMi9rChg3DZAH4MidSLHNfRaKCwyqaTyyRsev", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 120, + old_hotkey: "5DAGsDentUAs6Uh9SYJ2uLEQvYRWu1Euqai97AHF3A7RiGoT", + new_hotkey: "5HVyG7q3AiMLvG4GvkXTCfarerA3GnJ6a3r8pSVVeUiSLTng", + }, + HotkeySwapLockFix { + coldkey: Some("5C53wCYowihKwAxwTKd7ZA8hyzBkZJ1Qqa3Ry7v75Ed6eRNP"), + netuid: 97, + old_hotkey: "5GbMdbCdt4TJ94JUbf22uWGRvf17u99DdKpHuJGyMiexuCKx", + new_hotkey: "5CURjyKkCiSnaSPwMBUJXLC7mkadbPPkKQamyFhdsfb5DnSp", + }, + HotkeySwapLockFix { + coldkey: Some("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS"), + netuid: 97, + old_hotkey: "5CSiRF3sMKt1c3MT4KsRLBWENGkymVE7wA2zUDPsYy6JtpGE", + new_hotkey: "5EsnHJK89FgF55EYwXtqhUwLu3c14xakyQ8PWoomcFwpxk5e", + }, +]; + +fn decode_account_id32(ss58_string: &str) -> Option { + let account_id32: AccountId32 = AccountId32::from_ss58check(ss58_string).ok()?; + let mut account_id32_slice: &[u8] = account_id32.as_ref(); + T::AccountId::decode(&mut account_id32_slice).ok() +} + +fn is_non_zero_lock(lock: &LockState) -> bool { + !lock.locked_mass.is_zero() || lock.conviction > U64F64::saturating_from_num(0) +} + +fn add_lock_state(mut lhs: LockState, rhs: &LockState) -> LockState { + lhs.locked_mass = lhs.locked_mass.saturating_add(rhs.locked_mass); + lhs.conviction = lhs.conviction.saturating_add(rhs.conviction); + lhs.last_update = lhs.last_update.max(rhs.last_update); + lhs +} + +fn subtract_lock_state(mut lhs: LockState, rhs: &LockState) -> LockState { + lhs.locked_mass = lhs.locked_mass.saturating_sub(rhs.locked_mass); + lhs.conviction = lhs.conviction.saturating_sub(rhs.conviction); + lhs +} + +fn mutate_aggregate( + coldkey: &T::AccountId, + netuid: NetUid, + hotkey: &T::AccountId, + mutate: F, +) where + F: FnOnce(LockState) -> LockState + Clone, +{ + let perpetual = DecayingLock::::get(coldkey, netuid) == Some(false); + let owner = SubnetOwnerHotkey::::get(netuid) == *hotkey; + + match (owner, perpetual) { + (true, true) => OwnerLock::::mutate(netuid, |maybe_lock| { + if let Some(lock) = maybe_lock.take() { + let updated = mutate(lock); + if is_non_zero_lock(&updated) { + *maybe_lock = Some(updated); + } + } + }), + (true, false) => DecayingOwnerLock::::mutate(netuid, |maybe_lock| { + if let Some(lock) = maybe_lock.take() { + let updated = mutate(lock); + if is_non_zero_lock(&updated) { + *maybe_lock = Some(updated); + } + } + }), + (false, true) => HotkeyLock::::mutate(netuid, hotkey, |maybe_lock| { + if let Some(lock) = maybe_lock.take() { + let updated = mutate(lock); + if is_non_zero_lock(&updated) { + *maybe_lock = Some(updated); + } + } + }), + (false, false) => DecayingHotkeyLock::::mutate(netuid, hotkey, |maybe_lock| { + if let Some(lock) = maybe_lock.take() { + let updated = mutate(lock); + if is_non_zero_lock(&updated) { + *maybe_lock = Some(updated); + } + } + }), + } +} + +fn add_to_aggregate( + coldkey: &T::AccountId, + netuid: NetUid, + hotkey: &T::AccountId, + added: &LockState, +) { + let perpetual = DecayingLock::::get(coldkey, netuid) == Some(false); + let owner = SubnetOwnerHotkey::::get(netuid) == *hotkey; + + match (owner, perpetual) { + (true, true) => OwnerLock::::mutate(netuid, |maybe_lock| { + *maybe_lock = Some(match maybe_lock.take() { + Some(lock) => add_lock_state(lock, added), + None => added.clone(), + }); + }), + (true, false) => DecayingOwnerLock::::mutate(netuid, |maybe_lock| { + *maybe_lock = Some(match maybe_lock.take() { + Some(lock) => add_lock_state(lock, added), + None => added.clone(), + }); + }), + (false, true) => HotkeyLock::::mutate(netuid, hotkey, |maybe_lock| { + *maybe_lock = Some(match maybe_lock.take() { + Some(lock) => add_lock_state(lock, added), + None => added.clone(), + }); + }), + (false, false) => DecayingHotkeyLock::::mutate(netuid, hotkey, |maybe_lock| { + *maybe_lock = Some(match maybe_lock.take() { + Some(lock) => add_lock_state(lock, added), + None => added.clone(), + }); + }), + } +} + +/// Fixes lock state left behind by subnet-scoped hotkey swaps. +/// +/// If a destination lock already exists for the same coldkey, the old lock is +/// discarded instead of merged. +pub fn migrate_fix_subnet_hotkey_lock_swaps() -> Weight { + let migration_name = b"migrate_fix_subnet_hotkey_lock_swaps".to_vec(); + let mut weight = T::DbWeight::get().reads(1); + + if HasMigrationRun::::get(&migration_name) { + log::info!( + "Migration '{:?}' has already run. Skipping.", + String::from_utf8_lossy(&migration_name) + ); + return weight; + } + + log::info!( + "Running migration '{}'", + String::from_utf8_lossy(&migration_name) + ); + + let mut moved_locks = 0u64; + let mut discarded_locks = 0u64; + let mut missing_locks = 0u64; + + for fix in HOTKEY_SWAP_LOCK_FIXES { + let Some(old_hotkey) = decode_account_id32::(fix.old_hotkey) else { + log::error!("Failed to decode old hotkey: {}", fix.old_hotkey); + continue; + }; + let Some(new_hotkey) = decode_account_id32::(fix.new_hotkey) else { + log::error!("Failed to decode new hotkey: {}", fix.new_hotkey); + continue; + }; + let netuid = NetUid::from(fix.netuid); + + let locks_to_fix: Vec<(T::AccountId, LockState)> = if let Some(coldkey) = fix.coldkey { + let Some(coldkey) = decode_account_id32::(coldkey) else { + log::error!("Failed to decode coldkey: {}", coldkey); + continue; + }; + Lock::::take((coldkey.clone(), netuid, old_hotkey.clone())) + .map(|lock| vec![(coldkey, lock)]) + .unwrap_or_default() + } else { + let locks: Vec<(T::AccountId, LockState)> = Lock::::iter() + .filter_map(|((coldkey, lock_netuid, hotkey), lock)| { + (lock_netuid == netuid && hotkey == old_hotkey).then_some((coldkey, lock)) + }) + .collect(); + for (coldkey, _) in &locks { + Lock::::remove((coldkey.clone(), netuid, old_hotkey.clone())); + } + locks + }; + weight = weight.saturating_add( + T::DbWeight::get() + .reads_writes(locks_to_fix.len() as u64 + 1, locks_to_fix.len() as u64), + ); + + if locks_to_fix.is_empty() { + missing_locks = missing_locks.saturating_add(1); + continue; + } + + for (coldkey, lock) in locks_to_fix { + let destination_conflict = + Lock::::contains_key((coldkey.clone(), netuid, new_hotkey.clone())); + weight = weight.saturating_add(T::DbWeight::get().reads(1)); + + let new_hotkey_is_owner = SubnetOwnerHotkey::::get(netuid) == new_hotkey; + if !new_hotkey_is_owner || destination_conflict { + let removed = lock.clone(); + mutate_aggregate::(&coldkey, netuid, &old_hotkey, |aggregate| { + subtract_lock_state(aggregate, &removed) + }); + weight = weight.saturating_add(T::DbWeight::get().reads_writes(2, 1)); + } + + if destination_conflict { + discarded_locks = discarded_locks.saturating_add(1); + continue; + } + + Lock::::insert((coldkey.clone(), netuid, new_hotkey.clone()), lock.clone()); + weight = weight.saturating_add(T::DbWeight::get().writes(1)); + + if !new_hotkey_is_owner { + add_to_aggregate::(&coldkey, netuid, &new_hotkey, &lock); + weight = weight.saturating_add(T::DbWeight::get().reads_writes(2, 1)); + } + + moved_locks = moved_locks.saturating_add(1); + } + } + + HasMigrationRun::::insert(&migration_name, true); + weight = weight.saturating_add(T::DbWeight::get().writes(1)); + + log::info!( + "Migration '{:?}' completed successfully. Moved locks: {:?}, discarded locks: {:?}, missing locks: {:?}.", + String::from_utf8_lossy(&migration_name), + moved_locks, + discarded_locks, + missing_locks, + ); + + weight +} diff --git a/pallets/subtensor/src/migrations/mod.rs b/pallets/subtensor/src/migrations/mod.rs index 0e84214099..04f7615293 100644 --- a/pallets/subtensor/src/migrations/mod.rs +++ b/pallets/subtensor/src/migrations/mod.rs @@ -24,6 +24,7 @@ pub mod migrate_fix_root_claimed_overclaim; pub mod migrate_fix_root_subnet_tao; pub mod migrate_fix_root_tao_and_alpha_in; pub mod migrate_fix_staking_hot_keys; +pub mod migrate_fix_subnet_hotkey_lock_swaps; pub mod migrate_fix_total_issuance_evm_fees; pub mod migrate_init_tao_flow; pub mod migrate_init_total_issuance; diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index 944ea5877f..a998d41204 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -350,7 +350,11 @@ impl Pallet { weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); } - // 9. Perform the hotkey swap + // 9. Swap the stake locks + let (reads, writes) = Self::swap_hotkey_locks(old_hotkey, new_hotkey); + weight.saturating_accrue(T::DbWeight::get().reads_writes(reads, writes)); + + // 10. Perform the hotkey swap Self::perform_hotkey_swap_on_one_subnet( old_hotkey, new_hotkey, @@ -359,12 +363,12 @@ impl Pallet { keep_stake, )?; - // 10. Update the last transaction block for the coldkey + // 11. Update the last transaction block for the coldkey Self::set_last_tx_block(coldkey, block); LastHotkeySwapOnNetuid::::insert(netuid, coldkey, block); weight.saturating_accrue(T::DbWeight::get().writes(2)); - // 11. Emit an event for the hotkey swap + // 12. Emit an event for the hotkey swap Self::deposit_event(Event::HotkeySwappedOnSubnet { coldkey: coldkey.clone(), old_hotkey: old_hotkey.clone(), diff --git a/pallets/subtensor/src/tests/locks.rs b/pallets/subtensor/src/tests/locks.rs index ecefd49a6f..5f69d2c4d3 100644 --- a/pallets/subtensor/src/tests/locks.rs +++ b/pallets/subtensor/src/tests/locks.rs @@ -3836,3 +3836,108 @@ fn test_moving_partial_lock_same_owners() { ); }); } + +#[test] +fn test_hotkey_swap_moves_lock_and_conviction_to_new_hotkey() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let old_hotkey = U256::from(2); + let new_hotkey = U256::from(3); + let netuid = setup_subnet_with_stake(coldkey, old_hotkey, 100_000_000_000); + let lock_amount: AlphaBalance = 5000u64.into(); + let conviction = U64F64::from_num(1000); + + assert_ok!(SubtensorModule::do_lock_stake( + &coldkey, + netuid, + &old_hotkey, + lock_amount, + )); + + let mut lock = Lock::::get((coldkey, netuid, old_hotkey)).unwrap(); + lock.conviction = conviction; + Lock::::insert((coldkey, netuid, old_hotkey), lock); + + let mut hotkey_lock = HotkeyLock::::get(netuid, old_hotkey).unwrap(); + hotkey_lock.conviction = conviction; + HotkeyLock::::insert(netuid, old_hotkey, hotkey_lock); + + add_balance_to_coldkey_account( + &coldkey, + (SubtensorModule::get_key_swap_cost() + 1000.into()).into(), + ); + assert_ok!(SubtensorModule::do_swap_hotkey( + RuntimeOrigin::signed(coldkey), + &old_hotkey, + &new_hotkey, + None, + false, + )); + + assert!(Lock::::get((coldkey, netuid, old_hotkey)).is_none()); + assert!(HotkeyLock::::get(netuid, old_hotkey).is_none()); + + let moved_lock = Lock::::get((coldkey, netuid, new_hotkey)).unwrap(); + assert_eq!(moved_lock.locked_mass, lock_amount); + assert_eq!(moved_lock.conviction, conviction); + + let moved_hotkey_lock = HotkeyLock::::get(netuid, new_hotkey).unwrap(); + assert_eq!(moved_hotkey_lock.locked_mass, lock_amount); + assert_eq!(moved_hotkey_lock.conviction, conviction); + assert_eq!( + SubtensorModule::hotkey_conviction(&new_hotkey, netuid), + conviction + ); + }); +} + +#[test] +fn test_swap_hotkey_v2_on_subnet_moves_lock_and_conviction_to_new_hotkey() { + new_test_ext(100).execute_with(|| { + let coldkey = U256::from(1); + let old_hotkey = U256::from(2); + let new_hotkey = U256::from(3); + let netuid = setup_subnet_with_stake(coldkey, old_hotkey, 100_000_000_000); + let lock_amount: AlphaBalance = 5000u64.into(); + let conviction = U64F64::from_num(1000); + + assert_ok!(SubtensorModule::do_lock_stake( + &coldkey, + netuid, + &old_hotkey, + lock_amount, + )); + + let mut lock = Lock::::get((coldkey, netuid, old_hotkey)).unwrap(); + lock.conviction = conviction; + Lock::::insert((coldkey, netuid, old_hotkey), lock); + + let mut hotkey_lock = HotkeyLock::::get(netuid, old_hotkey).unwrap(); + hotkey_lock.conviction = conviction; + HotkeyLock::::insert(netuid, old_hotkey, hotkey_lock); + + add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000u64.into()); + assert_ok!(SubtensorModule::swap_hotkey_v2( + RuntimeOrigin::signed(coldkey), + old_hotkey, + new_hotkey, + Some(netuid), + false, + )); + + assert!(Lock::::get((coldkey, netuid, old_hotkey)).is_none()); + assert!(HotkeyLock::::get(netuid, old_hotkey).is_none()); + + let moved_lock = Lock::::get((coldkey, netuid, new_hotkey)).unwrap(); + assert_eq!(moved_lock.locked_mass, lock_amount); + assert_eq!(moved_lock.conviction, conviction); + + let moved_hotkey_lock = HotkeyLock::::get(netuid, new_hotkey).unwrap(); + assert_eq!(moved_hotkey_lock.locked_mass, lock_amount); + assert_eq!(moved_hotkey_lock.conviction, conviction); + assert_eq!( + SubtensorModule::hotkey_conviction(&new_hotkey, netuid), + conviction + ); + }); +} diff --git a/pallets/subtensor/src/tests/migration.rs b/pallets/subtensor/src/tests/migration.rs index 75be412858..6f2c3b2609 100644 --- a/pallets/subtensor/src/tests/migration.rs +++ b/pallets/subtensor/src/tests/migration.rs @@ -68,6 +68,143 @@ fn test_migrate_tao_in_refund_deployment_block() { assert_eq!(TaoInRefundDeploymentBlock::::get(), deployment_block); }); } + +#[test] +fn test_migrate_fix_subnet_hotkey_lock_swaps_moves_or_discards_conflicts() { + new_test_ext(1).execute_with(|| { + let migration_name = b"migrate_fix_subnet_hotkey_lock_swaps".to_vec(); + let old_hotkey = + decode_account_id32::("5Ca8L8PkbqXUtzohKtSM3i1naGQxANGLx51kJsEPNB14Admz") + .expect("old hotkey should decode"); + let new_hotkey = + decode_account_id32::("5Evgh9QTXJLxYLusVy3tcY5S6Z3GgRSNDb9AzXUchX5dco3P") + .expect("new hotkey should decode"); + let netuid = NetUid::from(28); + let coldkey_to_move = U256::from(1); + let coldkey_with_conflict = U256::from(2); + let chained_coldkey = + decode_account_id32::("5EWUPMenvyvHdEGUHfUhSTeTDJDLzLkKZq74LFLRWtzcqZiS") + .expect("chained coldkey should decode"); + let chained_first_hotkey = + decode_account_id32::("5H3Kuy7L7DBSy7BS2c9EBayJYGkHV1pzWtnJm3iXvThT4VUJ") + .expect("chained first hotkey should decode"); + let chained_middle_hotkey = + decode_account_id32::("5CSiRF3sMKt1c3MT4KsRLBWENGkymVE7wA2zUDPsYy6JtpGE") + .expect("chained middle hotkey should decode"); + let chained_final_hotkey = + decode_account_id32::("5EsnHJK89FgF55EYwXtqhUwLu3c14xakyQ8PWoomcFwpxk5e") + .expect("chained final hotkey should decode"); + let chained_netuid = NetUid::from(97); + + HasMigrationRun::::remove(&migration_name); + + let moved_lock = LockState { + locked_mass: AlphaBalance::from(10_u64), + conviction: U64F64::from_num(3), + last_update: 11, + }; + let discarded_lock = LockState { + locked_mass: AlphaBalance::from(20_u64), + conviction: U64F64::from_num(5), + last_update: 12, + }; + let existing_destination_lock = LockState { + locked_mass: AlphaBalance::from(77_u64), + conviction: U64F64::from_num(7), + last_update: 10, + }; + let chained_lock = LockState { + locked_mass: AlphaBalance::from(33_u64), + conviction: U64F64::from_num(4), + last_update: 13, + }; + + Lock::::insert( + (coldkey_to_move, netuid, old_hotkey), + moved_lock.clone(), + ); + Lock::::insert( + (coldkey_with_conflict, netuid, old_hotkey), + discarded_lock.clone(), + ); + Lock::::insert( + (coldkey_with_conflict, netuid, new_hotkey), + existing_destination_lock.clone(), + ); + DecayingLock::::insert(coldkey_to_move, netuid, false); + DecayingLock::::insert(coldkey_with_conflict, netuid, false); + DecayingLock::::insert(chained_coldkey, chained_netuid, false); + HotkeyLock::::insert( + netuid, + old_hotkey, + LockState { + locked_mass: AlphaBalance::from(30_u64), + conviction: U64F64::from_num(8), + last_update: 12, + }, + ); + HotkeyLock::::insert(netuid, new_hotkey, existing_destination_lock.clone()); + Lock::::insert( + (chained_coldkey, chained_netuid, chained_first_hotkey), + chained_lock.clone(), + ); + HotkeyLock::::insert(chained_netuid, chained_first_hotkey, chained_lock.clone()); + + let weight = + crate::migrations::migrate_fix_subnet_hotkey_lock_swaps::migrate_fix_subnet_hotkey_lock_swaps::(); + + assert!(!weight.is_zero(), "migration weight should be non-zero"); + assert!(HasMigrationRun::::get(&migration_name)); + assert!(Lock::::get((coldkey_to_move, netuid, old_hotkey)).is_none()); + assert!(Lock::::get((coldkey_with_conflict, netuid, old_hotkey)).is_none()); + assert_eq!( + Lock::::get((coldkey_to_move, netuid, new_hotkey)), + Some(moved_lock.clone()) + ); + assert_eq!( + Lock::::get((coldkey_with_conflict, netuid, new_hotkey)), + Some(existing_destination_lock.clone()) + ); + assert!(HotkeyLock::::get(netuid, old_hotkey).is_none()); + + let new_aggregate = HotkeyLock::::get(netuid, new_hotkey) + .expect("new aggregate should exist"); + assert_eq!( + new_aggregate.locked_mass, + existing_destination_lock + .locked_mass + .saturating_add(moved_lock.locked_mass) + ); + assert_eq!( + new_aggregate.conviction, + existing_destination_lock + .conviction + .saturating_add(moved_lock.conviction) + ); + assert!(Lock::::get(( + chained_coldkey, + chained_netuid, + chained_first_hotkey + )) + .is_none()); + assert!(Lock::::get(( + chained_coldkey, + chained_netuid, + chained_middle_hotkey + )) + .is_none()); + assert_eq!( + Lock::::get((chained_coldkey, chained_netuid, chained_final_hotkey)), + Some(chained_lock.clone()) + ); + assert!(HotkeyLock::::get(chained_netuid, chained_first_hotkey).is_none()); + assert!(HotkeyLock::::get(chained_netuid, chained_middle_hotkey).is_none()); + assert_eq!( + HotkeyLock::::get(chained_netuid, chained_final_hotkey), + Some(chained_lock) + ); + }); +} #[test] fn test_migration_transfer_nets_to_foundation() { new_test_ext(1).execute_with(|| { From e543b9126688728f225ab1a319308d048e51729c Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 8 Jun 2026 13:00:45 -0400 Subject: [PATCH 04/48] Scope hotkey lock swaps to subnet --- pallets/subtensor/src/staking/lock.rs | 27 ++++++++-- pallets/subtensor/src/swap/swap_hotkey.rs | 2 +- pallets/subtensor/src/tests/locks.rs | 64 +++++++++++++++++++++++ 3 files changed, 88 insertions(+), 5 deletions(-) diff --git a/pallets/subtensor/src/staking/lock.rs b/pallets/subtensor/src/staking/lock.rs index 27c5e5d646..aa4a6508ab 100644 --- a/pallets/subtensor/src/staking/lock.rs +++ b/pallets/subtensor/src/staking/lock.rs @@ -1384,14 +1384,29 @@ impl Pallet { /// Conviction is not reset because the hotkey ownership does not change, it's still /// the same hotkey owner who will own the new hotkey. pub fn swap_hotkey_locks(old_hotkey: &T::AccountId, new_hotkey: &T::AccountId) -> (u64, u64) { + Self::swap_hotkey_locks_for_netuids(old_hotkey, new_hotkey, Self::get_all_subnet_netuids()) + } + + /// Swap locks made to the old_hotkey to new_hotkey on one netuid. + pub fn swap_hotkey_locks_on_subnet( + old_hotkey: &T::AccountId, + new_hotkey: &T::AccountId, + netuid: NetUid, + ) -> (u64, u64) { + Self::swap_hotkey_locks_for_netuids(old_hotkey, new_hotkey, vec![netuid]) + } + + fn swap_hotkey_locks_for_netuids( + old_hotkey: &T::AccountId, + new_hotkey: &T::AccountId, + netuids: Vec, + ) -> (u64, u64) { let mut locks_to_transfer: Vec<(T::AccountId, NetUid, LockState)> = Vec::new(); let mut netuids_to_transfer: Vec<(NetUid, bool, bool)> = Vec::new(); let mut reads: u64 = 0; let mut writes: u64 = 0; - let netuids = Self::get_all_subnet_netuids(); - - for netuid in netuids { + for netuid in netuids.iter().copied() { let old_is_owner_hotkey = Self::is_subnet_owner_hotkey(netuid, old_hotkey); let new_is_owner_hotkey = Self::is_subnet_owner_hotkey(netuid, new_hotkey); let has_hotkey_lock = HotkeyLock::::contains_key(netuid, old_hotkey); @@ -1419,7 +1434,11 @@ impl Pallet { if !netuids_to_transfer.is_empty() { for ((coldkey, netuid, hotkey), lock) in Lock::::iter() { - if hotkey == *old_hotkey { + if hotkey == *old_hotkey + && netuids_to_transfer + .iter() + .any(|(rebuild_netuid, _, _)| *rebuild_netuid == netuid) + { locks_to_transfer.push((coldkey, netuid, lock)); } reads = reads.saturating_add(1); diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index a998d41204..4c8a0af5a8 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -351,7 +351,7 @@ impl Pallet { } // 9. Swap the stake locks - let (reads, writes) = Self::swap_hotkey_locks(old_hotkey, new_hotkey); + let (reads, writes) = Self::swap_hotkey_locks_on_subnet(old_hotkey, new_hotkey, netuid); weight.saturating_accrue(T::DbWeight::get().reads_writes(reads, writes)); // 10. Perform the hotkey swap diff --git a/pallets/subtensor/src/tests/locks.rs b/pallets/subtensor/src/tests/locks.rs index 5f69d2c4d3..47f18cafa6 100644 --- a/pallets/subtensor/src/tests/locks.rs +++ b/pallets/subtensor/src/tests/locks.rs @@ -3941,3 +3941,67 @@ fn test_swap_hotkey_v2_on_subnet_moves_lock_and_conviction_to_new_hotkey() { ); }); } + +#[test] +fn test_swap_hotkey_v2_on_subnet_does_not_move_locks_on_other_subnets() { + new_test_ext(100).execute_with(|| { + let coldkey = U256::from(1); + let old_hotkey = U256::from(2); + let new_hotkey = U256::from(3); + let swapped_netuid = setup_subnet_with_stake(coldkey, old_hotkey, 100_000_000_000); + let untouched_netuid = setup_subnet_with_stake(coldkey, old_hotkey, 100_000_000_000); + let lock_amount: AlphaBalance = 5000u64.into(); + let conviction = U64F64::from_num(1000); + + for netuid in [swapped_netuid, untouched_netuid] { + assert_ok!(SubtensorModule::do_lock_stake( + &coldkey, + netuid, + &old_hotkey, + lock_amount, + )); + + let mut lock = Lock::::get((coldkey, netuid, old_hotkey)).unwrap(); + lock.conviction = conviction; + Lock::::insert((coldkey, netuid, old_hotkey), lock); + + let mut hotkey_lock = HotkeyLock::::get(netuid, old_hotkey).unwrap(); + hotkey_lock.conviction = conviction; + HotkeyLock::::insert(netuid, old_hotkey, hotkey_lock); + } + + add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000u64.into()); + assert_ok!(SubtensorModule::swap_hotkey_v2( + RuntimeOrigin::signed(coldkey), + old_hotkey, + new_hotkey, + Some(swapped_netuid), + false, + )); + + assert!(Lock::::get((coldkey, swapped_netuid, old_hotkey)).is_none()); + assert!(HotkeyLock::::get(swapped_netuid, old_hotkey).is_none()); + assert_eq!( + Lock::::get((coldkey, swapped_netuid, new_hotkey)) + .unwrap() + .conviction, + conviction + ); + assert_eq!( + HotkeyLock::::get(swapped_netuid, new_hotkey) + .unwrap() + .conviction, + conviction + ); + + let untouched_lock = Lock::::get((coldkey, untouched_netuid, old_hotkey)).unwrap(); + assert_eq!(untouched_lock.locked_mass, lock_amount); + assert_eq!(untouched_lock.conviction, conviction); + assert!(Lock::::get((coldkey, untouched_netuid, new_hotkey)).is_none()); + + let untouched_hotkey_lock = HotkeyLock::::get(untouched_netuid, old_hotkey).unwrap(); + assert_eq!(untouched_hotkey_lock.locked_mass, lock_amount); + assert_eq!(untouched_hotkey_lock.conviction, conviction); + assert!(HotkeyLock::::get(untouched_netuid, new_hotkey).is_none()); + }); +} From e3ab314884c9f9737129c64f7ced19506299f6d9 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 8 Jun 2026 13:03:16 -0400 Subject: [PATCH 05/48] Use saturating weight accounting in lock swap migration --- .../src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs index be437fd212..7ff1dea7c8 100644 --- a/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs +++ b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs @@ -292,9 +292,10 @@ pub fn migrate_fix_subnet_hotkey_lock_swaps() -> Weight { } locks }; + let locks_to_fix_count = locks_to_fix.len() as u64; weight = weight.saturating_add( T::DbWeight::get() - .reads_writes(locks_to_fix.len() as u64 + 1, locks_to_fix.len() as u64), + .reads_writes(locks_to_fix_count.saturating_add(1), locks_to_fix_count), ); if locks_to_fix.is_empty() { From 2aee717089a9e908d0e8376b151ee22f0693ee9d Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 8 Jun 2026 14:41:48 -0400 Subject: [PATCH 06/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 7eb03654f2..06b9b85b87 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -278,7 +278,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 417, + spec_version: 418, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 112174b22d674b888bd93fdca169e006a47a473b Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 10 Jun 2026 16:30:14 -0400 Subject: [PATCH 07/48] Address AI review --- .../migrate_fix_subnet_hotkey_lock_swaps.rs | 38 +++++++++++++------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs index 7b97602a57..93af663092 100644 --- a/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs +++ b/pallets/subtensor/src/migrations/migrate_fix_subnet_hotkey_lock_swaps.rs @@ -273,37 +273,51 @@ pub fn migrate_fix_subnet_hotkey_lock_swaps() -> Weight { }; let netuid = NetUid::from(fix.netuid); - let indexed_coldkeys: u64; + let index_reads: u64; + let index_writes: u64; + let lock_take_reads: u64; + let lock_take_writes: u64; let locks_to_fix: Vec<(T::AccountId, LockState)> = if let Some(coldkey) = fix.coldkey { let Some(coldkey) = decode_account_id32::(coldkey) else { log::error!("Failed to decode coldkey: {}", coldkey); continue; }; - indexed_coldkeys = 1; + index_reads = 0; + index_writes = 1; + lock_take_reads = 1; LockingColdkeys::::remove((netuid, old_hotkey.clone(), coldkey.clone())); - Lock::::take((coldkey.clone(), netuid, old_hotkey.clone())) - .map(|lock| vec![(coldkey, lock)]) - .unwrap_or_default() + if let Some(lock) = Lock::::take((coldkey.clone(), netuid, old_hotkey.clone())) { + lock_take_writes = 1; + vec![(coldkey, lock)] + } else { + lock_take_writes = 0; + Vec::new() + } } else { let coldkeys: Vec = LockingColdkeys::::iter_prefix((netuid, old_hotkey.clone())) .map(|(coldkey, ())| coldkey) .collect(); - indexed_coldkeys = coldkeys.len() as u64; + let indexed_coldkeys = coldkeys.len() as u64; + index_reads = indexed_coldkeys; + index_writes = indexed_coldkeys; + lock_take_reads = indexed_coldkeys; - coldkeys + let locks: Vec<(T::AccountId, LockState)> = coldkeys .into_iter() .filter_map(|coldkey| { LockingColdkeys::::remove((netuid, old_hotkey.clone(), coldkey.clone())); Lock::::take((coldkey.clone(), netuid, old_hotkey.clone())) .map(|lock| (coldkey, lock)) }) - .collect() + .collect(); + lock_take_writes = locks.len() as u64; + locks }; - let locks_to_fix_count = locks_to_fix.len() as u64; - weight = weight.saturating_add( - T::DbWeight::get().reads_writes(locks_to_fix_count.saturating_add(1), indexed_coldkeys), - ); + weight = weight.saturating_add(T::DbWeight::get().reads_writes( + index_reads.saturating_add(lock_take_reads), + index_writes.saturating_add(lock_take_writes), + )); if locks_to_fix.is_empty() { missing_locks = missing_locks.saturating_add(1); From e2eafe6edb70034b40344b1b447f2662c8c1bfea Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 13:08:34 -0400 Subject: [PATCH 08/48] Make setting ck take extrinsics payable --- pallets/subtensor/src/macros/dispatches.rs | 4 ++-- pallets/subtensor/src/tests/staking.rs | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index b471328aec..9afa16922e 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -611,7 +611,7 @@ mod dispatches { /// - The delegate is setting a take which is not lower than the previous. /// #[pallet::call_index(65)] - #[pallet::weight((::WeightInfo::decrease_take(), DispatchClass::Normal, Pays::No))] + #[pallet::weight((::WeightInfo::decrease_take(), DispatchClass::Normal, Pays::Yes))] pub fn decrease_take( origin: OriginFor, hotkey: T::AccountId, @@ -651,7 +651,7 @@ mod dispatches { /// - The delegate is setting a take which is not greater than the previous. /// #[pallet::call_index(66)] - #[pallet::weight((::WeightInfo::increase_take(), DispatchClass::Normal, Pays::No))] + #[pallet::weight((::WeightInfo::increase_take(), DispatchClass::Normal, Pays::Yes))] pub fn increase_take( origin: OriginFor, hotkey: T::AccountId, diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index 7906c8b798..46b938b484 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -22,6 +22,26 @@ use crate::*; staking::add_stake() tests ************************************************************/ +#[test] +fn test_delegate_take_dispatch_info_pays_fee() { + new_test_ext(1).execute_with(|| { + let hotkey = U256::from(1); + let take = SubtensorModule::get_min_delegate_take(); + + let decrease_take_call = + RuntimeCall::SubtensorModule(SubtensorCall::decrease_take { hotkey, take }); + let decrease_take_dispatch_info = decrease_take_call.get_dispatch_info(); + assert_eq!(decrease_take_dispatch_info.class, DispatchClass::Normal); + assert_eq!(decrease_take_dispatch_info.pays_fee, Pays::Yes); + + let increase_take_call = + RuntimeCall::SubtensorModule(SubtensorCall::increase_take { hotkey, take }); + let increase_take_dispatch_info = increase_take_call.get_dispatch_info(); + assert_eq!(increase_take_dispatch_info.class, DispatchClass::Normal); + assert_eq!(increase_take_dispatch_info.pays_fee, Pays::Yes); + }); +} + #[test] fn test_add_stake_dispatch_info_ok() { new_test_ext(1).execute_with(|| { From fc0580a4514c2452fde2b627035028eeadbf83bc Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:32:11 -0400 Subject: [PATCH 09/48] merge main --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From 306cc58b8014f5da744f200216ee8eb3a8ebc41c Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:33:11 -0400 Subject: [PATCH 10/48] Fix main merge broken test --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From bde66c53e19a6f1602a2574db91327fdcb16bbbe Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:33:55 -0400 Subject: [PATCH 11/48] Fix main merge broken test --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From 7d11d6d1bb3342b0411de255cb7a58098dd5bd1e Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:46:42 -0400 Subject: [PATCH 12/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index df8d3a1a4a..7bc7028f68 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 417, + spec_version: 418, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 62db84b35f7fae8dd386c47c60f4c1d30aff4b5a Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:47:29 -0400 Subject: [PATCH 13/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index df8d3a1a4a..7bc7028f68 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 417, + spec_version: 418, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From fa9936bc63139da264c55929dbb048621e67502e Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 14:48:33 -0400 Subject: [PATCH 14/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 2c15537257..382f04af9c 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 417, + spec_version: 418, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 593ceba74645367ec49db3c1f755c2a398a2517b Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Thu, 11 Jun 2026 12:33:24 -0700 Subject: [PATCH 15/48] Update pallets/subtensor/src/swap/swap_hotkey.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- pallets/subtensor/src/swap/swap_hotkey.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index 39b53cffdb..55a067732b 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -46,17 +46,21 @@ impl Pallet { Error::::NonAssociatedColdKey ); - // 3. If the new hotkey already exists globally, ensure the coldkey owns it + // 3. Initialize the weight for this operation. This includes the old-hotkey + // owner check above. + let mut weight = T::DbWeight::get().reads(2); + + // 4. If the new hotkey already exists globally, ensure the coldkey owns it if Self::hotkey_account_exists(new_hotkey) { + weight.saturating_accrue(T::DbWeight::get().reads(2)); ensure!( Self::coldkey_owns_hotkey(&coldkey, new_hotkey), Error::::NonAssociatedColdKey ); + } else { + weight.saturating_accrue(T::DbWeight::get().reads(1)); } - // 4. Initialize the weight for this operation - let mut weight = T::DbWeight::get().reads(2); - // 5. Ensure the new hotkey is different from the old one ensure!(old_hotkey != new_hotkey, Error::::NewHotKeyIsSameWithOld); From aadd7afe93218c254bc48bbb5da3da02d3d83ea4 Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Thu, 11 Jun 2026 12:33:52 -0700 Subject: [PATCH 16/48] Update pallets/subtensor/src/swap/swap_hotkey.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- pallets/subtensor/src/swap/swap_hotkey.rs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index 39b53cffdb..7ea9360684 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -46,17 +46,20 @@ impl Pallet { Error::::NonAssociatedColdKey ); - // 3. If the new hotkey already exists globally, ensure the coldkey owns it + // 3. Initialize the weight for this operation. The coldkey/old_hotkey + // ownership check above reads Owner twice. + let mut weight = T::DbWeight::get().reads(2); + + // 4. If the new hotkey already exists globally, ensure the coldkey owns it + weight.saturating_accrue(T::DbWeight::get().reads(1)); if Self::hotkey_account_exists(new_hotkey) { + weight.saturating_accrue(T::DbWeight::get().reads(2)); ensure!( Self::coldkey_owns_hotkey(&coldkey, new_hotkey), Error::::NonAssociatedColdKey ); } - // 4. Initialize the weight for this operation - let mut weight = T::DbWeight::get().reads(2); - // 5. Ensure the new hotkey is different from the old one ensure!(old_hotkey != new_hotkey, Error::::NewHotKeyIsSameWithOld); From 485071c128c1e6f373dd8bde2b046d4acc10e76e Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Thu, 11 Jun 2026 13:20:17 -0700 Subject: [PATCH 17/48] Update pallets/subtensor/src/swap/swap_hotkey.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- pallets/subtensor/src/swap/swap_hotkey.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index 55a067732b..cac71b25a4 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -52,7 +52,7 @@ impl Pallet { // 4. If the new hotkey already exists globally, ensure the coldkey owns it if Self::hotkey_account_exists(new_hotkey) { - weight.saturating_accrue(T::DbWeight::get().reads(2)); +weight.saturating_accrue(T::DbWeight::get().reads(3)); ensure!( Self::coldkey_owns_hotkey(&coldkey, new_hotkey), Error::::NonAssociatedColdKey From 0a52e4106a68dabd3253882c42cee0b513c5e02a Mon Sep 17 00:00:00 2001 From: "subtensor-ai-review[bot]" Date: Thu, 11 Jun 2026 20:26:24 +0000 Subject: [PATCH 18/48] chore: auditor auto-fix --- pallets/subtensor/src/swap/swap_hotkey.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index cac71b25a4..8f81327e31 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -52,7 +52,7 @@ impl Pallet { // 4. If the new hotkey already exists globally, ensure the coldkey owns it if Self::hotkey_account_exists(new_hotkey) { -weight.saturating_accrue(T::DbWeight::get().reads(3)); + weight.saturating_accrue(T::DbWeight::get().reads(3)); ensure!( Self::coldkey_owns_hotkey(&coldkey, new_hotkey), Error::::NonAssociatedColdKey From 51068415bce36b1d9874ce1f7c67b046b3941c47 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 11 Jun 2026 16:44:03 -0400 Subject: [PATCH 19/48] Fix test_swap_owner_new_hotkey_already_exists --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From c0e6911da68282935a26e084d1d7a14a72a9f7a2 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Fri, 12 Jun 2026 14:45:53 -0400 Subject: [PATCH 20/48] Handle swap errors in chain buys --- .../subtensor/src/coinbase/run_coinbase.rs | 41 +++++++++++---- pallets/subtensor/src/coinbase/tao.rs | 29 +++++++++++ pallets/subtensor/src/tests/coinbase.rs | 50 +++++++++++++++++++ pallets/subtensor/src/tests/tao.rs | 27 ++++++++++ 4 files changed, 136 insertions(+), 11 deletions(-) diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index 494fc163f7..3ace3bc30d 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -107,17 +107,36 @@ impl Pallet { T::SwapInterface::max_price(), true, ); - if let Ok(buy_swap_result_ok) = buy_swap_result { - let bought_alpha: AlphaBalance = - buy_swap_result_ok.amount_paid_out.into(); - SubnetProtocolAlpha::::mutate(*netuid_i, |total| { - *total = total.saturating_add(bought_alpha); - }); - - // Record actual excess TAO that entered pool. - let actual_excess: TaoBalance = buy_swap_result_ok.amount_paid_in; - SubnetExcessTao::::insert(*netuid_i, actual_excess); - Self::record_protocol_inflow(*netuid_i, actual_excess); + match buy_swap_result { + Ok(buy_swap_result_ok) => { + let bought_alpha: AlphaBalance = + buy_swap_result_ok.amount_paid_out.into(); + SubnetProtocolAlpha::::mutate(*netuid_i, |total| { + *total = total.saturating_add(bought_alpha); + }); + + // Record actual excess TAO that entered pool. + let actual_excess: TaoBalance = + buy_swap_result_ok.amount_paid_in; + SubnetExcessTao::::insert(*netuid_i, actual_excess); + Self::record_protocol_inflow(*netuid_i, actual_excess); + } + Err(error) => { + match Self::withdraw_tao_as_credit( + &subnet_account_id, + tao_to_swap_with, + ) { + Ok(refund_credit) => { + remaining_credit = + remaining_credit.merge(refund_credit); + } + Err(withdraw_error) => { + log::error!( + "Failed to revert excess TAO deposit after swap failure: netuid_i = {netuid_i:?}, tao_to_swap_with = {tao_to_swap_with:?}, swap_error = {error:?}, withdraw_error = {withdraw_error:?}" + ); + } + } + } } } Err(remainder) => { diff --git a/pallets/subtensor/src/coinbase/tao.rs b/pallets/subtensor/src/coinbase/tao.rs index 0dee496c3b..44ba0fa4b0 100644 --- a/pallets/subtensor/src/coinbase/tao.rs +++ b/pallets/subtensor/src/coinbase/tao.rs @@ -286,6 +286,35 @@ impl Pallet { } } + /// Withdraw TAO from an account into a fresh credit. + /// + /// This is useful when a previous `spend_tao` resolve must be undone without + /// changing total issuance. + pub fn withdraw_tao_as_credit( + coldkey: &T::AccountId, + amount: BalanceOf, + ) -> Result, DispatchError> { + let balances_ti_before = ::Currency::total_issuance(); + + let credit = ::Currency::withdraw( + coldkey, + amount, + Precision::Exact, + Preservation::Expendable, + Fortitude::Polite, + )?; + + let balances_ti_after = ::Currency::total_issuance(); + if balances_ti_after < balances_ti_before { + let burned = balances_ti_before.saturating_sub(balances_ti_after); + TotalIssuance::::mutate(|total| { + *total = total.saturating_sub(burned); + }); + } + + Ok(credit) + } + /// Finalizes the unused part of the minted TAO. pub fn recycle_credit(credit: CreditOf) { let amount = credit.peek(); diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 20944a03d0..1a9bc5cd0b 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3678,6 +3678,56 @@ fn test_coinbase_inject_and_maybe_swap_does_not_skew_reserves() { }); } +#[test] +fn test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failure() { + new_test_ext(1).execute_with(|| { + let zero = U96F32::saturating_from_num(0); + let netuid = add_dynamic_network(&U256::from(1), &U256::from(2)); + let tao_to_swap = TaoBalance::from(789_100_u64); + + mock::setup_reserves( + netuid, + TaoBalance::from(1_000_000_000_000_u64), + AlphaBalance::from(1_000_000_000_000_u64), + ); + Swap::maybe_initialize_palswap(netuid, None); + + // Force the buy swap to fail after the excess TAO credit is deposited. + SubnetAlphaIn::::set( + netuid, + AlphaBalance::from(u64::from(mock::SwapMinimumReserve::get()) - 1), + ); + assert!( + SubtensorModule::swap_tao_for_alpha( + netuid, + tao_to_swap, + ::SwapInterface::max_price(), + true, + ) + .is_err() + ); + + let subnet_account = SubtensorModule::get_subnet_account_id(netuid).unwrap(); + let chain_before = Balances::free_balance(&subnet_account); + let subnet_tao_before = SubnetTAO::::get(netuid); + let total_issuance_before = TotalIssuance::::get(); + let balances_issuance_before = Balances::total_issuance(); + + let tao_in = BTreeMap::from([(netuid, zero)]); + let alpha_in = BTreeMap::from([(netuid, zero)]); + let excess_tao = BTreeMap::from([(netuid, U96F32::saturating_from_num(tao_to_swap))]); + let credit = SubtensorModule::mint_tao(tao_to_swap); + + SubtensorModule::inject_and_maybe_swap(&[netuid], &tao_in, &alpha_in, &excess_tao, credit); + + assert_eq!(Balances::free_balance(&subnet_account), chain_before); + assert_eq!(SubnetTAO::::get(netuid), subnet_tao_before); + assert_eq!(SubnetExcessTao::::get(netuid), TaoBalance::ZERO); + assert_eq!(TotalIssuance::::get(), total_issuance_before); + assert_eq!(Balances::total_issuance(), balances_issuance_before); + }); +} + #[test] fn test_coinbase_drain_pending_increments_blockssincelaststep() { new_test_ext(1).execute_with(|| { diff --git a/pallets/subtensor/src/tests/tao.rs b/pallets/subtensor/src/tests/tao.rs index b79b80e3f3..a0246a399d 100644 --- a/pallets/subtensor/src/tests/tao.rs +++ b/pallets/subtensor/src/tests/tao.rs @@ -500,6 +500,33 @@ fn test_transfer_tao_reaps_origin() { }); } +#[test] +fn test_withdraw_tao_as_credit_reaps_origin_and_updates_subtensor_total_issuance() { + new_test_ext(1).execute_with(|| { + let origin = U256::from(1); + + let ed = ExistentialDeposit::get(); + let dust = ed - 1u64.into(); + let amount = TaoBalance::from(1_000); + let balance = amount + dust; + add_balance_to_coldkey_account(&origin, balance); + + let subtensor_ti_before = subtensor_total_issuance(); + let balances_ti_before = balances_total_issuance(); + + let credit = SubtensorModule::withdraw_tao_as_credit(&origin, amount).unwrap(); + + let subtensor_ti_after = subtensor_total_issuance(); + let balances_ti_after = balances_total_issuance(); + + assert_eq!(credit.peek(), amount); + assert_eq!(Balances::total_balance(&origin), 0.into()); + assert_eq!(balances_ti_before - balances_ti_after, dust); + assert_eq!(subtensor_ti_before - subtensor_ti_after, dust); + assert_eq!(balances_ti_after, subtensor_ti_after); + }); +} + #[test] fn test_recycle_tao_cannot_cross_preserve_threshold_in_high_ed_runtime() { new_test_ext(1).execute_with(|| { From 8ac42bb2509bbdd01df235224ddbf135f5da5a15 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Fri, 12 Jun 2026 15:07:07 -0400 Subject: [PATCH 21/48] Handle dust in order_swap.rs and leasing.rs to sync TI --- pallets/subtensor/src/staking/order_swap.rs | 5 +--- pallets/subtensor/src/subnets/leasing.rs | 23 +++------------- pallets/subtensor/src/tests/tao.rs | 30 +++++++++++++++++++++ 3 files changed, 35 insertions(+), 23 deletions(-) diff --git a/pallets/subtensor/src/staking/order_swap.rs b/pallets/subtensor/src/staking/order_swap.rs index fd0ae3461c..9cf428d74c 100644 --- a/pallets/subtensor/src/staking/order_swap.rs +++ b/pallets/subtensor/src/staking/order_swap.rs @@ -1,6 +1,4 @@ use super::*; -use frame_support::traits::fungible::Mutate; -use frame_support::traits::tokens::Preservation; use frame_support::transactional; use substrate_fixed::types::U64F64; use subtensor_runtime_common::{AlphaBalance, NetUid, TaoBalance}; @@ -103,8 +101,7 @@ impl OrderSwapInterface for Pallet { } fn transfer_tao(from: &T::AccountId, to: &T::AccountId, amount: TaoBalance) -> DispatchResult { - ::Currency::transfer(from, to, amount, Preservation::Expendable)?; - Ok(()) + Pallet::::transfer_tao(from, to, amount) } #[transactional] diff --git a/pallets/subtensor/src/subnets/leasing.rs b/pallets/subtensor/src/subnets/leasing.rs index d3e1b84df5..3ba615b4c5 100644 --- a/pallets/subtensor/src/subnets/leasing.rs +++ b/pallets/subtensor/src/subnets/leasing.rs @@ -18,7 +18,7 @@ use super::*; use frame_support::{ dispatch::RawOrigin, - traits::{Defensive, fungible::*, tokens::Preservation}, + traits::{Defensive, fungible::*}, }; use frame_system::pallet_prelude::OriginFor; use frame_system::pallet_prelude::*; @@ -92,12 +92,7 @@ impl Pallet { frame_system::Pallet::::inc_providers(&lease_coldkey); frame_system::Pallet::::inc_providers(&lease_hotkey); - ::Currency::transfer( - &crowdloan.funds_account, - &lease_coldkey, - crowdloan.raised, - Preservation::Expendable, - )?; + Self::transfer_tao(&crowdloan.funds_account, &lease_coldkey, crowdloan.raised)?; Self::do_register_network( RawOrigin::Signed(lease_coldkey.clone()).into(), @@ -151,23 +146,13 @@ impl Pallet { .saturating_mul(U64F64::from(u64::from(leftover_cap))) .floor() .saturating_to_num::(); - ::Currency::transfer( - &lease_coldkey, - &contributor, - contributor_refund.into(), - Preservation::Expendable, - )?; + Self::transfer_tao(&lease_coldkey, &contributor, contributor_refund.into())?; refunded_cap = refunded_cap.saturating_add(contributor_refund); } // Refund what's left after refunding the contributors to the beneficiary let beneficiary_refund = leftover_cap.saturating_sub(refunded_cap.into()); - ::Currency::transfer( - &lease_coldkey, - &who, - beneficiary_refund, - Preservation::Expendable, - )?; + Self::transfer_tao(&lease_coldkey, &who, beneficiary_refund)?; Self::deposit_event(Event::SubnetLeaseCreated { beneficiary: who, diff --git a/pallets/subtensor/src/tests/tao.rs b/pallets/subtensor/src/tests/tao.rs index b79b80e3f3..320b447545 100644 --- a/pallets/subtensor/src/tests/tao.rs +++ b/pallets/subtensor/src/tests/tao.rs @@ -19,6 +19,7 @@ use frame_support::{ use sp_core::U256; use sp_runtime::traits::{AccountIdConversion, Zero}; use subtensor_runtime_common::TaoBalance; +use subtensor_swap_interface::OrderSwapInterface; const MAX_TAO_ISSUANCE: u64 = 21_000_000_000_000_000_u64; @@ -500,6 +501,35 @@ fn test_transfer_tao_reaps_origin() { }); } +#[test] +fn test_order_swap_transfer_tao_reaps_origin_and_updates_subtensor_total_issuance() { + new_test_ext(1).execute_with(|| { + let origin = U256::from(1); + let dest = U256::from(2); + + let ed = ExistentialDeposit::get(); + let dust = ed - 1u64.into(); + let amount = TaoBalance::from(1_000); + add_balance_to_coldkey_account(&origin, amount + dust); + + let subtensor_ti_before = subtensor_total_issuance(); + let balances_ti_before = balances_total_issuance(); + + assert_ok!(>::transfer_tao( + &origin, &dest, amount + )); + + let subtensor_ti_after = subtensor_total_issuance(); + let balances_ti_after = balances_total_issuance(); + + assert_eq!(Balances::total_balance(&origin), 0.into()); + assert_eq!(Balances::total_balance(&dest), amount); + assert_eq!(balances_ti_before - balances_ti_after, dust); + assert_eq!(subtensor_ti_before - subtensor_ti_after, dust); + assert_eq!(balances_ti_after, subtensor_ti_after); + }); +} + #[test] fn test_recycle_tao_cannot_cross_preserve_threshold_in_high_ed_runtime() { new_test_ext(1).execute_with(|| { From 8595e4781eae9fee02821aa99be8b10119c6b58a Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Fri, 12 Jun 2026 15:50:03 -0400 Subject: [PATCH 22/48] Fix test_swap_owner_new_hotkey_already_exists --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From 597d6ff49cdf9ba106032dc891ee4df0f15c45a7 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Fri, 12 Jun 2026 15:50:39 -0400 Subject: [PATCH 23/48] Fix test_swap_owner_new_hotkey_already_exists --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 426572bdcd..76dcd0a9ad 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -926,7 +926,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap From b32bed66bd7137dcd9e36755f09a6995ac12c91d Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Fri, 12 Jun 2026 15:56:34 -0400 Subject: [PATCH 24/48] clippy --- pallets/subtensor/src/tests/coinbase.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 1a9bc5cd0b..99b8b3a5b2 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3708,7 +3708,7 @@ fn test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failur ); let subnet_account = SubtensorModule::get_subnet_account_id(netuid).unwrap(); - let chain_before = Balances::free_balance(&subnet_account); + let chain_before = Balances::free_balance(subnet_account); let subnet_tao_before = SubnetTAO::::get(netuid); let total_issuance_before = TotalIssuance::::get(); let balances_issuance_before = Balances::total_issuance(); @@ -3720,7 +3720,7 @@ fn test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failur SubtensorModule::inject_and_maybe_swap(&[netuid], &tao_in, &alpha_in, &excess_tao, credit); - assert_eq!(Balances::free_balance(&subnet_account), chain_before); + assert_eq!(Balances::free_balance(subnet_account), chain_before); assert_eq!(SubnetTAO::::get(netuid), subnet_tao_before); assert_eq!(SubnetExcessTao::::get(netuid), TaoBalance::ZERO); assert_eq!(TotalIssuance::::get(), total_issuance_before); From 799af3847adb9947fe3a642e6b5b352c3f2e11ce Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 15 Jun 2026 07:26:08 -0400 Subject: [PATCH 25/48] Handle balancer misbalance on injection --- pallets/swap/src/pallet/impls.rs | 94 +++++++++++++++++++++++++------- pallets/swap/src/pallet/mod.rs | 9 +++ pallets/swap/src/pallet/tests.rs | 92 +++++++++++++++++++++++++++++++ 3 files changed, 176 insertions(+), 19 deletions(-) diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs index c3e0b2f1d3..57e759f7ad 100644 --- a/pallets/swap/src/pallet/impls.rs +++ b/pallets/swap/src/pallet/impls.rs @@ -79,8 +79,8 @@ impl Pallet { Ok(()) } - /// Returns actually added Tao and Alpha, which may be zero in case - /// of a high disbalance + /// Returns actually added Tao and Alpha. Amounts that would push weights + /// out of range are left in per-subnet reservoirs for a later injection. pub(super) fn adjust_protocol_liquidity( netuid: NetUid, tao_delta: TaoBalance, @@ -89,31 +89,85 @@ impl Pallet { // Get reserves let alpha_reserve = T::AlphaReserve::reserve(netuid.into()); let tao_reserve = T::TaoReserve::reserve(netuid.into()); - let mut balancer = SwapBalancer::::get(netuid); + let balancer = SwapBalancer::::get(netuid); + + let pending_tao = BalancerTaoReservoir::::get(netuid).saturating_add(tao_delta); + let pending_alpha = BalancerAlphaReservoir::::get(netuid).saturating_add(alpha_delta); + + if let Some(new_balancer) = Self::try_update_balancer( + &balancer, + tao_reserve, + alpha_reserve, + pending_tao, + pending_alpha, + ) { + BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); + BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); + SwapBalancer::::insert(netuid, new_balancer); + return (pending_tao, pending_alpha); + } - // Update weights and log errors if they go out of range - if balancer - .update_weights_for_added_liquidity( - u64::from(tao_reserve), - u64::from(alpha_reserve), - u64::from(tao_delta), - u64::from(alpha_delta), - ) - .is_err() - { + if let Some(new_balancer) = Self::try_update_balancer( + &balancer, + tao_reserve, + alpha_reserve, + TaoBalance::ZERO, + pending_alpha, + ) { + BalancerTaoReservoir::::insert(netuid, pending_tao); + BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); + SwapBalancer::::insert(netuid, new_balancer); + return (TaoBalance::ZERO, pending_alpha); + } + + if let Some(new_balancer) = Self::try_update_balancer( + &balancer, + tao_reserve, + alpha_reserve, + pending_tao, + AlphaBalance::ZERO, + ) { + BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); + BalancerAlphaReservoir::::insert(netuid, pending_alpha); + SwapBalancer::::insert(netuid, new_balancer); + return (pending_tao, AlphaBalance::ZERO); + } + + BalancerTaoReservoir::::insert(netuid, pending_tao); + BalancerAlphaReservoir::::insert(netuid, pending_alpha); + if pending_tao > TaoBalance::ZERO || pending_alpha > AlphaBalance::ZERO { log::warn!( - "Reserves are out of range for emission: netuid = {}, tao = {}, alpha = {}, tao_delta = {}, alpha_delta = {}", + "Reserves are out of range for emission: netuid = {}, tao = {}, alpha = {}, tao_delta = {}, alpha_delta = {}, tao_reservoir = {}, alpha_reservoir = {}", netuid, tao_reserve, alpha_reserve, tao_delta, - alpha_delta + alpha_delta, + pending_tao, + pending_alpha ); - (TaoBalance::ZERO, AlphaBalance::ZERO) - } else { - SwapBalancer::::insert(netuid, balancer); - (tao_delta, alpha_delta) } + + (TaoBalance::ZERO, AlphaBalance::ZERO) + } + + fn try_update_balancer( + balancer: &Balancer, + tao_reserve: TaoBalance, + alpha_reserve: AlphaBalance, + tao_delta: TaoBalance, + alpha_delta: AlphaBalance, + ) -> Option { + let mut new_balancer = balancer.clone(); + new_balancer + .update_weights_for_added_liquidity( + u64::from(tao_reserve), + u64::from(alpha_reserve), + u64::from(tao_delta), + u64::from(alpha_delta), + ) + .ok()?; + Some(new_balancer) } /// Executes a token swap on the specified subnet. @@ -276,6 +330,8 @@ impl Pallet { FeeRate::::remove(netuid); SwapBalancer::::remove(netuid); + BalancerTaoReservoir::::remove(netuid); + BalancerAlphaReservoir::::remove(netuid); log::debug!( "clear_protocol_liquidity: netuid={netuid:?}, protocol_burned: τ={burned_tao:?}, α={burned_alpha:?}; state cleared" diff --git a/pallets/swap/src/pallet/mod.rs b/pallets/swap/src/pallet/mod.rs index 1d2fd07c59..630e51c49f 100644 --- a/pallets/swap/src/pallet/mod.rs +++ b/pallets/swap/src/pallet/mod.rs @@ -113,6 +113,15 @@ mod pallet { #[pallet::storage] pub type PalSwapInitialized = StorageMap<_, Twox64Concat, NetUid, bool, ValueQuery>; + /// TAO protocol liquidity that could not be injected without exceeding balancer weight bounds. + #[pallet::storage] + pub type BalancerTaoReservoir = StorageMap<_, Twox64Concat, NetUid, TaoBalance, ValueQuery>; + + /// Alpha protocol liquidity that could not be injected without exceeding balancer weight bounds. + #[pallet::storage] + pub type BalancerAlphaReservoir = + StorageMap<_, Twox64Concat, NetUid, AlphaBalance, ValueQuery>; + /// --- Storage for migration run status #[pallet::storage] pub type HasMigrationRun = diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs index b1071294d3..84aa6524d8 100644 --- a/pallets/swap/src/pallet/tests.rs +++ b/pallets/swap/src/pallet/tests.rs @@ -155,6 +155,94 @@ mod dispatchables { }); } + #[test] + fn test_adjust_protocol_liquidity_injects_alpha_and_reservoirs_tao() { + new_test_ext().execute_with(|| { + let netuid = NetUid::from(1); + + let tao = TaoBalance::from(1_000_u64); + let alpha = AlphaBalance::from(1_000_u64); + TaoReserve::set_mock_reserve(netuid, tao); + AlphaReserve::set_mock_reserve(netuid, alpha); + + let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); + + assert_eq!(tao_added, TaoBalance::ZERO); + assert_eq!(alpha_added, AlphaBalance::from(1_000_u64)); + assert_eq!( + BalancerTaoReservoir::::get(netuid), + TaoBalance::from(200_000_u64) + ); + assert_eq!( + BalancerAlphaReservoir::::get(netuid), + AlphaBalance::ZERO + ); + }); + } + + #[test] + fn test_adjust_protocol_liquidity_injects_tao_and_reservoirs_alpha() { + new_test_ext().execute_with(|| { + let netuid = NetUid::from(1); + + let tao = TaoBalance::from(1_000_u64); + let alpha = AlphaBalance::from(1_000_u64); + TaoReserve::set_mock_reserve(netuid, tao); + AlphaReserve::set_mock_reserve(netuid, alpha); + + let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); + + assert_eq!(tao_added, TaoBalance::from(1_000_u64)); + assert_eq!(alpha_added, AlphaBalance::ZERO); + assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); + assert_eq!( + BalancerAlphaReservoir::::get(netuid), + AlphaBalance::from(200_000_u64) + ); + }); + } + + #[test] + fn test_adjust_protocol_liquidity_retries_reservoir_with_new_injection() { + new_test_ext().execute_with(|| { + let netuid = NetUid::from(1); + + let mut tao = TaoBalance::from(1_000_u64); + let mut alpha = AlphaBalance::from(1_000_u64); + TaoReserve::set_mock_reserve(netuid, tao); + AlphaReserve::set_mock_reserve(netuid, alpha); + + let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); + tao += tao_added; + alpha += alpha_added; + TaoReserve::set_mock_reserve(netuid, tao); + AlphaReserve::set_mock_reserve(netuid, alpha); + + let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); + + assert!(tao_added > TaoBalance::ZERO); + assert!(alpha_added > AlphaBalance::ZERO); + assert!(BalancerTaoReservoir::::get(netuid) < TaoBalance::from(200_000_u64)); + assert!(BalancerAlphaReservoir::::get(netuid) < AlphaBalance::from(200_000_u64)); + }); + } + /// This test case verifies that small gradual injections (like emissions in every block) /// in the worst case /// - Do not cause price to change @@ -749,6 +837,8 @@ fn test_liquidate_pal_simple_ok_and_clears() { // Insert map values FeeRate::::insert(netuid, 1_000); PalSwapInitialized::::insert(netuid, true); + BalancerTaoReservoir::::insert(netuid, TaoBalance::from(12_345_u64)); + BalancerAlphaReservoir::::insert(netuid, AlphaBalance::from(67_890_u64)); let w_quote_pt = Perquintill::from_rational(1u128, 2u128); let bal = Balancer::new(w_quote_pt).unwrap(); SwapBalancer::::insert(netuid, bal); @@ -763,6 +853,8 @@ fn test_liquidate_pal_simple_ok_and_clears() { assert!(!FeeRate::::contains_key(netuid)); assert!(!PalSwapInitialized::::contains_key(netuid)); assert!(!SwapBalancer::::contains_key(netuid)); + assert!(!BalancerTaoReservoir::::contains_key(netuid)); + assert!(!BalancerAlphaReservoir::::contains_key(netuid)); }); } From 0da9a76bc79064e5c05f4b9dea14de532590fbc3 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Mon, 15 Jun 2026 18:00:38 +0200 Subject: [PATCH 26/48] Fix adjust_protocol_liquidity in case when balancer is pushed out of weight range --- .../subtensor/src/coinbase/run_coinbase.rs | 71 +++++++----- pallets/subtensor/src/tests/coinbase.rs | 36 ++++++ pallets/subtensor/src/tests/networks.rs | 4 + pallets/swap/src/pallet/impls.rs | 33 ++++-- pallets/swap/src/pallet/tests.rs | 106 +++++++++++++----- primitives/swap-interface/src/lib.rs | 2 +- 6 files changed, 185 insertions(+), 67 deletions(-) diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index 494fc163f7..1a76984fcb 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -85,11 +85,6 @@ impl Pallet { let tao_to_swap_with: TaoBalance = tou64!(excess_tao.get(netuid_i).unwrap_or(&asfloat!(0))).into(); - // Inject tao and alpha into protocol liquidity. In theorry, it may not always - // be a success (returned values are 0s) in case of high liquidity disbalance - let (actual_injected_tao, actual_injected_alpha) = - T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i); - // Clear per-block pool-side emission counters up front so a subnet // disabled this block does not display stale values from an earlier block. SubnetExcessTao::::insert(*netuid_i, TaoBalance::ZERO); @@ -130,38 +125,60 @@ impl Pallet { } } - // Inject Alpha in. - SubnetAlphaInEmission::::insert(*netuid_i, actual_injected_alpha); - - // Mint alpha and resolve to alpha reserve - Self::resolve_to_alpha_in(Self::mint_alpha(*netuid_i, actual_injected_alpha)); - - // Inject TAO in. - if !actual_injected_tao.is_zero() { - match Self::spend_tao(&subnet_account_id, remaining_credit, actual_injected_tao) - { + // Materialize this block's TAO before updating balancer reservoir + // state. If spending fails, do not let the swap pallet consume + // reservoir state as if this block's TAO arrived. + let materialized_tao_delta = if tao_in_i.is_zero() { + TaoBalance::ZERO + } else { + match Self::spend_tao(&subnet_account_id, remaining_credit, tao_in_i) { Ok(remainder) => { remaining_credit = remainder; - - SubnetTaoInEmission::::insert(*netuid_i, actual_injected_tao); - SubnetTAO::::mutate(*netuid_i, |total| { - *total = total.saturating_add(actual_injected_tao); - }); - TotalStake::::mutate(|total| { - *total = total.saturating_add(actual_injected_tao); - }); - - // Record emission injection as protocol inflow. - Self::record_protocol_inflow(*netuid_i, actual_injected_tao); + tao_in_i } Err(remainder) => { remaining_credit = remainder; let remaining_balance = remaining_credit.peek(); log::error!( - "Failed to spend credit: injected_tao = {actual_injected_tao:?}, netuid_i = {netuid_i:?}, remaining_balance = {remaining_balance:?}" + "Failed to spend credit: tao_to_materialize = {tao_in_i:?}, netuid_i = {netuid_i:?}, remaining_balance = {remaining_balance:?}" ); + TaoBalance::ZERO } } + }; + + // Decide which current/reservoir liquidity can become price-active + // without pushing balancer weights out of range. Only already + // materialized current TAO is offered to the swap pallet. + let ( + price_active_tao, + _tao_to_materialize, + price_active_alpha, + alpha_to_materialize, + ) = T::SwapInterface::adjust_protocol_liquidity( + *netuid_i, + materialized_tao_delta, + alpha_in_i, + ); + + // Materialize this block's alpha emission, then add only the + // price-active portion to the pool reserve. The price-active + // portion may include alpha that was materialized in an earlier + // block and held in the reservoir. + let _ = Self::mint_alpha(*netuid_i, alpha_to_materialize); + SubnetAlphaInEmission::::insert(*netuid_i, price_active_alpha); + Self::increase_provided_alpha_reserve(*netuid_i, price_active_alpha); + + // Add only the price-active TAO to the pool reserve. This may + // include TAO materialized in an earlier block and held in the + // reservoir. + if !price_active_tao.is_zero() { + SubnetTaoInEmission::::insert(*netuid_i, price_active_tao); + Self::increase_provided_tao_reserve(*netuid_i, price_active_tao); + TotalStake::::mutate(|total| { + *total = total.saturating_add(price_active_tao); + }); + Self::record_protocol_inflow(*netuid_i, price_active_tao); } } } diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 20944a03d0..abbe18e08d 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3678,6 +3678,42 @@ fn test_coinbase_inject_and_maybe_swap_does_not_skew_reserves() { }); } +#[test] +fn test_coinbase_failed_tao_materialization_does_not_activate_current_tao() { + new_test_ext(1).execute_with(|| { + let netuid = add_dynamic_network(&U256::from(1), &U256::from(2)); + let initial_reserve = TaoBalance::from(1_000_000_u64); + let reservoir_tao = TaoBalance::from(100_u64); + let current_tao = TaoBalance::from(200_u64); + let current_alpha = AlphaBalance::from(100_u64); + + mock::setup_reserves(netuid, initial_reserve, AlphaBalance::from(1_000_000_u64)); + Swap::maybe_initialize_palswap(netuid, None); + pallet_subtensor_swap::BalancerTaoReservoir::::insert(netuid, reservoir_tao); + + let tao_in = BTreeMap::from([(netuid, U96F32::saturating_from_num(current_tao))]); + let alpha_in = BTreeMap::from([(netuid, U96F32::saturating_from_num(current_alpha))]); + let excess_tao = BTreeMap::new(); + let credit = SubtensorModule::mint_tao(TaoBalance::ZERO); + + SubtensorModule::inject_and_maybe_swap(&[netuid], &tao_in, &alpha_in, &excess_tao, credit); + + assert_eq!( + SubnetTAO::::get(netuid), + initial_reserve.saturating_add(reservoir_tao) + ); + assert_eq!(SubnetTaoInEmission::::get(netuid), reservoir_tao); + assert_eq!( + SubnetProtocolFlow::::get(netuid), + reservoir_tao.to_u64() as i64 + ); + assert_eq!( + pallet_subtensor_swap::BalancerTaoReservoir::::get(netuid), + TaoBalance::ZERO + ); + }); +} + #[test] fn test_coinbase_drain_pending_increments_blockssincelaststep() { new_test_ext(1).execute_with(|| { diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs index 4696507e2e..c49677bddf 100644 --- a/pallets/subtensor/src/tests/networks.rs +++ b/pallets/subtensor/src/tests/networks.rs @@ -370,6 +370,8 @@ fn dissolve_clears_all_per_subnet_storages() { SubnetAlphaOutEmission::::insert(net, AlphaBalance::from(1)); SubnetTaoInEmission::::insert(net, TaoBalance::from(1)); SubnetVolume::::insert(net, 1u128); + pallet_subtensor_swap::BalancerTaoReservoir::::insert(net, TaoBalance::from(1)); + pallet_subtensor_swap::BalancerAlphaReservoir::::insert(net, AlphaBalance::from(1)); // Items now REMOVED (not zeroed) by dissolution SubnetAlphaIn::::insert(net, AlphaBalance::from(2)); @@ -521,6 +523,8 @@ fn dissolve_clears_all_per_subnet_storages() { assert!(!SubnetAlphaOutEmission::::contains_key(net)); assert!(!SubnetTaoInEmission::::contains_key(net)); assert!(!SubnetVolume::::contains_key(net)); + assert!(!pallet_subtensor_swap::BalancerTaoReservoir::::contains_key(net)); + assert!(!pallet_subtensor_swap::BalancerAlphaReservoir::::contains_key(net)); // TAO Flow assert!(!SubnetTaoFlow::::contains_key(net)); diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs index 57e759f7ad..2afa9569b9 100644 --- a/pallets/swap/src/pallet/impls.rs +++ b/pallets/swap/src/pallet/impls.rs @@ -79,13 +79,30 @@ impl Pallet { Ok(()) } - /// Returns actually added Tao and Alpha. Amounts that would push weights - /// out of range are left in per-subnet reservoirs for a later injection. + /// Adjusts balancer weights with minted TAO and alpha liquidity to + /// maintain price. + /// + /// If weights cannot be adjusted (get pushed out of range), the excess TAO + /// and/or Alpha are added to reservoirs and an attempt to use them will be made + /// later. + /// + /// Returns: + /// 1. price-active TAO delta to add to `SubnetTAO` + /// 2. TAO delta to materialize by the caller + /// 3. price-active Alpha delta to add to `SubnetAlphaIn` + /// 4. Alpha delta to materialize by the caller + /// + /// Amounts that would push weights out of range are materialized but left in + /// per-subnet reservoirs for a later balancer update. + /// + /// Reservoir amounts may be included in the balancer update, but they are not + /// returned for materialization because they were already materialized when + /// first stored. pub(super) fn adjust_protocol_liquidity( netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, AlphaBalance) { + ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance) { // Get reserves let alpha_reserve = T::AlphaReserve::reserve(netuid.into()); let tao_reserve = T::TaoReserve::reserve(netuid.into()); @@ -104,7 +121,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); SwapBalancer::::insert(netuid, new_balancer); - return (pending_tao, pending_alpha); + return (pending_tao, tao_delta, pending_alpha, alpha_delta); } if let Some(new_balancer) = Self::try_update_balancer( @@ -117,7 +134,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, pending_tao); BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); SwapBalancer::::insert(netuid, new_balancer); - return (TaoBalance::ZERO, pending_alpha); + return (TaoBalance::ZERO, tao_delta, pending_alpha, alpha_delta); } if let Some(new_balancer) = Self::try_update_balancer( @@ -130,7 +147,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); BalancerAlphaReservoir::::insert(netuid, pending_alpha); SwapBalancer::::insert(netuid, new_balancer); - return (pending_tao, AlphaBalance::ZERO); + return (pending_tao, tao_delta, AlphaBalance::ZERO, alpha_delta); } BalancerTaoReservoir::::insert(netuid, pending_tao); @@ -148,7 +165,7 @@ impl Pallet { ); } - (TaoBalance::ZERO, AlphaBalance::ZERO) + (TaoBalance::ZERO, tao_delta, AlphaBalance::ZERO, alpha_delta) } fn try_update_balancer( @@ -446,7 +463,7 @@ impl SwapHandler for Pallet { netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, AlphaBalance) { + ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance) { Self::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta) } diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs index 84aa6524d8..689e48e3d4 100644 --- a/pallets/swap/src/pallet/tests.rs +++ b/pallets/swap/src/pallet/tests.rs @@ -156,7 +156,7 @@ mod dispatchables { } #[test] - fn test_adjust_protocol_liquidity_injects_alpha_and_reservoirs_tao() { + fn test_adjust_protocol_liquidity_materializes_tao_when_reservoiring_tao() { new_test_ext().execute_with(|| { let netuid = NetUid::from(1); @@ -165,14 +165,17 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(200_000_u64), - AlphaBalance::from(1_000_u64), - ); + let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); - assert_eq!(tao_added, TaoBalance::ZERO); - assert_eq!(alpha_added, AlphaBalance::from(1_000_u64)); + assert_eq!(price_active_tao, TaoBalance::ZERO); + assert_eq!(tao_materialized, TaoBalance::from(200_000_u64)); + assert_eq!(price_active_alpha, AlphaBalance::from(1_000_u64)); + assert_eq!(alpha_materialized, AlphaBalance::from(1_000_u64)); assert_eq!( BalancerTaoReservoir::::get(netuid), TaoBalance::from(200_000_u64) @@ -185,7 +188,7 @@ mod dispatchables { } #[test] - fn test_adjust_protocol_liquidity_injects_tao_and_reservoirs_alpha() { + fn test_adjust_protocol_liquidity_materializes_alpha_when_reservoiring_alpha() { new_test_ext().execute_with(|| { let netuid = NetUid::from(1); @@ -194,14 +197,17 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(1_000_u64), - AlphaBalance::from(200_000_u64), - ); + let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); - assert_eq!(tao_added, TaoBalance::from(1_000_u64)); - assert_eq!(alpha_added, AlphaBalance::ZERO); + assert_eq!(price_active_tao, TaoBalance::from(1_000_u64)); + assert_eq!(tao_materialized, TaoBalance::from(1_000_u64)); + assert_eq!(price_active_alpha, AlphaBalance::ZERO); + assert_eq!(alpha_materialized, AlphaBalance::from(200_000_u64)); assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); assert_eq!( BalancerAlphaReservoir::::get(netuid), @@ -220,26 +226,64 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(200_000_u64), - AlphaBalance::from(1_000_u64), - ); - tao += tao_added; - alpha += alpha_added; + let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); + assert_eq!(price_active_tao, TaoBalance::ZERO); + assert_eq!(tao_materialized, TaoBalance::from(200_000_u64)); + assert_eq!(price_active_alpha, AlphaBalance::from(1_000_u64)); + assert_eq!(alpha_materialized, AlphaBalance::from(1_000_u64)); + tao += price_active_tao; + alpha += price_active_alpha; TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (tao_added, alpha_added) = Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(1_000_u64), - AlphaBalance::from(200_000_u64), + let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); + + assert!(price_active_tao >= tao_materialized); + assert!(price_active_alpha >= alpha_materialized); + assert_eq!(tao_materialized, TaoBalance::from(1_000_u64)); + assert_eq!(alpha_materialized, AlphaBalance::from(200_000_u64)); + assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); + assert_eq!( + BalancerAlphaReservoir::::get(netuid), + AlphaBalance::ZERO ); + }); + } + + #[test] + fn test_adjust_protocol_liquidity_does_not_materialize_reservoir_amounts() { + new_test_ext().execute_with(|| { + let netuid = NetUid::from(1); - assert!(tao_added > TaoBalance::ZERO); - assert!(alpha_added > AlphaBalance::ZERO); - assert!(BalancerTaoReservoir::::get(netuid) < TaoBalance::from(200_000_u64)); - assert!(BalancerAlphaReservoir::::get(netuid) < AlphaBalance::from(200_000_u64)); + TaoReserve::set_mock_reserve(netuid, TaoBalance::from(1_000_000_u64)); + AlphaReserve::set_mock_reserve(netuid, AlphaBalance::from(1_000_000_u64)); + BalancerTaoReservoir::::insert(netuid, TaoBalance::from(10_000_u64)); + BalancerAlphaReservoir::::insert(netuid, AlphaBalance::from(20_000_u64)); + + let tao_delta = TaoBalance::from(300_u64); + let alpha_delta = AlphaBalance::from(400_u64); + let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + Swap::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta); + + assert_eq!(price_active_tao, TaoBalance::from(10_300_u64)); + assert_eq!(tao_materialized, tao_delta); + assert_eq!(price_active_alpha, AlphaBalance::from(20_400_u64)); + assert_eq!(alpha_materialized, alpha_delta); + assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); + assert_eq!( + BalancerAlphaReservoir::::get(netuid), + AlphaBalance::ZERO + ); }); } diff --git a/primitives/swap-interface/src/lib.rs b/primitives/swap-interface/src/lib.rs index 9980604707..85e8cacc7a 100644 --- a/primitives/swap-interface/src/lib.rs +++ b/primitives/swap-interface/src/lib.rs @@ -46,7 +46,7 @@ pub trait SwapHandler { netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, AlphaBalance); + ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance); fn clear_protocol_liquidity(netuid: NetUid) -> DispatchResult; fn init_swap(netuid: NetUid, maybe_price: Option); fn get_alpha_amount_for_tao(netuid: NetUid, tao_amount: TaoBalance) -> AlphaBalance; From 2a0fd3c09dc9ed8c758a6ee9367f408ce78440ea Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 18 Jun 2026 15:51:09 +0300 Subject: [PATCH 27/48] Fix test_swap_owner_new_hotkey_already_exists --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 3fb8288f94..beb8ec9a75 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -900,22 +900,23 @@ fn test_swap_owner_old_hotkey_not_exist() { }); } -// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_new_hotkey_already_exists --exact --nocapture +// SKIP_WASM_BUILD=1 cargo test --package pallet-subtensor --lib -- tests::swap_hotkey_with_subnet::test_swap_owner_new_hotkey_already_exists --exact --nocapture #[test] fn test_swap_owner_new_hotkey_already_exists() { new_test_ext(1).execute_with(|| { let old_hotkey = U256::from(1); let new_hotkey = U256::from(2); let coldkey = U256::from(3); + let another_coldkey = U256::from(4); - let netuid = add_dynamic_network(&new_hotkey, &coldkey); + let netuid = add_dynamic_network(&old_hotkey, &coldkey); add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); // old_hotkey is owned by coldkey; new_hotkey was already registered on `netuid` // by add_dynamic_network (the condition under test). Do NOT reassign new_hotkey to // a foreign coldkey — the new_hotkey-ownership check (NonAssociatedColdKey) would // then fire before the already-registered-in-subnet check this test targets. - Owner::::insert(old_hotkey, coldkey); + Owner::::insert(new_hotkey, another_coldkey); // Perform the swap System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); From f173757b50582b801a0b1facb539b742577c4a28 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 18 Jun 2026 15:56:55 +0300 Subject: [PATCH 28/48] merge devnet-ready --- pallets/subtensor/src/tests/subnet_info.rs | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/pallets/subtensor/src/tests/subnet_info.rs b/pallets/subtensor/src/tests/subnet_info.rs index 342b3bc885..378d641343 100644 --- a/pallets/subtensor/src/tests/subnet_info.rs +++ b/pallets/subtensor/src/tests/subnet_info.rs @@ -122,12 +122,8 @@ fn test_get_subnet_hyperparams_v3_values_reflect_storage() { SubtensorModule::set_bonds_reset(netuid, true); SubtensorModule::set_owner_cut_enabled_flag(netuid, true); SubtensorModule::set_owner_cut_auto_lock_enabled(netuid, true); -<<<<<<< HEAD - SubtensorModule::set_min_childkey_take_for_subnet(netuid, 31); -======= SubtensorModule::set_min_childkey_take(31); SubtensorModule::set_min_childkey_take_for_subnet(netuid, 32); ->>>>>>> devnet-ready let result = SubtensorModule::get_subnet_hyperparams_v3(netuid).unwrap(); let p = &result; @@ -187,16 +183,10 @@ fn test_get_subnet_hyperparams_v3_values_reflect_storage() { &HyperparamValue::U16(Compact(30)) ); assert_eq!(find(p, b"yuma_version"), &HyperparamValue::U16(Compact(3))); -<<<<<<< HEAD - assert_eq!( - find(p, b"min_childkey_take_per_subnet"), - &HyperparamValue::U16(Compact(31)) -======= // Effective min childkey take = max(global, per-subnet). assert_eq!( find(p, b"min_childkey_take"), &HyperparamValue::U16(Compact(32)) ->>>>>>> devnet-ready ); // U64 variants From 02982dc8406645d49e9869059337b23eae318b16 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 18 Jun 2026 16:14:21 +0300 Subject: [PATCH 29/48] merge devnet-ready --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 5cf4d7aadb..94e25a46fb 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 419, + spec_version: 420, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From db24fe48f10a1a8412a01a347486f45a32a88aa3 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 25 Jun 2026 14:01:19 +0300 Subject: [PATCH 30/48] Address ai review: Handle reservoirs properly on network dissolution --- pallets/subtensor/src/coinbase/root.rs | 13 ++++- pallets/subtensor/src/staking/stake_utils.rs | 4 +- pallets/subtensor/src/tests/coinbase.rs | 28 ++++++++++ pallets/subtensor/src/tests/networks.rs | 54 +++++++++++++++++++- pallets/subtensor/src/tests/staking.rs | 8 +-- pallets/swap/src/pallet/impls.rs | 33 +++++++++--- pallets/swap/src/pallet/tests.rs | 15 +++--- primitives/swap-interface/src/lib.rs | 5 +- runtime/src/lib.rs | 2 +- 9 files changed, 133 insertions(+), 29 deletions(-) diff --git a/pallets/subtensor/src/coinbase/root.rs b/pallets/subtensor/src/coinbase/root.rs index b4db388621..0e6bf7269a 100644 --- a/pallets/subtensor/src/coinbase/root.rs +++ b/pallets/subtensor/src/coinbase/root.rs @@ -210,11 +210,22 @@ impl Pallet { Error::::SubnetNotExists ); + let reservoir_tao = T::SwapInterface::protocol_tao_reservoir(netuid); + let reservoir_alpha = T::SwapInterface::protocol_alpha_reservoir(netuid); + T::SwapInterface::clear_protocol_liquidity_reservoirs(netuid); + Self::increase_provided_tao_reserve(netuid, reservoir_tao); + Self::increase_provided_alpha_reserve(netuid, reservoir_alpha); + if !reservoir_tao.is_zero() { + TotalStake::::mutate(|total| { + *total = total.saturating_add(reservoir_tao); + }); + } + Self::finalize_all_subnet_root_dividends(netuid); // --- Perform the cleanup before removing the network. Self::destroy_alpha_in_out_stakes(netuid)?; - T::SwapInterface::clear_protocol_liquidity(netuid)?; + T::SwapInterface::clear_protocol_liquidity(netuid); T::CommitmentsInterface::purge_netuid(netuid); // --- Remove the network diff --git a/pallets/subtensor/src/staking/stake_utils.rs b/pallets/subtensor/src/staking/stake_utils.rs index 2826590c50..8327a9a72b 100644 --- a/pallets/subtensor/src/staking/stake_utils.rs +++ b/pallets/subtensor/src/staking/stake_utils.rs @@ -18,7 +18,9 @@ impl Pallet { /// # Returns /// * `u64` - The total alpha issuance for the specified subnet. pub fn get_alpha_issuance(netuid: NetUid) -> AlphaBalance { - SubnetAlphaIn::::get(netuid).saturating_add(SubnetAlphaOut::::get(netuid)) + SubnetAlphaIn::::get(netuid) + .saturating_add(SubnetAlphaOut::::get(netuid)) + .saturating_add(T::SwapInterface::protocol_alpha_reservoir(netuid)) } pub fn get_moving_alpha_price(netuid: NetUid) -> U64F64 { diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index cc508891e0..be23066c34 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3737,6 +3737,34 @@ fn test_coinbase_failed_tao_materialization_does_not_activate_current_tao() { }); } +#[test] +fn test_alpha_reservoir_counts_toward_subnet_issuance_across_blocks() { + new_test_ext(1).execute_with(|| { + let netuid = add_dynamic_network(&U256::from(1), &U256::from(2)); + let alpha_in = AlphaBalance::from(10_000_u64); + let alpha_out = AlphaBalance::from(20_000_u64); + let reservoir_alpha = AlphaBalance::from(30_000_u64); + + SubnetAlphaIn::::insert(netuid, alpha_in); + SubnetAlphaOut::::insert(netuid, alpha_out); + pallet_subtensor_swap::BalancerAlphaReservoir::::insert(netuid, reservoir_alpha); + + let expected = alpha_in + .saturating_add(alpha_out) + .saturating_add(reservoir_alpha); + assert_eq!(SubtensorModule::get_alpha_issuance(netuid), expected); + + System::set_block_number(System::block_number().saturating_add(1)); + + assert_eq!(SubnetAlphaIn::::get(netuid), alpha_in); + assert_eq!( + pallet_subtensor_swap::BalancerAlphaReservoir::::get(netuid), + reservoir_alpha + ); + assert_eq!(SubtensorModule::get_alpha_issuance(netuid), expected); + }); +} + #[test] fn test_coinbase_drain_pending_increments_blockssincelaststep() { new_test_ext(1).execute_with(|| { diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs index 38d0d49fe1..20531e370d 100644 --- a/pallets/subtensor/src/tests/networks.rs +++ b/pallets/subtensor/src/tests/networks.rs @@ -370,8 +370,6 @@ fn dissolve_clears_all_per_subnet_storages() { SubnetAlphaOutEmission::::insert(net, AlphaBalance::from(1)); SubnetTaoInEmission::::insert(net, TaoBalance::from(1)); SubnetVolume::::insert(net, 1u128); - pallet_subtensor_swap::BalancerTaoReservoir::::insert(net, TaoBalance::from(1)); - pallet_subtensor_swap::BalancerAlphaReservoir::::insert(net, AlphaBalance::from(1)); // Items now REMOVED (not zeroed) by dissolution SubnetAlphaIn::::insert(net, AlphaBalance::from(2)); @@ -647,6 +645,58 @@ fn dissolve_clears_all_per_subnet_storages() { }); } +#[test] +fn dissolve_materializes_nonzero_protocol_reservoirs_before_cleanup() { + new_test_ext(0).execute_with(|| { + let owner_cold = U256::from(123); + let owner_hot = U256::from(456); + let net = add_dynamic_network(&owner_hot, &owner_cold); + remove_owner_registration_stake(net); + + // Force the modern dissolve branch where pool alpha participates in + // the protocol denominator. + TaoInRefundDeploymentBlock::::put(0); + NetworkRegisteredAt::::insert(net, 1); + + let reservoir_tao = TaoBalance::from(100_u64); + let reservoir_alpha = AlphaBalance::from(100_u64); + let staker_hot = U256::from(789); + let staker_cold = U256::from(987); + + let subnet_account = SubtensorModule::get_subnet_account_id(net).unwrap(); + add_balance_to_coldkey_account(&subnet_account, reservoir_tao); + + SubnetTAO::::insert(net, TaoBalance::ZERO); + SubtensorModule::set_subnet_locked_balance(net, TaoBalance::ZERO); + SubnetAlphaIn::::insert(net, AlphaBalance::ZERO); + SubnetProtocolAlpha::::insert(net, AlphaBalance::ZERO); + AlphaV2::::insert((staker_hot, staker_cold, net), sf_from_u64(100u64)); + TotalHotkeyAlpha::::insert(staker_hot, net, AlphaBalance::from(100u64)); + pallet_subtensor_swap::BalancerTaoReservoir::::insert(net, reservoir_tao); + pallet_subtensor_swap::BalancerAlphaReservoir::::insert(net, reservoir_alpha); + + let staker_before = SubtensorModule::get_coldkey_balance(&staker_cold); + let issuance_before = TotalIssuance::::get(); + + assert_ok!(SubtensorModule::do_dissolve_network(net)); + + // Reservoir alpha is treated like materialized protocol pool alpha. + // The staker owns half the denominator, so receives half the reservoir + // TAO pot; the protocol share is recycled. + assert_eq!( + SubtensorModule::get_coldkey_balance(&staker_cold), + staker_before + TaoBalance::from(50_u64) + ); + assert!(TotalIssuance::::get() < issuance_before); + assert!(!NetworksAdded::::contains_key(net)); + assert!(!SubnetOwner::::contains_key(net)); + assert!(!SubnetAlphaIn::::contains_key(net)); + assert!(!SubnetProtocolAlpha::::contains_key(net)); + assert!(!pallet_subtensor_swap::BalancerTaoReservoir::::contains_key(net)); + assert!(!pallet_subtensor_swap::BalancerAlphaReservoir::::contains_key(net)); + }); +} + #[test] fn dissolve_alpha_out_but_zero_tao_no_rewards() { new_test_ext(0).execute_with(|| { diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index 660b6957d7..4ecbd9f7a8 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -4279,12 +4279,8 @@ fn test_move_stake_limit_partial() { // Registration now goes through the burn/swap path, which initializes swap V3 state. // Clear that state first so the manual reserve fixture below actually controls price. - assert_ok!( - ::SwapInterface::clear_protocol_liquidity(origin_netuid) - ); - assert_ok!( - ::SwapInterface::clear_protocol_liquidity(destination_netuid) - ); + ::SwapInterface::clear_protocol_liquidity(origin_netuid); + ::SwapInterface::clear_protocol_liquidity(destination_netuid); // Force-set alpha in and tao reserve to make price equal 1.5 on both origin and destination, // but there's much more liquidity on destination, so its price wouldn't go up when restaked. diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs index 2afa9569b9..ea24f7e821 100644 --- a/pallets/swap/src/pallet/impls.rs +++ b/pallets/swap/src/pallet/impls.rs @@ -6,7 +6,7 @@ use frame_support::{ }; use safe_math::*; use sp_arithmetic::Perquintill; -use sp_runtime::{DispatchResult, traits::AccountIdConversion}; +use sp_runtime::traits::AccountIdConversion; use substrate_fixed::types::U64F64; use subtensor_runtime_common::{AlphaBalance, NetUid, SubnetInfo, TaoBalance, Token, TokenReserve}; use subtensor_swap_interface::{ @@ -335,7 +335,15 @@ impl Pallet { } /// Clear **protocol-owned** liquidity and wipe all swap state for `netuid`. - pub fn do_clear_protocol_liquidity(netuid: NetUid) -> DispatchResult { + pub fn do_clear_protocol_liquidity(netuid: NetUid) { + // Reservoir balances are materialized protocol liquidity that never became + // price-active. Fold them into the reserve abstraction first so cleanup + // clears them through the same path as active protocol liquidity. + let reservoir_tao = BalancerTaoReservoir::::take(netuid); + let reservoir_alpha = BalancerAlphaReservoir::::take(netuid); + T::TaoReserve::increase_provided(netuid.into(), reservoir_tao); + T::AlphaReserve::increase_provided(netuid.into(), reservoir_alpha); + // 1) Force-close protocol liquidity, burning proceeds. let burned_tao = T::TaoReserve::reserve(netuid.into()); let burned_alpha = T::AlphaReserve::reserve(netuid.into()); @@ -347,14 +355,10 @@ impl Pallet { FeeRate::::remove(netuid); SwapBalancer::::remove(netuid); - BalancerTaoReservoir::::remove(netuid); - BalancerAlphaReservoir::::remove(netuid); log::debug!( "clear_protocol_liquidity: netuid={netuid:?}, protocol_burned: τ={burned_tao:?}, α={burned_alpha:?}; state cleared" ); - - Ok(()) } } @@ -467,8 +471,21 @@ impl SwapHandler for Pallet { Self::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta) } - fn clear_protocol_liquidity(netuid: NetUid) -> DispatchResult { - Self::do_clear_protocol_liquidity(netuid) + fn protocol_alpha_reservoir(netuid: NetUid) -> AlphaBalance { + BalancerAlphaReservoir::::get(netuid) + } + + fn protocol_tao_reservoir(netuid: NetUid) -> TaoBalance { + BalancerTaoReservoir::::get(netuid) + } + + fn clear_protocol_liquidity_reservoirs(netuid: NetUid) { + BalancerTaoReservoir::::remove(netuid); + BalancerAlphaReservoir::::remove(netuid); + } + + fn clear_protocol_liquidity(netuid: NetUid) { + Self::do_clear_protocol_liquidity(netuid); } fn init_swap(netuid: NetUid, maybe_price: Option) { diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs index 689e48e3d4..997dfdc2e0 100644 --- a/pallets/swap/src/pallet/tests.rs +++ b/pallets/swap/src/pallet/tests.rs @@ -870,11 +870,10 @@ fn print_current_price(netuid: NetUid) { log::trace!("Current price: {current_price:.6}"); } -/// Simple palswap path: PalSwap is initialized, but no positions, only protocol; function -/// must still clear any residual storages and succeed. -/// TODO: Revise when user liquidity is available +/// Reservoir liquidity is already materialized but not price-active; direct +/// cleanup materializes it into the reserve abstraction before clearing. #[test] -fn test_liquidate_pal_simple_ok_and_clears() { +fn test_clear_protocol_liquidity_clears_nonzero_reservoirs() { new_test_ext().execute_with(|| { let netuid = NetUid::from(202); @@ -890,10 +889,8 @@ fn test_liquidate_pal_simple_ok_and_clears() { // Sanity: PalSwap is not initialized assert!(PalSwapInitialized::::get(netuid)); - // ACT - assert_ok!(Pallet::::do_clear_protocol_liquidity(netuid)); + Pallet::::do_clear_protocol_liquidity(netuid); - // All single-key maps should not have the key after liquidation assert!(!FeeRate::::contains_key(netuid)); assert!(!PalSwapInitialized::::contains_key(netuid)); assert!(!SwapBalancer::::contains_key(netuid)); @@ -917,7 +914,7 @@ fn test_clear_protocol_liquidity_green_path() { // --- Act --- // Green path: just clear protocol liquidity and wipe all V3 state. - assert_ok!(Pallet::::do_clear_protocol_liquidity(netuid)); + Pallet::::do_clear_protocol_liquidity(netuid); // Flags assert!(!PalSwapInitialized::::contains_key(netuid)); @@ -926,7 +923,7 @@ fn test_clear_protocol_liquidity_green_path() { assert!(!FeeRate::::contains_key(netuid)); // --- And it's idempotent --- - assert_ok!(Pallet::::do_clear_protocol_liquidity(netuid)); + Pallet::::do_clear_protocol_liquidity(netuid); assert!(!PalSwapInitialized::::contains_key(netuid)); }); } diff --git a/primitives/swap-interface/src/lib.rs b/primitives/swap-interface/src/lib.rs index 85e8cacc7a..b813f193bc 100644 --- a/primitives/swap-interface/src/lib.rs +++ b/primitives/swap-interface/src/lib.rs @@ -47,7 +47,10 @@ pub trait SwapHandler { tao_delta: TaoBalance, alpha_delta: AlphaBalance, ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance); - fn clear_protocol_liquidity(netuid: NetUid) -> DispatchResult; + fn protocol_alpha_reservoir(netuid: NetUid) -> AlphaBalance; + fn protocol_tao_reservoir(netuid: NetUid) -> TaoBalance; + fn clear_protocol_liquidity_reservoirs(netuid: NetUid); + fn clear_protocol_liquidity(netuid: NetUid); fn init_swap(netuid: NetUid, maybe_price: Option); fn get_alpha_amount_for_tao(netuid: NetUid, tao_amount: TaoBalance) -> AlphaBalance; } diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index a39c473880..52a517873a 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 423, + spec_version: 424, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 447ca995a325ba6ab2720237f70576d3e4e3936e Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Thu, 25 Jun 2026 21:46:11 +0300 Subject: [PATCH 31/48] Refactor adjust_protocol_liquidity --- .../subtensor/src/coinbase/run_coinbase.rs | 20 +++--- pallets/swap/src/pallet/impls.rs | 21 +++---- pallets/swap/src/pallet/tests.rs | 62 +++++++------------ primitives/swap-interface/src/lib.rs | 2 +- 4 files changed, 42 insertions(+), 63 deletions(-) diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index a66a0aaa73..117ef4ed32 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -140,7 +140,7 @@ impl Pallet { remaining_credit = remainder; let remaining_balance = remaining_credit.peek(); log::error!( - "Failed to spend credit: tao_to_materialize = {tao_in_i:?}, netuid_i = {netuid_i:?}, remaining_balance = {remaining_balance:?}" + "Failed to spend credit: tao_delta = {tao_in_i:?}, netuid_i = {netuid_i:?}, remaining_balance = {remaining_balance:?}" ); TaoBalance::ZERO } @@ -150,22 +150,18 @@ impl Pallet { // Decide which current/reservoir liquidity can become price-active // without pushing balancer weights out of range. Only already // materialized current TAO is offered to the swap pallet. - let ( - price_active_tao, - _tao_to_materialize, - price_active_alpha, - alpha_to_materialize, - ) = T::SwapInterface::adjust_protocol_liquidity( - *netuid_i, - materialized_tao_delta, - alpha_in_i, - ); + let (price_active_tao, price_active_alpha) = + T::SwapInterface::adjust_protocol_liquidity( + *netuid_i, + materialized_tao_delta, + alpha_in_i, + ); // Materialize this block's alpha emission, then add only the // price-active portion to the pool reserve. The price-active // portion may include alpha that was materialized in an earlier // block and held in the reservoir. - let _ = Self::mint_alpha(*netuid_i, alpha_to_materialize); + let _ = Self::mint_alpha(*netuid_i, alpha_in_i); SubnetAlphaInEmission::::insert(*netuid_i, price_active_alpha); Self::increase_provided_alpha_reserve(*netuid_i, price_active_alpha); diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs index ea24f7e821..07c4ffc62c 100644 --- a/pallets/swap/src/pallet/impls.rs +++ b/pallets/swap/src/pallet/impls.rs @@ -88,21 +88,18 @@ impl Pallet { /// /// Returns: /// 1. price-active TAO delta to add to `SubnetTAO` - /// 2. TAO delta to materialize by the caller - /// 3. price-active Alpha delta to add to `SubnetAlphaIn` - /// 4. Alpha delta to materialize by the caller + /// 2. price-active Alpha delta to add to `SubnetAlphaIn` /// /// Amounts that would push weights out of range are materialized but left in /// per-subnet reservoirs for a later balancer update. /// - /// Reservoir amounts may be included in the balancer update, but they are not - /// returned for materialization because they were already materialized when - /// first stored. + /// The caller is responsible for materializing the current `tao_delta` and + /// `alpha_delta`; reservoir amounts were materialized when first stored. pub(super) fn adjust_protocol_liquidity( netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance) { + ) -> (TaoBalance, AlphaBalance) { // Get reserves let alpha_reserve = T::AlphaReserve::reserve(netuid.into()); let tao_reserve = T::TaoReserve::reserve(netuid.into()); @@ -121,7 +118,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); SwapBalancer::::insert(netuid, new_balancer); - return (pending_tao, tao_delta, pending_alpha, alpha_delta); + return (pending_tao, pending_alpha); } if let Some(new_balancer) = Self::try_update_balancer( @@ -134,7 +131,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, pending_tao); BalancerAlphaReservoir::::insert(netuid, AlphaBalance::ZERO); SwapBalancer::::insert(netuid, new_balancer); - return (TaoBalance::ZERO, tao_delta, pending_alpha, alpha_delta); + return (TaoBalance::ZERO, pending_alpha); } if let Some(new_balancer) = Self::try_update_balancer( @@ -147,7 +144,7 @@ impl Pallet { BalancerTaoReservoir::::insert(netuid, TaoBalance::ZERO); BalancerAlphaReservoir::::insert(netuid, pending_alpha); SwapBalancer::::insert(netuid, new_balancer); - return (pending_tao, tao_delta, AlphaBalance::ZERO, alpha_delta); + return (pending_tao, AlphaBalance::ZERO); } BalancerTaoReservoir::::insert(netuid, pending_tao); @@ -165,7 +162,7 @@ impl Pallet { ); } - (TaoBalance::ZERO, tao_delta, AlphaBalance::ZERO, alpha_delta) + (TaoBalance::ZERO, AlphaBalance::ZERO) } fn try_update_balancer( @@ -467,7 +464,7 @@ impl SwapHandler for Pallet { netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance) { + ) -> (TaoBalance, AlphaBalance) { Self::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta) } diff --git a/pallets/swap/src/pallet/tests.rs b/pallets/swap/src/pallet/tests.rs index 997dfdc2e0..eafb5a8edd 100644 --- a/pallets/swap/src/pallet/tests.rs +++ b/pallets/swap/src/pallet/tests.rs @@ -165,17 +165,14 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = - Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(200_000_u64), - AlphaBalance::from(1_000_u64), - ); + let (price_active_tao, price_active_alpha) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); assert_eq!(price_active_tao, TaoBalance::ZERO); - assert_eq!(tao_materialized, TaoBalance::from(200_000_u64)); assert_eq!(price_active_alpha, AlphaBalance::from(1_000_u64)); - assert_eq!(alpha_materialized, AlphaBalance::from(1_000_u64)); assert_eq!( BalancerTaoReservoir::::get(netuid), TaoBalance::from(200_000_u64) @@ -197,17 +194,14 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = - Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(1_000_u64), - AlphaBalance::from(200_000_u64), - ); + let (price_active_tao, price_active_alpha) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); assert_eq!(price_active_tao, TaoBalance::from(1_000_u64)); - assert_eq!(tao_materialized, TaoBalance::from(1_000_u64)); assert_eq!(price_active_alpha, AlphaBalance::ZERO); - assert_eq!(alpha_materialized, AlphaBalance::from(200_000_u64)); assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); assert_eq!( BalancerAlphaReservoir::::get(netuid), @@ -226,32 +220,26 @@ mod dispatchables { TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = - Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(200_000_u64), - AlphaBalance::from(1_000_u64), - ); + let (price_active_tao, price_active_alpha) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(200_000_u64), + AlphaBalance::from(1_000_u64), + ); assert_eq!(price_active_tao, TaoBalance::ZERO); - assert_eq!(tao_materialized, TaoBalance::from(200_000_u64)); assert_eq!(price_active_alpha, AlphaBalance::from(1_000_u64)); - assert_eq!(alpha_materialized, AlphaBalance::from(1_000_u64)); tao += price_active_tao; alpha += price_active_alpha; TaoReserve::set_mock_reserve(netuid, tao); AlphaReserve::set_mock_reserve(netuid, alpha); - let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = - Swap::adjust_protocol_liquidity( - netuid, - TaoBalance::from(1_000_u64), - AlphaBalance::from(200_000_u64), - ); + let (price_active_tao, price_active_alpha) = Swap::adjust_protocol_liquidity( + netuid, + TaoBalance::from(1_000_u64), + AlphaBalance::from(200_000_u64), + ); - assert!(price_active_tao >= tao_materialized); - assert!(price_active_alpha >= alpha_materialized); - assert_eq!(tao_materialized, TaoBalance::from(1_000_u64)); - assert_eq!(alpha_materialized, AlphaBalance::from(200_000_u64)); + assert!(price_active_tao >= TaoBalance::from(1_000_u64)); + assert!(price_active_alpha >= AlphaBalance::from(200_000_u64)); assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); assert_eq!( BalancerAlphaReservoir::::get(netuid), @@ -261,7 +249,7 @@ mod dispatchables { } #[test] - fn test_adjust_protocol_liquidity_does_not_materialize_reservoir_amounts() { + fn test_adjust_protocol_liquidity_activates_reservoir_amounts() { new_test_ext().execute_with(|| { let netuid = NetUid::from(1); @@ -272,13 +260,11 @@ mod dispatchables { let tao_delta = TaoBalance::from(300_u64); let alpha_delta = AlphaBalance::from(400_u64); - let (price_active_tao, tao_materialized, price_active_alpha, alpha_materialized) = + let (price_active_tao, price_active_alpha) = Swap::adjust_protocol_liquidity(netuid, tao_delta, alpha_delta); assert_eq!(price_active_tao, TaoBalance::from(10_300_u64)); - assert_eq!(tao_materialized, tao_delta); assert_eq!(price_active_alpha, AlphaBalance::from(20_400_u64)); - assert_eq!(alpha_materialized, alpha_delta); assert_eq!(BalancerTaoReservoir::::get(netuid), TaoBalance::ZERO); assert_eq!( BalancerAlphaReservoir::::get(netuid), diff --git a/primitives/swap-interface/src/lib.rs b/primitives/swap-interface/src/lib.rs index b813f193bc..5b202a8bae 100644 --- a/primitives/swap-interface/src/lib.rs +++ b/primitives/swap-interface/src/lib.rs @@ -46,7 +46,7 @@ pub trait SwapHandler { netuid: NetUid, tao_delta: TaoBalance, alpha_delta: AlphaBalance, - ) -> (TaoBalance, TaoBalance, AlphaBalance, AlphaBalance); + ) -> (TaoBalance, AlphaBalance); fn protocol_alpha_reservoir(netuid: NetUid) -> AlphaBalance; fn protocol_tao_reservoir(netuid: NetUid) -> TaoBalance; fn clear_protocol_liquidity_reservoirs(netuid: NetUid); From 9759f677d2b05d7f996ea272a7fd78cb1c6b261b Mon Sep 17 00:00:00 2001 From: yeuyeuh Date: Mon, 29 Jun 2026 23:16:17 +0200 Subject: [PATCH 32/48] Add eco-tests protecting Mentat indexer storage reads --- eco-tests/src/lib.rs | 3 + eco-tests/src/mock.rs | 37 +- eco-tests/src/tests_mentat_indexer.rs | 612 ++++++++++++++++++++++++++ 3 files changed, 650 insertions(+), 2 deletions(-) create mode 100644 eco-tests/src/tests_mentat_indexer.rs diff --git a/eco-tests/src/lib.rs b/eco-tests/src/lib.rs index 980de0f3da..4613d7dbe2 100644 --- a/eco-tests/src/lib.rs +++ b/eco-tests/src/lib.rs @@ -7,3 +7,6 @@ mod tests; #[cfg(test)] mod tests_taocom_indexer; + +#[cfg(test)] +mod tests_mentat_indexer; diff --git a/eco-tests/src/mock.rs b/eco-tests/src/mock.rs index 5ce8bc9b6b..a3a8ce1e39 100644 --- a/eco-tests/src/mock.rs +++ b/eco-tests/src/mock.rs @@ -612,11 +612,19 @@ pub fn add_balance_to_coldkey_account(coldkey: &U256, tao: TaoBalance) { mod api_mocks { use codec::Compact; use pallet_subtensor::rpc_info::delegate_info::DelegateInfo; + use pallet_subtensor::rpc_info::dynamic_info::DynamicInfo; + use pallet_subtensor::rpc_info::metagraph::{Metagraph, SelectiveMetagraph}; + use pallet_subtensor::rpc_info::show_subnet::SubnetState; use pallet_subtensor::rpc_info::stake_info::StakeInfo; + use pallet_subtensor::rpc_info::subnet_info::{ + SubnetHyperparams, SubnetHyperparamsV2, SubnetHyperparamsV3, SubnetInfo, SubnetInfov2, + }; use pallet_subtensor_swap_runtime_api::{SimSwapResult, SubnetPrice, SwapRuntimeApi}; use sp_runtime::AccountId32; - use subtensor_custom_rpc_runtime_api::{DelegateInfoRuntimeApi, StakeInfoRuntimeApi}; - use subtensor_runtime_common::{AlphaBalance, NetUid, TaoBalance}; + use subtensor_custom_rpc_runtime_api::{ + DelegateInfoRuntimeApi, StakeInfoRuntimeApi, SubnetInfoRuntimeApi, + }; + use subtensor_runtime_common::{AlphaBalance, MechId, NetUid, TaoBalance}; use super::Block; @@ -660,6 +668,31 @@ mod api_mocks { } } + impl SubnetInfoRuntimeApi for MockApi { + fn get_subnet_info(_netuid: NetUid) -> Option> { None } + fn get_subnets_info() -> Vec>> { Vec::new() } + fn get_subnet_info_v2(_netuid: NetUid) -> Option> { None } + fn get_subnets_info_v2() -> Vec>> { Vec::new() } + #[allow(deprecated)] + fn get_subnet_hyperparams(_netuid: NetUid) -> Option { None } + #[allow(deprecated)] + fn get_subnet_hyperparams_v2(_netuid: NetUid) -> Option { None } + fn get_subnet_hyperparams_v3(_netuid: NetUid) -> Option { None } + fn get_all_dynamic_info() -> Vec>> { Vec::new() } + fn get_all_metagraphs() -> Vec>> { Vec::new() } + fn get_metagraph(_netuid: NetUid) -> Option> { None } + fn get_all_mechagraphs() -> Vec>> { Vec::new() } + fn get_mechagraph(_netuid: NetUid, _mecid: MechId) -> Option> { None } + fn get_dynamic_info(_netuid: NetUid) -> Option> { None } + fn get_subnet_state(_netuid: NetUid) -> Option> { None } + fn get_selective_metagraph(_netuid: NetUid, _metagraph_indexes: Vec) -> Option> { None } + fn get_coldkey_auto_stake_hotkey(_coldkey: AccountId32, _netuid: NetUid) -> Option { None } + fn get_selective_mechagraph(_netuid: NetUid, _subid: MechId, _metagraph_indexes: Vec) -> Option> { None } + fn get_subnet_to_prune() -> Option { None } + fn get_subnet_account_id(_netuid: NetUid) -> Option { None } + fn get_next_epoch_start_block(_netuid: NetUid) -> Option { None } + } + impl SwapRuntimeApi for MockApi { fn current_alpha_price(_netuid: NetUid) -> u64 { 0 } fn current_alpha_price_all() -> Vec { Vec::new() } diff --git a/eco-tests/src/tests_mentat_indexer.rs b/eco-tests/src/tests_mentat_indexer.rs new file mode 100644 index 0000000000..0968100a35 --- /dev/null +++ b/eco-tests/src/tests_mentat_indexer.rs @@ -0,0 +1,612 @@ +//! Indexer-contract tests for Mentat +//! Any modification in these tests will notify the member responsible +//! for the communication between protocol and the Mentat team. + + +#![allow(clippy::unwrap_used)] +#![allow(clippy::arithmetic_side_effects)] + +use frame_system as system; +use pallet_subtensor::*; +use pallet_subtensor_proxy::{Proxies, RealPaysFee}; +use pallet_subtensor_swap::FeeRate; +use pallet_subtensor_swap_runtime_api::SwapRuntimeApi; +use sp_core::U256; +use sp_runtime::traits::Block as BlockT; +use substrate_fixed::types::{I96F32, U64F64}; +use subtensor_custom_rpc_runtime_api::{StakeInfoRuntimeApi, SubnetInfoRuntimeApi}; +use subtensor_runtime_common::{AlphaBalance, MechId, NetUid, NetUidStorageIndex, TaoBalance}; + +use super::helpers::*; +use super::mock::*; + +// --------------------------------------------------------------------------- +// Storage queries — SubtensorModule +// --------------------------------------------------------------------------- + +#[test] +fn indexer_hotkey_ownership() { + new_test_ext(1).execute_with(|| { + let hotkey = U256::from(1); + + let _: U256 = Owner::::get(hotkey); + }); +} + +#[test] +fn indexer_staking_hotkeys() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + + let _: Vec = StakingHotkeys::::get(coldkey); + }); +} + +#[test] +fn indexer_alpha_shares_and_stake() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + let hotkey = U256::from(1); + let coldkey = U256::from(2); + + let _: AlphaBalance = TotalHotkeyAlpha::::get(hotkey, netuid); + let _: U64F64 = Alpha::::get((hotkey, coldkey, netuid)); + }); +} + +#[test] +fn indexer_subnet_pool_data() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: u16 = TotalNetworks::::get(); + let _: TaoBalance = SubnetTAO::::get(netuid); + let _: AlphaBalance = SubnetAlphaIn::::get(netuid); + let _: AlphaBalance = SubnetAlphaOut::::get(netuid); + let _: I96F32 = SubnetMovingPrice::::get(netuid); + }); +} + +#[test] +fn indexer_subnet_metadata() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: MechId = MechanismCountCurrent::::get(netuid); + let _: u64 = NetworkImmunityPeriod::::get(); + let _: u64 = NetworkRegisteredAt::::get(netuid); + let _: Option = SubnetIdentitiesV3::::get(netuid); + }); +} + +#[test] +fn indexer_neuron_per_subnet_vectors() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: Vec = Active::::get(netuid); + let _: Vec = Dividends::::get(netuid); + let _: Vec = Emission::::get(netuid); + let _: Vec = Incentive::::get(NetUidStorageIndex::from(netuid)); + let _: Vec = ValidatorTrust::::get(netuid); + }); +} + +#[test] +fn indexer_neuron_uid_maps() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + let uid: u16 = 0; + + let _: u16 = SubnetworkN::::get(netuid); + let _: U256 = Keys::::get(netuid, uid); + }); +} + +#[test] +fn indexer_childkey_and_parentkey_graph() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + let hotkey = U256::from(1); + + let _: Vec<(u64, U256)> = ChildKeys::::get(hotkey, netuid); + let _: Vec<(u64, U256)> = ParentKeys::::get(hotkey, netuid); + let _: u16 = ChildkeyTake::::get(hotkey, netuid); + }); +} + +#[test] +fn indexer_subnet_hyperparams() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: u16 = Tempo::::get(netuid); + let _: u16 = MaxAllowedUids::::get(netuid); + }); +} + +#[test] +fn indexer_validator_dividends() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + let hotkey = U256::from(1); + + let _: AlphaBalance = AlphaDividendsPerSubnet::::get(netuid, hotkey); + }); +} + +#[test] +fn indexer_network_economics() { + new_test_ext(1).execute_with(|| { + let _: u64 = TaoWeight::::get(); + }); +} + +#[test] +fn indexer_swap_fee_rate() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: u16 = FeeRate::::get(netuid); + }); +} + +#[test] +fn indexer_mechanism_emission() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + + let _: MechId = MechanismCountCurrent::::get(netuid); + let _: Option> = MechanismEmissionSplit::::get(netuid); + }); +} + +#[test] +fn indexer_root_claim_type() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + + let _: RootClaimTypeEnum = RootClaimType::::get(coldkey); + }); +} + +#[test] +fn indexer_pending_childkey_cooldown() { + new_test_ext(1).execute_with(|| { + let _: u64 = PendingChildKeyCooldown::::get(); + }); +} + +#[test] +fn indexer_root_alpha_dividends_per_subnet() { + new_test_ext(1).execute_with(|| { + let netuid = NetUid::from(1u16); + let hotkey = U256::from(1); + + let _: AlphaBalance = RootAlphaDividendsPerSubnet::::get(netuid, hotkey); + }); +} + +// --------------------------------------------------------------------------- +// Storage queries — proxy pallet +// --------------------------------------------------------------------------- + +#[test] +fn indexer_proxy_proxies() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + + let _ = Proxies::::get(coldkey); + }); +} + +#[test] +fn indexer_proxy_real_pays_fee() { + new_test_ext(1).execute_with(|| { + let real = U256::from(1); + let delegate = U256::from(2); + + let _: Option<()> = RealPaysFee::::get(real, delegate); + }); +} + +// --------------------------------------------------------------------------- +// Extrinsics — SubtensorModule (call signatures) +// +// These run inside externalities and the Result is intentionally ignored: +// the call will typically return Err (no funds / no network), which is fine. +// We only lock that the dispatchable's argument list and types are unchanged. +// --------------------------------------------------------------------------- + +#[test] +fn indexer_extrinsic_add_stake() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid = NetUid::from(1u16); + let amount = TaoBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::add_stake( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid, + amount, + ); + }); +} + +#[test] +fn indexer_extrinsic_remove_stake() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid = NetUid::from(1u16); + let amount = AlphaBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::remove_stake( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid, + amount, + ); + }); +} + +#[test] +fn indexer_extrinsic_add_stake_limit() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid = NetUid::from(1u16); + let amount = TaoBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::add_stake_limit( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid, + amount, + TaoBalance::from(0u64), + false, + ); + }); +} + +#[test] +fn indexer_extrinsic_remove_stake_limit() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid = NetUid::from(1u16); + let alpha_amount = AlphaBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::remove_stake_limit( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid, + alpha_amount, + TaoBalance::from(0u64), + false, + ); + }); +} + +#[test] +fn indexer_extrinsic_swap_stake() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid_origin = NetUid::from(1u16); + let netuid_dest = NetUid::from(2u16); + let alpha_amount = AlphaBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::swap_stake( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid_origin, + netuid_dest, + alpha_amount, + ); + }); +} + +#[test] +fn indexer_extrinsic_swap_stake_limit() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let netuid_origin = NetUid::from(1u16); + let netuid_dest = NetUid::from(2u16); + let alpha_amount = AlphaBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::swap_stake_limit( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid_origin, + netuid_dest, + alpha_amount, + TaoBalance::from(0u64), + false, + ); + }); +} + +#[test] +fn indexer_extrinsic_move_stake() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey_origin = U256::from(2); + let hotkey_dest = U256::from(3); + let netuid = NetUid::from(1u16); + let alpha_amount = AlphaBalance::from(1_000_000_000u64); + + let _ = SubtensorModule::move_stake( + RuntimeOrigin::signed(coldkey), + hotkey_origin, + hotkey_dest, + netuid, + netuid, + alpha_amount, + ); + }); +} + +#[test] +fn indexer_extrinsic_set_children() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let child = U256::from(3); + let netuid = NetUid::from(1u16); + let children: Vec<(u64, U256)> = vec![(u64::MAX, child)]; + + let _ = SubtensorModule::set_children( + RuntimeOrigin::signed(coldkey), + hotkey, + netuid, + children, + ); + }); +} + +#[test] +fn indexer_extrinsic_decrease_take() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let hotkey = U256::from(2); + let take_u16: u16 = 1000; + + let _ = SubtensorModule::decrease_take( + RuntimeOrigin::signed(coldkey), + hotkey, + take_u16, + ); + }); +} + +#[test] +fn indexer_extrinsic_set_root_claim_type() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + + let _ = SubtensorModule::set_root_claim_type( + RuntimeOrigin::signed(coldkey), + RootClaimTypeEnum::Swap, + ); + }); +} + +// --------------------------------------------------------------------------- +// Extrinsics — proxy pallet +// --------------------------------------------------------------------------- + +#[test] +fn indexer_extrinsic_proxy_add_proxy() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let delegate = U256::from(2); + + let _ = pallet_subtensor_proxy::Pallet::::add_proxy( + RuntimeOrigin::signed(coldkey), + delegate, + subtensor_runtime_common::ProxyType::Any, + 0u64.into(), + ); + }); +} + +#[test] +fn indexer_extrinsic_proxy_proxy() { + new_test_ext(1).execute_with(|| { + let delegate = U256::from(1); + let real = U256::from(2); + let call = Box::new(RuntimeCall::System(system::Call::remark { remark: vec![] })); + + let _ = pallet_subtensor_proxy::Pallet::::proxy( + RuntimeOrigin::signed(delegate), + real, + Some(subtensor_runtime_common::ProxyType::Any), + call, + ); + }); +} + +#[test] +fn indexer_extrinsic_proxy_remove_proxy() { + new_test_ext(1).execute_with(|| { + let coldkey = U256::from(1); + let delegate = U256::from(2); + + let _ = pallet_subtensor_proxy::Pallet::::remove_proxy( + RuntimeOrigin::signed(coldkey), + delegate, + subtensor_runtime_common::ProxyType::Any, + 0u64.into(), + ); + }); +} + +#[test] +fn indexer_extrinsic_proxy_set_real_pays_fee() { + new_test_ext(1).execute_with(|| { + let real = U256::from(1); + let delegate = U256::from(2); + + let _ = pallet_subtensor_proxy::Pallet::::set_real_pays_fee( + RuntimeOrigin::signed(real), + delegate, + true, + ); + }); +} + +// --------------------------------------------------------------------------- +// Extrinsics — balances pallet +// --------------------------------------------------------------------------- + +#[test] +fn indexer_extrinsic_balances_transfer_keep_alive() { + new_test_ext(1).execute_with(|| { + let from = U256::from(1); + let dest = U256::from(2); + let value = TaoBalance::from(1_000_000_000u64); + + let _ = Balances::transfer_keep_alive( + RuntimeOrigin::signed(from), + dest, + value, + ); + }); +} + +// --------------------------------------------------------------------------- +// Extrinsics — system pallet +// --------------------------------------------------------------------------- + +#[test] +fn indexer_extrinsic_system_remark() { + new_test_ext(1).execute_with(|| { + let who = U256::from(1); + let remark = vec![0u8; 32]; + + let _ = system::Pallet::::remark( + RuntimeOrigin::signed(who), + remark, + ); + }); +} + +// --------------------------------------------------------------------------- +// Extrinsics — utility pallet +// --------------------------------------------------------------------------- + +#[test] +fn indexer_extrinsic_utility_batch() { + new_test_ext(1).execute_with(|| { + let who = U256::from(1); + let calls: Vec = vec![ + RuntimeCall::System(system::Call::remark { remark: vec![] }), + ]; + + let _ = pallet_subtensor_utility::Pallet::::batch( + RuntimeOrigin::signed(who), + calls, + ); + }); +} + +#[test] +fn indexer_extrinsic_utility_batch_all() { + new_test_ext(1).execute_with(|| { + let who = U256::from(1); + let calls: Vec = vec![ + RuntimeCall::System(system::Call::remark { remark: vec![] }), + ]; + + let _ = pallet_subtensor_utility::Pallet::::batch_all( + RuntimeOrigin::signed(who), + calls, + ); + }); +} + +#[test] +fn indexer_extrinsic_utility_force_batch() { + new_test_ext(1).execute_with(|| { + let who = U256::from(1); + let calls: Vec = vec![ + RuntimeCall::System(system::Call::remark { remark: vec![] }), + ]; + + let _ = pallet_subtensor_utility::Pallet::::force_batch( + RuntimeOrigin::signed(who), + calls, + ); + }); +} + +// --------------------------------------------------------------------------- +// Runtime API signatures +// --------------------------------------------------------------------------- + +#[test] +fn indexer_runtime_api_current_alpha_price() { + let at = ::Hash::default(); + let netuid = NetUid::from(1u16); + + let _: u64 = SwapRuntimeApi::current_alpha_price(&MockApi, at, netuid).unwrap(); +} + +#[test] +fn indexer_runtime_api_sim_swap() { + let at = ::Hash::default(); + let netuid = NetUid::from(1u16); + let tao = TaoBalance::from(1_000_000_000u64); + let alpha = AlphaBalance::from(1_000_000_000u64); + + let _: pallet_subtensor_swap_runtime_api::SimSwapResult = + SwapRuntimeApi::sim_swap_tao_for_alpha(&MockApi, at, netuid, tao).unwrap(); + let _: pallet_subtensor_swap_runtime_api::SimSwapResult = + SwapRuntimeApi::sim_swap_alpha_for_tao(&MockApi, at, netuid, alpha).unwrap(); +} + +#[test] +fn indexer_runtime_api_get_metagraph() { + let at = ::Hash::default(); + let netuid = NetUid::from(1u16); + + let _: Option> = + SubnetInfoRuntimeApi::get_metagraph(&MockApi, at, netuid).unwrap(); +} + +#[test] +fn indexer_runtime_api_get_mechagraph() { + let at = ::Hash::default(); + let netuid = NetUid::from(1u16); + let mecid = MechId::from(0u8); + + let _: Option> = + SubnetInfoRuntimeApi::get_mechagraph(&MockApi, at, netuid, mecid).unwrap(); +} + +#[test] +fn indexer_runtime_api_stake_info_for_coldkey() { + let at = ::Hash::default(); + let acct = sp_runtime::AccountId32::new([0u8; 32]); + + let _: Vec> = + StakeInfoRuntimeApi::get_stake_info_for_coldkey(&MockApi, at, acct).unwrap(); +} + +#[test] +fn indexer_runtime_api_stake_info_for_hotkey_coldkey_netuid() { + let at = ::Hash::default(); + let hotkey = sp_runtime::AccountId32::new([1u8; 32]); + let coldkey = sp_runtime::AccountId32::new([2u8; 32]); + let netuid = NetUid::from(1u16); + + let _: Option> = + StakeInfoRuntimeApi::get_stake_info_for_hotkey_coldkey_netuid( + &MockApi, at, hotkey, coldkey, netuid, + ) + .unwrap(); +} \ No newline at end of file From f77dcce6ef395f3200d9a7c359106605ba09986c Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 30 Jun 2026 16:38:50 +0300 Subject: [PATCH 33/48] Add AlphaV2 presence test --- eco-tests/src/tests_mentat_indexer.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/eco-tests/src/tests_mentat_indexer.rs b/eco-tests/src/tests_mentat_indexer.rs index 0968100a35..f67567a797 100644 --- a/eco-tests/src/tests_mentat_indexer.rs +++ b/eco-tests/src/tests_mentat_indexer.rs @@ -11,6 +11,7 @@ use pallet_subtensor::*; use pallet_subtensor_proxy::{Proxies, RealPaysFee}; use pallet_subtensor_swap::FeeRate; use pallet_subtensor_swap_runtime_api::SwapRuntimeApi; +use share_pool::SafeFloat; use sp_core::U256; use sp_runtime::traits::Block as BlockT; use substrate_fixed::types::{I96F32, U64F64}; @@ -51,6 +52,7 @@ fn indexer_alpha_shares_and_stake() { let _: AlphaBalance = TotalHotkeyAlpha::::get(hotkey, netuid); let _: U64F64 = Alpha::::get((hotkey, coldkey, netuid)); + let _: SafeFloat = AlphaV2::::get((hotkey, coldkey, netuid)); }); } @@ -609,4 +611,4 @@ fn indexer_runtime_api_stake_info_for_hotkey_coldkey_netuid() { &MockApi, at, hotkey, coldkey, netuid, ) .unwrap(); -} \ No newline at end of file +} From 9d49f17b23cfee9e4958a9a13816b1871ae1d37a Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 30 Jun 2026 17:23:27 +0300 Subject: [PATCH 34/48] Remove Alpha and AlphaV2 presence test from mentat eco --- eco-tests/src/tests_mentat_indexer.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/eco-tests/src/tests_mentat_indexer.rs b/eco-tests/src/tests_mentat_indexer.rs index f67567a797..055ee859a6 100644 --- a/eco-tests/src/tests_mentat_indexer.rs +++ b/eco-tests/src/tests_mentat_indexer.rs @@ -51,8 +51,6 @@ fn indexer_alpha_shares_and_stake() { let coldkey = U256::from(2); let _: AlphaBalance = TotalHotkeyAlpha::::get(hotkey, netuid); - let _: U64F64 = Alpha::::get((hotkey, coldkey, netuid)); - let _: SafeFloat = AlphaV2::::get((hotkey, coldkey, netuid)); }); } From 5c1c7ffab0ea25c05dada4861a859b7cbd44fa17 Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Wed, 1 Jul 2026 07:47:16 -0700 Subject: [PATCH 35/48] Update eco-tests/src/mock.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- eco-tests/src/mock.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/eco-tests/src/mock.rs b/eco-tests/src/mock.rs index a3a8ce1e39..c19e49906a 100644 --- a/eco-tests/src/mock.rs +++ b/eco-tests/src/mock.rs @@ -691,6 +691,7 @@ mod api_mocks { fn get_subnet_to_prune() -> Option { None } fn get_subnet_account_id(_netuid: NetUid) -> Option { None } fn get_next_epoch_start_block(_netuid: NetUid) -> Option { None } + fn get_block_emission() -> TaoBalance { TaoBalance::ZERO } } impl SwapRuntimeApi for MockApi { From 71044fd163c25caf7e446f367872f020cedff799 Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Wed, 1 Jul 2026 07:47:30 -0700 Subject: [PATCH 36/48] Update eco-tests/src/mock.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- eco-tests/src/mock.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/eco-tests/src/mock.rs b/eco-tests/src/mock.rs index c19e49906a..ac685684ef 100644 --- a/eco-tests/src/mock.rs +++ b/eco-tests/src/mock.rs @@ -691,6 +691,7 @@ mod api_mocks { fn get_subnet_to_prune() -> Option { None } fn get_subnet_account_id(_netuid: NetUid) -> Option { None } fn get_next_epoch_start_block(_netuid: NetUid) -> Option { None } + fn get_block_emission() -> TaoBalance { TaoBalance::from(0u64) } fn get_block_emission() -> TaoBalance { TaoBalance::ZERO } } From 026b8f3966e54416251b1c4eeba72c1c803ec25f Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 1 Jul 2026 17:49:25 +0300 Subject: [PATCH 37/48] Fix AI fix --- eco-tests/src/mock.rs | 1 - eco-tests/src/tests_mentat_indexer.rs | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/eco-tests/src/mock.rs b/eco-tests/src/mock.rs index ac685684ef..2a064c8840 100644 --- a/eco-tests/src/mock.rs +++ b/eco-tests/src/mock.rs @@ -692,7 +692,6 @@ mod api_mocks { fn get_subnet_account_id(_netuid: NetUid) -> Option { None } fn get_next_epoch_start_block(_netuid: NetUid) -> Option { None } fn get_block_emission() -> TaoBalance { TaoBalance::from(0u64) } - fn get_block_emission() -> TaoBalance { TaoBalance::ZERO } } impl SwapRuntimeApi for MockApi { diff --git a/eco-tests/src/tests_mentat_indexer.rs b/eco-tests/src/tests_mentat_indexer.rs index 055ee859a6..8b0f6ae69f 100644 --- a/eco-tests/src/tests_mentat_indexer.rs +++ b/eco-tests/src/tests_mentat_indexer.rs @@ -11,10 +11,9 @@ use pallet_subtensor::*; use pallet_subtensor_proxy::{Proxies, RealPaysFee}; use pallet_subtensor_swap::FeeRate; use pallet_subtensor_swap_runtime_api::SwapRuntimeApi; -use share_pool::SafeFloat; use sp_core::U256; use sp_runtime::traits::Block as BlockT; -use substrate_fixed::types::{I96F32, U64F64}; +use substrate_fixed::types::I96F32; use subtensor_custom_rpc_runtime_api::{StakeInfoRuntimeApi, SubnetInfoRuntimeApi}; use subtensor_runtime_common::{AlphaBalance, MechId, NetUid, NetUidStorageIndex, TaoBalance}; @@ -48,7 +47,6 @@ fn indexer_alpha_shares_and_stake() { new_test_ext(1).execute_with(|| { let netuid = NetUid::from(1u16); let hotkey = U256::from(1); - let coldkey = U256::from(2); let _: AlphaBalance = TotalHotkeyAlpha::::get(hotkey, netuid); }); From 9d8075b356a553261e0c6be0c318ae35b5b2a3fd Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 1 Jul 2026 18:53:16 +0300 Subject: [PATCH 38/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 05a15e8ff9..f659980c1a 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 424, + spec_version: 426, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 537915474f56a7df2bd93cf9a688f73e18ffe194 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 1 Jul 2026 18:54:08 +0300 Subject: [PATCH 39/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 05a15e8ff9..f659980c1a 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 424, + spec_version: 426, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 0e9b807d7819c6b312fab85df86c46935cfb18d1 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 1 Jul 2026 19:01:59 +0300 Subject: [PATCH 40/48] spec bump --- runtime/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 05a15e8ff9..f659980c1a 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 424, + spec_version: 426, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1, From 2e7a0f7a82ad3db455e201f24c68bc953e471a47 Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Wed, 1 Jul 2026 19:20:49 +0300 Subject: [PATCH 41/48] merge conflicts --- pallets/subtensor/src/lib.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs index 7c15a49acc..cc41003e70 100644 --- a/pallets/subtensor/src/lib.rs +++ b/pallets/subtensor/src/lib.rs @@ -67,7 +67,6 @@ pub const MAX_SUBNET_CLAIMS: usize = 5; pub const MAX_ROOT_CLAIM_THRESHOLD: u64 = 10_000_000; -<<<<<<< HEAD pub struct SubtensorDustRemoval(PhantomData); impl frame_support::traits::OnUnbalanced> for SubtensorDustRemoval @@ -82,10 +81,9 @@ where }); } } -======= + /// Account flag bit that opts into receiving locked alpha transfers. pub const ACCOUNT_FLAGS_ACCEPT_LOCKED_ALPHA: u128 = 1u128 << 0; ->>>>>>> devnet-ready #[allow(deprecated)] #[deny(missing_docs)] From 3cb715da0ef08650605c21e951c91df1d567de17 Mon Sep 17 00:00:00 2001 From: gztensor <166415444+gztensor@users.noreply.github.com> Date: Wed, 1 Jul 2026 09:24:54 -0700 Subject: [PATCH 42/48] Update pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../subtensor/src/tests/swap_hotkey_with_subnet.rs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index e60b85fab0..432ac37d6c 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -845,15 +845,13 @@ fn test_swap_owner_new_hotkey_already_exists() { let new_hotkey = U256::from(2); let coldkey = U256::from(3); let another_coldkey = U256::from(4); - - let netuid = add_dynamic_network(&old_hotkey, &coldkey); + let netuid = add_dynamic_network(&new_hotkey, &coldkey); add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); - // old_hotkey is owned by coldkey; new_hotkey was already registered on `netuid` - // by add_dynamic_network (the condition under test). Do NOT reassign new_hotkey to - // a foreign coldkey — the new_hotkey-ownership check (NonAssociatedColdKey) would - // then fire before the already-registered-in-subnet check this test targets. - Owner::::insert(new_hotkey, another_coldkey); + // old_hotkey is owned by coldkey; new_hotkey is already registered on `netuid` + // by add_dynamic_network, so this reaches the already-registered-in-subnet + // check this test targets. + Owner::::insert(old_hotkey, coldkey); // Perform the swap System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); @@ -865,7 +863,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::NonAssociatedColdKey + Error::::HotKeyAlreadyRegisteredInSubNet ); // Verify the swap From 713052adbef4cd21449041ad497a2dc4cdc7b9ec Mon Sep 17 00:00:00 2001 From: "subtensor-ai-review[bot]" Date: Wed, 1 Jul 2026 16:32:47 +0000 Subject: [PATCH 43/48] chore: auditor auto-fix --- pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 432ac37d6c..da8268ebe3 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -844,7 +844,6 @@ fn test_swap_owner_new_hotkey_already_exists() { let old_hotkey = U256::from(1); let new_hotkey = U256::from(2); let coldkey = U256::from(3); - let another_coldkey = U256::from(4); let netuid = add_dynamic_network(&new_hotkey, &coldkey); add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); @@ -852,6 +851,7 @@ fn test_swap_owner_new_hotkey_already_exists() { // by add_dynamic_network, so this reaches the already-registered-in-subnet // check this test targets. Owner::::insert(old_hotkey, coldkey); + assert!(IsNetworkMember::::get(new_hotkey, netuid)); // Perform the swap System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); From 9dfbf0bc8bcb29731e8f2d47cfa6defc40fe3d1e Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 7 Jul 2026 00:12:57 +0300 Subject: [PATCH 44/48] fmt coinbase tests --- pallets/subtensor/src/tests/coinbase.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index f8deaaabb7..5fb22625f9 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3764,7 +3764,7 @@ fn test_alpha_reservoir_counts_toward_subnet_issuance_across_blocks() { assert_eq!(SubtensorModule::get_alpha_issuance(netuid), expected); }); } - + fn test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failure() { new_test_ext(1).execute_with(|| { let zero = U96F32::saturating_from_num(0); From 06489b435369fe564f6d5aacaa1f6fb38f72f81f Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 7 Jul 2026 12:03:24 +0300 Subject: [PATCH 45/48] remove contract-tests generated files --- contract-tests/.papi/contracts/bittensor.json | 1404 --- contract-tests/.papi/descriptors/.gitignore | 3 - .../.papi/descriptors/dist/chunk-7P6ASYW6.mjs | 9 - .../.papi/descriptors/dist/common-types.d.ts | 9229 ----------------- .../.papi/descriptors/dist/common.d.ts | 1 - .../descriptors/dist/contracts/bittensor.d.ts | 187 - .../descriptors/dist/contracts/index.d.ts | 1 - .../descriptors/dist/descriptors-UMN7HDMZ.mjs | 29 - .../.papi/descriptors/dist/descriptors.d.ts | 1 - .../.papi/descriptors/dist/devnet.d.ts | 8736 ---------------- .../dist/devnet_metadata-NGDS3DPZ.mjs | 8 - .../descriptors/dist/devnet_metadata.d.ts | 2 - .../.papi/descriptors/dist/index.d.ts | 6 - .../.papi/descriptors/dist/index.js | 194 - .../.papi/descriptors/dist/index.mjs | 109 - .../dist/metadataTypes-4SGFT3Q5.mjs | 8 - .../.papi/descriptors/dist/metadataTypes.d.ts | 2 - contract-tests/.papi/descriptors/package.json | 24 - contract-tests/.papi/metadata/devnet.scale | Bin 312629 -> 0 bytes contract-tests/.papi/polkadot-api.json | 15 - 20 files changed, 19968 deletions(-) delete mode 100644 contract-tests/.papi/contracts/bittensor.json delete mode 100644 contract-tests/.papi/descriptors/.gitignore delete mode 100644 contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs delete mode 100644 contract-tests/.papi/descriptors/dist/common-types.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/common.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/contracts/index.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs delete mode 100644 contract-tests/.papi/descriptors/dist/descriptors.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/devnet.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs delete mode 100644 contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/index.d.ts delete mode 100644 contract-tests/.papi/descriptors/dist/index.js delete mode 100644 contract-tests/.papi/descriptors/dist/index.mjs delete mode 100644 contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs delete mode 100644 contract-tests/.papi/descriptors/dist/metadataTypes.d.ts delete mode 100644 contract-tests/.papi/descriptors/package.json delete mode 100644 contract-tests/.papi/metadata/devnet.scale delete mode 100644 contract-tests/.papi/polkadot-api.json diff --git a/contract-tests/.papi/contracts/bittensor.json b/contract-tests/.papi/contracts/bittensor.json deleted file mode 100644 index 4e48547282..0000000000 --- a/contract-tests/.papi/contracts/bittensor.json +++ /dev/null @@ -1,1404 +0,0 @@ -{ - "source": { - "hash": "0xd15a29edfb7134dface2e0b6c704c173d47d3b48f1afc87193922ff8114e457d", - "language": "ink! 5.1.1", - "compiler": "rustc 1.89.0", - "build_info": { - "build_mode": "Release", - "cargo_contract_version": "5.0.3", - "rust_toolchain": "stable-aarch64-apple-darwin", - "wasm_opt_settings": { - "keep_debug_symbols": false, - "optimization_passes": "Z" - } - } - }, - "contract": { - "name": "bittensor", - "version": "0.1.0", - "authors": [ - "[your_name] <[your_email]>" - ] - }, - "image": null, - "spec": { - "constructors": [ - { - "args": [], - "default": false, - "docs": [ - "Constructor" - ], - "label": "new", - "payable": false, - "returnType": { - "displayName": [ - "ink_primitives", - "ConstructorResult" - ], - "type": 1 - }, - "selector": "0x9bae9d5e" - }, - { - "args": [], - "default": false, - "docs": [ - "Constructor" - ], - "label": "default", - "payable": false, - "returnType": { - "displayName": [ - "ink_primitives", - "ConstructorResult" - ], - "type": 1 - }, - "selector": "0xed4b9d1b" - } - ], - "docs": [], - "environment": { - "accountId": { - "displayName": [ - "AccountId" - ], - "type": 11 - }, - "balance": { - "displayName": [ - "Balance" - ], - "type": 14 - }, - "blockNumber": { - "displayName": [ - "BlockNumber" - ], - "type": 24 - }, - "chainExtension": { - "displayName": [ - "ChainExtension" - ], - "type": 25 - }, - "hash": { - "displayName": [ - "Hash" - ], - "type": 23 - }, - "maxEventTopics": 4, - "staticBufferSize": 16384, - "timestamp": { - "displayName": [ - "Timestamp" - ], - "type": 14 - } - }, - "events": [], - "lang_error": { - "displayName": [ - "ink", - "LangError" - ], - "type": 3 - }, - "messages": [ - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "coldkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - } - ], - "default": false, - "docs": [], - "label": "get_stake_info_for_hotkey_coldkey_netuid", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 7 - }, - "selector": "0x5b73b8b9" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "add_stake", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x3a656e31" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "remove_stake", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x7758d434" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - } - ], - "default": false, - "docs": [], - "label": "unstake_all", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x3f525cc7" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - } - ], - "default": false, - "docs": [], - "label": "unstake_all_alpha", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0xab74c422" - }, - { - "args": [ - { - "label": "origin_hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "destination_hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "origin_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "destination_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "move_stake", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0xa06b0c55" - }, - { - "args": [ - { - "label": "destination_coldkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "origin_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "destination_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "transfer_stake", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x3528ef5e" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "origin_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "destination_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "swap_stake", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x04f7ca30" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "limit_price", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "allow_partial", - "type": { - "displayName": [ - "bool" - ], - "type": 17 - } - } - ], - "default": false, - "docs": [], - "label": "add_stake_limit", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x30013b98" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "limit_price", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "allow_partial", - "type": { - "displayName": [ - "bool" - ], - "type": 17 - } - } - ], - "default": false, - "docs": [], - "label": "remove_stake_limit", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0xc3ce39c8" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "origin_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "destination_netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "amount", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "limit_price", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - }, - { - "label": "allow_partial", - "type": { - "displayName": [ - "bool" - ], - "type": 17 - } - } - ], - "default": false, - "docs": [], - "label": "swap_stake_limit", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x212ef7ad" - }, - { - "args": [ - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - }, - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "limit_price", - "type": { - "displayName": [ - "u64" - ], - "type": 14 - } - } - ], - "default": false, - "docs": [], - "label": "remove_stake_full_limit", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0xa6d6ea64" - }, - { - "args": [ - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - }, - { - "label": "hotkey", - "type": { - "displayName": [], - "type": 4 - } - } - ], - "default": false, - "docs": [], - "label": "set_coldkey_auto_stake_hotkey", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0xe24f0d8a" - }, - { - "args": [ - { - "label": "delegate", - "type": { - "displayName": [], - "type": 4 - } - } - ], - "default": false, - "docs": [], - "label": "add_proxy", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x528b6757" - }, - { - "args": [ - { - "label": "delegate", - "type": { - "displayName": [], - "type": 4 - } - } - ], - "default": false, - "docs": [], - "label": "remove_proxy", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 19 - }, - "selector": "0x129d4f75" - }, - { - "args": [ - { - "label": "netuid", - "type": { - "displayName": [ - "u16" - ], - "type": 6 - } - } - ], - "default": false, - "docs": [], - "label": "get_alpha_price", - "mutates": false, - "payable": false, - "returnType": { - "displayName": [ - "ink", - "MessageResult" - ], - "type": 21 - }, - "selector": "0x08adc2e2" - } - ] - }, - "storage": { - "root": { - "layout": { - "struct": { - "fields": [], - "name": "Bittensor" - } - }, - "root_key": "0x00000000", - "ty": 0 - } - }, - "types": [ - { - "id": 0, - "type": { - "def": { - "composite": {} - }, - "path": [ - "bittensor", - "bittensor", - "Bittensor" - ] - } - }, - { - "id": 1, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 2 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 3 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 2 - }, - { - "name": "E", - "type": 3 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 2, - "type": { - "def": { - "tuple": [] - } - } - }, - { - "id": 3, - "type": { - "def": { - "variant": { - "variants": [ - { - "index": 1, - "name": "CouldNotReadInput" - } - ] - } - }, - "path": [ - "ink_primitives", - "LangError" - ] - } - }, - { - "id": 4, - "type": { - "def": { - "array": { - "len": 32, - "type": 5 - } - } - } - }, - { - "id": 5, - "type": { - "def": { - "primitive": "u8" - } - } - }, - { - "id": 6, - "type": { - "def": { - "primitive": "u16" - } - } - }, - { - "id": 7, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 8 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 3 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 8 - }, - { - "name": "E", - "type": 3 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 8, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 9 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 18 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 9 - }, - { - "name": "E", - "type": 18 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 9, - "type": { - "def": { - "variant": { - "variants": [ - { - "index": 0, - "name": "None" - }, - { - "fields": [ - { - "type": 10 - } - ], - "index": 1, - "name": "Some" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 10 - } - ], - "path": [ - "Option" - ] - } - }, - { - "id": 10, - "type": { - "def": { - "composite": { - "fields": [ - { - "name": "hotkey", - "type": 11, - "typeName": "AccountId" - }, - { - "name": "coldkey", - "type": 11, - "typeName": "AccountId" - }, - { - "name": "netuid", - "type": 12, - "typeName": "Compact" - }, - { - "name": "stake", - "type": 13, - "typeName": "Compact" - }, - { - "name": "locked", - "type": 15, - "typeName": "Compact" - }, - { - "name": "emission", - "type": 13, - "typeName": "Compact" - }, - { - "name": "tao_emission", - "type": 16, - "typeName": "Compact" - }, - { - "name": "drain", - "type": 15, - "typeName": "Compact" - }, - { - "name": "is_registered", - "type": 17, - "typeName": "bool" - } - ] - } - }, - "params": [ - { - "name": "AccountId", - "type": 11 - } - ], - "path": [ - "bittensor", - "StakeInfo" - ] - } - }, - { - "id": 11, - "type": { - "def": { - "composite": { - "fields": [ - { - "type": 4, - "typeName": "[u8; 32]" - } - ] - } - }, - "path": [ - "ink_primitives", - "types", - "AccountId" - ] - } - }, - { - "id": 12, - "type": { - "def": { - "compact": { - "type": 6 - } - } - } - }, - { - "id": 13, - "type": { - "def": { - "compact": { - "type": 14 - } - } - } - }, - { - "id": 14, - "type": { - "def": { - "primitive": "u64" - } - } - }, - { - "id": 15, - "type": { - "def": { - "compact": { - "type": 14 - } - } - } - }, - { - "id": 16, - "type": { - "def": { - "compact": { - "type": 14 - } - } - } - }, - { - "id": 17, - "type": { - "def": { - "primitive": "bool" - } - } - }, - { - "id": 18, - "type": { - "def": { - "variant": { - "variants": [ - { - "index": 0, - "name": "ReadFailed" - }, - { - "index": 1, - "name": "WriteFailed" - } - ] - } - }, - "path": [ - "bittensor", - "ReadWriteErrorCode" - ] - } - }, - { - "id": 19, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 20 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 3 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 20 - }, - { - "name": "E", - "type": 3 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 20, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 2 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 18 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 2 - }, - { - "name": "E", - "type": 18 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 21, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 22 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 3 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 22 - }, - { - "name": "E", - "type": 3 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 22, - "type": { - "def": { - "variant": { - "variants": [ - { - "fields": [ - { - "type": 14 - } - ], - "index": 0, - "name": "Ok" - }, - { - "fields": [ - { - "type": 18 - } - ], - "index": 1, - "name": "Err" - } - ] - } - }, - "params": [ - { - "name": "T", - "type": 14 - }, - { - "name": "E", - "type": 18 - } - ], - "path": [ - "Result" - ] - } - }, - { - "id": 23, - "type": { - "def": { - "composite": { - "fields": [ - { - "type": 4, - "typeName": "[u8; 32]" - } - ] - } - }, - "path": [ - "ink_primitives", - "types", - "Hash" - ] - } - }, - { - "id": 24, - "type": { - "def": { - "primitive": "u32" - } - } - }, - { - "id": 25, - "type": { - "def": { - "variant": {} - }, - "path": [ - "bittensor", - "RuntimeReadWrite" - ] - } - } - ], - "version": 5 -} \ No newline at end of file diff --git a/contract-tests/.papi/descriptors/.gitignore b/contract-tests/.papi/descriptors/.gitignore deleted file mode 100644 index 557cc81498..0000000000 --- a/contract-tests/.papi/descriptors/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -* -!.gitignore -!package.json diff --git a/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs b/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs deleted file mode 100644 index bf4ad0eb02..0000000000 --- a/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs +++ /dev/null @@ -1,9 +0,0 @@ -var __defProp = Object.defineProperty; -var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); -}; - -export { - __export -}; diff --git a/contract-tests/.papi/descriptors/dist/common-types.d.ts b/contract-tests/.papi/descriptors/dist/common-types.d.ts deleted file mode 100644 index c883025696..0000000000 --- a/contract-tests/.papi/descriptors/dist/common-types.d.ts +++ /dev/null @@ -1,9229 +0,0 @@ -import { Enum, GetEnum, FixedSizeBinary, Binary, SS58String, FixedSizeArray, ResultPayload, TxCallData } from "polkadot-api"; -type AnonymousEnum = T & { - __anonymous: true; -}; -type MyTuple = [T, ...T[]]; -type SeparateUndefined = undefined extends T ? undefined | Exclude : T; -type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { - [K in keyof T]: T[K]; -} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { - [K in keyof T & string]: T[K]; -}>; -export type I5sesotjlssv2d = { - "nonce": number; - "consumers": number; - "providers": number; - "sufficients": number; - "data": Anonymize; -}; -export type I1q8tnt1cluu5j = { - "free": bigint; - "reserved": bigint; - "frozen": bigint; - "flags": bigint; -}; -export type Iffmde3ekjedi9 = { - "normal": Anonymize; - "operational": Anonymize; - "mandatory": Anonymize; -}; -export type I4q39t5hn830vp = { - "ref_time": bigint; - "proof_size": bigint; -}; -export type I4mddgoa69c0a2 = Array; -export type DigestItem = Enum<{ - "PreRuntime": [FixedSizeBinary<4>, Binary]; - "Consensus": [FixedSizeBinary<4>, Binary]; - "Seal": [FixedSizeBinary<4>, Binary]; - "Other": Binary; - "RuntimeEnvironmentUpdated": undefined; -}>; -export declare const DigestItem: GetEnum; -export type Icr4vaj0vrd6je = Array<{ - "phase": Phase; - "event": Enum<{ - "System": Anonymize; - "Grandpa": GrandpaEvent; - "Balances": Anonymize; - "TransactionPayment": TransactionPaymentEvent; - "SubtensorModule": Anonymize; - "Utility": Anonymize; - "Sudo": Anonymize; - "Multisig": Anonymize; - "Preimage": PreimageEvent; - "Scheduler": Anonymize; - "Proxy": Anonymize; - "Registry": Anonymize; - "Commitments": Anonymize; - "AdminUtils": Anonymize; - "SafeMode": Anonymize; - "Ethereum": Anonymize; - "EVM": Anonymize; - "BaseFee": Anonymize; - "Drand": Anonymize; - "Crowdloan": Anonymize; - "Swap": Anonymize; - "Contracts": Anonymize; - "MevShield": Anonymize; - }>; - "topics": Anonymize; -}>; -export type Phase = Enum<{ - "ApplyExtrinsic": number; - "Finalization": undefined; - "Initialization": undefined; -}>; -export declare const Phase: GetEnum; -export type Icfds8s8ncea16 = AnonymousEnum<{ - /** - * An extrinsic completed successfully. - */ - "ExtrinsicSuccess": Anonymize; - /** - * An extrinsic failed. - */ - "ExtrinsicFailed": Anonymize; - /** - * `:code` was updated. - */ - "CodeUpdated": undefined; - /** - * A new account was created. - */ - "NewAccount": Anonymize; - /** - * An account was reaped. - */ - "KilledAccount": Anonymize; - /** - * On on-chain remark happened. - */ - "Remarked": Anonymize; - /** - * An upgrade was authorized. - */ - "UpgradeAuthorized": Anonymize; - /** - * An invalid authorized upgrade was rejected while trying to apply it. - */ - "RejectedInvalidAuthorizedUpgrade": Anonymize; -}>; -export type Ia82mnkmeo2rhc = { - "dispatch_info": Anonymize; -}; -export type Ic9s8f85vjtncc = { - "weight": Anonymize; - "class": DispatchClass; - "pays_fee": Anonymize; -}; -export type DispatchClass = Enum<{ - "Normal": undefined; - "Operational": undefined; - "Mandatory": undefined; -}>; -export declare const DispatchClass: GetEnum; -export type Iehg04bj71rkd = AnonymousEnum<{ - "Yes": undefined; - "No": undefined; -}>; -export type I6u3ru0d29kkj0 = { - "dispatch_error": Anonymize; - "dispatch_info": Anonymize; -}; -export type Ic871mj76419vm = AnonymousEnum<{ - "Other": undefined; - "CannotLookup": undefined; - "BadOrigin": undefined; - "Module": Enum<{ - "System": Anonymize; - "RandomnessCollectiveFlip": undefined; - "Timestamp": undefined; - "Aura": undefined; - "Grandpa": Anonymize; - "Balances": Anonymize; - "TransactionPayment": undefined; - "SubtensorModule": Anonymize; - "Utility": Anonymize; - "Sudo": Anonymize; - "Multisig": Anonymize; - "Preimage": Anonymize; - "Scheduler": Anonymize; - "Proxy": Anonymize; - "Registry": Anonymize; - "Commitments": Anonymize; - "AdminUtils": Anonymize; - "SafeMode": Anonymize; - "Ethereum": Anonymize; - "EVM": Anonymize; - "EVMChainId": undefined; - "BaseFee": undefined; - "Drand": Anonymize; - "Crowdloan": Anonymize; - "Swap": Anonymize; - "Contracts": Anonymize; - "MevShield": Anonymize; - }>; - "ConsumerRemaining": undefined; - "NoProviders": undefined; - "TooManyConsumers": undefined; - "Token": TokenError; - "Arithmetic": ArithmeticError; - "Transactional": TransactionalError; - "Exhausted": undefined; - "Corruption": undefined; - "Unavailable": undefined; - "RootNotAllowed": undefined; - "Trie": Enum<{ - "InvalidStateRoot": undefined; - "IncompleteDatabase": undefined; - "ValueAtIncompleteKey": undefined; - "DecoderError": undefined; - "InvalidHash": undefined; - "DuplicateKey": undefined; - "ExtraneousNode": undefined; - "ExtraneousValue": undefined; - "ExtraneousHashReference": undefined; - "InvalidChildReference": undefined; - "ValueMismatch": undefined; - "IncompleteProof": undefined; - "RootMismatch": undefined; - "DecodeError": undefined; - }>; -}>; -export type I5o0s7c8q1cc9b = AnonymousEnum<{ - /** - * The name of specification does not match between the current runtime - * and the new runtime. - */ - "InvalidSpecName": undefined; - /** - * The specification version is not allowed to decrease between the current runtime - * and the new runtime. - */ - "SpecVersionNeedsToIncrease": undefined; - /** - * Failed to extract the runtime version from the new runtime. - * - * Either calling `Core_version` or decoding `RuntimeVersion` failed. - */ - "FailedToExtractRuntimeVersion": undefined; - /** - * Suicide called when the account has non-default composite data. - */ - "NonDefaultComposite": undefined; - /** - * There is a non-zero reference count preventing the account from being purged. - */ - "NonZeroRefCount": undefined; - /** - * The origin filter prevent the call to be dispatched. - */ - "CallFiltered": undefined; - /** - * A multi-block migration is ongoing and prevents the current code from being replaced. - */ - "MultiBlockMigrationsOngoing": undefined; - /** - * No upgrade authorized. - */ - "NothingAuthorized": undefined; - /** - * The submitted code is not authorized. - */ - "Unauthorized": undefined; -}>; -export type I7q8i0pp1gkas6 = AnonymousEnum<{ - /** - * Attempt to signal GRANDPA pause when the authority set isn't live - * (either paused or already pending pause). - */ - "PauseFailed": undefined; - /** - * Attempt to signal GRANDPA resume when the authority set isn't paused - * (either live or already pending resume). - */ - "ResumeFailed": undefined; - /** - * Attempt to signal GRANDPA change with one already pending. - */ - "ChangePending": undefined; - /** - * Cannot signal forced change so soon after last. - */ - "TooSoon": undefined; - /** - * A key ownership proof provided as part of an equivocation report is invalid. - */ - "InvalidKeyOwnershipProof": undefined; - /** - * An equivocation proof provided as part of an equivocation report is invalid. - */ - "InvalidEquivocationProof": undefined; - /** - * A given equivocation report is valid but already previously reported. - */ - "DuplicateOffenceReport": undefined; -}>; -export type Idj13i7adlomht = AnonymousEnum<{ - /** - * Vesting balance too high to send value. - */ - "VestingBalance": undefined; - /** - * Account liquidity restrictions prevent withdrawal. - */ - "LiquidityRestrictions": undefined; - /** - * Balance too low to send value. - */ - "InsufficientBalance": undefined; - /** - * Value too low to create account due to existential deposit. - */ - "ExistentialDeposit": undefined; - /** - * Transfer/payment would kill account. - */ - "Expendability": undefined; - /** - * A vesting schedule already exists for this account. - */ - "ExistingVestingSchedule": undefined; - /** - * Beneficiary account must pre-exist. - */ - "DeadAccount": undefined; - /** - * Number of named reserves exceed `MaxReserves`. - */ - "TooManyReserves": undefined; - /** - * Number of holds exceed `VariantCountOf`. - */ - "TooManyHolds": undefined; - /** - * Number of freezes exceed `MaxFreezes`. - */ - "TooManyFreezes": undefined; - /** - * The issuance cannot be modified since it is already deactivated. - */ - "IssuanceDeactivated": undefined; - /** - * The delta cannot be zero. - */ - "DeltaZero": undefined; -}>; -export type Ib31febi51tc1 = AnonymousEnum<{ - /** - * The root network does not exist. - */ - "RootNetworkDoesNotExist": undefined; - /** - * The user is trying to serve an axon which is not of type 4 (IPv4) or 6 (IPv6). - */ - "InvalidIpType": undefined; - /** - * An invalid IP address is passed to the serve function. - */ - "InvalidIpAddress": undefined; - /** - * An invalid port is passed to the serve function. - */ - "InvalidPort": undefined; - /** - * The hotkey is not registered in subnet - */ - "HotKeyNotRegisteredInSubNet": undefined; - /** - * The hotkey does not exists - */ - "HotKeyAccountNotExists": undefined; - /** - * The hotkey is not registered in any subnet. - */ - "HotKeyNotRegisteredInNetwork": undefined; - /** - * Request to stake, unstake or subscribe is made by a coldkey that is not associated with - * the hotkey account. - */ - "NonAssociatedColdKey": undefined; - /** - * DEPRECATED: Stake amount to withdraw is zero. - * The caller does not have enought stake to perform this action. - */ - "NotEnoughStake": undefined; - /** - * The caller is requesting removing more stake than there exists in the staking account. - * See: "[remove_stake()]". - */ - "NotEnoughStakeToWithdraw": undefined; - /** - * The caller is requesting to set weights but the caller has less than minimum stake - * required to set weights (less than WeightsMinStake). - */ - "NotEnoughStakeToSetWeights": undefined; - /** - * The parent hotkey doesn't have enough own stake to set childkeys. - */ - "NotEnoughStakeToSetChildkeys": undefined; - /** - * The caller is requesting adding more stake than there exists in the coldkey account. - * See: "[add_stake()]" - */ - "NotEnoughBalanceToStake": undefined; - /** - * The caller is trying to add stake, but for some reason the requested amount could not be - * withdrawn from the coldkey account. - */ - "BalanceWithdrawalError": undefined; - /** - * Unsuccessfully withdraw, balance could be zero (can not make account exist) after - * withdrawal. - */ - "ZeroBalanceAfterWithdrawn": undefined; - /** - * The caller is attempting to set non-self weights without being a permitted validator. - */ - "NeuronNoValidatorPermit": undefined; - /** - * The caller is attempting to set the weight keys and values but these vectors have - * different size. - */ - "WeightVecNotEqualSize": undefined; - /** - * The caller is attempting to set weights with duplicate UIDs in the weight matrix. - */ - "DuplicateUids": undefined; - /** - * The caller is attempting to set weight to at least one UID that does not exist in the - * metagraph. - */ - "UidVecContainInvalidOne": undefined; - /** - * The dispatch is attempting to set weights on chain with fewer elements than are allowed. - */ - "WeightVecLengthIsLow": undefined; - /** - * Number of registrations in this block exceeds the allowed number (i.e., exceeds the - * subnet hyperparameter "max_regs_per_block"). - */ - "TooManyRegistrationsThisBlock": undefined; - /** - * The caller is requesting registering a neuron which already exists in the active set. - */ - "HotKeyAlreadyRegisteredInSubNet": undefined; - /** - * The new hotkey is the same as old one - */ - "NewHotKeyIsSameWithOld": undefined; - /** - * The supplied PoW hash block is in the future or negative. - */ - "InvalidWorkBlock": undefined; - /** - * The supplied PoW hash block does not meet the network difficulty. - */ - "InvalidDifficulty": undefined; - /** - * The supplied PoW hash seal does not match the supplied work. - */ - "InvalidSeal": undefined; - /** - * The dispatch is attempting to set weights on chain with weight value exceeding the - * configured max weight limit (currently `u16::MAX`). - */ - "MaxWeightExceeded": undefined; - /** - * The hotkey is attempting to become a delegate when the hotkey is already a delegate. - */ - "HotKeyAlreadyDelegate": undefined; - /** - * A transactor exceeded the rate limit for setting weights. - */ - "SettingWeightsTooFast": undefined; - /** - * A validator is attempting to set weights from a validator with incorrect weight version. - */ - "IncorrectWeightVersionKey": undefined; - /** - * An axon or prometheus serving exceeded the rate limit for a registered neuron. - */ - "ServingRateLimitExceeded": undefined; - /** - * The caller is attempting to set weights with more UIDs than allowed. - */ - "UidsLengthExceedUidsInSubNet": undefined; - /** - * A transactor exceeded the rate limit for add network transaction. - */ - "NetworkTxRateLimitExceeded": undefined; - /** - * A transactor exceeded the rate limit for delegate transaction. - */ - "DelegateTxRateLimitExceeded": undefined; - /** - * A transactor exceeded the rate limit for setting or swapping hotkey. - */ - "HotKeySetTxRateLimitExceeded": undefined; - /** - * A transactor exceeded the rate limit for staking. - */ - "StakingRateLimitExceeded": undefined; - /** - * Registration is disabled. - */ - "SubNetRegistrationDisabled": undefined; - /** - * The number of registration attempts exceeded the allowed number in the interval. - */ - "TooManyRegistrationsThisInterval": undefined; - /** - * The hotkey is required to be the origin. - */ - "TransactorAccountShouldBeHotKey": undefined; - /** - * Faucet is disabled. - */ - "FaucetDisabled": undefined; - /** - * Not a subnet owner. - */ - "NotSubnetOwner": undefined; - /** - * Operation is not permitted on the root subnet. - */ - "RegistrationNotPermittedOnRootSubnet": undefined; - /** - * A hotkey with too little stake is attempting to join the root subnet. - */ - "StakeTooLowForRoot": undefined; - /** - * All subnets are in the immunity period. - */ - "AllNetworksInImmunity": undefined; - /** - * Not enough balance to pay swapping hotkey. - */ - "NotEnoughBalanceToPaySwapHotKey": undefined; - /** - * Netuid does not match for setting root network weights. - */ - "NotRootSubnet": undefined; - /** - * Can not set weights for the root network. - */ - "CanNotSetRootNetworkWeights": undefined; - /** - * No neuron ID is available. - */ - "NoNeuronIdAvailable": undefined; - /** - * Delegate take is too low. - */ - "DelegateTakeTooLow": undefined; - /** - * Delegate take is too high. - */ - "DelegateTakeTooHigh": undefined; - /** - * No commit found for the provided hotkey+netuid combination when attempting to reveal the - * weights. - */ - "NoWeightsCommitFound": undefined; - /** - * Committed hash does not equal the hashed reveal data. - */ - "InvalidRevealCommitHashNotMatch": undefined; - /** - * Attempting to call set_weights when commit/reveal is enabled - */ - "CommitRevealEnabled": undefined; - /** - * Attemtping to commit/reveal weights when disabled. - */ - "CommitRevealDisabled": undefined; - /** - * Attempting to set alpha high/low while disabled - */ - "LiquidAlphaDisabled": undefined; - /** - * Alpha high is too low: alpha_high > 0.8 - */ - "AlphaHighTooLow": undefined; - /** - * Alpha low is out of range: alpha_low > 0 && alpha_low < 0.8 - */ - "AlphaLowOutOfRange": undefined; - /** - * The coldkey has already been swapped - */ - "ColdKeyAlreadyAssociated": undefined; - /** - * The coldkey balance is not enough to pay for the swap - */ - "NotEnoughBalanceToPaySwapColdKey": undefined; - /** - * Attempting to set an invalid child for a hotkey on a network. - */ - "InvalidChild": undefined; - /** - * Duplicate child when setting children. - */ - "DuplicateChild": undefined; - /** - * Proportion overflow when setting children. - */ - "ProportionOverflow": undefined; - /** - * Too many children MAX 5. - */ - "TooManyChildren": undefined; - /** - * Default transaction rate limit exceeded. - */ - "TxRateLimitExceeded": undefined; - /** - * Coldkey swap announcement not found - */ - "ColdkeySwapAnnouncementNotFound": undefined; - /** - * Coldkey swap too early. - */ - "ColdkeySwapTooEarly": undefined; - /** - * Coldkey swap reannounced too early. - */ - "ColdkeySwapReannouncedTooEarly": undefined; - /** - * The announced coldkey hash does not match the new coldkey hash. - */ - "AnnouncedColdkeyHashDoesNotMatch": undefined; - /** - * Coldkey swap already disputed - */ - "ColdkeySwapAlreadyDisputed": undefined; - /** - * New coldkey is hotkey - */ - "NewColdKeyIsHotkey": undefined; - /** - * Childkey take is invalid. - */ - "InvalidChildkeyTake": undefined; - /** - * Childkey take rate limit exceeded. - */ - "TxChildkeyTakeRateLimitExceeded": undefined; - /** - * Invalid identity. - */ - "InvalidIdentity": undefined; - /** - * Subnet mechanism does not exist. - */ - "MechanismDoesNotExist": undefined; - /** - * Trying to unstake your lock amount. - */ - "CannotUnstakeLock": undefined; - /** - * Trying to perform action on non-existent subnet. - */ - "SubnetNotExists": undefined; - /** - * Maximum commit limit reached - */ - "TooManyUnrevealedCommits": undefined; - /** - * Attempted to reveal weights that are expired. - */ - "ExpiredWeightCommit": undefined; - /** - * Attempted to reveal weights too early. - */ - "RevealTooEarly": undefined; - /** - * Attempted to batch reveal weights with mismatched vector input lenghts. - */ - "InputLengthsUnequal": undefined; - /** - * A transactor exceeded the rate limit for setting weights. - */ - "CommittingWeightsTooFast": undefined; - /** - * Stake amount is too low. - */ - "AmountTooLow": undefined; - /** - * Not enough liquidity. - */ - "InsufficientLiquidity": undefined; - /** - * Slippage is too high for the transaction. - */ - "SlippageTooHigh": undefined; - /** - * Subnet disallows transfer. - */ - "TransferDisallowed": undefined; - /** - * Activity cutoff is being set too low. - */ - "ActivityCutoffTooLow": undefined; - /** - * Call is disabled - */ - "CallDisabled": undefined; - /** - * FirstEmissionBlockNumber is already set. - */ - "FirstEmissionBlockNumberAlreadySet": undefined; - /** - * need wait for more blocks to accept the start call extrinsic. - */ - "NeedWaitingMoreBlocksToStarCall": undefined; - /** - * Not enough AlphaOut on the subnet to recycle - */ - "NotEnoughAlphaOutToRecycle": undefined; - /** - * Cannot burn or recycle TAO from root subnet - */ - "CannotBurnOrRecycleOnRootSubnet": undefined; - /** - * Public key cannot be recovered. - */ - "UnableToRecoverPublicKey": undefined; - /** - * Recovered public key is invalid. - */ - "InvalidRecoveredPublicKey": undefined; - /** - * SubToken disabled now - */ - "SubtokenDisabled": undefined; - /** - * Too frequent hotkey swap on subnet - */ - "HotKeySwapOnSubnetIntervalNotPassed": undefined; - /** - * Zero max stake amount - */ - "ZeroMaxStakeAmount": undefined; - /** - * Invalid netuid duplication - */ - "SameNetuid": undefined; - /** - * The caller does not have enough balance for the operation. - */ - "InsufficientBalance": undefined; - /** - * Too frequent staking operations - */ - "StakingOperationRateLimitExceeded": undefined; - /** - * Invalid lease beneficiary to register the leased network. - */ - "InvalidLeaseBeneficiary": undefined; - /** - * Lease cannot end in the past. - */ - "LeaseCannotEndInThePast": undefined; - /** - * Couldn't find the lease netuid. - */ - "LeaseNetuidNotFound": undefined; - /** - * Lease does not exist. - */ - "LeaseDoesNotExist": undefined; - /** - * Lease has no end block. - */ - "LeaseHasNoEndBlock": undefined; - /** - * Lease has not ended. - */ - "LeaseHasNotEnded": undefined; - /** - * An overflow occurred. - */ - "Overflow": undefined; - /** - * Beneficiary does not own hotkey. - */ - "BeneficiaryDoesNotOwnHotkey": undefined; - /** - * Expected beneficiary origin. - */ - "ExpectedBeneficiaryOrigin": undefined; - /** - * Admin operation is prohibited during the protected weights window - */ - "AdminActionProhibitedDuringWeightsWindow": undefined; - /** - * Symbol does not exist. - */ - "SymbolDoesNotExist": undefined; - /** - * Symbol already in use. - */ - "SymbolAlreadyInUse": undefined; - /** - * Incorrect commit-reveal version. - */ - "IncorrectCommitRevealVersion": undefined; - /** - * Reveal period is too large. - */ - "RevealPeriodTooLarge": undefined; - /** - * Reveal period is too small. - */ - "RevealPeriodTooSmall": undefined; - /** - * Generic error for out-of-range parameter value - */ - "InvalidValue": undefined; - /** - * Subnet limit reached & there is no eligible subnet to prune - */ - "SubnetLimitReached": undefined; - /** - * Insufficient funds to meet the subnet lock cost - */ - "CannotAffordLockCost": undefined; - /** - * exceeded the rate limit for associating an EVM key. - */ - "EvmKeyAssociateRateLimitExceeded": undefined; - /** - * Same auto stake hotkey already set - */ - "SameAutoStakeHotkeyAlreadySet": undefined; - /** - * The UID map for the subnet could not be cleared - */ - "UidMapCouldNotBeCleared": undefined; - /** - * Trimming would exceed the max immune neurons percentage - */ - "TrimmingWouldExceedMaxImmunePercentage": undefined; - /** - * Violating the rules of Childkey-Parentkey consistency - */ - "ChildParentInconsistency": undefined; - /** - * Invalid number of root claims - */ - "InvalidNumRootClaim": undefined; - /** - * Invalid value of root claim threshold - */ - "InvalidRootClaimThreshold": undefined; - /** - * Exceeded subnet limit number or zero. - */ - "InvalidSubnetNumber": undefined; - /** - * The maximum allowed UIDs times mechanism count should not exceed 256. - */ - "TooManyUIDsPerMechanism": undefined; - /** - * Voting power tracking is not enabled for this subnet. - */ - "VotingPowerTrackingNotEnabled": undefined; - /** - * Invalid voting power EMA alpha value (must be <= 10^18). - */ - "InvalidVotingPowerEmaAlpha": undefined; - /** - * Unintended precision loss when unstaking alpha - */ - "PrecisionLoss": undefined; - /** - * Deprecated call. - */ - "Deprecated": undefined; - /** - * "Add stake and burn" exceeded the operation rate limit - */ - "AddStakeBurnRateLimitExceeded": undefined; -}>; -export type I499qmubmch1cg = AnonymousEnum<{ - /** - * Too many calls batched. - */ - "TooManyCalls": undefined; - /** - * Bad input data for derived account ID - */ - "InvalidDerivedAccount": undefined; -}>; -export type Iaug04qjhbli00 = AnonymousEnum<{ - /** - * Sender must be the Sudo account. - */ - "RequireSudo": undefined; -}>; -export type Ia76qmhhg4jvb9 = AnonymousEnum<{ - /** - * Threshold must be 2 or greater. - */ - "MinimumThreshold": undefined; - /** - * Call is already approved by this signatory. - */ - "AlreadyApproved": undefined; - /** - * Call doesn't need any (more) approvals. - */ - "NoApprovalsNeeded": undefined; - /** - * There are too few signatories in the list. - */ - "TooFewSignatories": undefined; - /** - * There are too many signatories in the list. - */ - "TooManySignatories": undefined; - /** - * The signatories were provided out of order; they should be ordered. - */ - "SignatoriesOutOfOrder": undefined; - /** - * The sender was contained in the other signatories; it shouldn't be. - */ - "SenderInSignatories": undefined; - /** - * Multisig operation not found in storage. - */ - "NotFound": undefined; - /** - * Only the account that originally created the multisig is able to cancel it or update - * its deposits. - */ - "NotOwner": undefined; - /** - * No timepoint was given, yet the multisig operation is already underway. - */ - "NoTimepoint": undefined; - /** - * A different timepoint was given to the multisig operation that is underway. - */ - "WrongTimepoint": undefined; - /** - * A timepoint was given, yet no multisig operation is underway. - */ - "UnexpectedTimepoint": undefined; - /** - * The maximum weight information provided was too low. - */ - "MaxWeightTooLow": undefined; - /** - * The data to be stored is already stored. - */ - "AlreadyStored": undefined; -}>; -export type I4cfhml1prt4lu = AnonymousEnum<{ - /** - * Preimage is too large to store on-chain. - */ - "TooBig": undefined; - /** - * Preimage has already been noted on-chain. - */ - "AlreadyNoted": undefined; - /** - * The user is not authorized to perform this action. - */ - "NotAuthorized": undefined; - /** - * The preimage cannot be removed since it has not yet been noted. - */ - "NotNoted": undefined; - /** - * A preimage may not be removed when there are outstanding requests. - */ - "Requested": undefined; - /** - * The preimage request cannot be removed since no outstanding requests exist. - */ - "NotRequested": undefined; - /** - * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once. - */ - "TooMany": undefined; - /** - * Too few hashes were requested to be upgraded (i.e. zero). - */ - "TooFew": undefined; -}>; -export type If7oa8fprnilo5 = AnonymousEnum<{ - /** - * Failed to schedule a call - */ - "FailedToSchedule": undefined; - /** - * Cannot find the scheduled call. - */ - "NotFound": undefined; - /** - * Given target block number is in the past. - */ - "TargetBlockNumberInPast": undefined; - /** - * Reschedule failed because it does not change scheduled time. - */ - "RescheduleNoChange": undefined; - /** - * Attempt to use a non-named function on a named task. - */ - "Named": undefined; -}>; -export type I7ae37ntp06co6 = AnonymousEnum<{ - /** - * There are too many proxies registered or too many announcements pending. - */ - "TooMany": undefined; - /** - * Proxy registration not found. - */ - "NotFound": undefined; - /** - * Sender is not a proxy of the account to be proxied. - */ - "NotProxy": undefined; - /** - * A call which is incompatible with the proxy type's filter was attempted. - */ - "Unproxyable": undefined; - /** - * Account is already a proxy. - */ - "Duplicate": undefined; - /** - * Call may not be made by proxy because it may escalate its privileges. - */ - "NoPermission": undefined; - /** - * Announcement, if made at all, was made too recently. - */ - "Unannounced": undefined; - /** - * Cannot add self as proxy. - */ - "NoSelfProxy": undefined; - /** - * Invariant violated: deposit recomputation returned None after updating announcements. - */ - "AnnouncementDepositInvariantViolated": undefined; - /** - * Failed to derive a valid account id from the provided entropy. - */ - "InvalidDerivedAccountId": undefined; -}>; -export type Id6jmtdau2lr6l = AnonymousEnum<{ - /** - * Account attempted to register an identity but does not meet the requirements. - */ - "CannotRegister": undefined; - /** - * Account passed too many additional fields to their identity - */ - "TooManyFieldsInIdentityInfo": undefined; - /** - * Account doesn't have a registered identity - */ - "NotRegistered": undefined; -}>; -export type I8a8dfn9etteh2 = AnonymousEnum<{ - /** - * Account passed too many additional fields to their commitment - */ - "TooManyFieldsInCommitmentInfo": undefined; - /** - * Account is not allowed to make commitments to the chain - */ - "AccountNotAllowedCommit": undefined; - /** - * Space Limit Exceeded for the current interval - */ - "SpaceLimitExceeded": undefined; - /** - * Indicates that unreserve returned a leftover, which is unexpected. - */ - "UnexpectedUnreserveLeftover": undefined; -}>; -export type I8br6rdnlvg28h = AnonymousEnum<{ - /** - * The subnet does not exist, check the netuid parameter - */ - "SubnetDoesNotExist": undefined; - /** - * The maximum number of subnet validators must be less than the maximum number of allowed UIDs in the subnet. - */ - "MaxValidatorsLargerThanMaxUIds": undefined; - /** - * The maximum number of subnet validators must be more than the current number of UIDs already in the subnet. - */ - "MaxAllowedUIdsLessThanCurrentUIds": undefined; - /** - * The maximum value for bonds moving average is reached - */ - "BondsMovingAverageMaxReached": undefined; - /** - * Only root can set negative sigmoid steepness values - */ - "NegativeSigmoidSteepness": undefined; - /** - * Value not in allowed bounds. - */ - "ValueNotInBounds": undefined; - /** - * The minimum allowed UIDs must be less than the current number of UIDs in the subnet. - */ - "MinAllowedUidsGreaterThanCurrentUids": undefined; - /** - * The minimum allowed UIDs must be less than the maximum allowed UIDs. - */ - "MinAllowedUidsGreaterThanMaxAllowedUids": undefined; - /** - * The maximum allowed UIDs must be greater than the minimum allowed UIDs. - */ - "MaxAllowedUidsLessThanMinAllowedUids": undefined; - /** - * The maximum allowed UIDs must be less than the default maximum allowed UIDs. - */ - "MaxAllowedUidsGreaterThanDefaultMaxAllowedUids": undefined; - /** - * Bad parameter value - */ - "InvalidValue": undefined; -}>; -export type I65gapcjsc3grr = AnonymousEnum<{ - /** - * The safe-mode is (already or still) entered. - */ - "Entered": undefined; - /** - * The safe-mode is (already or still) exited. - */ - "Exited": undefined; - /** - * This functionality of the pallet is disabled by the configuration. - */ - "NotConfigured": undefined; - /** - * There is no balance reserved. - */ - "NoDeposit": undefined; - /** - * The account already has a deposit reserved and can therefore not enter or extend again. - */ - "AlreadyDeposited": undefined; - /** - * This deposit cannot be released yet. - */ - "CannotReleaseYet": undefined; - /** - * An error from the underlying `Currency`. - */ - "CurrencyError": undefined; -}>; -export type I1mp6vnoh32l4q = AnonymousEnum<{ - /** - * Signature is invalid. - */ - "InvalidSignature": undefined; - /** - * Pre-log is present, therefore transact is not allowed. - */ - "PreLogExists": undefined; -}>; -export type I226s9mgj51cd2 = AnonymousEnum<{ - /** - * Not enough balance to perform action - */ - "BalanceLow": undefined; - /** - * Calculating total fee overflowed - */ - "FeeOverflow": undefined; - /** - * Calculating total payment overflowed - */ - "PaymentOverflow": undefined; - /** - * Withdraw fee failed - */ - "WithdrawFailed": undefined; - /** - * Gas price is too low. - */ - "GasPriceTooLow": undefined; - /** - * Nonce is invalid - */ - "InvalidNonce": undefined; - /** - * Gas limit is too low. - */ - "GasLimitTooLow": undefined; - /** - * Gas limit is too high. - */ - "GasLimitTooHigh": undefined; - /** - * The chain id is invalid. - */ - "InvalidChainId": undefined; - /** - * the signature is invalid. - */ - "InvalidSignature": undefined; - /** - * EVM reentrancy - */ - "Reentrancy": undefined; - /** - * EIP-3607, - */ - "TransactionMustComeFromEOA": undefined; - /** - * Undefined error. - */ - "Undefined": undefined; - /** - * Origin is not allowed to perform the operation. - */ - "NotAllowed": undefined; - /** - * Address not allowed to deploy contracts either via CREATE or CALL(CREATE). - */ - "CreateOriginNotAllowed": undefined; -}>; -export type I8veee4gumsdel = AnonymousEnum<{ - /** - * The value retrieved was `None` as no value was previously set. - */ - "NoneValue": undefined; - /** - * There was an attempt to increment the value in storage over `u32::MAX`. - */ - "StorageOverflow": undefined; - /** - * failed to connect to the - */ - "DrandConnectionFailure": undefined; - /** - * the pulse is invalid - */ - "UnverifiedPulse": undefined; - /** - * the round number did not increment - */ - "InvalidRoundNumber": undefined; - /** - * the pulse could not be verified - */ - "PulseVerificationError": undefined; -}>; -export type I1ots9pukq67tt = AnonymousEnum<{ - /** - * The crowdloan initial deposit is too low. - */ - "DepositTooLow": undefined; - /** - * The crowdloan cap is too low. - */ - "CapTooLow": undefined; - /** - * The minimum contribution is too low. - */ - "MinimumContributionTooLow": undefined; - /** - * The crowdloan cannot end in the past. - */ - "CannotEndInPast": undefined; - /** - * The crowdloan block duration is too short. - */ - "BlockDurationTooShort": undefined; - /** - * The block duration is too long. - */ - "BlockDurationTooLong": undefined; - /** - * The account does not have enough balance to pay for the initial deposit/contribution. - */ - "InsufficientBalance": undefined; - /** - * An overflow occurred. - */ - "Overflow": undefined; - /** - * The crowdloan id is invalid. - */ - "InvalidCrowdloanId": undefined; - /** - * The crowdloan cap has been fully raised. - */ - "CapRaised": undefined; - /** - * The contribution period has ended. - */ - "ContributionPeriodEnded": undefined; - /** - * The contribution is too low. - */ - "ContributionTooLow": undefined; - /** - * The origin of this call is invalid. - */ - "InvalidOrigin": undefined; - /** - * The crowdloan has already been finalized. - */ - "AlreadyFinalized": undefined; - /** - * The crowdloan contribution period has not ended yet. - */ - "ContributionPeriodNotEnded": undefined; - /** - * The contributor has no contribution for this crowdloan. - */ - "NoContribution": undefined; - /** - * The crowdloan cap has not been raised. - */ - "CapNotRaised": undefined; - /** - * An underflow occurred. - */ - "Underflow": undefined; - /** - * Call to dispatch was not found in the preimage storage. - */ - "CallUnavailable": undefined; - /** - * The crowdloan is not ready to be dissolved, it still has contributions. - */ - "NotReadyToDissolve": undefined; - /** - * The deposit cannot be withdrawn from the crowdloan. - */ - "DepositCannotBeWithdrawn": undefined; - /** - * The maximum number of contributors has been reached. - */ - "MaxContributorsReached": undefined; -}>; -export type I581cn6i0ettg7 = AnonymousEnum<{ - /** - * The fee rate is too high - */ - "FeeRateTooHigh": undefined; - /** - * The provided amount is insufficient for the swap. - */ - "InsufficientInputAmount": undefined; - /** - * The provided liquidity is insufficient for the operation. - */ - "InsufficientLiquidity": undefined; - /** - * The operation would exceed the price limit. - */ - "PriceLimitExceeded": undefined; - /** - * The caller does not have enough balance for the operation. - */ - "InsufficientBalance": undefined; - /** - * Attempted to remove liquidity that does not exist. - */ - "LiquidityNotFound": undefined; - /** - * The provided tick range is invalid. - */ - "InvalidTickRange": undefined; - /** - * Maximum user positions exceeded - */ - "MaxPositionsExceeded": undefined; - /** - * Too many swap steps - */ - "TooManySwapSteps": undefined; - /** - * Provided liquidity parameter is invalid (likely too small) - */ - "InvalidLiquidityValue": undefined; - /** - * Reserves too low for operation. - */ - "ReservesTooLow": undefined; - /** - * The subnet does not exist. - */ - "MechanismDoesNotExist": undefined; - /** - * User liquidity operations are disabled for this subnet - */ - "UserLiquidityDisabled": undefined; - /** - * The subnet does not have subtoken enabled - */ - "SubtokenDisabled": undefined; -}>; -export type I2489g9rnboo1t = AnonymousEnum<{ - /** - * Invalid schedule supplied, e.g. with zero weight of a basic operation. - */ - "InvalidSchedule": undefined; - /** - * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`. - */ - "InvalidCallFlags": undefined; - /** - * The executed contract exhausted its gas limit. - */ - "OutOfGas": undefined; - /** - * The output buffer supplied to a contract API call was too small. - */ - "OutputBufferTooSmall": undefined; - /** - * Performing the requested transfer failed. Probably because there isn't enough - * free balance in the sender's account. - */ - "TransferFailed": undefined; - /** - * Performing a call was denied because the calling depth reached the limit - * of what is specified in the schedule. - */ - "MaxCallDepthReached": undefined; - /** - * No contract was found at the specified address. - */ - "ContractNotFound": undefined; - /** - * The code supplied to `instantiate_with_code` exceeds the limit specified in the - * current schedule. - */ - "CodeTooLarge": undefined; - /** - * No code could be found at the supplied code hash. - */ - "CodeNotFound": undefined; - /** - * No code info could be found at the supplied code hash. - */ - "CodeInfoNotFound": undefined; - /** - * A buffer outside of sandbox memory was passed to a contract API function. - */ - "OutOfBounds": undefined; - /** - * Input passed to a contract API function failed to decode as expected type. - */ - "DecodingFailed": undefined; - /** - * Contract trapped during execution. - */ - "ContractTrapped": undefined; - /** - * The size defined in `T::MaxValueSize` was exceeded. - */ - "ValueTooLarge": undefined; - /** - * Termination of a contract is not allowed while the contract is already - * on the call stack. Can be triggered by `seal_terminate`. - */ - "TerminatedWhileReentrant": undefined; - /** - * `seal_call` forwarded this contracts input. It therefore is no longer available. - */ - "InputForwarded": undefined; - /** - * The subject passed to `seal_random` exceeds the limit. - */ - "RandomSubjectTooLong": undefined; - /** - * The amount of topics passed to `seal_deposit_events` exceeds the limit. - */ - "TooManyTopics": undefined; - /** - * The chain does not provide a chain extension. Calling the chain extension results - * in this error. Note that this usually shouldn't happen as deploying such contracts - * is rejected. - */ - "NoChainExtension": undefined; - /** - * Failed to decode the XCM program. - */ - "XCMDecodeFailed": undefined; - /** - * A contract with the same AccountId already exists. - */ - "DuplicateContract": undefined; - /** - * A contract self destructed in its constructor. - * - * This can be triggered by a call to `seal_terminate`. - */ - "TerminatedInConstructor": undefined; - /** - * A call tried to invoke a contract that is flagged as non-reentrant. - * The only other cause is that a call from a contract into the runtime tried to call back - * into `pallet-contracts`. This would make the whole pallet reentrant with regard to - * contract code execution which is not supported. - */ - "ReentranceDenied": undefined; - /** - * A contract attempted to invoke a state modifying API while being in read-only mode. - */ - "StateChangeDenied": undefined; - /** - * Origin doesn't have enough balance to pay the required storage deposits. - */ - "StorageDepositNotEnoughFunds": undefined; - /** - * More storage was created than allowed by the storage deposit limit. - */ - "StorageDepositLimitExhausted": undefined; - /** - * Code removal was denied because the code is still in use by at least one contract. - */ - "CodeInUse": undefined; - /** - * The contract ran to completion but decided to revert its storage changes. - * Please note that this error is only returned from extrinsics. When called directly - * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags - * to determine whether a reversion has taken place. - */ - "ContractReverted": undefined; - /** - * The contract's code was found to be invalid during validation. - * - * The most likely cause of this is that an API was used which is not supported by the - * node. This happens if an older node is used with a new version of ink!. Try updating - * your node to the newest available version. - * - * A more detailed error can be found on the node console if debug messages are enabled - * by supplying `-lruntime::contracts=debug`. - */ - "CodeRejected": undefined; - /** - * An indeterministic code was used in a context where this is not permitted. - */ - "Indeterministic": undefined; - /** - * A pending migration needs to complete before the extrinsic can be called. - */ - "MigrationInProgress": undefined; - /** - * Migrate dispatch call was attempted but no migration was performed. - */ - "NoMigrationPerformed": undefined; - /** - * The contract has reached its maximum number of delegate dependencies. - */ - "MaxDelegateDependenciesReached": undefined; - /** - * The dependency was not found in the contract's delegate dependencies. - */ - "DelegateDependencyNotFound": undefined; - /** - * The contract already depends on the given delegate dependency. - */ - "DelegateDependencyAlreadyExists": undefined; - /** - * Can not add a delegate dependency to the code hash of the contract itself. - */ - "CannotAddSelfAsDelegateDependency": undefined; - /** - * Can not add more data to transient storage. - */ - "OutOfTransientStorage": undefined; -}>; -export type I4ngcc5keahtro = AnonymousEnum<{ - /** - * A submission with the same id already exists in `Submissions`. - */ - "SubmissionAlreadyExists": undefined; - /** - * The referenced submission id does not exist in `Submissions`. - */ - "MissingSubmission": undefined; - /** - * The recomputed commitment does not match the stored commitment. - */ - "CommitmentMismatch": undefined; - /** - * The provided signature over the payload is invalid. - */ - "SignatureInvalid": undefined; - /** - * The announced ML‑KEM public key length is invalid. - */ - "BadPublicKeyLen": undefined; - /** - * The MEV‑Shield key epoch for this submission has expired and is no longer accepted. - */ - "KeyExpired": undefined; - /** - * The provided `key_hash` does not match the expected epoch key hash. - */ - "KeyHashMismatch": undefined; -}>; -export type TokenError = Enum<{ - "FundsUnavailable": undefined; - "OnlyProvider": undefined; - "BelowMinimum": undefined; - "CannotCreate": undefined; - "UnknownAsset": undefined; - "Frozen": undefined; - "Unsupported": undefined; - "CannotCreateHold": undefined; - "NotExpendable": undefined; - "Blocked": undefined; -}>; -export declare const TokenError: GetEnum; -export type ArithmeticError = Enum<{ - "Underflow": undefined; - "Overflow": undefined; - "DivisionByZero": undefined; -}>; -export declare const ArithmeticError: GetEnum; -export type TransactionalError = Enum<{ - "LimitReached": undefined; - "NoLayer": undefined; -}>; -export declare const TransactionalError: GetEnum; -export type Icbccs0ug47ilf = { - "account": SS58String; -}; -export type I855j4i3kr8ko1 = { - "sender": SS58String; - "hash": FixedSizeBinary<32>; -}; -export type Ibgl04rn6nbfm6 = { - "code_hash": FixedSizeBinary<32>; - "check_version": boolean; -}; -export type Ibk0nulspilods = { - "code_hash": FixedSizeBinary<32>; - "error": Anonymize; -}; -export type GrandpaEvent = Enum<{ - /** - * New authority set has been applied. - */ - "NewAuthorities": Anonymize; - /** - * Current authority set has been paused. - */ - "Paused": undefined; - /** - * Current authority set has been resumed. - */ - "Resumed": undefined; -}>; -export declare const GrandpaEvent: GetEnum; -export type I5768ac424h061 = { - "authority_set": Anonymize; -}; -export type I3geksg000c171 = Array<[FixedSizeBinary<32>, bigint]>; -export type Iao8h4hv7atnq3 = AnonymousEnum<{ - /** - * An account was created with some free balance. - */ - "Endowed": Anonymize; - /** - * An account was removed whose balance was non-zero but below ExistentialDeposit, - * resulting in an outright loss. - */ - "DustLost": Anonymize; - /** - * Transfer succeeded. - */ - "Transfer": Anonymize; - /** - * A balance was set by root. - */ - "BalanceSet": Anonymize; - /** - * Some balance was reserved (moved from free to reserved). - */ - "Reserved": Anonymize; - /** - * Some balance was unreserved (moved from reserved to free). - */ - "Unreserved": Anonymize; - /** - * Some balance was moved from the reserve of the first account to the second account. - * Final argument indicates the destination balance type. - */ - "ReserveRepatriated": Anonymize; - /** - * Some amount was deposited (e.g. for transaction fees). - */ - "Deposit": Anonymize; - /** - * Some amount was withdrawn from the account (e.g. for transaction fees). - */ - "Withdraw": Anonymize; - /** - * Some amount was removed from the account (e.g. for misbehavior). - */ - "Slashed": Anonymize; - /** - * Some amount was minted into an account. - */ - "Minted": Anonymize; - /** - * Some amount was burned from an account. - */ - "Burned": Anonymize; - /** - * Some amount was suspended from an account (it can be restored later). - */ - "Suspended": Anonymize; - /** - * Some amount was restored into an account. - */ - "Restored": Anonymize; - /** - * An account was upgraded. - */ - "Upgraded": Anonymize; - /** - * Total issuance was increased by `amount`, creating a credit to be balanced. - */ - "Issued": Anonymize; - /** - * Total issuance was decreased by `amount`, creating a debt to be balanced. - */ - "Rescinded": Anonymize; - /** - * Some balance was locked. - */ - "Locked": Anonymize; - /** - * Some balance was unlocked. - */ - "Unlocked": Anonymize; - /** - * Some balance was frozen. - */ - "Frozen": Anonymize; - /** - * Some balance was thawed. - */ - "Thawed": Anonymize; - /** - * The `TotalIssuance` was forcefully changed. - */ - "TotalIssuanceForced": Anonymize; -}>; -export type Icv68aq8841478 = { - "account": SS58String; - "free_balance": bigint; -}; -export type Ic262ibdoec56a = { - "account": SS58String; - "amount": bigint; -}; -export type Iflcfm9b6nlmdd = { - "from": SS58String; - "to": SS58String; - "amount": bigint; -}; -export type Ijrsf4mnp3eka = { - "who": SS58String; - "free": bigint; -}; -export type Id5fm4p8lj5qgi = { - "who": SS58String; - "amount": bigint; -}; -export type I8tjvj9uq4b7hi = { - "from": SS58String; - "to": SS58String; - "amount": bigint; - "destination_status": BalanceStatus; -}; -export type BalanceStatus = Enum<{ - "Free": undefined; - "Reserved": undefined; -}>; -export declare const BalanceStatus: GetEnum; -export type I4cbvqmqadhrea = { - "who": SS58String; -}; -export type I3qt1hgg4djhgb = { - "amount": bigint; -}; -export type I4fooe9dun9o0t = { - "old": bigint; - "new": bigint; -}; -export type TransactionPaymentEvent = Enum<{ - /** - * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, - * has been paid by `who`. - */ - "TransactionFeePaid": Anonymize; -}>; -export declare const TransactionPaymentEvent: GetEnum; -export type Ier2cke86dqbr2 = { - "who": SS58String; - "actual_fee": bigint; - "tip": bigint; -}; -export type I2hado50khaobu = AnonymousEnum<{ - /** - * a new network is added. - */ - "NetworkAdded": Anonymize; - /** - * a network is removed. - */ - "NetworkRemoved": number; - /** - * stake has been transferred from the a coldkey account onto the hotkey staking account. - */ - "StakeAdded": Anonymize; - /** - * stake has been removed from the hotkey staking account onto the coldkey account. - */ - "StakeRemoved": Anonymize; - /** - * stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO). - */ - "StakeMoved": Anonymize; - /** - * a caller successfully sets their weights on a subnetwork. - */ - "WeightsSet": Anonymize; - /** - * a new neuron account has been registered to the chain. - */ - "NeuronRegistered": Anonymize; - /** - * multiple uids have been concurrently registered. - */ - "BulkNeuronsRegistered": Anonymize; - /** - * FIXME: Not used yet - */ - "BulkBalancesSet": Anonymize; - /** - * max allowed uids has been set for a subnetwork. - */ - "MaxAllowedUidsSet": Anonymize; - /** - * DEPRECATED: max weight limit updates are no longer supported. - */ - "MaxWeightLimitSet": Anonymize; - /** - * the difficulty has been set for a subnet. - */ - "DifficultySet": Anonymize; - /** - * the adjustment interval is set for a subnet. - */ - "AdjustmentIntervalSet": Anonymize; - /** - * registration per interval is set for a subnet. - */ - "RegistrationPerIntervalSet": Anonymize; - /** - * we set max registrations per block. - */ - "MaxRegistrationsPerBlockSet": Anonymize; - /** - * an activity cutoff is set for a subnet. - */ - "ActivityCutoffSet": Anonymize; - /** - * Rho value is set. - */ - "RhoSet": Anonymize; - /** - * steepness of the sigmoid used to compute alpha values. - */ - "AlphaSigmoidSteepnessSet": Anonymize; - /** - * Kappa is set for a subnet. - */ - "KappaSet": Anonymize; - /** - * minimum allowed weight is set for a subnet. - */ - "MinAllowedWeightSet": Anonymize; - /** - * the validator pruning length has been set. - */ - "ValidatorPruneLenSet": Anonymize; - /** - * the scaling law power has been set for a subnet. - */ - "ScalingLawPowerSet": Anonymize; - /** - * weights set rate limit has been set for a subnet. - */ - "WeightsSetRateLimitSet": Anonymize; - /** - * immunity period is set for a subnet. - */ - "ImmunityPeriodSet": Anonymize; - /** - * bonds moving average is set for a subnet. - */ - "BondsMovingAverageSet": Anonymize; - /** - * bonds penalty is set for a subnet. - */ - "BondsPenaltySet": Anonymize; - /** - * bonds reset is set for a subnet. - */ - "BondsResetOnSet": Anonymize; - /** - * setting the max number of allowed validators on a subnet. - */ - "MaxAllowedValidatorsSet": Anonymize; - /** - * the axon server information is added to the network. - */ - "AxonServed": Anonymize; - /** - * the prometheus server information is added to the network. - */ - "PrometheusServed": Anonymize; - /** - * a hotkey has become a delegate. - */ - "DelegateAdded": Anonymize; - /** - * the default take is set. - */ - "DefaultTakeSet": number; - /** - * weights version key is set for a network. - */ - "WeightsVersionKeySet": Anonymize; - /** - * setting min difficulty on a network. - */ - "MinDifficultySet": Anonymize; - /** - * setting max difficulty on a network. - */ - "MaxDifficultySet": Anonymize; - /** - * setting the prometheus serving rate limit. - */ - "ServingRateLimitSet": Anonymize; - /** - * setting burn on a network. - */ - "BurnSet": Anonymize; - /** - * setting max burn on a network. - */ - "MaxBurnSet": Anonymize; - /** - * setting min burn on a network. - */ - "MinBurnSet": Anonymize; - /** - * setting the transaction rate limit. - */ - "TxRateLimitSet": bigint; - /** - * setting the delegate take transaction rate limit. - */ - "TxDelegateTakeRateLimitSet": bigint; - /** - * setting the childkey take transaction rate limit. - */ - "TxChildKeyTakeRateLimitSet": bigint; - /** - * setting the admin freeze window length (last N blocks of tempo) - */ - "AdminFreezeWindowSet": number; - /** - * setting the owner hyperparameter rate limit in epochs - */ - "OwnerHyperparamRateLimitSet": number; - /** - * minimum childkey take set - */ - "MinChildKeyTakeSet": number; - /** - * maximum childkey take set - */ - "MaxChildKeyTakeSet": number; - /** - * childkey take set - */ - "ChildKeyTakeSet": Anonymize; - /** - * a sudo call is done. - */ - "Sudid": Anonymize; - /** - * registration is allowed/disallowed for a subnet. - */ - "RegistrationAllowed": Anonymize; - /** - * POW registration is allowed/disallowed for a subnet. - */ - "PowRegistrationAllowed": Anonymize; - /** - * setting tempo on a network - */ - "TempoSet": Anonymize; - /** - * setting the RAO recycled for registration. - */ - "RAORecycledForRegistrationSet": Anonymize; - /** - * min stake is set for validators to set weights. - */ - "StakeThresholdSet": bigint; - /** - * setting the adjustment alpha on a subnet. - */ - "AdjustmentAlphaSet": Anonymize; - /** - * the faucet it called on the test net. - */ - "Faucet": Anonymize; - /** - * the subnet owner cut is set. - */ - "SubnetOwnerCutSet": number; - /** - * the network creation rate limit is set. - */ - "NetworkRateLimitSet": bigint; - /** - * the network immunity period is set. - */ - "NetworkImmunityPeriodSet": bigint; - /** - * the start call delay is set. - */ - "StartCallDelaySet": bigint; - /** - * the network minimum locking cost is set. - */ - "NetworkMinLockCostSet": bigint; - /** - * the maximum number of subnets is set - */ - "SubnetLimitSet": number; - /** - * the lock cost reduction is set - */ - "NetworkLockCostReductionIntervalSet": bigint; - /** - * the take for a delegate is decreased. - */ - "TakeDecreased": Anonymize; - /** - * the take for a delegate is increased. - */ - "TakeIncreased": Anonymize; - /** - * the hotkey is swapped - */ - "HotkeySwapped": Anonymize; - /** - * maximum delegate take is set by sudo/admin transaction - */ - "MaxDelegateTakeSet": number; - /** - * minimum delegate take is set by sudo/admin transaction - */ - "MinDelegateTakeSet": number; - /** - * A coldkey swap announcement has been made. - */ - "ColdkeySwapAnnounced": Anonymize; - /** - * A coldkey swap has been reset. - */ - "ColdkeySwapReset": Anonymize; - /** - * A coldkey has been swapped. - */ - "ColdkeySwapped": Anonymize; - /** - * A coldkey swap has been disputed. - */ - "ColdkeySwapDisputed": Anonymize; - /** - * All balance of a hotkey has been unstaked and transferred to a new coldkey - */ - "AllBalanceUnstakedAndTransferredToNewColdkey": Anonymize; - /** - * The arbitration period has been extended - */ - "ArbitrationPeriodExtended": Anonymize; - /** - * Setting of children of a hotkey have been scheduled - */ - "SetChildrenScheduled": Anonymize; - /** - * The children of a hotkey have been set - */ - "SetChildren": Anonymize; - /** - * The identity of a coldkey has been set - */ - "ChainIdentitySet": SS58String; - /** - * The identity of a subnet has been set - */ - "SubnetIdentitySet": number; - /** - * The identity of a subnet has been removed - */ - "SubnetIdentityRemoved": number; - /** - * A dissolve network extrinsic scheduled. - */ - "DissolveNetworkScheduled": Anonymize; - /** - * The coldkey swap announcement delay has been set. - */ - "ColdkeySwapAnnouncementDelaySet": number; - /** - * The coldkey swap reannouncement delay has been set. - */ - "ColdkeySwapReannouncementDelaySet": number; - /** - * The duration of dissolve network has been set - */ - "DissolveNetworkScheduleDurationSet": number; - /** - * Commit-reveal v3 weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - */ - "CRV3WeightsCommitted": Anonymize; - /** - * Weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - */ - "WeightsCommitted": Anonymize; - /** - * Weights have been successfully revealed. - * - * - **who**: The account ID of the user revealing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash of the revealed weights. - */ - "WeightsRevealed": Anonymize; - /** - * Weights have been successfully batch revealed. - * - * - **who**: The account ID of the user revealing the weights. - * - **netuid**: The network identifier. - * - **revealed_hashes**: A vector of hashes representing each revealed weight set. - */ - "WeightsBatchRevealed": Anonymize; - /** - * A batch of weights (or commits) have been force-set. - * - * - **netuids**: The netuids these weights were successfully set/committed for. - * - **who**: The hotkey that set this batch. - */ - "BatchWeightsCompleted": Anonymize; - /** - * A batch extrinsic completed but with some errors. - */ - "BatchCompletedWithErrors": undefined; - /** - * A weight set among a batch of weights failed. - * - * - **error**: The dispatch error emitted by the failed item. - */ - "BatchWeightItemFailed": Anonymize; - /** - * Stake has been transferred from one coldkey to another on the same subnet. - * Parameters: - * (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount) - */ - "StakeTransferred": Anonymize; - /** - * Stake has been swapped from one subnet to another for the same coldkey-hotkey pair. - * - * Parameters: - * (coldkey, hotkey, origin_netuid, destination_netuid, amount) - */ - "StakeSwapped": Anonymize; - /** - * Event called when transfer is toggled on a subnet. - * - * Parameters: - * (netuid, bool) - */ - "TransferToggle": Anonymize; - /** - * The owner hotkey for a subnet has been set. - * - * Parameters: - * (netuid, new_hotkey) - */ - "SubnetOwnerHotkeySet": Anonymize; - /** - * FirstEmissionBlockNumber is set via start call extrinsic - * - * Parameters: - * netuid - * block number - */ - "FirstEmissionBlockNumberSet": Anonymize; - /** - * Alpha has been recycled, reducing AlphaOut on a subnet. - * - * Parameters: - * (coldkey, hotkey, amount, subnet_id) - */ - "AlphaRecycled": Anonymize; - /** - * Alpha have been burned without reducing AlphaOut. - * - * Parameters: - * (coldkey, hotkey, amount, subnet_id) - */ - "AlphaBurned": Anonymize; - /** - * An EVM key has been associated with a hotkey. - */ - "EvmKeyAssociated": Anonymize; - /** - * CRV3 Weights have been successfully revealed. - * - * - **netuid**: The network identifier. - * - **who**: The account ID of the user revealing the weights. - */ - "CRV3WeightsRevealed": Anonymize; - /** - * Commit-Reveal periods has been successfully set. - * - * - **netuid**: The network identifier. - * - **periods**: The number of epochs before the reveal. - */ - "CommitRevealPeriodsSet": Anonymize; - /** - * Commit-Reveal has been successfully toggled. - * - * - **netuid**: The network identifier. - * - **Enabled**: Is Commit-Reveal enabled. - */ - "CommitRevealEnabled": Anonymize; - /** - * the hotkey is swapped - */ - "HotkeySwappedOnSubnet": Anonymize; - /** - * A subnet lease has been created. - */ - "SubnetLeaseCreated": Anonymize; - /** - * A subnet lease has been terminated. - */ - "SubnetLeaseTerminated": Anonymize; - /** - * The symbol for a subnet has been updated. - */ - "SymbolUpdated": Anonymize; - /** - * Commit Reveal Weights version has been updated. - * - * - **version**: The required version. - */ - "CommitRevealVersionSet": number; - /** - * Timelocked weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - * - **reveal_round**: The round at which weights can be revealed. - */ - "TimelockedWeightsCommitted": Anonymize; - /** - * Timelocked Weights have been successfully revealed. - * - * - **netuid**: The network identifier. - * - **who**: The account ID of the user revealing the weights. - */ - "TimelockedWeightsRevealed": Anonymize; - /** - * Auto-staking hotkey received stake - */ - "AutoStakeAdded": Anonymize; - /** - * End-of-epoch miner incentive alpha by UID - */ - "IncentiveAlphaEmittedToMiners": Anonymize; - /** - * The minimum allowed UIDs for a subnet have been set. - */ - "MinAllowedUidsSet": Anonymize; - /** - * The auto stake destination has been set. - * - * - **coldkey**: The account ID of the coldkey. - * - **netuid**: The network identifier. - * - **hotkey**: The account ID of the hotkey. - */ - "AutoStakeDestinationSet": Anonymize; - /** - * The minimum allowed non-Immune UIDs has been set. - */ - "MinNonImmuneUidsSet": Anonymize; - /** - * Root emissions have been claimed for a coldkey on all subnets and hotkeys. - * Parameters: - * (coldkey) - */ - "RootClaimed": Anonymize; - /** - * Root claim type for a coldkey has been set. - * Parameters: - * (coldkey, u8) - */ - "RootClaimTypeSet": Anonymize; - /** - * Voting power tracking has been enabled for a subnet. - */ - "VotingPowerTrackingEnabled": Anonymize; - /** - * Voting power tracking has been scheduled for disabling. - * Tracking will continue until disable_at_block, then stop and clear entries. - */ - "VotingPowerTrackingDisableScheduled": Anonymize; - /** - * Voting power tracking has been fully disabled and entries cleared. - */ - "VotingPowerTrackingDisabled": Anonymize; - /** - * Voting power EMA alpha has been set for a subnet. - */ - "VotingPowerEmaAlphaSet": Anonymize; - /** - * Subnet lease dividends have been distributed. - */ - "SubnetLeaseDividendsDistributed": Anonymize; - /** - * "Add stake and burn" event: alpha token was purchased and burned. - */ - "AddStakeBurn": Anonymize; -}>; -export type I9jd27rnpm8ttv = FixedSizeArray<2, number>; -export type Io45lnue7n40k = [SS58String, SS58String, bigint, bigint, number, bigint]; -export type I83e4tgdv5ohg1 = [SS58String, SS58String, number, SS58String, number, bigint]; -export type I6o6dmud53u1fj = [number, number, SS58String]; -export type I4ojmnsk1dchql = [number, bigint]; -export type I5g2vv0ckl2m8b = [number, number]; -export type I39p6ln31i4n46 = [number, boolean]; -export type I7svnfko10tq2e = [number, SS58String]; -export type I7svrbkiu01iec = [SS58String, SS58String, number]; -export type I6ouflveob4eli = [SS58String, number]; -export type Ibq6c27da62s2q = ResultPayload>; -export type I95l2k9b1re95f = [SS58String, bigint]; -export type Ifkgc6cte1k96e = { - /** - * the account ID of coldkey - */ - "coldkey": SS58String; - /** - * the account ID of old hotkey - */ - "old_hotkey": SS58String; - /** - * the account ID of new hotkey - */ - "new_hotkey": SS58String; -}; -export type I6kvs2mb8unk0t = { - /** - * The account ID of the coldkey that made the announcement. - */ - "who": SS58String; - /** - * The hash of the new coldkey. - */ - "new_coldkey_hash": FixedSizeBinary<32>; -}; -export type Idbuci3sr3i1f7 = { - /** - * The account ID of old coldkey. - */ - "old_coldkey": SS58String; - /** - * The account ID of new coldkey. - */ - "new_coldkey": SS58String; -}; -export type I375tmdui1ejfc = { - /** - * The account ID of the coldkey that was disputed. - */ - "coldkey": SS58String; -}; -export type I73drt1hl9e70v = { - /** - * The account ID of the current coldkey - */ - "current_coldkey": SS58String; - /** - * The account ID of the new coldkey - */ - "new_coldkey": SS58String; - /** - * The total balance of the hotkey - */ - "total_balance": bigint; -}; -export type I1dm4sip108q0g = [SS58String, number, bigint, Anonymize]; -export type I5n8gpu725k1nu = Array<[bigint, SS58String]>; -export type Iajgphfb1fka7l = [SS58String, number, Anonymize]; -export type I4hnmf90qkrer9 = { - /** - * The account ID schedule the dissolve network extrinsic - */ - "account": SS58String; - /** - * network ID will be dissolved - */ - "netuid": number; - /** - * extrinsic execution block number - */ - "execution_block": number; -}; -export type Ijsohbv0raf36 = [SS58String, number, FixedSizeBinary<32>]; -export type I4ga01hppthoe1 = [SS58String, number, Anonymize]; -export type Ic5m5lp1oioo8r = Array>; -export type I4hckkcv10tcue = [Anonymize, SS58String]; -export type Icgljjb6j82uhn = Array; -export type If2ieedn10ujdv = [SS58String, SS58String, SS58String, number, number, bigint]; -export type Iaseh340tnovdh = [SS58String, SS58String, number, number, bigint]; -export type I8m5umt6snnmlj = [SS58String, SS58String, bigint, number]; -export type I5aeg4u9kpsp8o = { - /** - * The subnet that the hotkey belongs to. - */ - "netuid": number; - /** - * The hotkey associated with the EVM key. - */ - "hotkey": SS58String; - /** - * The EVM key being associated with the hotkey. - */ - "evm_key": FixedSizeBinary<20>; - /** - * The block where the association happened. - */ - "block_associated": bigint; -}; -export type I3fsv5f1boeqf3 = { - /** - * the account ID of coldkey - */ - "coldkey": SS58String; - /** - * the account ID of old hotkey - */ - "old_hotkey": SS58String; - /** - * the account ID of new hotkey - */ - "new_hotkey": SS58String; - /** - * the subnet ID - */ - "netuid": number; -}; -export type Ifoov68qt28nbm = { - /** - * The beneficiary of the lease. - */ - "beneficiary": SS58String; - /** - * The lease ID - */ - "lease_id": number; - /** - * The subnet ID - */ - "netuid": number; - /** - * The end block of the lease - */ - "end_block"?: Anonymize; -}; -export type I4arjljr6dpflb = (number) | undefined; -export type Ib937mhlbop6j7 = { - /** - * The beneficiary of the lease. - */ - "beneficiary": SS58String; - /** - * The subnet ID - */ - "netuid": number; -}; -export type I62rrikn5vj0p5 = { - /** - * The subnet ID - */ - "netuid": number; - /** - * The symbol that has been updated. - */ - "symbol": Binary; -}; -export type I838gqvljm75tj = [SS58String, number, FixedSizeBinary<32>, bigint]; -export type I1cu36qostj5d8 = { - /** - * Subnet identifier. - */ - "netuid": number; - /** - * Destination account that received the auto-staked funds. - */ - "destination": SS58String; - /** - * Hotkey account whose stake was auto-staked. - */ - "hotkey": SS58String; - /** - * Owner (coldkey) account associated with the hotkey. - */ - "owner": SS58String; - /** - * Amount of alpha auto-staked. - */ - "incentive": bigint; -}; -export type I4r2ptfsrl017r = { - /** - * Subnet identifier. - */ - "netuid": number; - /** - * UID-indexed array of miner incentive alpha; index equals UID. - */ - "emissions": Anonymize; -}; -export type Iafqnechp3omqg = Array; -export type Ielglukq9ekcit = { - /** - * The account ID of the coldkey. - */ - "coldkey": SS58String; - /** - * The network identifier. - */ - "netuid": number; - /** - * The account ID of the hotkey. - */ - "hotkey": SS58String; -}; -export type I1clsdhcok4nle = { - /** - * Claim coldkey - */ - "coldkey": SS58String; - /** - * Claim type - */ - "root_claim_type": Anonymize; -}; -export type Iapm6e7vtp0l6r = AnonymousEnum<{ - "Swap": undefined; - "Keep": undefined; - "KeepSubnets": Anonymize; -}>; -export type I2t4b7068rtebl = { - "subnets": Anonymize; -}; -export type I6cm4c5a1euio9 = { - /** - * The subnet ID - */ - "netuid": number; -}; -export type Iemddv6u2buvfn = { - /** - * The subnet ID - */ - "netuid": number; - /** - * Block at which tracking will be disabled - */ - "disable_at_block": bigint; -}; -export type I4guv8rii4s6je = { - /** - * The subnet ID - */ - "netuid": number; - /** - * The new alpha value (u64 with 18 decimal precision) - */ - "alpha": bigint; -}; -export type Ic149bnrif7lpr = { - /** - * The lease ID - */ - "lease_id": number; - /** - * The contributor - */ - "contributor": SS58String; - /** - * The amount of alpha distributed - */ - "alpha": bigint; -}; -export type I89dsvf7sdo4ko = { - /** - * The subnet ID - */ - "netuid": number; - /** - * hotky account ID - */ - "hotkey": SS58String; - /** - * Tao provided - */ - "amount": bigint; - /** - * Alpha burned - */ - "alpha": bigint; -}; -export type If1btu4npshog7 = AnonymousEnum<{ - /** - * Batch of dispatches did not complete fully. Index of first failing dispatch given, as - * well as the error. - */ - "BatchInterrupted": Anonymize; - /** - * Batch of dispatches completed fully with no error. - */ - "BatchCompleted": undefined; - /** - * Batch of dispatches completed but has errors. - */ - "BatchCompletedWithErrors": undefined; - /** - * A single item within a Batch of dispatches has completed with no error. - */ - "ItemCompleted": undefined; - /** - * A single item within a Batch of dispatches has completed with error. - */ - "ItemFailed": Anonymize; - /** - * A call was dispatched. - */ - "DispatchedAs": Anonymize; - /** - * Main call was dispatched. - */ - "IfElseMainSuccess": undefined; - /** - * The fallback call was dispatched. - */ - "IfElseFallbackCalled": Anonymize; -}>; -export type I804q3c12638a0 = { - "index": number; - "error": Anonymize; -}; -export type Idguve298jnare = { - "error": Anonymize; -}; -export type Idi3fb8585u2lp = { - "result": Anonymize; -}; -export type I1327b77famnt3 = { - "main_error": Anonymize; -}; -export type I8gl492p92bk6l = AnonymousEnum<{ - /** - * A sudo call just took place. - */ - "Sudid": Anonymize; - /** - * The sudo key has been updated. - */ - "KeyChanged": Anonymize; - /** - * The key was permanently removed. - */ - "KeyRemoved": undefined; - /** - * A [sudo_as](Pallet::sudo_as) call just took place. - */ - "SudoAsDone": Anonymize; -}>; -export type If58ibsptjm2at = { - /** - * The result of the call made by the sudo user. - */ - "sudo_result": Anonymize; -}; -export type I5rtkmhm2dng4u = { - /** - * The old sudo key (if one was previously set). - */ - "old"?: Anonymize; - /** - * The new sudo key (if one was set). - */ - "new": SS58String; -}; -export type Ihfphjolmsqq1 = (SS58String) | undefined; -export type Ibmokdg2doop8d = AnonymousEnum<{ - /** - * A new multisig operation has begun. - */ - "NewMultisig": Anonymize; - /** - * A multisig operation has been approved by someone. - */ - "MultisigApproval": Anonymize; - /** - * A multisig operation has been executed. - */ - "MultisigExecuted": Anonymize; - /** - * A multisig operation has been cancelled. - */ - "MultisigCancelled": Anonymize; - /** - * The deposit for a multisig operation has been updated/poked. - */ - "DepositPoked": Anonymize; -}>; -export type Iep27ialq4a7o7 = { - "approving": SS58String; - "multisig": SS58String; - "call_hash": FixedSizeBinary<32>; -}; -export type Iasu5jvoqr43mv = { - "approving": SS58String; - "timepoint": Anonymize; - "multisig": SS58String; - "call_hash": FixedSizeBinary<32>; -}; -export type Itvprrpb0nm3o = { - "height": number; - "index": number; -}; -export type I88p4dmln8611r = { - "approving": SS58String; - "timepoint": Anonymize; - "multisig": SS58String; - "call_hash": FixedSizeBinary<32>; - "result": Anonymize; -}; -export type I5qolde99acmd1 = { - "cancelling": SS58String; - "timepoint": Anonymize; - "multisig": SS58String; - "call_hash": FixedSizeBinary<32>; -}; -export type I8gtde5abn1g9a = { - "who": SS58String; - "call_hash": FixedSizeBinary<32>; - "old_deposit": bigint; - "new_deposit": bigint; -}; -export type PreimageEvent = Enum<{ - /** - * A preimage has been noted. - */ - "Noted": Anonymize; - /** - * A preimage has been requested. - */ - "Requested": Anonymize; - /** - * A preimage has ben cleared. - */ - "Cleared": Anonymize; -}>; -export declare const PreimageEvent: GetEnum; -export type I1jm8m1rh9e20v = { - "hash": FixedSizeBinary<32>; -}; -export type Iav5po3qov3sjo = AnonymousEnum<{ - /** - * Scheduled some task. - */ - "Scheduled": Anonymize; - /** - * Canceled some task. - */ - "Canceled": Anonymize; - /** - * Dispatched some task. - */ - "Dispatched": Anonymize; - /** - * Set a retry configuration for some task. - */ - "RetrySet": Anonymize; - /** - * Cancel a retry configuration for some task. - */ - "RetryCancelled": Anonymize; - /** - * The call for the provided hash was not found so the task has been aborted. - */ - "CallUnavailable": Anonymize; - /** - * The given task was unable to be renewed since the agenda is full at that block. - */ - "PeriodicFailed": Anonymize; - /** - * The given task was unable to be retried since the agenda is full at that block or there - * was not enough weight to reschedule it. - */ - "RetryFailed": Anonymize; - /** - * The given task can never be executed since it is overweight. - */ - "PermanentlyOverweight": Anonymize; - /** - * Agenda is incomplete from `when`. - */ - "AgendaIncomplete": Anonymize; -}>; -export type I5n4sebgkfr760 = { - "when": number; - "index": number; -}; -export type I3dvon8akhmsut = { - "task": Anonymize; - "id"?: Anonymize; - "result": Anonymize; -}; -export type I4s6vifaf8k998 = (FixedSizeBinary<32>) | undefined; -export type Ia3c82eadg79bj = { - "task": Anonymize; - "id"?: Anonymize; - "period": number; - "retries": number; -}; -export type Ienusoeb625ftq = { - "task": Anonymize; - "id"?: Anonymize; -}; -export type Ibtsa3docbr9el = { - "when": number; -}; -export type I65un9enf26o4o = AnonymousEnum<{ - /** - * A proxy was executed correctly, with the given. - */ - "ProxyExecuted": Anonymize; - /** - * A pure account has been created by new proxy with given - * disambiguation index and proxy type. - */ - "PureCreated": Anonymize; - /** - * A pure proxy was killed by its spawner. - */ - "PureKilled": Anonymize; - /** - * An announcement was placed to make a call in the future. - */ - "Announced": Anonymize; - /** - * A proxy was added. - */ - "ProxyAdded": Anonymize; - /** - * A proxy was removed. - */ - "ProxyRemoved": Anonymize; - /** - * A deposit stored for proxies or announcements was poked / updated. - */ - "DepositPoked": Anonymize; -}>; -export type Iek6442ldi23n3 = { - "pure": SS58String; - "who": SS58String; - "proxy_type": Anonymize; - "disambiguation_index": number; -}; -export type I8v1041j74kmaj = AnonymousEnum<{ - "Any": undefined; - "Owner": undefined; - "NonCritical": undefined; - "NonTransfer": undefined; - "Senate": undefined; - "NonFungible": undefined; - "Triumvirate": undefined; - "Governance": undefined; - "Staking": undefined; - "Registration": undefined; - "Transfer": undefined; - "SmallTransfer": undefined; - "RootWeights": undefined; - "ChildKeys": undefined; - "SudoUncheckedSetCode": undefined; - "SwapHotkey": undefined; - "SubnetLeaseBeneficiary": undefined; - "RootClaim": undefined; -}>; -export type Idpdo54rotesu2 = { - "pure": SS58String; - "spawner": SS58String; - "proxy_type": Anonymize; - "disambiguation_index": number; -}; -export type I2ur0oeqg495j8 = { - "real": SS58String; - "proxy": SS58String; - "call_hash": FixedSizeBinary<32>; -}; -export type Ibco2bqthggul0 = { - "delegator": SS58String; - "delegatee": SS58String; - "proxy_type": Anonymize; - "delay": number; -}; -export type I1bhd210c3phjj = { - "who": SS58String; - "kind": Enum<{ - "Proxies": undefined; - "Announcements": undefined; - }>; - "old_deposit": bigint; - "new_deposit": bigint; -}; -export type I626vh1cit09ni = AnonymousEnum<{ - /** - * Emitted when a user registers an identity - */ - "IdentitySet": Anonymize; - /** - * Emitted when a user dissolves an identity - */ - "IdentityDissolved": Anonymize; -}>; -export type I5ohlg8gv4pe9g = AnonymousEnum<{ - /** - * A commitment was set - */ - "Commitment": Anonymize; - /** - * A timelock-encrypted commitment was set - */ - "TimelockCommitment": Anonymize; - /** - * A timelock-encrypted commitment was auto-revealed - */ - "CommitmentRevealed": Anonymize; -}>; -export type Idcqgi2844k5he = { - /** - * The netuid of the commitment - */ - "netuid": number; - /** - * The account - */ - "who": SS58String; -}; -export type Iej2173ou338sm = { - /** - * The netuid of the commitment - */ - "netuid": number; - /** - * The account - */ - "who": SS58String; - /** - * The drand round to reveal - */ - "reveal_round": bigint; -}; -export type Ic1vmbif9o0nug = AnonymousEnum<{ - /** - * Event emitted when a precompile operation is updated. - */ - "PrecompileUpdated": Anonymize; - /** - * Event emitted when the Yuma3 enable is toggled. - */ - "Yuma3EnableToggled": Anonymize; - /** - * Event emitted when Bonds Reset is toggled. - */ - "BondsResetToggled": Anonymize; -}>; -export type I1sj8huj7of8mb = { - /** - * The type of precompile operation being updated. - */ - "precompile_id": Anonymize; - /** - * Indicates if the precompile operation is enabled or not. - */ - "enabled": boolean; -}; -export type I8un1ap2r4hhbj = AnonymousEnum<{ - "BalanceTransfer": undefined; - "Staking": undefined; - "Subnet": undefined; - "Metagraph": undefined; - "Neuron": undefined; - "UidLookup": undefined; - "Alpha": undefined; - "Crowdloan": undefined; - "Proxy": undefined; - "Leasing": undefined; - "AddressMapping": undefined; - "VotingPower": undefined; -}>; -export type Ie31ro5s5e089f = { - /** - * The network identifier. - */ - "netuid": number; - /** - * Indicates if the Yuma3 enable was enabled or disabled. - */ - "enabled": boolean; -}; -export type I3q8c83f5dvokp = AnonymousEnum<{ - /** - * The safe-mode was entered until inclusively this block. - */ - "Entered": Anonymize; - /** - * The safe-mode was extended until inclusively this block. - */ - "Extended": Anonymize; - /** - * Exited the safe-mode for a specific reason. - */ - "Exited": Anonymize; - /** - * An account reserved funds for either entering or extending the safe-mode. - */ - "DepositPlaced": Anonymize; - /** - * An account had a reserve released that was reserved. - */ - "DepositReleased": Anonymize; - /** - * An account had reserve slashed that was reserved. - */ - "DepositSlashed": Anonymize; - /** - * Could not hold funds for entering or extending the safe-mode. - * - * This error comes from the underlying `Currency`. - */ - "CannotDeposit": undefined; - /** - * Could not release funds for entering or extending the safe-mode. - * - * This error comes from the underlying `Currency`. - */ - "CannotRelease": undefined; -}>; -export type I20e9ph536u7ti = { - "until": number; -}; -export type I8kcpmsh450rp = { - "reason": Enum<{ - "Timeout": undefined; - "Force": undefined; - }>; -}; -export type I510u4q1qqh897 = AnonymousEnum<{ - /** - * An ethereum transaction was successfully executed. - */ - "Executed": Anonymize; -}>; -export type Iea4g5ovhnolus = { - "from": FixedSizeBinary<20>; - "to": FixedSizeBinary<20>; - "transaction_hash": FixedSizeBinary<32>; - "exit_reason": Anonymize; - "extra_data": Binary; -}; -export type Iag9iovb9j5ijo = AnonymousEnum<{ - "Succeed": Enum<{ - "Stopped": undefined; - "Returned": undefined; - "Suicided": undefined; - }>; - "Error": Anonymize; - "Revert": Enum<{ - "Reverted": undefined; - }>; - "Fatal": Enum<{ - "NotSupported": undefined; - "UnhandledInterrupt": undefined; - "CallErrorAsFatal": Anonymize; - "Other": string; - }>; -}>; -export type I5ksr7ru2gk4nh = AnonymousEnum<{ - "StackUnderflow": undefined; - "StackOverflow": undefined; - "InvalidJump": undefined; - "InvalidRange": undefined; - "DesignatedInvalid": undefined; - "CallTooDeep": undefined; - "CreateCollision": undefined; - "CreateContractLimit": undefined; - "InvalidCode": number; - "OutOfOffset": undefined; - "OutOfGas": undefined; - "OutOfFund": undefined; - "PCUnderflow": undefined; - "CreateEmpty": undefined; - "Other": string; - "MaxNonce": undefined; -}>; -export type I9k071kk4cn1u8 = AnonymousEnum<{ - /** - * Ethereum events from contracts. - */ - "Log": Anonymize; - /** - * A contract has been created at given address. - */ - "Created": Anonymize; - /** - * A contract was attempted to be created, but the execution failed. - */ - "CreatedFailed": Anonymize; - /** - * A contract has been executed successfully with states applied. - */ - "Executed": Anonymize; - /** - * A contract has been executed with errors. States are reverted with only gas fees applied. - */ - "ExecutedFailed": Anonymize; -}>; -export type Ifmc9boeeia623 = { - "log": Anonymize; -}; -export type I10qb03fpuk6em = { - "address": FixedSizeBinary<20>; - "topics": Anonymize; - "data": Binary; -}; -export type Itmchvgqfl28g = { - "address": FixedSizeBinary<20>; -}; -export type I3bmatomsds8j7 = AnonymousEnum<{ - "NewBaseFeePerGas": Anonymize; - "BaseFeeOverflow": undefined; - "NewElasticity": Anonymize; -}>; -export type I7vi74gbubc8u5 = { - "fee": Anonymize; -}; -export type I4totqt881mlti = FixedSizeArray<4, bigint>; -export type I3u0knmtb1ueq7 = { - "elasticity": number; -}; -export type Ibdlgbf9b95hbj = AnonymousEnum<{ - /** - * Beacon Configuration has changed. - */ - "BeaconConfigChanged": undefined; - /** - * Successfully set a new pulse(s). - */ - "NewPulse": Anonymize; - /** - * Oldest Stored Round has been set. - */ - "SetOldestStoredRound": bigint; -}>; -export type I5tf7b5o64mfpl = { - "rounds": Anonymize; -}; -export type Ifj1h07t3i0np9 = AnonymousEnum<{ - /** - * A crowdloan was created. - */ - "Created": Anonymize; - /** - * A contribution was made to an active crowdloan. - */ - "Contributed": Anonymize; - /** - * A contribution was withdrawn from a failed crowdloan. - */ - "Withdrew": Anonymize; - /** - * A refund was partially processed for a failed crowdloan. - */ - "PartiallyRefunded": Anonymize; - /** - * A refund was fully processed for a failed crowdloan. - */ - "AllRefunded": Anonymize; - /** - * A crowdloan was finalized, funds were transferred and the call was dispatched. - */ - "Finalized": Anonymize; - /** - * A crowdloan was dissolved. - */ - "Dissolved": Anonymize; - /** - * The minimum contribution was updated. - */ - "MinContributionUpdated": Anonymize; - /** - * The end was updated. - */ - "EndUpdated": Anonymize; - /** - * The cap was updated. - */ - "CapUpdated": Anonymize; -}>; -export type If71d2q730qf6n = { - "crowdloan_id": number; - "creator": SS58String; - "end": number; - "cap": bigint; -}; -export type If0sk51c1n7ri8 = { - "crowdloan_id": number; - "contributor": SS58String; - "amount": bigint; -}; -export type I5dueehi6i2dg9 = { - "crowdloan_id": number; -}; -export type I64ev05f6q10es = { - "crowdloan_id": number; - "new_min_contribution": bigint; -}; -export type Ikc5h15joooak = { - "crowdloan_id": number; - "new_end": number; -}; -export type Ie8f436ua5fs59 = { - "crowdloan_id": number; - "new_cap": bigint; -}; -export type I6qodidnq3s4e1 = AnonymousEnum<{ - /** - * Event emitted when the fee rate has been updated for a subnet - */ - "FeeRateSet": Anonymize; - /** - * Event emitted when user liquidity operations are enabled for a subnet. - * First enable even indicates a switch from V2 to V3 swap. - */ - "UserLiquidityToggled": Anonymize; - /** - * Event emitted when a liquidity position is added to a subnet's liquidity pool. - */ - "LiquidityAdded": Anonymize; - /** - * Event emitted when a liquidity position is removed from a subnet's liquidity pool. - */ - "LiquidityRemoved": Anonymize; - /** - * Event emitted when a liquidity position is modified in a subnet's liquidity pool. - * Modifying causes the fees to be claimed. - */ - "LiquidityModified": Anonymize; -}>; -export type I3mkis681qg30e = { - "netuid": number; - "rate": number; -}; -export type I2foqo7cbqf35v = { - "netuid": number; - "enable": boolean; -}; -export type I4b2eh3b1oi815 = { - /** - * The coldkey account that owns the position - */ - "coldkey": SS58String; - /** - * The hotkey account where Alpha comes from - */ - "hotkey": SS58String; - /** - * The subnet identifier - */ - "netuid": number; - /** - * Unique identifier for the liquidity position - */ - "position_id": bigint; - /** - * The amount of liquidity added to the position - */ - "liquidity": bigint; - /** - * The amount of TAO tokens committed to the position - */ - "tao": bigint; - /** - * The amount of Alpha tokens committed to the position - */ - "alpha": bigint; - /** - * the lower tick - */ - "tick_low": number; - /** - * the upper tick - */ - "tick_high": number; -}; -export type I57q620f4fu1bl = { - /** - * The coldkey account that owns the position - */ - "coldkey": SS58String; - /** - * The hotkey account where Alpha goes to - */ - "hotkey": SS58String; - /** - * The subnet identifier - */ - "netuid": number; - /** - * Unique identifier for the liquidity position - */ - "position_id": bigint; - /** - * The amount of liquidity removed from the position - */ - "liquidity": bigint; - /** - * The amount of TAO tokens returned to the user - */ - "tao": bigint; - /** - * The amount of Alpha tokens returned to the user - */ - "alpha": bigint; - /** - * The amount of TAO fees earned from the position - */ - "fee_tao": bigint; - /** - * The amount of Alpha fees earned from the position - */ - "fee_alpha": bigint; - /** - * the lower tick - */ - "tick_low": number; - /** - * the upper tick - */ - "tick_high": number; -}; -export type I211sbjvh5hjqu = AnonymousEnum<{ - /** - * Contract deployed by address at the specified address. - */ - "Instantiated": Anonymize; - /** - * Contract has been removed. - * - * # Note - * - * The only way for a contract to be removed and emitting this event is by calling - * `seal_terminate`. - */ - "Terminated": Anonymize; - /** - * Code with the specified hash has been stored. - */ - "CodeStored": Anonymize; - /** - * A custom event emitted by the contract. - */ - "ContractEmitted": Anonymize; - /** - * A code with the specified hash was removed. - */ - "CodeRemoved": Anonymize; - /** - * A contract's code was updated. - */ - "ContractCodeUpdated": Anonymize; - /** - * A contract was called either by a plain account or another contract. - * - * # Note - * - * Please keep in mind that like all events this is only emitted for successful - * calls. This is because on failure all storage changes including events are - * rolled back. - */ - "Called": Anonymize; - /** - * A contract delegate called a code hash. - * - * # Note - * - * Please keep in mind that like all events this is only emitted for successful - * calls. This is because on failure all storage changes including events are - * rolled back. - */ - "DelegateCalled": Anonymize; - /** - * Some funds have been transferred and held as storage deposit. - */ - "StorageDepositTransferredAndHeld": Anonymize; - /** - * Some storage deposit funds have been transferred and released. - */ - "StorageDepositTransferredAndReleased": Anonymize; -}>; -export type Ie5222qfrr24ek = { - "deployer": SS58String; - "contract": SS58String; -}; -export type I28g8sphdu312k = { - /** - * The contract that was terminated. - */ - "contract": SS58String; - /** - * The account that received the contracts remaining balance - */ - "beneficiary": SS58String; -}; -export type Idqbjt2c6r46t6 = { - "code_hash": FixedSizeBinary<32>; - "deposit_held": bigint; - "uploader": SS58String; -}; -export type I853aigjva3f0t = { - /** - * The contract that emitted the event. - */ - "contract": SS58String; - /** - * Data supplied by the contract. Metadata generated during contract compilation - * is needed to decode it. - */ - "data": Binary; -}; -export type I9uehhems5hkqm = { - "code_hash": FixedSizeBinary<32>; - "deposit_released": bigint; - "remover": SS58String; -}; -export type I7q5qk4uoanhof = { - /** - * The contract that has been updated. - */ - "contract": SS58String; - /** - * New code hash that was set for the contract. - */ - "new_code_hash": FixedSizeBinary<32>; - /** - * Previous code hash of the contract. - */ - "old_code_hash": FixedSizeBinary<32>; -}; -export type Iehpbs40l3jkit = { - /** - * The caller of the `contract`. - */ - "caller": Enum<{ - "Root": undefined; - "Signed": SS58String; - }>; - /** - * The contract that was called. - */ - "contract": SS58String; -}; -export type Idht9upmipvd4j = { - /** - * The contract that performed the delegate call and hence in whose context - * the `code_hash` is executed. - */ - "contract": SS58String; - /** - * The code hash that was delegate called. - */ - "code_hash": FixedSizeBinary<32>; -}; -export type I70thgcbmbqm91 = AnonymousEnum<{ - /** - * Encrypted wrapper accepted. - */ - "EncryptedSubmitted": Anonymize; - /** - * Decrypted call executed. - */ - "DecryptedExecuted": Anonymize; - /** - * Decrypted execution rejected. - */ - "DecryptedRejected": Anonymize; - /** - * Decryption failed - validator could not decrypt the submission. - */ - "DecryptionFailed": Anonymize; -}>; -export type Icns2sqr5hp8s3 = { - "id": FixedSizeBinary<32>; - "who": SS58String; -}; -export type I9n4hs8p3rlkag = { - "id": FixedSizeBinary<32>; - "signer": SS58String; -}; -export type I6a8j73186lfdf = { - "id": FixedSizeBinary<32>; - "reason": { - "post_info": { - "actual_weight"?: Anonymize; - "pays_fee": Anonymize; - }; - "error": Anonymize; - }; -}; -export type Iasb8k6ash5mjn = (Anonymize) | undefined; -export type I602p6mm30elei = { - "id": FixedSizeBinary<32>; - "reason": Binary; -}; -export type I95g6i7ilua7lq = Array>; -export type Ieniouoqkq4icf = { - "spec_version": number; - "spec_name": string; -}; -export type GrandpaStoredState = Enum<{ - "Live": undefined; - "PendingPause": { - "scheduled_at": number; - "delay": number; - }; - "Paused": undefined; - "PendingResume": { - "scheduled_at": number; - "delay": number; - }; -}>; -export declare const GrandpaStoredState: GetEnum; -export type I7pe2me3i3vtn9 = { - "scheduled_at": number; - "delay": number; - "next_authorities": Anonymize; - "forced"?: Anonymize; -}; -export type I8ds64oj6581v0 = Array<{ - "id": FixedSizeBinary<8>; - "amount": bigint; - "reasons": BalancesTypesReasons; -}>; -export type BalancesTypesReasons = Enum<{ - "Fee": undefined; - "Misc": undefined; - "All": undefined; -}>; -export declare const BalancesTypesReasons: GetEnum; -export type Ia7pdug7cdsg8g = Array<{ - "id": FixedSizeBinary<8>; - "amount": bigint; -}>; -export type I2hnk9r4ukuj1p = Array<{ - "id": Enum<{ - "Preimage": PreimagePalletHoldReason; - "Registry": Enum<{ - "RegistryIdentity": undefined; - }>; - "SafeMode": Enum<{ - "EnterOrExtend": undefined; - }>; - "Contracts": Enum<{ - "CodeUploadDepositReserve": undefined; - "StorageDepositReserve": undefined; - }>; - }>; - "amount": bigint; -}>; -export type PreimagePalletHoldReason = Enum<{ - "Preimage": undefined; -}>; -export declare const PreimagePalletHoldReason: GetEnum; -export type I9bin2jc70qt6q = Array>; -export type TransactionPaymentReleases = Enum<{ - "V1Ancient": undefined; - "V2": undefined; -}>; -export declare const TransactionPaymentReleases: GetEnum; -export type Idoeu5t0dum8va = [Anonymize, bigint]; -export type Ia2lhg7l2hilo3 = Array; -export type I4p5t2krb1gmvp = [number, FixedSizeBinary<32>]; -export type Iabpgqcjikia83 = (Binary) | undefined; -export type I2j729bmgsdiuo = [bigint, bigint]; -export type Iakavvne152v30 = AnonymousEnum<{ - "SetSNOwnerHotkey": number; - "OwnerHyperparamUpdate": [number, Enum<{ - "Unknown": undefined; - "ServingRateLimit": undefined; - "MaxDifficulty": undefined; - "AdjustmentAlpha": undefined; - "MaxWeightLimit": undefined; - "ImmunityPeriod": undefined; - "MinAllowedWeights": undefined; - "Kappa": undefined; - "Rho": undefined; - "ActivityCutoff": undefined; - "PowRegistrationAllowed": undefined; - "MinBurn": undefined; - "MaxBurn": undefined; - "BondsMovingAverage": undefined; - "BondsPenalty": undefined; - "CommitRevealEnabled": undefined; - "LiquidAlphaEnabled": undefined; - "AlphaValues": undefined; - "WeightCommitInterval": undefined; - "TransferEnabled": undefined; - "AlphaSigmoidSteepness": undefined; - "Yuma3Enabled": undefined; - "BondsResetEnabled": undefined; - "ImmuneNeuronLimit": undefined; - "RecycleOrBurn": undefined; - "MaxAllowedUids": undefined; - }>]; - "NetworkLastRegistered": undefined; - "LastTxBlock": SS58String; - "LastTxBlockChildKeyTake": SS58String; - "LastTxBlockDelegateTake": SS58String; - "AddStakeBurn": number; -}>; -export type Ib9tptuv3cggfs = AnonymousEnum<{ - "Burn": undefined; - "Recycle": undefined; -}>; -export type I4h6ivgjtd51lv = Array<[SS58String, bigint, bigint]>; -export type I9eir063evtfb6 = Array; -export type Ibc83gdj8hi3rc = { - "block": bigint; - "version": number; - "ip": bigint; - "port": number; - "ip_type": number; - "protocol": number; - "placeholder1": number; - "placeholder2": number; -}; -export type I9lpjucl20l82d = { - "public_key": Binary; - "algorithm": number; -}; -export type Iaap7oohdmr1sb = { - "block": bigint; - "version": number; - "ip": bigint; - "port": number; - "ip_type": number; -}; -export type Ifjlj958aeheic = { - "name": Binary; - "url": Binary; - "github_repo": Binary; - "image": Binary; - "discord": Binary; - "description": Binary; - "additional": Binary; -}; -export type I4tc54pa558g5n = { - "subnet_name": Binary; - "github_repo": Binary; - "subnet_contact": Binary; - "subnet_url": Binary; - "discord": Binary; - "description": Binary; - "logo_url": Binary; - "additional": Binary; -}; -export type Id32h28hjj1tch = [SS58String, number, number]; -export type Icrrf4uohj5gb0 = Array<[FixedSizeBinary<32>, bigint, bigint, bigint]>; -export type I76jd8kl1mtn5g = Array<[SS58String, bigint, Binary, bigint]>; -export type I4jqk5si14p5oi = Array<[SS58String, Binary, bigint]>; -export type I2na29tt2afp0j = FixedSizeArray<2, SS58String>; -export type If9jidduiuq7vv = Array>; -export type I2brm5b9jij1st = [number, SS58String, SS58String]; -export type I7tof95tckt2r = [FixedSizeBinary<20>, bigint]; -export type Ieruonr5pk2d7h = { - "beneficiary": SS58String; - "coldkey": SS58String; - "hotkey": SS58String; - "emissions_share": number; - "end_block"?: Anonymize; - "netuid": number; - "cost": bigint; -}; -export type Iag146hmjgqfgj = { - "when": Anonymize; - "deposit": bigint; - "depositor": SS58String; - "approvals": Anonymize; -}; -export type I8uo3fpd3bcc6f = [SS58String, FixedSizeBinary<32>]; -export type PreimageOldRequestStatus = Enum<{ - "Unrequested": { - "deposit": Anonymize; - "len": number; - }; - "Requested": { - "deposit"?: Anonymize; - "count": number; - "len"?: Anonymize; - }; -}>; -export declare const PreimageOldRequestStatus: GetEnum; -export type I92hdo1clkbp4g = (Anonymize) | undefined; -export type PreimageRequestStatus = Enum<{ - "Unrequested": { - "ticket": Anonymize; - "len": number; - }; - "Requested": { - "maybe_ticket"?: Anonymize; - "count": number; - "maybe_len"?: Anonymize; - }; -}>; -export declare const PreimageRequestStatus: GetEnum; -export type I4pact7n2e9a0i = [FixedSizeBinary<32>, number]; -export type I11tetbe8ces3o = Array<({ - "maybe_id"?: Anonymize; - "priority": number; - "call": PreimagesBounded; - "maybe_periodic"?: Anonymize; - "origin": Anonymize; -}) | undefined>; -export type PreimagesBounded = Enum<{ - "Legacy": Anonymize; - "Inline": Binary; - "Lookup": { - "hash": FixedSizeBinary<32>; - "len": number; - }; -}>; -export declare const PreimagesBounded: GetEnum; -export type Iep7au1720bm0e = (Anonymize) | undefined; -export type I32es0rp64745v = AnonymousEnum<{ - "system": Enum<{ - "Root": undefined; - "Signed": SS58String; - "None": undefined; - "Authorized": undefined; - }>; - "Ethereum": Enum<{ - "EthereumTransaction": FixedSizeBinary<20>; - }>; -}>; -export type I56u24ncejr5kt = { - "total_retries": number; - "remaining": number; - "period": number; -}; -export type I6tqrno2gaos08 = [Array<{ - "delegate": SS58String; - "proxy_type": Anonymize; - "delay": number; -}>, bigint]; -export type I9p9lq3rej5bhc = [Array<{ - "real": SS58String; - "call_hash": FixedSizeBinary<32>; - "height": number; -}>, bigint]; -export type Ib6u9l1gtc5l4t = { - "deposit": bigint; - "info": Anonymize; -}; -export type Ifiu33afi2n7qs = { - "additional": Array>>; - "display": Anonymize; - "legal": Anonymize; - "web": Anonymize; - "riot": Anonymize; - "email": Anonymize; - "pgp_fingerprint"?: Anonymize; - "image": Anonymize; - "twitter": Anonymize; -}; -export type I2fomq92gvvqhc = AnonymousEnum<{ - "None": undefined; - "Raw0": undefined; - "Raw1": number; - "Raw2": FixedSizeBinary<2>; - "Raw3": FixedSizeBinary<3>; - "Raw4": FixedSizeBinary<4>; - "Raw5": FixedSizeBinary<5>; - "Raw6": FixedSizeBinary<6>; - "Raw7": FixedSizeBinary<7>; - "Raw8": FixedSizeBinary<8>; - "Raw9": FixedSizeBinary<9>; - "Raw10": FixedSizeBinary<10>; - "Raw11": FixedSizeBinary<11>; - "Raw12": FixedSizeBinary<12>; - "Raw13": FixedSizeBinary<13>; - "Raw14": FixedSizeBinary<14>; - "Raw15": FixedSizeBinary<15>; - "Raw16": FixedSizeBinary<16>; - "Raw17": FixedSizeBinary<17>; - "Raw18": FixedSizeBinary<18>; - "Raw19": FixedSizeBinary<19>; - "Raw20": FixedSizeBinary<20>; - "Raw21": FixedSizeBinary<21>; - "Raw22": FixedSizeBinary<22>; - "Raw23": FixedSizeBinary<23>; - "Raw24": FixedSizeBinary<24>; - "Raw25": FixedSizeBinary<25>; - "Raw26": FixedSizeBinary<26>; - "Raw27": FixedSizeBinary<27>; - "Raw28": FixedSizeBinary<28>; - "Raw29": FixedSizeBinary<29>; - "Raw30": FixedSizeBinary<30>; - "Raw31": FixedSizeBinary<31>; - "Raw32": FixedSizeBinary<32>; - "Raw33": FixedSizeBinary<33>; - "Raw34": FixedSizeBinary<34>; - "Raw35": FixedSizeBinary<35>; - "Raw36": FixedSizeBinary<36>; - "Raw37": FixedSizeBinary<37>; - "Raw38": FixedSizeBinary<38>; - "Raw39": FixedSizeBinary<39>; - "Raw40": FixedSizeBinary<40>; - "Raw41": FixedSizeBinary<41>; - "Raw42": FixedSizeBinary<42>; - "Raw43": FixedSizeBinary<43>; - "Raw44": FixedSizeBinary<44>; - "Raw45": FixedSizeBinary<45>; - "Raw46": FixedSizeBinary<46>; - "Raw47": FixedSizeBinary<47>; - "Raw48": FixedSizeBinary<48>; - "Raw49": FixedSizeBinary<49>; - "Raw50": FixedSizeBinary<50>; - "Raw51": FixedSizeBinary<51>; - "Raw52": FixedSizeBinary<52>; - "Raw53": FixedSizeBinary<53>; - "Raw54": FixedSizeBinary<54>; - "Raw55": FixedSizeBinary<55>; - "Raw56": FixedSizeBinary<56>; - "Raw57": FixedSizeBinary<57>; - "Raw58": FixedSizeBinary<58>; - "Raw59": FixedSizeBinary<59>; - "Raw60": FixedSizeBinary<60>; - "Raw61": FixedSizeBinary<61>; - "Raw62": FixedSizeBinary<62>; - "Raw63": FixedSizeBinary<63>; - "Raw64": FixedSizeBinary<64>; - "BlakeTwo256": FixedSizeBinary<32>; - "Sha256": FixedSizeBinary<32>; - "Keccak256": FixedSizeBinary<32>; - "ShaThree256": FixedSizeBinary<32>; -}>; -export type If7b8240vgt2q5 = (FixedSizeBinary<20>) | undefined; -export type I7nkl7ntqohel8 = Array>; -export type I3m6d7ohcp5n4v = { - "deposit": bigint; - "block": number; - "info": Anonymize; -}; -export type I4122t6tpcniur = Array; - "Raw3": FixedSizeBinary<3>; - "Raw4": FixedSizeBinary<4>; - "Raw5": FixedSizeBinary<5>; - "Raw6": FixedSizeBinary<6>; - "Raw7": FixedSizeBinary<7>; - "Raw8": FixedSizeBinary<8>; - "Raw9": FixedSizeBinary<9>; - "Raw10": FixedSizeBinary<10>; - "Raw11": FixedSizeBinary<11>; - "Raw12": FixedSizeBinary<12>; - "Raw13": FixedSizeBinary<13>; - "Raw14": FixedSizeBinary<14>; - "Raw15": FixedSizeBinary<15>; - "Raw16": FixedSizeBinary<16>; - "Raw17": FixedSizeBinary<17>; - "Raw18": FixedSizeBinary<18>; - "Raw19": FixedSizeBinary<19>; - "Raw20": FixedSizeBinary<20>; - "Raw21": FixedSizeBinary<21>; - "Raw22": FixedSizeBinary<22>; - "Raw23": FixedSizeBinary<23>; - "Raw24": FixedSizeBinary<24>; - "Raw25": FixedSizeBinary<25>; - "Raw26": FixedSizeBinary<26>; - "Raw27": FixedSizeBinary<27>; - "Raw28": FixedSizeBinary<28>; - "Raw29": FixedSizeBinary<29>; - "Raw30": FixedSizeBinary<30>; - "Raw31": FixedSizeBinary<31>; - "Raw32": FixedSizeBinary<32>; - "Raw33": FixedSizeBinary<33>; - "Raw34": FixedSizeBinary<34>; - "Raw35": FixedSizeBinary<35>; - "Raw36": FixedSizeBinary<36>; - "Raw37": FixedSizeBinary<37>; - "Raw38": FixedSizeBinary<38>; - "Raw39": FixedSizeBinary<39>; - "Raw40": FixedSizeBinary<40>; - "Raw41": FixedSizeBinary<41>; - "Raw42": FixedSizeBinary<42>; - "Raw43": FixedSizeBinary<43>; - "Raw44": FixedSizeBinary<44>; - "Raw45": FixedSizeBinary<45>; - "Raw46": FixedSizeBinary<46>; - "Raw47": FixedSizeBinary<47>; - "Raw48": FixedSizeBinary<48>; - "Raw49": FixedSizeBinary<49>; - "Raw50": FixedSizeBinary<50>; - "Raw51": FixedSizeBinary<51>; - "Raw52": FixedSizeBinary<52>; - "Raw53": FixedSizeBinary<53>; - "Raw54": FixedSizeBinary<54>; - "Raw55": FixedSizeBinary<55>; - "Raw56": FixedSizeBinary<56>; - "Raw57": FixedSizeBinary<57>; - "Raw58": FixedSizeBinary<58>; - "Raw59": FixedSizeBinary<59>; - "Raw60": FixedSizeBinary<60>; - "Raw61": FixedSizeBinary<61>; - "Raw62": FixedSizeBinary<62>; - "Raw63": FixedSizeBinary<63>; - "Raw64": FixedSizeBinary<64>; - "Raw65": FixedSizeBinary<65>; - "Raw66": FixedSizeBinary<66>; - "Raw67": FixedSizeBinary<67>; - "Raw68": FixedSizeBinary<68>; - "Raw69": FixedSizeBinary<69>; - "Raw70": FixedSizeBinary<70>; - "Raw71": FixedSizeBinary<71>; - "Raw72": FixedSizeBinary<72>; - "Raw73": FixedSizeBinary<73>; - "Raw74": FixedSizeBinary<74>; - "Raw75": FixedSizeBinary<75>; - "Raw76": FixedSizeBinary<76>; - "Raw77": FixedSizeBinary<77>; - "Raw78": FixedSizeBinary<78>; - "Raw79": FixedSizeBinary<79>; - "Raw80": FixedSizeBinary<80>; - "Raw81": FixedSizeBinary<81>; - "Raw82": FixedSizeBinary<82>; - "Raw83": FixedSizeBinary<83>; - "Raw84": FixedSizeBinary<84>; - "Raw85": FixedSizeBinary<85>; - "Raw86": FixedSizeBinary<86>; - "Raw87": FixedSizeBinary<87>; - "Raw88": FixedSizeBinary<88>; - "Raw89": FixedSizeBinary<89>; - "Raw90": FixedSizeBinary<90>; - "Raw91": FixedSizeBinary<91>; - "Raw92": FixedSizeBinary<92>; - "Raw93": FixedSizeBinary<93>; - "Raw94": FixedSizeBinary<94>; - "Raw95": FixedSizeBinary<95>; - "Raw96": FixedSizeBinary<96>; - "Raw97": FixedSizeBinary<97>; - "Raw98": FixedSizeBinary<98>; - "Raw99": FixedSizeBinary<99>; - "Raw100": FixedSizeBinary<100>; - "Raw101": FixedSizeBinary<101>; - "Raw102": FixedSizeBinary<102>; - "Raw103": FixedSizeBinary<103>; - "Raw104": FixedSizeBinary<104>; - "Raw105": FixedSizeBinary<105>; - "Raw106": FixedSizeBinary<106>; - "Raw107": FixedSizeBinary<107>; - "Raw108": FixedSizeBinary<108>; - "Raw109": FixedSizeBinary<109>; - "Raw110": FixedSizeBinary<110>; - "Raw111": FixedSizeBinary<111>; - "Raw112": FixedSizeBinary<112>; - "Raw113": FixedSizeBinary<113>; - "Raw114": FixedSizeBinary<114>; - "Raw115": FixedSizeBinary<115>; - "Raw116": FixedSizeBinary<116>; - "Raw117": FixedSizeBinary<117>; - "Raw118": FixedSizeBinary<118>; - "Raw119": FixedSizeBinary<119>; - "Raw120": FixedSizeBinary<120>; - "Raw121": FixedSizeBinary<121>; - "Raw122": FixedSizeBinary<122>; - "Raw123": FixedSizeBinary<123>; - "Raw124": FixedSizeBinary<124>; - "Raw125": FixedSizeBinary<125>; - "Raw126": FixedSizeBinary<126>; - "Raw127": FixedSizeBinary<127>; - "Raw128": FixedSizeBinary<128>; - "BlakeTwo256": FixedSizeBinary<32>; - "Sha256": FixedSizeBinary<32>; - "Keccak256": FixedSizeBinary<32>; - "ShaThree256": FixedSizeBinary<32>; - "TimelockEncrypted": { - "encrypted": Binary; - "reveal_round": bigint; - }; - "ResetBondsFlag": undefined; - "BigRaw": Binary; -}>>; -export type Ib9pv5dg6upo6t = Array<[Binary, bigint]>; -export type I27ub49plcvb4c = { - "last_epoch": bigint; - "used_space": bigint; -}; -export type Ic3l568el19b24 = [Anonymize, Anonymize, Anonymize]; -export type Ibjuap2vk03rp6 = AnonymousEnum<{ - "Legacy": { - "nonce": Anonymize; - "gas_price": Anonymize; - "gas_limit": Anonymize; - "action": Anonymize; - "value": Anonymize; - "input": Binary; - "signature": { - "v": bigint; - "r": FixedSizeBinary<32>; - "s": FixedSizeBinary<32>; - }; - }; - "EIP2930": { - "chain_id": bigint; - "nonce": Anonymize; - "gas_price": Anonymize; - "gas_limit": Anonymize; - "action": Anonymize; - "value": Anonymize; - "input": Binary; - "access_list": Anonymize; - "signature": Anonymize; - }; - "EIP1559": { - "chain_id": bigint; - "nonce": Anonymize; - "max_priority_fee_per_gas": Anonymize; - "max_fee_per_gas": Anonymize; - "gas_limit": Anonymize; - "action": Anonymize; - "value": Anonymize; - "input": Binary; - "access_list": Anonymize; - "signature": Anonymize; - }; - "EIP7702": { - "chain_id": bigint; - "nonce": Anonymize; - "max_priority_fee_per_gas": Anonymize; - "max_fee_per_gas": Anonymize; - "gas_limit": Anonymize; - "destination": Anonymize; - "value": Anonymize; - "data": Binary; - "access_list": Anonymize; - "authorization_list": Anonymize; - "signature": Anonymize; - }; -}>; -export type I2do93a3gr3ege = AnonymousEnum<{ - "Call": FixedSizeBinary<20>; - "Create": undefined; -}>; -export type Ieap15h2pjii9u = Array<{ - "address": FixedSizeBinary<20>; - "storage_keys": Anonymize; -}>; -export type I9veufneid0sta = { - "odd_y_parity": boolean; - "r": FixedSizeBinary<32>; - "s": FixedSizeBinary<32>; -}; -export type Idg0qi60379vnh = Array<{ - "chain_id": bigint; - "address": FixedSizeBinary<20>; - "nonce": Anonymize; - "signature": Anonymize; -}>; -export type Ifoernv5r40rfc = { - "transaction_hash": FixedSizeBinary<32>; - "transaction_index": number; - "from": FixedSizeBinary<20>; - "to"?: Anonymize; - "contract_address"?: Anonymize; - "logs": Anonymize; - "logs_bloom": FixedSizeBinary<256>; -}; -export type Ids7ng2qsv7snu = Array>; -export type Ideko6oeomboa6 = AnonymousEnum<{ - "Legacy": { - "status_code": number; - "used_gas": Anonymize; - "logs_bloom": FixedSizeBinary<256>; - "logs": Anonymize; - }; - "EIP2930": { - "status_code": number; - "used_gas": Anonymize; - "logs_bloom": FixedSizeBinary<256>; - "logs": Anonymize; - }; - "EIP1559": { - "status_code": number; - "used_gas": Anonymize; - "logs_bloom": FixedSizeBinary<256>; - "logs": Anonymize; - }; - "EIP7702": { - "status_code": number; - "used_gas": Anonymize; - "logs_bloom": FixedSizeBinary<256>; - "logs": Anonymize; - }; -}>; -export type Ib0hfhkohlekcj = { - "header": Anonymize; - "transactions": Anonymize; - "ommers": Array>; -}; -export type I4v962mnhj6j6r = { - "parent_hash": FixedSizeBinary<32>; - "ommers_hash": FixedSizeBinary<32>; - "beneficiary": FixedSizeBinary<20>; - "state_root": FixedSizeBinary<32>; - "transactions_root": FixedSizeBinary<32>; - "receipts_root": FixedSizeBinary<32>; - "logs_bloom": FixedSizeBinary<256>; - "difficulty": Anonymize; - "number": Anonymize; - "gas_limit": Anonymize; - "gas_used": Anonymize; - "timestamp": bigint; - "extra_data": Binary; - "mix_hash": FixedSizeBinary<32>; - "nonce": FixedSizeBinary<8>; -}; -export type Ie30stbbeaul1o = Array>; -export type I32lgu058i52q9 = Array>; -export type Ie7atdsih6q14b = Array>; -export type I7jidl7qnnq87c = { - "size": bigint; - "hash": FixedSizeBinary<32>; -}; -export type I82cps8ng2jtug = [FixedSizeBinary<20>, FixedSizeBinary<32>]; -export type I4gqmlq9k6jlk3 = Array>; -export type I494mq1ertfc9k = { - "public_key": Binary; - "period": number; - "genesis_time": number; - "hash": Binary; - "group_hash": Binary; - "scheme_id": Binary; - "metadata": Binary; -}; -export type Ialchst9lgd11u = { - "round": bigint; - "randomness": Binary; - "signature": Binary; -}; -export type If0p9hvn3kegj1 = { - "creator": SS58String; - "deposit": bigint; - "min_contribution": bigint; - "end": number; - "cap": bigint; - "funds_account": SS58String; - "raised": bigint; - "target_address"?: Anonymize; - "call"?: (PreimagesBounded) | undefined; - "finalized": boolean; - "contributors_count": number; -}; -export type I8ac0r18acljm6 = { - "liquidity_net": bigint; - "liquidity_gross": bigint; - "fees_out_tao": bigint; - "fees_out_alpha": bigint; -}; -export type I5mi4kb05lrsa9 = { - "id": bigint; - "netuid": number; - "tick_low": number; - "tick_high": number; - "liquidity": bigint; - "fees_tao": bigint; - "fees_alpha": bigint; -}; -export type Icsknfl0f6r973 = [number, SS58String, bigint]; -export type I1ptic1rnhda0n = [number, Enum<{ - "Top": undefined; - "Middle": undefined; - "Bottom": undefined; -}>, number]; -export type I5kulbesqc1h1t = { - "owner": SS58String; - "deposit": bigint; - "refcount": bigint; - "determinism": Anonymize; - "code_len": number; -}; -export type I2dfliekq1ed7e = AnonymousEnum<{ - "Enforced": undefined; - "Relaxed": undefined; -}>; -export type I36dvimehsh2tm = { - "trie_id": Binary; - "code_hash": FixedSizeBinary<32>; - "storage_bytes": number; - "storage_items": number; - "storage_byte_deposit": bigint; - "storage_item_deposit": bigint; - "storage_base_deposit": bigint; - "delegate_dependencies": Anonymize; -}; -export type I8t4pajubp34g3 = { - "insert_counter": number; - "delete_counter": number; -}; -export type Ifdiflqufkknl8 = { - "author": SS58String; - "commitment": FixedSizeBinary<32>; - "ciphertext": Binary; - "submitted_in": number; -}; -export type In7a38730s6qs = { - "base_block": Anonymize; - "max_block": Anonymize; - "per_class": { - "normal": { - "base_extrinsic": Anonymize; - "max_extrinsic"?: Anonymize; - "max_total"?: Anonymize; - "reserved"?: Anonymize; - }; - "operational": { - "base_extrinsic": Anonymize; - "max_extrinsic"?: Anonymize; - "max_total"?: Anonymize; - "reserved"?: Anonymize; - }; - "mandatory": { - "base_extrinsic": Anonymize; - "max_extrinsic"?: Anonymize; - "max_total"?: Anonymize; - "reserved"?: Anonymize; - }; - }; -}; -export type If15el53dd76v9 = { - "normal": number; - "operational": number; - "mandatory": number; -}; -export type I9s0ave7t0vnrk = { - "read": bigint; - "write": bigint; -}; -export type I4fo08joqmcqnm = { - "spec_name": string; - "impl_name": string; - "authoring_version": number; - "spec_version": number; - "impl_version": number; - "apis": Array<[FixedSizeBinary<8>, number]>; - "transaction_version": number; - "system_version": number; -}; -export type I35p85j063s0il = (bigint) | undefined; -export type Ijc5n210o8bbf = { - "limits": { - "event_topics": number; - "memory_pages": number; - "subject_len": number; - "payload_len": number; - "runtime_memory": number; - "validator_runtime_memory": number; - "event_ref_time": bigint; - }; - "instruction_weights": number; -}; -export type I3m5sq54sjdlso = {}; -export type Iekve0i6djpd9f = AnonymousEnum<{ - /** - * Make some on-chain remark. - * - * Can be executed by every `origin`. - */ - "remark": Anonymize; - /** - * Set the number of pages in the WebAssembly environment's heap. - */ - "set_heap_pages": Anonymize; - /** - * Set the new runtime code. - */ - "set_code": Anonymize; - /** - * Set the new runtime code without doing any checks of the given `code`. - * - * Note that runtime upgrades will not run if this is called with a not-increasing spec - * version! - */ - "set_code_without_checks": Anonymize; - /** - * Set some items of storage. - */ - "set_storage": Anonymize; - /** - * Kill some items from storage. - */ - "kill_storage": Anonymize; - /** - * Kill all storage items with a key that starts with the given prefix. - * - * **NOTE:** We rely on the Root origin to provide us the number of subkeys under - * the prefix we are removing to accurately calculate the weight of this function. - */ - "kill_prefix": Anonymize; - /** - * Make some on-chain remark and emit event. - */ - "remark_with_event": Anonymize; - /** - * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied - * later. - * - * This call requires Root origin. - */ - "authorize_upgrade": Anonymize; - /** - * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied - * later. - * - * WARNING: This authorizes an upgrade that will take place without any safety checks, for - * example that the spec name remains the same and that the version number increases. Not - * recommended for normal use. Use `authorize_upgrade` instead. - * - * This call requires Root origin. - */ - "authorize_upgrade_without_checks": Anonymize; - /** - * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. - * - * If the authorization required a version check, this call will ensure the spec name - * remains unchanged and that the spec version has increased. - * - * Depending on the runtime's `OnSetCode` configuration, this function may directly apply - * the new `code` in the same block or attempt to schedule the upgrade. - * - * All origins are allowed. - */ - "apply_authorized_upgrade": Anonymize; -}>; -export type I8ofcg5rbj0g2c = { - "remark": Binary; -}; -export type I4adgbll7gku4i = { - "pages": bigint; -}; -export type I6pjjpfvhvcfru = { - "code": Binary; -}; -export type I9pj91mj79qekl = { - "items": Array>; -}; -export type I39uah9nss64h9 = { - "keys": Anonymize; -}; -export type Itom7fk49o0c9 = Array; -export type Ik64dknsq7k08 = { - "prefix": Binary; - "subkeys": number; -}; -export type Ib51vk42m1po4n = { - "code_hash": FixedSizeBinary<32>; -}; -export type I7d75gqfg6jh9c = AnonymousEnum<{ - /** - * Set the current time. - * - * This call should be invoked exactly once per block. It will panic at the finalization - * phase, if this call hasn't been invoked by that time. - * - * The timestamp should be greater than the previous one by the amount specified by - * [`Config::MinimumPeriod`]. - * - * The dispatch origin for this call must be _None_. - * - * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware - * that changing the complexity of this call could result exhausting the resources in a - * block to execute any other calls. - * - * ## Complexity - * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) - * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in - * `on_finalize`) - * - 1 event handler `on_timestamp_set`. Must be `O(1)`. - */ - "set": Anonymize; -}>; -export type Idcr6u6361oad9 = { - "now": bigint; -}; -export type Ibck9ekr2i96uj = AnonymousEnum<{ - /** - * Report voter equivocation/misbehavior. This method will verify the - * equivocation proof and validate the given key ownership proof - * against the extracted offender. If both are valid, the offence - * will be reported. - */ - "report_equivocation": Anonymize; - /** - * Report voter equivocation/misbehavior. This method will verify the - * equivocation proof and validate the given key ownership proof - * against the extracted offender. If both are valid, the offence - * will be reported. - * - * This extrinsic must be called unsigned and it is expected that only - * block authors will call it (validated in `ValidateUnsigned`), as such - * if the block author is defined it will be defined as the equivocation - * reporter. - */ - "report_equivocation_unsigned": Anonymize; - /** - * Note that the current authority set of the GRANDPA finality gadget has stalled. - * - * This will trigger a forced authority set change at the beginning of the next session, to - * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume - * that the block signalling the forced change will not be re-orged e.g. 1000 blocks. - * The block production rate (which may be slowed down because of finality lagging) should - * be taken into account when choosing the `delay`. The GRANDPA voters based on the new - * authority will start voting on top of `best_finalized_block_number` for new finalized - * blocks. `best_finalized_block_number` should be the highest of the latest finalized - * block of all validators of the new authority set. - * - * Only callable by root. - */ - "note_stalled": Anonymize; -}>; -export type I3a5kuu5t5jj3g = { - "equivocation_proof": Anonymize; -}; -export type I9puqgoda8ofk4 = { - "set_id": bigint; - "equivocation": GrandpaEquivocation; -}; -export type GrandpaEquivocation = Enum<{ - "Prevote": { - "round_number": bigint; - "identity": FixedSizeBinary<32>; - "first": [{ - "target_hash": FixedSizeBinary<32>; - "target_number": number; - }, FixedSizeBinary<64>]; - "second": [{ - "target_hash": FixedSizeBinary<32>; - "target_number": number; - }, FixedSizeBinary<64>]; - }; - "Precommit": { - "round_number": bigint; - "identity": FixedSizeBinary<32>; - "first": [{ - "target_hash": FixedSizeBinary<32>; - "target_number": number; - }, FixedSizeBinary<64>]; - "second": [{ - "target_hash": FixedSizeBinary<32>; - "target_number": number; - }, FixedSizeBinary<64>]; - }; -}>; -export declare const GrandpaEquivocation: GetEnum; -export type I2hviml3snvhhn = { - "delay": number; - "best_finalized_block_number": number; -}; -export type I9svldsp29mh87 = AnonymousEnum<{ - /** - * Transfer some liquid free balance to another account. - * - * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. - * If the sender's account is below the existential deposit as a result - * of the transfer, the account will be reaped. - * - * The dispatch origin for this call must be `Signed` by the transactor. - */ - "transfer_allow_death": Anonymize; - /** - * Exactly as `transfer_allow_death`, except the origin must be root and the source account - * may be specified. - */ - "force_transfer": Anonymize; - /** - * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not - * kill the origin account. - * - * 99% of the time you want [`transfer_allow_death`] instead. - * - * [`transfer_allow_death`]: struct.Pallet.html#method.transfer - */ - "transfer_keep_alive": Anonymize; - /** - * Transfer the entire transferable balance from the caller account. - * - * NOTE: This function only attempts to transfer _transferable_ balances. This means that - * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be - * transferred by this function. To ensure that this function results in a killed account, - * you might need to prepare the account by removing any reference counters, storage - * deposits, etc... - * - * The dispatch origin of this call must be Signed. - * - * - `dest`: The recipient of the transfer. - * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all - * of the funds the account has, causing the sender account to be killed (false), or - * transfer everything except at least the existential deposit, which will guarantee to - * keep the sender account alive (true). - */ - "transfer_all": Anonymize; - /** - * Unreserve some balance from a user by force. - * - * Can only be called by ROOT. - */ - "force_unreserve": Anonymize; - /** - * Upgrade a specified account. - * - * - `origin`: Must be `Signed`. - * - `who`: The account to be upgraded. - * - * This will waive the transaction fee if at least all but 10% of the accounts needed to - * be upgraded. (We let some not have to be upgraded just in order to allow for the - * possibility of churn). - */ - "upgrade_accounts": Anonymize; - /** - * Set the regular balance of a given account. - * - * The dispatch origin for this call is `root`. - */ - "force_set_balance": Anonymize; - /** - * Adjust the total issuance in a saturating way. - * - * Can only be called by root and always needs a positive `delta`. - * - * # Example - */ - "force_adjust_total_issuance": Anonymize; - /** - * Burn the specified liquid free balance from the origin account. - * - * If the origin's account ends up below the existential deposit as a result - * of the burn and `keep_alive` is false, the account will be reaped. - * - * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible, - * this `burn` operation will reduce total issuance by the amount _burned_. - */ - "burn": Anonymize; -}>; -export type I4ktuaksf5i1gk = { - "dest": MultiAddress; - "value": bigint; -}; -export type MultiAddress = Enum<{ - "Id": SS58String; - "Index": undefined; - "Raw": Binary; - "Address32": FixedSizeBinary<32>; - "Address20": FixedSizeBinary<20>; -}>; -export declare const MultiAddress: GetEnum; -export type I9bqtpv2ii35mp = { - "source": MultiAddress; - "dest": MultiAddress; - "value": bigint; -}; -export type I9j7pagd6d4bda = { - "dest": MultiAddress; - "keep_alive": boolean; -}; -export type I2h9pmio37r7fb = { - "who": MultiAddress; - "amount": bigint; -}; -export type Ibmr18suc9ikh9 = { - "who": Anonymize; -}; -export type I9iq22t0burs89 = { - "who": MultiAddress; - "new_free": bigint; -}; -export type I5u8olqbbvfnvf = { - "direction": BalancesAdjustmentDirection; - "delta": bigint; -}; -export type BalancesAdjustmentDirection = Enum<{ - "Increase": undefined; - "Decrease": undefined; -}>; -export declare const BalancesAdjustmentDirection: GetEnum; -export type I5utcetro501ir = { - "value": bigint; - "keep_alive": boolean; -}; -export type I70bgb5j7tau9l = AnonymousEnum<{ - /** - * --- Sets the caller weights for the incentive mechanism. The call can be - * made from the hotkey account so is potentially insecure, however, the damage - * of changing weights is minimal if caught early. This function includes all the - * checks that the passed weights meet the requirements. Stored as u16s they represent - * rational values in the range [0,1] which sum to 1 and can be interpreted as - * probabilities. The specific weights determine how inflation propagates outward - * from this peer. - * - * Note: The 16 bit integers weights should represent 1.0 as the max u16. - * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all - * elements is larger or smaller than the amount of elements * u16_max, all elements - * will be corrected for this deviation. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuid` (u16): - * - The network uid we are setting these weights on. - * - * * `dests` (Vec): - * - The edge endpoint for the weight, i.e. j for w_ij. - * - * * 'weights' (Vec): - * - The u16 integer encoded weights. Interpreted as rational - * values in the range [0,1]. They must sum to in32::MAX. - * - * * 'version_key' ( u64 ): - * - The network version key to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'WeightVecNotEqualSize': - * - Attempting to set weights with uids not of same length. - * - * * 'DuplicateUids': - * - Attempting to set weights with duplicate uids. - * - * * 'UidsLengthExceedUidsInSubNet': - * - Attempting to set weights above the max allowed uids. - * - * * 'UidVecContainInvalidOne': - * - Attempting to set weights with invalid uids. - * - * * 'WeightVecLengthIsLow': - * - Attempting to set weights with fewer weights than min. - * - * * 'MaxWeightExceeded': - * - Attempting to set weights with max value exceeding limit. - */ - "set_weights": Anonymize; - /** - * --- Sets the caller weights for the incentive mechanism for mechanisms. The call - * can be made from the hotkey account so is potentially insecure, however, the damage - * of changing weights is minimal if caught early. This function includes all the - * checks that the passed weights meet the requirements. Stored as u16s they represent - * rational values in the range [0,1] which sum to 1 and can be interpreted as - * probabilities. The specific weights determine how inflation propagates outward - * from this peer. - * - * Note: The 16 bit integers weights should represent 1.0 as the max u16. - * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all - * elements is larger or smaller than the amount of elements * u16_max, all elements - * will be corrected for this deviation. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuid` (u16): - * - The network uid we are setting these weights on. - * - * * `mecid` (`u8`): - * - The u8 mechnism identifier. - * - * * `dests` (Vec): - * - The edge endpoint for the weight, i.e. j for w_ij. - * - * * 'weights' (Vec): - * - The u16 integer encoded weights. Interpreted as rational - * values in the range [0,1]. They must sum to in32::MAX. - * - * * 'version_key' ( u64 ): - * - The network version key to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'WeightVecNotEqualSize': - * - Attempting to set weights with uids not of same length. - * - * * 'DuplicateUids': - * - Attempting to set weights with duplicate uids. - * - * * 'UidsLengthExceedUidsInSubNet': - * - Attempting to set weights above the max allowed uids. - * - * * 'UidVecContainInvalidOne': - * - Attempting to set weights with invalid uids. - * - * * 'WeightVecLengthIsLow': - * - Attempting to set weights with fewer weights than min. - * - * * 'MaxWeightExceeded': - * - Attempting to set weights with max value exceeding limit. - */ - "set_mechanism_weights": Anonymize; - /** - * --- Allows a hotkey to set weights for multiple netuids as a batch. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuids` (Vec>): - * - The network uids we are setting these weights on. - * - * * `weights` (Vec, Compact)>): - * - The weights to set for each network. [(uid, weight), ...] - * - * * `version_keys` (Vec>): - * - The network version keys to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * * BatchWeightsCompleted; - * - On success of the batch. - * * BatchCompletedWithErrors; - * - On failure of any of the weights in the batch. - * * BatchWeightItemFailed; - * - On failure for each failed item in the batch. - * - */ - "batch_set_weights": Anonymize; - /** - * ---- Used to commit a hash of your weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit_hash` (`H256`): - * - The hash representing the committed weights. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - "commit_weights": Anonymize; - /** - * ---- Used to commit a hash of your weight values to later be revealed for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit_hash` (`H256`): - * - The hash representing the committed weights. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - "commit_mechanism_weights": Anonymize; - /** - * --- Allows a hotkey to commit weight hashes for multiple netuids as a batch. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuids` (Vec>): - * - The network uids we are setting these weights on. - * - * * `commit_hashes` (Vec): - * - The commit hashes to commit. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * * BatchWeightsCompleted; - * - On success of the batch. - * * BatchCompletedWithErrors; - * - On failure of any of the weights in the batch. - * * BatchWeightItemFailed; - * - On failure for each failed item in the batch. - * - */ - "batch_commit_weights": Anonymize; - /** - * ---- Used to reveal the weights for a previously committed hash. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `uids` (`Vec`): - * - The uids for the weights being revealed. - * - * * `values` (`Vec`): - * - The values of the weights being revealed. - * - * * `salt` (`Vec`): - * - The salt used to generate the commit hash. - * - * * `version_key` (`u64`): - * - The network version key. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - */ - "reveal_weights": Anonymize; - /** - * ---- Used to reveal the weights for a previously committed hash for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `uids` (`Vec`): - * - The uids for the weights being revealed. - * - * * `values` (`Vec`): - * - The values of the weights being revealed. - * - * * `salt` (`Vec`): - * - The salt used to generate the commit hash. - * - * * `version_key` (`u64`): - * - The network version key. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - */ - "reveal_mechanism_weights": Anonymize; - /** - * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * # Raises: - * * `CommitRevealV3Disabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * # Raises: - * * `CommitRevealV3Disabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - "commit_crv3_mechanism_weights": Anonymize; - /** - * ---- The implementation for batch revealing committed weights. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `uids_list` (`Vec>`): - * - A list of uids for each set of weights being revealed. - * - * * `values_list` (`Vec>`): - * - A list of values for each set of weights being revealed. - * - * * `salts_list` (`Vec>`): - * - A list of salts used to generate the commit hashes. - * - * * `version_keys` (`Vec`): - * - A list of network version keys. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - * * `InvalidInputLengths`: - * - The input vectors are of mismatched lengths. - */ - "batch_reveal_weights": Anonymize; - /** - * --- Allows delegates to decrease its take value. - * - * # Args: - * * 'origin': (::Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The hotkey we are delegating (must be owned by the coldkey.) - * - * * 'netuid' (u16): - * - Subnet ID to decrease take for - * - * * 'take' (u16): - * - The new stake proportion that this hotkey takes from delegations. - * The new value can be between 0 and 11_796 and should be strictly - * lower than the previous value. It T is the new value (rational number), - * the the parameter is calculated as [65535 * T]. For example, 1% would be - * [0.01 * 65535] = [655.35] = 655 - * - * # Event: - * * TakeDecreased; - * - On successfully setting a decreased take for this hotkey. - * - * # Raises: - * * 'NotRegistered': - * - The hotkey we are delegating is not registered on the network. - * - * * 'NonAssociatedColdKey': - * - The hotkey we are delegating is not owned by the calling coldkey. - * - * * 'DelegateTakeTooLow': - * - The delegate is setting a take which is not lower than the previous. - * - */ - "decrease_take": Anonymize; - /** - * --- Allows delegates to increase its take value. This call is rate-limited. - * - * # Args: - * * 'origin': (::Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The hotkey we are delegating (must be owned by the coldkey.) - * - * * 'take' (u16): - * - The new stake proportion that this hotkey takes from delegations. - * The new value can be between 0 and 11_796 and should be strictly - * greater than the previous value. T is the new value (rational number), - * the the parameter is calculated as [65535 * T]. For example, 1% would be - * [0.01 * 65535] = [655.35] = 655 - * - * # Event: - * * TakeIncreased; - * - On successfully setting a increased take for this hotkey. - * - * # Raises: - * * 'NotRegistered': - * - The hotkey we are delegating is not registered on the network. - * - * * 'NonAssociatedColdKey': - * - The hotkey we are delegating is not owned by the calling coldkey. - * - * * 'DelegateTakeTooHigh': - * - The delegate is setting a take which is not greater than the previous. - * - */ - "increase_take": Anonymize; - /** - * --- Adds stake to a hotkey. The call is made from a coldkey account. - * This delegates stake to the hotkey. - * - * Note: the coldkey account may own the hotkey, in which case they are - * delegating to themselves. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_staked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * # Event: - * * StakeAdded; - * - On the successfully adding stake to a global account. - * - * # Raises: - * * 'NotEnoughBalanceToStake': - * - Not enough balance on the coldkey to add onto the global account. - * - * * 'NonAssociatedColdKey': - * - The calling coldkey is not associated with this hotkey. - * - * * 'BalanceWithdrawalError': - * - Errors stemming from transaction pallet. - * - */ - "add_stake": Anonymize; - /** - * Remove stake from the staking account. The call must be made - * from the coldkey account attached to the neuron metadata. Only this key - * has permission to make staking and unstaking requests. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_unstaked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * 'NotRegistered': - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * 'NonAssociatedColdKey': - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * 'NotEnoughStakeToWithdraw': - * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. - * - */ - "remove_stake": Anonymize; - /** - * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is - * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u64): - * - The bittensor version identifier. - * - * * 'ip' (u64): - * - The endpoint ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The endpoint port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The endpoint ip version as a u8, 4 or 6. - * - * * 'protocol' (u8): - * - UDP:1 or TCP:0 - * - * * 'placeholder1' (u8): - * - Placeholder for further extra params. - * - * * 'placeholder2' (u8): - * - Placeholder for further extra params. - * - * # Event: - * * AxonServed; - * - On successfully serving the axon info. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'InvalidIpType': - * - The ip type is not 4 or 6. - * - * * 'InvalidIpAddress': - * - The numerically encoded ip address does not resolve to a proper ip. - * - * * 'ServingRateLimitExceeded': - * - Attempting to set prometheus information withing the rate limit min. - * - */ - "serve_axon": Anonymize; - /** - * Same as `serve_axon` but takes a certificate as an extra optional argument. - * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is - * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u64): - * - The bittensor version identifier. - * - * * 'ip' (u64): - * - The endpoint ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The endpoint port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The endpoint ip version as a u8, 4 or 6. - * - * * 'protocol' (u8): - * - UDP:1 or TCP:0 - * - * * 'placeholder1' (u8): - * - Placeholder for further extra params. - * - * * 'placeholder2' (u8): - * - Placeholder for further extra params. - * - * * 'certificate' (Vec): - * - TLS certificate for inter neuron communitation. - * - * # Event: - * * AxonServed; - * - On successfully serving the axon info. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'InvalidIpType': - * - The ip type is not 4 or 6. - * - * * 'InvalidIpAddress': - * - The numerically encoded ip address does not resolve to a proper ip. - * - * * 'ServingRateLimitExceeded': - * - Attempting to set prometheus information withing the rate limit min. - * - */ - "serve_axon_tls": Anonymize; - /** - * ---- Set prometheus information for the neuron. - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u16): - * - The bittensor version identifier. - * - * * 'ip' (u128): - * - The prometheus ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The prometheus port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The ip type v4 or v6. - * - */ - "serve_prometheus": Anonymize; - /** - * ---- Registers a new neuron to the subnetwork. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'block_number' ( u64 ): - * - Block hash used to prove work done. - * - * * 'nonce' ( u64 ): - * - Positive integer nonce used in POW. - * - * * 'work' ( Vec ): - * - Vector encoded bytes representing work done. - * - * * 'hotkey' ( T::AccountId ): - * - Hotkey to be registered to the network. - * - * * 'coldkey' ( T::AccountId ): - * - Associated coldkey account. - * - * # Event: - * * NeuronRegistered; - * - On successfully registering a uid to a neuron slot on a subnetwork. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to register to a non existent network. - * - * * 'TooManyRegistrationsThisBlock': - * - This registration exceeds the total allowed on this network this block. - * - * * 'HotKeyAlreadyRegisteredInSubNet': - * - The hotkey is already registered on this network. - * - * * 'InvalidWorkBlock': - * - The work has been performed on a stale, future, or non existent block. - * - * * 'InvalidDifficulty': - * - The work does not match the difficulty. - * - * * 'InvalidSeal': - * - The seal is incorrect. - * - */ - "register": Anonymize; - /** - * Register the hotkey to root network - */ - "root_register": Anonymize; - /** - * User register a new subnetwork via burning token - */ - "burned_register": Anonymize; - /** - * The extrinsic for user to change its hotkey in subnet or all subnets. - */ - "swap_hotkey": Anonymize; - /** - * Performs an arbitrary coldkey swap for any coldkey. - * - * Only callable by root as it doesn't require an announcement and can be used to swap any coldkey. - */ - "swap_coldkey": Anonymize; - /** - * Sets the childkey take for a given hotkey. - * - * This function allows a coldkey to set the childkey take for a given hotkey. - * The childkey take determines the proportion of stake that the hotkey keeps for itself - * when distributing stake to its children. - * - * # Arguments: - * * `origin` (::RuntimeOrigin): - * - The signature of the calling coldkey. Setting childkey take can only be done by the coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey for which the childkey take will be set. - * - * * `take` (u16): - * - The new childkey take value. This is a percentage represented as a value between 0 and 10000, - * where 10000 represents 100%. - * - * # Events: - * * `ChildkeyTakeSet`: - * - On successfully setting the childkey take for a hotkey. - * - * # Errors: - * * `NonAssociatedColdKey`: - * - The coldkey does not own the hotkey. - * * `InvalidChildkeyTake`: - * - The provided take value is invalid (greater than the maximum allowed take). - * * `TxChildkeyTakeRateLimitExceeded`: - * - The rate limit for changing childkey take has been exceeded. - * - */ - "set_childkey_take": Anonymize; - /** - * Sets the transaction rate limit for changing childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `tx_rate_limit` - The new rate limit in blocks. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - "sudo_set_tx_childkey_take_rate_limit": Anonymize; - /** - * Sets the minimum allowed childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `take` - The new minimum childkey take value. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - "sudo_set_min_childkey_take": Anonymize; - /** - * Sets the maximum allowed childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `take` - The new maximum childkey take value. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - "sudo_set_max_childkey_take": Anonymize; - /** - * User register a new subnetwork - */ - "register_network": Anonymize; - /** - * Facility extrinsic for user to get taken from faucet - * It is only available when pow-faucet feature enabled - * Just deployed in testnet and devnet for testing purpose - */ - "faucet": Anonymize; - /** - * Remove a user's subnetwork - * The caller must be the owner of the network - */ - "dissolve_network": Anonymize; - /** - * Set a single child for a given hotkey on a specified network. - * - * This function allows a coldkey to set a single child for a given hotkey on a specified network. - * The proportion of the hotkey's stake to be allocated to the child is also specified. - * - * # Arguments: - * * `origin` (::RuntimeOrigin): - * - The signature of the calling coldkey. Setting a hotkey child can only be done by the coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey which will be assigned the child. - * - * * `child` (T::AccountId): - * - The child which will be assigned to the hotkey. - * - * * `netuid` (u16): - * - The u16 network identifier where the childkey will exist. - * - * * `proportion` (u64): - * - Proportion of the hotkey's stake to be given to the child, the value must be u64 normalized. - * - * # Events: - * * `ChildAddedSingular`: - * - On successfully registering a child to a hotkey. - * - * # Errors: - * * `MechanismDoesNotExist`: - * - Attempting to register to a non-existent network. - * * `RegistrationNotPermittedOnRootSubnet`: - * - Attempting to register a child on the root network. - * * `NonAssociatedColdKey`: - * - The coldkey does not own the hotkey or the child is the same as the hotkey. - * * `HotKeyAccountNotExists`: - * - The hotkey account does not exist. - * - * # Detailed Explanation of Checks: - * 1. **Signature Verification**: Ensures that the caller has signed the transaction, verifying the coldkey. - * 2. **Root Network Check**: Ensures that the delegation is not on the root network, as child hotkeys are not valid on the root. - * 3. **Network Existence Check**: Ensures that the specified network exists. - * 4. **Ownership Verification**: Ensures that the coldkey owns the hotkey. - * 5. **Hotkey Account Existence Check**: Ensures that the hotkey account already exists. - * 6. **Child-Hotkey Distinction**: Ensures that the child is not the same as the hotkey. - * 7. **Old Children Cleanup**: Removes the hotkey from the parent list of its old children. - * 8. **New Children Assignment**: Assigns the new child to the hotkey and updates the parent list for the new child. - */ - "set_children": Anonymize; - /** - * Schedules a coldkey swap operation to be executed at a future block. - * - * WARNING: This function is deprecated, please migrate to `announce_coldkey_swap`/`coldkey_swap` - */ - "schedule_swap_coldkey": Anonymize; - /** - * ---- Set prometheus information for the neuron. - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u16): - * - The bittensor version identifier. - * - * * 'ip' (u128): - * - The prometheus ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The prometheus port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The ip type v4 or v6. - * - */ - "set_identity": Anonymize; - /** - * ---- Set the identity information for a subnet. - * # Args: - * * `origin` - (::Origin): - * - The signature of the calling coldkey, which must be the owner of the subnet. - * - * * `netuid` (u16): - * - The unique network identifier of the subnet. - * - * * `subnet_name` (Vec): - * - The name of the subnet. - * - * * `github_repo` (Vec): - * - The GitHub repository associated with the subnet identity. - * - * * `subnet_contact` (Vec): - * - The contact information for the subnet. - */ - "set_subnet_identity": Anonymize; - /** - * User register a new subnetwork - */ - "register_network_with_identity": Anonymize; - /** - * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The associated hotkey account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * `NotRegistered`: - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * `NonAssociatedColdKey`: - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * `NotEnoughStakeToWithdraw`: - * - Thrown if there is not enough stake on the hotkey to withdraw this amount. - * - * * `TxRateLimitExceeded`: - * - Thrown if key has hit transaction rate limit - */ - "unstake_all": Anonymize; - /** - * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The associated hotkey account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * `NotRegistered`: - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * `NonAssociatedColdKey`: - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * `NotEnoughStakeToWithdraw`: - * - Thrown if there is not enough stake on the hotkey to withdraw this amount. - * - * * `TxRateLimitExceeded`: - * - Thrown if key has hit transaction rate limit - */ - "unstake_all_alpha": Anonymize; - /** - * ---- The implementation for the extrinsic move_stake: Moves specified amount of stake from a hotkey to another across subnets. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `origin_hotkey` (T::AccountId): - * - The hotkey account to move stake from. - * - * * `destination_hotkey` (T::AccountId): - * - The hotkey account to move stake to. - * - * * `origin_netuid` (T::AccountId): - * - The subnet ID to move stake from. - * - * * `destination_netuid` (T::AccountId): - * - The subnet ID to move stake to. - * - * * `alpha_amount` (T::AccountId): - * - The alpha stake amount to move. - * - */ - "move_stake": Anonymize; - /** - * Transfers a specified amount of stake from one coldkey to another, optionally across subnets, - * while keeping the same hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`. - * * `destination_coldkey` - The coldkey to which the stake is transferred. - * * `hotkey` - The hotkey associated with the stake. - * * `origin_netuid` - The network/subnet ID to move stake from. - * * `destination_netuid` - The network/subnet ID to move stake to (for cross-subnet transfer). - * * `alpha_amount` - The amount of stake to transfer. - * - * # Errors - * Returns an error if: - * * The origin is not signed by the correct coldkey. - * * Either subnet does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(origin_coldkey, hotkey, origin_netuid)`. - * * The transfer amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeTransferred` event on success. - */ - "transfer_stake": Anonymize; - /** - * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey whose stake is being swapped. - * * `origin_netuid` - The network/subnet ID from which stake is removed. - * * `destination_netuid` - The network/subnet ID to which stake is added. - * * `alpha_amount` - The amount of stake to swap. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). - * * Either `origin_netuid` or `destination_netuid` does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. - * * The swap amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeSwapped` event on success. - */ - "swap_stake": Anonymize; - /** - * --- Adds stake to a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (lower) the staking should execute. - * - * In case if slippage occurs and the price shall move beyond the limit - * price, the staking order may execute only partially or not execute - * at all. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_staked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * * 'limit_price' (u64): - * - The limit price expressed in units of RAO per one Alpha. - * - * * 'allow_partial' (bool): - * - Allows partial execution of the amount. If set to false, this becomes - * fill or kill type or order. - * - * # Event: - * * StakeAdded; - * - On the successfully adding stake to a global account. - * - * # Raises: - * * 'NotEnoughBalanceToStake': - * - Not enough balance on the coldkey to add onto the global account. - * - * * 'NonAssociatedColdKey': - * - The calling coldkey is not associated with this hotkey. - * - * * 'BalanceWithdrawalError': - * - Errors stemming from transaction pallet. - * - */ - "add_stake_limit": Anonymize; - /** - * --- Removes stake from a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (higher) the staking should execute. - * - * In case if slippage occurs and the price shall move beyond the limit - * price, the staking order may execute only partially or not execute - * at all. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_unstaked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * * 'limit_price' (u64): - * - The limit price expressed in units of RAO per one Alpha. - * - * * 'allow_partial' (bool): - * - Allows partial execution of the amount. If set to false, this becomes - * fill or kill type or order. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * 'NotRegistered': - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * 'NonAssociatedColdKey': - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * 'NotEnoughStakeToWithdraw': - * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. - * - */ - "remove_stake_limit": Anonymize; - /** - * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey whose stake is being swapped. - * * `origin_netuid` - The network/subnet ID from which stake is removed. - * * `destination_netuid` - The network/subnet ID to which stake is added. - * * `alpha_amount` - The amount of stake to swap. - * * `limit_price` - The limit price expressed in units of RAO per one Alpha. - * * `allow_partial` - Allows partial execution of the amount. If set to false, this becomes fill or kill type or order. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). - * * Either `origin_netuid` or `destination_netuid` does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. - * * The swap amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeSwapped` event on success. - */ - "swap_stake_limit": Anonymize; - /** - * Attempts to associate a hotkey with a coldkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey to associate with the coldkey. - * - * # Note - * Will charge based on the weight even if the hotkey is already associated with a coldkey. - */ - "try_associate_hotkey": Anonymize; - /** - * Initiates a call on a subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be signed by the subnet owner. - * * `netuid` - The unique identifier of the subnet on which the call is being initiated. - * - * # Events - * Emits a `FirstEmissionBlockNumberSet` event on success. - */ - "start_call": Anonymize; - /** - * Attempts to associate a hotkey with an EVM key. - * - * The signature will be checked to see if the recovered public key matches the `evm_key` provided. - * - * The EVM key is expected to sign the message according to this formula to produce the signature: - * ```text - * keccak_256(hotkey ++ keccak_256(block_number)) - * ``` - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the `hotkey`. - * * `netuid` - The netuid that the `hotkey` belongs to. - * * `evm_key` - The EVM key to associate with the `hotkey`. - * * `block_number` - The block number used in the `signature`. - * * `signature` - A signed message by the `evm_key` containing the `hotkey` and the hashed `block_number`. - * - * # Errors - * Returns an error if: - * * The transaction is not signed. - * * The hotkey does not belong to the subnet identified by the netuid. - * * The EVM key cannot be recovered from the signature. - * * The EVM key recovered from the signature does not match the given EVM key. - * - * # Events - * May emit a `EvmKeyAssociated` event on success - */ - "associate_evm_key": Anonymize; - /** - * Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet - * - * # Arguments - * * `origin` - The origin of the call (must be signed by the coldkey) - * * `hotkey` - The hotkey account - * * `amount` - The amount of alpha to recycle - * * `netuid` - The subnet ID - * - * # Events - * Emits a `TokensRecycled` event on success. - */ - "recycle_alpha": Anonymize; - /** - * Burns alpha from a cold/hot key pair without reducing `AlphaOut` - * - * # Arguments - * * `origin` - The origin of the call (must be signed by the coldkey) - * * `hotkey` - The hotkey account - * * `amount` - The amount of alpha to burn - * * `netuid` - The subnet ID - * - * # Events - * Emits a `TokensBurned` event on success. - */ - "burn_alpha": Anonymize; - /** - * Sets the pending childkey cooldown (in blocks). Root only. - */ - "set_pending_childkey_cooldown": Anonymize; - /** - * Removes all stake from a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (higher) the staking should execute. - * Without limit_price it remove all the stake similar to `remove_stake` extrinsic - */ - "remove_stake_full_limit": Anonymize; - /** - * Register a new leased network. - * - * The crowdloan's contributions are used to compute the share of the emissions that the contributors - * will receive as dividends. - * - * The leftover cap is refunded to the contributors and the beneficiary. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `emissions_share` (Percent): - * - The share of the emissions that the contributors will receive as dividends. - * - * * `end_block` (Option>): - * - The block at which the lease will end. If not defined, the lease is perpetual. - */ - "register_leased_network": Anonymize; - /** - * Terminate a lease. - * - * The beneficiary can terminate the lease after the end block has passed and get the subnet ownership. - * The subnet is transferred to the beneficiary and the lease is removed from storage. - * - * **The hotkey must be owned by the beneficiary coldkey.** - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `lease_id` (LeaseId): - * - The ID of the lease to terminate. - * - * * `hotkey` (T::AccountId): - * - The hotkey of the beneficiary to mark as subnet owner hotkey. - */ - "terminate_lease": Anonymize; - /** - * Updates the symbol for a subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or root. - * * `netuid` - The unique identifier of the subnet on which the symbol is being set. - * * `symbol` - The symbol to set for the subnet. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the subnet owner. - * * The symbol does not exist. - * * The symbol is already in use by another subnet. - * - * # Events - * Emits a `SymbolUpdated` event on success. - */ - "update_symbol": Anonymize; - /** - * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * * commit_reveal_version (`u16`): - * - The client (bittensor-drand) version - */ - "commit_timelocked_weights": Anonymize; - /** - * Set the autostake destination hotkey for a coldkey. - * - * The caller selects a hotkey where all future rewards - * will be automatically staked. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey account to designate as the autostake destination. - */ - "set_coldkey_auto_stake_hotkey": Anonymize; - /** - * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed for - * a mechanism. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * * commit_reveal_version (`u16`): - * - The client (bittensor-drand) version - */ - "commit_timelocked_mechanism_weights": Anonymize; - /** - * Remove a subnetwork - * The caller must be root - */ - "root_dissolve_network": Anonymize; - /** - * --- Claims the root emissions for a coldkey. - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * # Event: - * * RootClaimed; - * - On the successfully claiming the root emissions for a coldkey. - * - * # Raises: - * - */ - "claim_root": Anonymize; - /** - * --- Sets the root claim type for the coldkey. - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * # Event: - * * RootClaimTypeSet; - * - On the successfully setting the root claim type for the coldkey. - * - */ - "set_root_claim_type": Anonymize; - /** - * --- Sets root claim number (sudo extrinsic). Zero disables auto-claim. - */ - "sudo_set_num_root_claims": Anonymize; - /** - * --- Sets root claim threshold for subnet (sudo or owner origin). - */ - "sudo_set_root_claim_threshold": Anonymize; - /** - * Announces a coldkey swap using BlakeTwo256 hash of the new coldkey. - * - * This is required before the coldkey swap can be performed - * after the delay period. - * - * It can be reannounced after a delay of `ColdkeySwapReannouncementDelay` following - * the first valid execution block of the original announcement. - * - * The dispatch origin of this call must be the original coldkey that made the announcement. - * - * - `new_coldkey_hash`: The hash of the new coldkey using BlakeTwo256. - * - * The `ColdkeySwapAnnounced` event is emitted on successful announcement. - * - */ - "announce_coldkey_swap": Anonymize; - /** - * Performs a coldkey swap if an announcement has been made. - * - * The dispatch origin of this call must be the original coldkey that made the announcement. - * - * - `new_coldkey`: The new coldkey to swap to. The BlakeTwo256 hash of the new coldkey must be - * the same as the announced coldkey hash. - * - * The `ColdkeySwapped` event is emitted on successful swap. - */ - "swap_coldkey_announced": Anonymize; - /** - * Dispute a coldkey swap. - * - * This will prevent any further actions on the coldkey swap - * until triumvirate step in to resolve the issue. - * - * - `coldkey`: The coldkey to dispute the swap for. - * - */ - "dispute_coldkey_swap": undefined; - /** - * Reset a coldkey swap by clearing the announcement and dispute status. - * - * The dispatch origin of this call must be root. - * - * - `coldkey`: The coldkey to reset the swap for. - * - */ - "reset_coldkey_swap": Anonymize; - /** - * Enables voting power tracking for a subnet. - * - * This function can be called by the subnet owner or root. - * When enabled, voting power EMA is updated every epoch for all validators. - * Voting power starts at 0 and increases over epochs. - * - * # Arguments: - * * `origin` - The origin of the call, must be subnet owner or root. - * * `netuid` - The subnet to enable voting power tracking for. - * - * # Errors: - * * `SubnetNotExist` - If the subnet does not exist. - * * `NotSubnetOwner` - If the caller is not the subnet owner or root. - */ - "enable_voting_power_tracking": Anonymize; - /** - * Schedules disabling of voting power tracking for a subnet. - * - * This function can be called by the subnet owner or root. - * Voting power tracking will continue for 14 days (grace period) after this call, - * then automatically disable and clear all VotingPower entries for the subnet. - * - * # Arguments: - * * `origin` - The origin of the call, must be subnet owner or root. - * * `netuid` - The subnet to schedule disabling voting power tracking for. - * - * # Errors: - * * `SubnetNotExist` - If the subnet does not exist. - * * `NotSubnetOwner` - If the caller is not the subnet owner or root. - * * `VotingPowerTrackingNotEnabled` - If voting power tracking is not enabled. - */ - "disable_voting_power_tracking": Anonymize; - /** - * Sets the EMA alpha value for voting power calculation on a subnet. - * - * This function can only be called by root (sudo). - * Higher alpha = faster response to stake changes. - * Alpha is stored as u64 with 18 decimal precision (1.0 = 10^18). - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `netuid` - The subnet to set the alpha for. - * * `alpha` - The new alpha value (u64 with 18 decimal precision). - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * * `SubnetNotExist` - If the subnet does not exist. - * * `InvalidVotingPowerEmaAlpha` - If alpha is greater than 10^18 (1.0). - */ - "sudo_set_voting_power_ema_alpha": Anonymize; - /** - * --- The extrinsic is a combination of add_stake(add_stake_limit) and burn_alpha. We buy - * alpha token first and immediately burn the acquired amount of alpha (aka Subnet buyback). - */ - "add_stake_burn": Anonymize; -}>; -export type Icv6ofu4lqekr4 = { - "netuid": number; - "dests": Anonymize; - "weights": Anonymize; - "version_key": bigint; -}; -export type I48embv0n659kj = { - "netuid": number; - "mecid": number; - "dests": Anonymize; - "weights": Anonymize; - "version_key": bigint; -}; -export type I8l6dbd18t5aja = { - "netuids": Anonymize; - "weights": Array>; - "version_keys": Anonymize; -}; -export type I513du23unvan = { - "netuid": number; - "commit_hash": FixedSizeBinary<32>; -}; -export type I36o6oho99gjm8 = { - "netuid": number; - "mecid": number; - "commit_hash": FixedSizeBinary<32>; -}; -export type If3mvus4cmnb7l = { - "netuids": Anonymize; - "commit_hashes": Anonymize; -}; -export type I3qrhi1ua10nnf = { - "netuid": number; - "uids": Anonymize; - "values": Anonymize; - "salt": Anonymize; - "version_key": bigint; -}; -export type I2hpc4ev2drsf2 = { - "netuid": number; - "mecid": number; - "uids": Anonymize; - "values": Anonymize; - "salt": Anonymize; - "version_key": bigint; -}; -export type I73q6qh9ckhm04 = { - "netuid": number; - "mecid": number; - "commit": Binary; - "reveal_round": bigint; -}; -export type Idia8cmqvul6et = { - "netuid": number; - "uids_list": Array>; - "values_list": Array>; - "salts_list": Array>; - "version_keys": Anonymize; -}; -export type Idardmhchnv8aa = { - "hotkey": SS58String; - "take": number; -}; -export type Icud5m8j0nlgtj = { - "hotkey": SS58String; - "netuid": number; - "amount_staked": bigint; -}; -export type I850u7ir5o34um = { - "hotkey": SS58String; - "netuid": number; - "amount_unstaked": bigint; -}; -export type Ica88a899k1afk = { - "netuid": number; - "version": number; - "ip": bigint; - "port": number; - "ip_type": number; - "protocol": number; - "placeholder1": number; - "placeholder2": number; -}; -export type I4tfn6eb3ekqt2 = { - "netuid": number; - "version": number; - "ip": bigint; - "port": number; - "ip_type": number; - "protocol": number; - "placeholder1": number; - "placeholder2": number; - "certificate": Binary; -}; -export type Ia5r6mm7trbg6a = { - "netuid": number; - "version": number; - "ip": bigint; - "port": number; - "ip_type": number; -}; -export type I27gr0ss2ikvqh = { - "netuid": number; - "block_number": bigint; - "nonce": bigint; - "work": Binary; - "hotkey": SS58String; - "coldkey": SS58String; -}; -export type Ie7hipi75c7vn0 = { - "hotkey": SS58String; -}; -export type I7f38r2vt6r9k1 = { - "netuid": number; - "hotkey": SS58String; -}; -export type I6b53cjq4m9nsr = { - "hotkey": SS58String; - "new_hotkey": SS58String; - "netuid"?: Anonymize; -}; -export type I216fvnrl9nq6l = { - "old_coldkey": SS58String; - "new_coldkey": SS58String; - "swap_cost": bigint; -}; -export type I9n4d52k0luroe = { - "hotkey": SS58String; - "netuid": number; - "take": number; -}; -export type I3gk6eeddm0hsd = { - "tx_rate_limit": bigint; -}; -export type I6ue7qc27uhiev = { - "take": number; -}; -export type Ifp8lgrkla2dig = { - "block_number": bigint; - "nonce": bigint; - "work": Binary; -}; -export type I30l38oi9ed9dj = { - "coldkey": SS58String; - "netuid": number; -}; -export type Ifj9gf4ekq9snm = { - "hotkey": SS58String; - "netuid": number; - "children": Anonymize; -}; -export type If2k69ql8jgivj = { - "new_coldkey": SS58String; -}; -export type I4378ieh1uba9u = { - "netuid": number; - "subnet_name": Binary; - "github_repo": Binary; - "subnet_contact": Binary; - "subnet_url": Binary; - "discord": Binary; - "description": Binary; - "logo_url": Binary; - "additional": Binary; -}; -export type I8e6f7r9dtk9c1 = { - "hotkey": SS58String; - "identity"?: Anonymize; -}; -export type I3m38saj8mvtpv = (Anonymize) | undefined; -export type I9d117ni3tprb = { - "origin_hotkey": SS58String; - "destination_hotkey": SS58String; - "origin_netuid": number; - "destination_netuid": number; - "alpha_amount": bigint; -}; -export type I340k0hbj1hc6r = { - "destination_coldkey": SS58String; - "hotkey": SS58String; - "origin_netuid": number; - "destination_netuid": number; - "alpha_amount": bigint; -}; -export type Ibapoov2fa817a = { - "hotkey": SS58String; - "origin_netuid": number; - "destination_netuid": number; - "alpha_amount": bigint; -}; -export type I2eon60c4gde7f = { - "hotkey": SS58String; - "netuid": number; - "amount_staked": bigint; - "limit_price": bigint; - "allow_partial": boolean; -}; -export type I7egr0053sjpci = { - "hotkey": SS58String; - "netuid": number; - "amount_unstaked": bigint; - "limit_price": bigint; - "allow_partial": boolean; -}; -export type I6r22p9usi2mkl = { - "hotkey": SS58String; - "origin_netuid": number; - "destination_netuid": number; - "alpha_amount": bigint; - "limit_price": bigint; - "allow_partial": boolean; -}; -export type I96k3nrdjfd63k = { - "netuid": number; - "evm_key": FixedSizeBinary<20>; - "block_number": bigint; - "signature": FixedSizeBinary<65>; -}; -export type Ibg3cp8vjl5u55 = { - "hotkey": SS58String; - "amount": bigint; - "netuid": number; -}; -export type Ibtu1gfmdnou5k = { - "cooldown": bigint; -}; -export type Iaoomvri5btde = { - "hotkey": SS58String; - "netuid": number; - "limit_price"?: Anonymize; -}; -export type Ic80igo4eds6rq = { - "emissions_share": number; - "end_block"?: Anonymize; -}; -export type Iflrm8un6aibtn = { - "lease_id": number; - "hotkey": SS58String; -}; -export type Ietm4rjshhu7sf = { - "netuid": number; - "commit": Binary; - "reveal_round": bigint; - "commit_reveal_version": number; -}; -export type I1v9m3ms1elitm = { - "netuid": number; - "mecid": number; - "commit": Binary; - "reveal_round": bigint; - "commit_reveal_version": number; -}; -export type I7a99hd3nbic2l = { - "new_root_claim_type": Anonymize; -}; -export type Ie8hpsm3jhsvo3 = { - "new_value": bigint; -}; -export type Ifcj247vgfdg56 = { - "netuid": number; - "new_value": bigint; -}; -export type Ic21uicfit5vcu = { - "new_coldkey_hash": FixedSizeBinary<32>; -}; -export type I2t2h3sjr2mdj0 = { - "hotkey": SS58String; - "netuid": number; - "amount": bigint; - "limit"?: Anonymize; -}; -export type If4ks1adspb2ai = AnonymousEnum<{ - /** - * Send a batch of dispatch calls. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatched without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - * - * This will return `Ok` in all circumstances. To determine the success of the batch, an - * event is deposited. If a call failed and the batch was interrupted, then the - * `BatchInterrupted` event is deposited, along with the number of successful calls made - * and the error of the failed call. If all were successful, then the `BatchCompleted` - * event is deposited. - */ - "batch": Anonymize; - /** - * Send a call through an indexed pseudonym of the sender. - * - * Filter from origin are passed along. The call will be dispatched with an origin which - * use the same filter as the origin of this call. - * - * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. - * because you expect `proxy` to have been used prior in the call stack and you do not want - * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` - * in the Multisig pallet instead. - * - * NOTE: Prior to version *12, this was called `as_limited_sub`. - * - * The dispatch origin for this call must be _Signed_. - */ - "as_derivative": Anonymize; - /** - * Send a batch of dispatch calls and atomically execute them. - * The whole transaction will rollback and fail if any of the calls failed. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatched without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - */ - "batch_all": Anonymize; - /** - * Dispatches a function call with a provided origin. - * - * The dispatch origin for this call must be _Root_. - * - * ## Complexity - * - O(1). - */ - "dispatch_as": Anonymize; - /** - * Send a batch of dispatch calls. - * Unlike `batch`, it allows errors and won't interrupt. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatch without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - */ - "force_batch": Anonymize; - /** - * Dispatch a function call with a specified weight. - * - * This function does not check the weight of the call, and instead allows the - * Root origin to specify the weight of the call. - * - * The dispatch origin for this call must be _Root_. - */ - "with_weight": Anonymize; - /** - * Dispatch a fallback call in the event the main call fails to execute. - * May be called from any origin except `None`. - * - * This function first attempts to dispatch the `main` call. - * If the `main` call fails, the `fallback` is attemted. - * if the fallback is successfully dispatched, the weights of both calls - * are accumulated and an event containing the main call error is deposited. - * - * In the event of a fallback failure the whole call fails - * with the weights returned. - * - * - `main`: The main call to be dispatched. This is the primary action to execute. - * - `fallback`: The fallback call to be dispatched in case the `main` call fails. - * - * ## Dispatch Logic - * - If the origin is `root`, both the main and fallback calls are executed without - * applying any origin filters. - * - If the origin is not `root`, the origin filter is applied to both the `main` and - * `fallback` calls. - * - * ## Use Case - * - Some use cases might involve submitting a `batch` type call in either main, fallback - * or both. - */ - "if_else": Anonymize; - /** - * Dispatches a function call with a provided origin. - * - * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call. - * - * The dispatch origin for this call must be _Root_. - */ - "dispatch_as_fallible": Anonymize; -}>; -export type I80tnmsfsu19sl = { - "calls": Array; -}; -export type Ib7nn1mns0usdp = { - "index": number; - "call": TxCallData; -}; -export type I4fivl1mrn0hhc = { - "as_origin": Anonymize; - "call": TxCallData; -}; -export type I2ead8rm0h16hm = { - "call": TxCallData; - "weight": Anonymize; -}; -export type I25l72483lbgf9 = { - "main": TxCallData; - "fallback": TxCallData; -}; -export type Ic3n0u1krodt07 = AnonymousEnum<{ - /** - * Authenticates the sudo key and dispatches a function call with `Root` origin. - */ - "sudo": Anonymize; - /** - * Authenticates the sudo key and dispatches a function call with `Root` origin. - * This function does not check the weight of the call, and instead allows the - * Sudo user to specify the weight of the call. - * - * The dispatch origin for this call must be _Signed_. - */ - "sudo_unchecked_weight": Anonymize; - /** - * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo - * key. - */ - "set_key": Anonymize; - /** - * Authenticates the sudo key and dispatches a function call with `Signed` origin from - * a given account. - * - * The dispatch origin for this call must be _Signed_. - */ - "sudo_as": Anonymize; - /** - * Permanently removes the sudo key. - * - * **This cannot be un-done.** - */ - "remove_key": undefined; -}>; -export type I9okvr56cd7277 = { - "call": TxCallData; -}; -export type I8k3rnvpeeh4hv = { - "new": MultiAddress; -}; -export type I56sht7incdimf = { - "who": MultiAddress; - "call": TxCallData; -}; -export type I92oc1s48b79mg = AnonymousEnum<{ - /** - * Immediately dispatch a multi-signature call using a single approval from the caller. - * - * The dispatch origin for this call must be _Signed_. - * - * - `other_signatories`: The accounts (other than the sender) who are part of the - * multi-signature, but do not participate in the approval process. - * - `call`: The call to be executed. - * - * Result is equivalent to the dispatched result. - * - * ## Complexity - * O(Z + C) where Z is the length of the call and C its execution weight. - */ - "as_multi_threshold_1": Anonymize; - /** - * Register approval for a dispatch to be made from a deterministic composite account if - * approved by a total of `threshold - 1` of `other_signatories`. - * - * If there are enough, then dispatch the call. - * - * Payment: `DepositBase` will be reserved if this is the first approval, plus - * `threshold` times `DepositFactor`. It is returned once this dispatch happens or - * is cancelled. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is - * not the first approval, then it must be `Some`, with the timepoint (block number and - * transaction index) of the first approval transaction. - * - `call`: The call to be executed. - * - * NOTE: Unless this is the final approval, you will generally want to use - * `approve_as_multi` instead, since it only requires a hash of the call. - * - * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise - * on success, result is `Ok` and the result from the interior call, if it was executed, - * may be found in the deposited `MultisigExecuted` event. - * - * ## Complexity - * - `O(S + Z + Call)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. - * - One encode & hash, both of complexity `O(S)`. - * - Up to one binary search and insert (`O(logS + S)`). - * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. - * - One event. - * - The weight of the `call`. - * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit - * taken for its lifetime of `DepositBase + threshold * DepositFactor`. - */ - "as_multi": Anonymize; - /** - * Register approval for a dispatch to be made from a deterministic composite account if - * approved by a total of `threshold - 1` of `other_signatories`. - * - * Payment: `DepositBase` will be reserved if this is the first approval, plus - * `threshold` times `DepositFactor`. It is returned once this dispatch happens or - * is cancelled. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is - * not the first approval, then it must be `Some`, with the timepoint (block number and - * transaction index) of the first approval transaction. - * - `call_hash`: The hash of the call to be executed. - * - * NOTE: If this is the final approval, you will want to use `as_multi` instead. - * - * ## Complexity - * - `O(S)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One encode & hash, both of complexity `O(S)`. - * - Up to one binary search and insert (`O(logS + S)`). - * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. - * - One event. - * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit - * taken for its lifetime of `DepositBase + threshold * DepositFactor`. - */ - "approve_as_multi": Anonymize; - /** - * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously - * for this operation will be unreserved on success. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `timepoint`: The timepoint (block number and transaction index) of the first approval - * transaction for this dispatch. - * - `call_hash`: The hash of the call to be executed. - * - * ## Complexity - * - `O(S)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One encode & hash, both of complexity `O(S)`. - * - One event. - * - I/O: 1 read `O(S)`, one remove. - * - Storage: removes one item. - */ - "cancel_as_multi": Anonymize; - /** - * Poke the deposit reserved for an existing multisig operation. - * - * The dispatch origin for this call must be _Signed_ and must be the original depositor of - * the multisig operation. - * - * The transaction fee is waived if the deposit amount has changed. - * - * - `threshold`: The total number of approvals needed for this multisig. - * - `other_signatories`: The accounts (other than the sender) who are part of the - * multisig. - * - `call_hash`: The hash of the call this deposit is reserved for. - * - * Emits `DepositPoked` if successful. - */ - "poke_deposit": Anonymize; -}>; -export type I8hge8nrufr05f = { - "other_signatories": Anonymize; - "call": TxCallData; -}; -export type I5v0mk7rggegmh = { - "threshold": number; - "other_signatories": Anonymize; - "maybe_timepoint"?: Anonymize; - "call": TxCallData; - "max_weight": Anonymize; -}; -export type I95jfd8j5cr5eh = (Anonymize) | undefined; -export type Ideaemvoneh309 = { - "threshold": number; - "other_signatories": Anonymize; - "maybe_timepoint"?: Anonymize; - "call_hash": FixedSizeBinary<32>; - "max_weight": Anonymize; -}; -export type I3d9o9d7epp66v = { - "threshold": number; - "other_signatories": Anonymize; - "timepoint": Anonymize; - "call_hash": FixedSizeBinary<32>; -}; -export type I6lqh1vgb4mcja = { - "threshold": number; - "other_signatories": Anonymize; - "call_hash": FixedSizeBinary<32>; -}; -export type If81ks88t5mpk5 = AnonymousEnum<{ - /** - * Register a preimage on-chain. - * - * If the preimage was previously requested, no fees or deposits are taken for providing - * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. - */ - "note_preimage": Anonymize; - /** - * Clear an unrequested preimage from the runtime storage. - * - * If `len` is provided, then it will be a much cheaper operation. - * - * - `hash`: The hash of the preimage to be removed from the store. - * - `len`: The length of the preimage of `hash`. - */ - "unnote_preimage": Anonymize; - /** - * Request a preimage be uploaded to the chain without paying any fees or deposits. - * - * If the preimage requests has already been provided on-chain, we unreserve any deposit - * a user may have paid, and take the control of the preimage out of their hands. - */ - "request_preimage": Anonymize; - /** - * Clear a previously made request for a preimage. - * - * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. - */ - "unrequest_preimage": Anonymize; - /** - * Ensure that the bulk of pre-images is upgraded. - * - * The caller pays no fee if at least 90% of pre-images were successfully updated. - */ - "ensure_updated": Anonymize; -}>; -export type I82nfqfkd48n10 = { - "bytes": Binary; -}; -export type I3o5j3bli1pd8e = { - "hashes": Anonymize; -}; -export type I8joseop2odch3 = AnonymousEnum<{ - /** - * Anonymously schedule a task. - */ - "schedule": Anonymize; - /** - * Cancel an anonymously scheduled task. - */ - "cancel": Anonymize; - /** - * Schedule a named task. - */ - "schedule_named": Anonymize; - /** - * Cancel a named scheduled task. - */ - "cancel_named": Anonymize; - /** - * Anonymously schedule a task after a delay. - */ - "schedule_after": Anonymize; - /** - * Schedule a named task after a delay. - */ - "schedule_named_after": Anonymize; - /** - * Set a retry configuration for a task so that, in case its scheduled run fails, it will - * be retried after `period` blocks, for a total amount of `retries` retries or until it - * succeeds. - * - * Tasks which need to be scheduled for a retry are still subject to weight metering and - * agenda space, same as a regular task. If a periodic task fails, it will be scheduled - * normally while the task is retrying. - * - * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic - * clones of the original task. Their retry configuration will be derived from the - * original task's configuration, but will have a lower value for `remaining` than the - * original `total_retries`. - */ - "set_retry": Anonymize; - /** - * Set a retry configuration for a named task so that, in case its scheduled run fails, it - * will be retried after `period` blocks, for a total amount of `retries` retries or until - * it succeeds. - * - * Tasks which need to be scheduled for a retry are still subject to weight metering and - * agenda space, same as a regular task. If a periodic task fails, it will be scheduled - * normally while the task is retrying. - * - * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic - * clones of the original task. Their retry configuration will be derived from the - * original task's configuration, but will have a lower value for `remaining` than the - * original `total_retries`. - */ - "set_retry_named": Anonymize; - /** - * Removes the retry configuration of a task. - */ - "cancel_retry": Anonymize; - /** - * Cancel the retry configuration of a named task. - */ - "cancel_retry_named": Anonymize; -}>; -export type Ivqkjqsbgj1dj = { - "when": number; - "maybe_periodic"?: Anonymize; - "priority": number; - "call": TxCallData; -}; -export type Ib6bm2ug64rldc = { - "id": FixedSizeBinary<32>; - "when": number; - "maybe_periodic"?: Anonymize; - "priority": number; - "call": TxCallData; -}; -export type Ifs1i5fk9cqvr6 = { - "id": FixedSizeBinary<32>; -}; -export type I5q3t0hm83a58h = { - "after": number; - "maybe_periodic"?: Anonymize; - "priority": number; - "call": TxCallData; -}; -export type I2gnaqoj2eimi0 = { - "id": FixedSizeBinary<32>; - "after": number; - "maybe_periodic"?: Anonymize; - "priority": number; - "call": TxCallData; -}; -export type Ieg3fd8p4pkt10 = { - "task": Anonymize; - "retries": number; - "period": number; -}; -export type I8kg5ll427kfqq = { - "id": FixedSizeBinary<32>; - "retries": number; - "period": number; -}; -export type I467333262q1l9 = { - "task": Anonymize; -}; -export type Ia2ee5fnr4ukkf = AnonymousEnum<{ - /** - * Dispatch the given `call` from an account that the sender is authorised for through - * `add_proxy`. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. - * - `call`: The call to be made by the `real` account. - */ - "proxy": Anonymize; - /** - * Register a proxy account for the sender that is able to make calls on its behalf. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `proxy`: The account that the `caller` would like to make a proxy. - * - `proxy_type`: The permissions allowed for this proxy account. - * - `delay`: The announcement period required of the initial proxy. Will generally be - * zero. - */ - "add_proxy": Anonymize; - /** - * Unregister a proxy account for the sender. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `proxy`: The account that the `caller` would like to remove as a proxy. - * - `proxy_type`: The permissions currently enabled for the removed proxy account. - */ - "remove_proxy": Anonymize; - /** - * Unregister all proxy accounts for the sender. - * - * The dispatch origin for this call must be _Signed_. - * - * WARNING: This may be called on accounts created by `create_pure`, however if done, then - * the unreserved fees will be inaccessible. **All access to this account will be lost.** - */ - "remove_proxies": undefined; - /** - * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and - * initialize it with a proxy of `proxy_type` for `origin` sender. - * - * Requires a `Signed` origin. - * - * - `proxy_type`: The type of the proxy that the sender will be registered as over the - * new account. This will almost always be the most permissive `ProxyType` possible to - * allow for maximum flexibility. - * - `index`: A disambiguation index, in case this is called multiple times in the same - * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just - * want to use `0`. - * - `delay`: The announcement period required of the initial proxy. Will generally be - * zero. - * - * Fails with `Duplicate` if this has already been called in this transaction, from the - * same sender, with the same parameters. - * - * Fails if there are insufficient funds to pay for deposit. - */ - "create_pure": Anonymize; - /** - * Removes a previously spawned pure proxy. - * - * WARNING: **All access to this account will be lost.** Any funds held in it will be - * inaccessible. - * - * Requires a `Signed` origin, and the sender account must have been created by a call to - * `create_pure` with corresponding parameters. - * - * - `spawner`: The account that originally called `create_pure` to create this account. - * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`. - * - `proxy_type`: The proxy type originally passed to `create_pure`. - * - `height`: The height of the chain when the call to `create_pure` was processed. - * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed. - * - * Fails with `NoPermission` in case the caller is not a previously created pure - * account whose `create_pure` call has corresponding parameters. - */ - "kill_pure": Anonymize; - /** - * Publish the hash of a proxy-call that will be made in the future. - * - * This must be called some number of blocks before the corresponding `proxy` is attempted - * if the delay associated with the proxy relationship is greater than zero. - * - * No more than `MaxPending` announcements may be made at any one time. - * - * This will take a deposit of `AnnouncementDepositFactor` as well as - * `AnnouncementDepositBase` if there are no other pending announcements. - * - * The dispatch origin for this call must be _Signed_ and a proxy of `real`. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `call_hash`: The hash of the call to be made by the `real` account. - */ - "announce": Anonymize; - /** - * Remove a given announcement. - * - * May be called by a proxy account to remove a call they previously announced and return - * the deposit. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `call_hash`: The hash of the call to be made by the `real` account. - */ - "remove_announcement": Anonymize; - /** - * Remove the given announcement of a delegate. - * - * May be called by a target (proxied) account to remove a call that one of their delegates - * (`delegate`) has announced they want to execute. The deposit is returned. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `delegate`: The account that previously announced the call. - * - `call_hash`: The hash of the call to be made. - */ - "reject_announcement": Anonymize; - /** - * Dispatch the given `call` from an account that the sender is authorized for through - * `add_proxy`. - * - * Removes any corresponding announcement(s). - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. - * - `call`: The call to be made by the `real` account. - */ - "proxy_announced": Anonymize; - /** - * Poke / Adjust deposits made for proxies and announcements based on current values. - * This can be used by accounts to possibly lower their locked amount. - * - * The dispatch origin for this call must be _Signed_. - * - * The transaction fee is waived if the deposit amount has changed. - * - * Emits `DepositPoked` if successful. - */ - "poke_deposit": undefined; -}>; -export type Idlqs144rc48hk = { - "real": MultiAddress; - "force_proxy_type"?: Anonymize; - "call": TxCallData; -}; -export type Iccd9gbcgdpjso = (Anonymize) | undefined; -export type It11trpppbc3l = { - "delegate": MultiAddress; - "proxy_type": Anonymize; - "delay": number; -}; -export type Ietml13sclqs1q = { - "proxy_type": Anonymize; - "delay": number; - "index": number; -}; -export type Iftfic7p3uban2 = { - "spawner": MultiAddress; - "proxy_type": Anonymize; - "index": number; - "height": number; - "ext_index": number; -}; -export type I2eb501t8s6hsq = { - "real": MultiAddress; - "call_hash": FixedSizeBinary<32>; -}; -export type Ianmuoljk2sk1u = { - "delegate": MultiAddress; - "call_hash": FixedSizeBinary<32>; -}; -export type I7hgtlnpelk0fc = { - "delegate": MultiAddress; - "real": MultiAddress; - "force_proxy_type"?: Anonymize; - "call": TxCallData; -}; -export type Ifml9odtov51l3 = AnonymousEnum<{ - /** - * Register an identity for an account. This will overwrite any existing identity. - */ - "set_identity": Anonymize; - /** - * Clear the identity of an account. - */ - "clear_identity": Anonymize; -}>; -export type I3p6khp3nv37cu = { - "identified": SS58String; - "info": Anonymize; -}; -export type I6pnnj50tnq448 = { - "identified": SS58String; -}; -export type I5bqhvupj937er = AnonymousEnum<{ - /** - * Set the commitment for a given netuid - */ - "set_commitment": Anonymize; - /** - * Sudo-set MaxSpace - */ - "set_max_space": Anonymize; -}>; -export type I57v1t6776pl3a = { - "netuid": number; - "info": Anonymize; -}; -export type I1il5mj68vvsms = { - "new_limit": number; -}; -export type Iemvun0dttbcqs = AnonymousEnum<{ - /** - * The extrinsic sets the new authorities for Aura consensus. - * It is only callable by the root account. - * The extrinsic will call the Aura pallet to change the authorities. - */ - "swap_authorities": Anonymize; - /** - * The extrinsic sets the default take for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the default take. - */ - "sudo_set_default_take": Anonymize; - /** - * The extrinsic sets the transaction rate limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the transaction rate limit. - */ - "sudo_set_tx_rate_limit": Anonymize; - /** - * The extrinsic sets the serving rate limit for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the serving rate limit. - */ - "sudo_set_serving_rate_limit": Anonymize; - /** - * The extrinsic sets the minimum difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum difficulty. - */ - "sudo_set_min_difficulty": Anonymize; - /** - * The extrinsic sets the maximum difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum difficulty. - */ - "sudo_set_max_difficulty": Anonymize; - /** - * The extrinsic sets the weights version key for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the weights version key. - */ - "sudo_set_weights_version_key": Anonymize; - /** - * The extrinsic sets the weights set rate limit for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the weights set rate limit. - */ - "sudo_set_weights_set_rate_limit": Anonymize; - /** - * The extrinsic sets the adjustment interval for a subnet. - * It is only callable by the root account, not changeable by the subnet owner. - * The extrinsic will call the Subtensor pallet to set the adjustment interval. - */ - "sudo_set_adjustment_interval": Anonymize; - /** - * The extrinsic sets the adjustment alpha for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the adjustment alpha. - */ - "sudo_set_adjustment_alpha": Anonymize; - /** - * The extrinsic sets the immunity period for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the immunity period. - */ - "sudo_set_immunity_period": Anonymize; - /** - * The extrinsic sets the minimum allowed weights for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum allowed weights. - */ - "sudo_set_min_allowed_weights": Anonymize; - /** - * The extrinsic sets the maximum allowed UIDs for a subnet. - * It is only callable by the root account and subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum allowed UIDs for a subnet. - */ - "sudo_set_max_allowed_uids": Anonymize; - /** - * The extrinsic sets the kappa for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the kappa. - */ - "sudo_set_kappa": Anonymize; - /** - * The extrinsic sets the rho for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the rho. - */ - "sudo_set_rho": Anonymize; - /** - * The extrinsic sets the activity cutoff for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the activity cutoff. - */ - "sudo_set_activity_cutoff": Anonymize; - /** - * The extrinsic sets the network registration allowed for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the network registration allowed. - */ - "sudo_set_network_registration_allowed": Anonymize; - /** - * The extrinsic sets the network PoW registration allowed for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the network PoW registration allowed. - */ - "sudo_set_network_pow_registration_allowed": Anonymize; - /** - * The extrinsic sets the target registrations per interval for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the target registrations per interval. - */ - "sudo_set_target_registrations_per_interval": Anonymize; - /** - * The extrinsic sets the minimum burn for a subnet. - * It is only callable by root and subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum burn. - */ - "sudo_set_min_burn": Anonymize; - /** - * The extrinsic sets the maximum burn for a subnet. - * It is only callable by root and subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum burn. - */ - "sudo_set_max_burn": Anonymize; - /** - * The extrinsic sets the difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the difficulty. - */ - "sudo_set_difficulty": Anonymize; - /** - * The extrinsic sets the maximum allowed validators for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the maximum allowed validators. - */ - "sudo_set_max_allowed_validators": Anonymize; - /** - * The extrinsic sets the bonds moving average for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the bonds moving average. - */ - "sudo_set_bonds_moving_average": Anonymize; - /** - * The extrinsic sets the bonds penalty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the bonds penalty. - */ - "sudo_set_bonds_penalty": Anonymize; - /** - * The extrinsic sets the maximum registrations per block for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the maximum registrations per block. - */ - "sudo_set_max_registrations_per_block": Anonymize; - /** - * The extrinsic sets the subnet owner cut for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the subnet owner cut. - */ - "sudo_set_subnet_owner_cut": Anonymize; - /** - * The extrinsic sets the network rate limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the network rate limit. - */ - "sudo_set_network_rate_limit": Anonymize; - /** - * The extrinsic sets the tempo for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the tempo. - */ - "sudo_set_tempo": Anonymize; - /** - * The extrinsic sets the total issuance for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the issuance for the network. - */ - "sudo_set_total_issuance": Anonymize; - /** - * The extrinsic sets the immunity period for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the immunity period for the network. - */ - "sudo_set_network_immunity_period": Anonymize; - /** - * The extrinsic sets the min lock cost for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the min lock cost for the network. - */ - "sudo_set_network_min_lock_cost": Anonymize; - /** - * The extrinsic sets the subnet limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the subnet limit. - */ - "sudo_set_subnet_limit": Anonymize; - /** - * The extrinsic sets the lock reduction interval for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the lock reduction interval. - */ - "sudo_set_lock_reduction_interval": Anonymize; - /** - * The extrinsic sets the recycled RAO for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the recycled RAO. - */ - "sudo_set_rao_recycled": Anonymize; - /** - * The extrinsic sets the weights min stake. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the weights min stake. - */ - "sudo_set_stake_threshold": Anonymize; - /** - * The extrinsic sets the minimum stake required for nominators. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the minimum stake required for nominators. - */ - "sudo_set_nominator_min_required_stake": Anonymize; - /** - * The extrinsic sets the rate limit for delegate take transactions. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the rate limit for delegate take transactions. - */ - "sudo_set_tx_delegate_take_rate_limit": Anonymize; - /** - * The extrinsic sets the minimum delegate take. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the minimum delegate take. - */ - "sudo_set_min_delegate_take": Anonymize; - /** - * The extrinsic enabled/disables commit/reaveal for a given subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the value. - */ - "sudo_set_commit_reveal_weights_enabled": Anonymize; - /** - * Enables or disables Liquid Alpha for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Liquid Alpha. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - "sudo_set_liquid_alpha_enabled": Anonymize; - /** - * Sets values for liquid alpha - */ - "sudo_set_alpha_values": Anonymize; - /** - * Sets the duration of the dissolve network schedule. - * - * This extrinsic allows the root account to set the duration for the dissolve network schedule. - * The dissolve network schedule determines how long it takes for a network dissolution operation to complete. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `duration` - The new duration for the dissolve network schedule, in number of blocks. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_dissolve_network_schedule_duration": Anonymize; - /** - * Sets the commit-reveal weights periods for a specific subnet. - * - * This extrinsic allows the subnet owner or root account to set the duration (in epochs) during which committed weights must be revealed. - * The commit-reveal mechanism ensures that users commit weights in advance and reveal them only within a specified period. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or the root account. - * * `netuid` - The unique identifier of the subnet for which the periods are being set. - * * `periods` - The number of epochs that define the commit-reveal period. - * - * # Errors - * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. - * * `SubnetDoesNotExist` - If the specified subnet does not exist. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_commit_reveal_weights_interval": Anonymize; - /** - * Sets the EVM ChainID. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or the root account. - * * `chainId` - The u64 chain ID - * - * # Errors - * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_evm_chain_id": Anonymize; - /** - * A public interface for `pallet_grandpa::Pallet::schedule_grandpa_change`. - * - * Schedule a change in the authorities. - * - * The change will be applied at the end of execution of the block `in_blocks` after the - * current block. This value may be 0, in which case the change is applied at the end of - * the current block. - * - * If the `forced` parameter is defined, this indicates that the current set has been - * synchronously determined to be offline and that after `in_blocks` the given change - * should be applied. The given block number indicates the median last finalized block - * number and it should be used as the canon block when starting the new grandpa voter. - * - * No change should be signaled while any change is pending. Returns an error if a change - * is already pending. - */ - "schedule_grandpa_change": Anonymize; - /** - * Enable or disable atomic alpha transfers for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Liquid Alpha. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - "sudo_set_toggle_transfer": Anonymize; - /** - * Set the behaviour of the "burn" UID(s) for a given subnet. - * If set to `Burn`, the miner emission sent to the burn UID(s) will be burned. - * If set to `Recycle`, the miner emission sent to the burn UID(s) will be recycled. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `recycle_or_burn`: The desired behaviour of the "burn" UID(s) for the subnet. - * - */ - "sudo_set_recycle_or_burn": Anonymize; - /** - * Toggles the enablement of an EVM precompile. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `precompile_id` - The identifier of the EVM precompile to toggle. - * * `enabled` - The new enablement state of the precompile. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_toggle_evm_precompile": Anonymize; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `alpha` - The new moving alpha value for the SubnetMovingAlpha. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_subnet_moving_alpha": Anonymize; - /** - * Change the SubnetOwnerHotkey for a given subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner. - * * `netuid` - The unique identifier for the subnet. - * * `hotkey` - The new hotkey for the subnet owner. - * - * # Errors - * * `BadOrigin` - If the caller is not the subnet owner or root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_subnet_owner_hotkey": Anonymize; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `ema_alpha_period` - Number of blocks for EMA price to halve - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_ema_price_halving_period": Anonymize; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `netuid` - The unique identifier for the subnet. - * * `steepness` - The Steepness for the alpha sigmoid function. (range is 0-int16::MAX, - * negative values are reserved for future use) - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * * `SubnetDoesNotExist` - If the specified subnet does not exist. - * * `NegativeSigmoidSteepness` - If the steepness is negative and the caller is - * root. - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_alpha_sigmoid_steepness": Anonymize; - /** - * Enables or disables Yuma3 for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Yuma3. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - "sudo_set_yuma3_enabled": Anonymize; - /** - * Enables or disables Bonds Reset for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Bonds Reset. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - "sudo_set_bonds_reset_enabled": Anonymize; - /** - * Sets or updates the hotkey account associated with the owner of a specific subnet. - * - * This function allows either the root origin or the current subnet owner to set or update - * the hotkey for a given subnet. The subnet must already exist. To prevent abuse, the call is - * rate-limited to once per configured interval (default: one week) per subnet. - * - * # Parameters - * - `origin`: The dispatch origin of the call. Must be either root or the current owner of the subnet. - * - `netuid`: The unique identifier of the subnet whose owner hotkey is being set. - * - `hotkey`: The new hotkey account to associate with the subnet owner. - * - * # Returns - * - `DispatchResult`: Returns `Ok(())` if the hotkey was successfully set, or an appropriate error otherwise. - * - * # Errors - * - `Error::SubnetNotExists`: If the specified subnet does not exist. - * - `Error::TxRateLimitExceeded`: If the function is called more frequently than the allowed rate limit. - * - * # Access Control - * Only callable by: - * - Root origin, or - * - The coldkey account that owns the subnet. - * - * # Storage - * - Updates [`SubnetOwnerHotkey`] for the given `netuid`. - * - Reads and updates [`LastRateLimitedBlock`] for rate-limiting. - * - Reads [`DefaultSetSNOwnerHotkeyRateLimit`] to determine the interval between allowed updates. - * - * # Rate Limiting - * This function is rate-limited to one call per subnet per interval (e.g., one week). - */ - "sudo_set_sn_owner_hotkey": Anonymize; - /** - * Enables or disables subtoken trading for a given subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `netuid` - The unique identifier of the subnet. - * * `subtoken_enabled` - A boolean indicating whether subtoken trading should be enabled or disabled. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - "sudo_set_subtoken_enabled": Anonymize; - /** - * Sets the commit-reveal weights version for all subnets - */ - "sudo_set_commit_reveal_version": Anonymize; - /** - * Sets the number of immune owner neurons - */ - "sudo_set_owner_immune_neuron_limit": Anonymize; - /** - * Sets the childkey burn for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the childkey burn. - */ - "sudo_set_ck_burn": Anonymize; - /** - * Sets the admin freeze window length (in blocks) at the end of a tempo. - * Only callable by root. - */ - "sudo_set_admin_freeze_window": Anonymize; - /** - * Sets the owner hyperparameter rate limit in epochs (global multiplier). - * Only callable by root. - */ - "sudo_set_owner_hparam_rate_limit": Anonymize; - /** - * Sets the desired number of mechanisms in a subnet - */ - "sudo_set_mechanism_count": Anonymize; - /** - * Sets the emission split between mechanisms in a subnet - */ - "sudo_set_mechanism_emission_split": Anonymize; - /** - * Trims the maximum number of UIDs for a subnet. - * - * The trimming is done by sorting the UIDs by emission descending and then trimming - * the lowest emitters while preserving temporally and owner immune UIDs. The UIDs are - * then compressed to the left and storage is migrated to the new compressed UIDs. - */ - "sudo_trim_to_max_allowed_uids": Anonymize; - /** - * The extrinsic sets the minimum allowed UIDs for a subnet. - * It is only callable by the root account. - */ - "sudo_set_min_allowed_uids": Anonymize; - /** - * Sets TAO flow cutoff value (A) - */ - "sudo_set_tao_flow_cutoff": Anonymize; - /** - * Sets TAO flow normalization exponent (p) - */ - "sudo_set_tao_flow_normalization_exponent": Anonymize; - /** - * Sets TAO flow smoothing factor (alpha) - */ - "sudo_set_tao_flow_smoothing_factor": Anonymize; - /** - * Sets the global maximum number of mechanisms in a subnet - */ - "sudo_set_max_mechanism_count": Anonymize; - /** - * Sets the minimum number of non-immortal & non-immune UIDs that must remain in a subnet - */ - "sudo_set_min_non_immune_uids": Anonymize; - /** - * Sets the delay before a subnet can call start - */ - "sudo_set_start_call_delay": Anonymize; - /** - * Sets the announcement delay for coldkey swap. - */ - "sudo_set_coldkey_swap_announcement_delay": Anonymize; - /** - * Sets the coldkey swap reannouncement delay. - */ - "sudo_set_coldkey_swap_reannouncement_delay": Anonymize; -}>; -export type I42mob3hqe6j7h = { - "new_authorities": Anonymize; -}; -export type Icdbq0j31b3g9c = { - "default_take": number; -}; -export type I2t2rlclb0ce3e = { - "netuid": number; - "serving_rate_limit": bigint; -}; -export type Iar87gdqmug5o7 = { - "netuid": number; - "min_difficulty": bigint; -}; -export type I3oullii9p80a1 = { - "netuid": number; - "max_difficulty": bigint; -}; -export type I8t8ta6lfbia9e = { - "netuid": number; - "weights_version_key": bigint; -}; -export type I3akfmjle982qg = { - "netuid": number; - "weights_set_rate_limit": bigint; -}; -export type Ibaje86kdit7s6 = { - "netuid": number; - "adjustment_interval": number; -}; -export type I90lra4vl5j4db = { - "netuid": number; - "adjustment_alpha": bigint; -}; -export type I1q480m57ftcms = { - "netuid": number; - "immunity_period": number; -}; -export type Ie2bjglo51atf6 = { - "netuid": number; - "min_allowed_weights": number; -}; -export type Ievma38tc25kil = { - "netuid": number; - "max_allowed_uids": number; -}; -export type I2er75v4akf5cc = { - "netuid": number; - "kappa": number; -}; -export type I5pldh0j0v0u4l = { - "netuid": number; - "rho": number; -}; -export type Ifhou5p0slv68r = { - "netuid": number; - "activity_cutoff": number; -}; -export type I9m89dnau2i4tt = { - "netuid": number; - "registration_allowed": boolean; -}; -export type Ifunpjbsc4jrrr = { - "netuid": number; - "target_registrations_per_interval": number; -}; -export type I85uujfpnu8gum = { - "netuid": number; - "min_burn": bigint; -}; -export type I7bl5t0it6ck2m = { - "netuid": number; - "max_burn": bigint; -}; -export type I4iope0tjiqgu4 = { - "netuid": number; - "difficulty": bigint; -}; -export type Iptqa236frcvo = { - "netuid": number; - "max_allowed_validators": number; -}; -export type I8hbi1vrve1i2 = { - "netuid": number; - "bonds_moving_average": bigint; -}; -export type I1v9a50gjqk26k = { - "netuid": number; - "bonds_penalty": number; -}; -export type Idv4d3rktbigfh = { - "netuid": number; - "max_registrations_per_block": number; -}; -export type I56j1e9gqlq602 = { - "subnet_owner_cut": number; -}; -export type Ib6k4vik9ruq8h = { - "rate_limit": bigint; -}; -export type I9u9gu9aa92l5m = { - "netuid": number; - "tempo": number; -}; -export type Idmd4tos09qd68 = { - "total_issuance": bigint; -}; -export type Ia0sp2p68e9k16 = { - "immunity_period": bigint; -}; -export type Ie318529rgoagk = { - "lock_cost": bigint; -}; -export type Iam4iou8r3isc1 = { - "max_subnets": number; -}; -export type I21ajnsdtbutjh = { - "interval": bigint; -}; -export type I203rofi4rpmo4 = { - "netuid": number; - "rao_recycled": bigint; -}; -export type I1e290fmo892vi = { - "min_stake": bigint; -}; -export type I71lu4gpn88cf0 = { - "netuid": number; - "alpha_low": number; - "alpha_high": number; -}; -export type I98iornf3ajrp9 = { - "duration": number; -}; -export type I9893mbk9nh201 = { - "netuid": number; - "interval": bigint; -}; -export type I623eo8t3jrbeo = { - "chain_id": bigint; -}; -export type Ieo8qamskgm4dk = { - "next_authorities": Anonymize; - "in_blocks": number; - "forced"?: Anonymize; -}; -export type Ift1efpssa32g2 = { - "netuid": number; - "toggle": boolean; -}; -export type Ibk3v0rrpo1bio = { - "netuid": number; - "recycle_or_burn": Anonymize; -}; -export type I6av3sq9jkhmm3 = { - "alpha": bigint; -}; -export type I70cd7doki8rme = { - "netuid": number; - "ema_halving": bigint; -}; -export type Iam7j42j9f1go6 = { - "netuid": number; - "steepness": number; -}; -export type Idco9ambhipg4i = { - "netuid": number; - "subtoken_enabled": boolean; -}; -export type I6s1nbislhk619 = { - "version": number; -}; -export type I9jtu7slb30qvs = { - "netuid": number; - "immune_neurons": number; -}; -export type Idv3j6a15pjc16 = { - "burn": bigint; -}; -export type I206qvjkjun95i = { - "window": number; -}; -export type I4qhb3plq4ifmq = { - "epochs": number; -}; -export type Ic58lhlh1ocpm1 = { - "netuid": number; - "mechanism_count": number; -}; -export type I6uopd4b2os90n = { - "netuid": number; - "maybe_split"?: Anonymize; -}; -export type I35lk2003i8c8g = (Anonymize) | undefined; -export type I6idbvi8v00o5j = { - "netuid": number; - "max_n": number; -}; -export type Ifbgbhkj74b35k = { - "netuid": number; - "min_allowed_uids": number; -}; -export type Ibt4a800kb7frq = { - "flow_cutoff": bigint; -}; -export type Icb4un8h4cokoo = { - "exponent": bigint; -}; -export type I1up607q6ce947 = { - "smoothing_factor": bigint; -}; -export type I7hktg5sccf8op = { - "max_mechanism_count": number; -}; -export type Ib1d0bomkbrqv1 = { - "netuid": number; - "min": number; -}; -export type Iaflrold1ds0nq = { - "delay": bigint; -}; -export type I48eehof2eias5 = AnonymousEnum<{ - /** - * Enter safe-mode permissionlessly for [`Config::EnterDuration`] blocks. - * - * Reserves [`Config::EnterDepositAmount`] from the caller's account. - * Emits an [`Event::Entered`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is already entered. - * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. - */ - "enter": undefined; - /** - * Enter safe-mode by force for a per-origin configured number of blocks. - * - * Emits an [`Event::Entered`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is already entered. - * - * Can only be called by the [`Config::ForceEnterOrigin`] origin. - */ - "force_enter": undefined; - /** - * Extend the safe-mode permissionlessly for [`Config::ExtendDuration`] blocks. - * - * This accumulates on top of the current remaining duration. - * Reserves [`Config::ExtendDepositAmount`] from the caller's account. - * Emits an [`Event::Extended`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is entered. - * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. - * - * This may be called by any signed origin with [`Config::ExtendDepositAmount`] free - * currency to reserve. This call can be disabled for all origins by configuring - * [`Config::ExtendDepositAmount`] to `None`. - */ - "extend": undefined; - /** - * Extend the safe-mode by force for a per-origin configured number of blocks. - * - * Emits an [`Event::Extended`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is inactive. - * - * Can only be called by the [`Config::ForceExtendOrigin`] origin. - */ - "force_extend": undefined; - /** - * Exit safe-mode by force. - * - * Emits an [`Event::Exited`] with [`ExitReason::Force`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is inactive. - * - * Note: `safe-mode` will be automatically deactivated by [`Pallet::on_initialize`] hook - * after the block height is greater than the [`EnteredUntil`] storage item. - * Emits an [`Event::Exited`] with [`ExitReason::Timeout`] event when deactivated in the - * hook. - */ - "force_exit": undefined; - /** - * Slash a deposit for an account that entered or extended safe-mode at a given - * historical block. - * - * This can only be called while safe-mode is entered. - * - * Emits a [`Event::DepositSlashed`] event on success. - * Errors with [`Error::Entered`] if safe-mode is entered. - * - * Can only be called by the [`Config::ForceDepositOrigin`] origin. - */ - "force_slash_deposit": Anonymize; - /** - * Permissionlessly release a deposit for an account that entered safe-mode at a - * given historical block. - * - * The call can be completely disabled by setting [`Config::ReleaseDelay`] to `None`. - * This cannot be called while safe-mode is entered and not until - * [`Config::ReleaseDelay`] blocks have passed since safe-mode was entered. - * - * Emits a [`Event::DepositReleased`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is entered. - * Errors with [`Error::CannotReleaseYet`] if [`Config::ReleaseDelay`] block have not - * passed since safe-mode was entered. Errors with [`Error::NoDeposit`] if the payee has no - * reserved currency at the block specified. - */ - "release_deposit": Anonymize; - /** - * Force to release a deposit for an account that entered safe-mode at a given - * historical block. - * - * This can be called while safe-mode is still entered. - * - * Emits a [`Event::DepositReleased`] event on success. - * Errors with [`Error::Entered`] if safe-mode is entered. - * Errors with [`Error::NoDeposit`] if the payee has no reserved currency at the - * specified block. - * - * Can only be called by the [`Config::ForceDepositOrigin`] origin. - */ - "force_release_deposit": Anonymize; -}>; -export type I1ssp78ejl639m = { - "account": SS58String; - "block": number; -}; -export type I3lo8is2egp8k4 = AnonymousEnum<{ - /** - * Transact an Ethereum transaction. - */ - "transact": Anonymize; -}>; -export type I13qib3vtm9cs3 = { - "transaction": Anonymize; -}; -export type Iafltn68socb5h = AnonymousEnum<{ - /** - * Withdraw balance from EVM into currency/balances pallet. - */ - "withdraw": Anonymize; - /** - * Issue an EVM call operation. This is similar to a message call transaction in Ethereum. - */ - "call": Anonymize; - /** - * Issue an EVM create operation. This is similar to a contract creation transaction in - * Ethereum. - */ - "create": Anonymize; - /** - * Issue an EVM create2 operation. - */ - "create2": Anonymize; - "set_whitelist": Anonymize; - "disable_whitelist": Anonymize; -}>; -export type Idcabvplu05lea = { - "address": FixedSizeBinary<20>; - "value": bigint; -}; -export type Id38gdpcotl637 = { - "source": FixedSizeBinary<20>; - "target": FixedSizeBinary<20>; - "input": Binary; - "value": Anonymize; - "gas_limit": bigint; - "max_fee_per_gas": Anonymize; - "max_priority_fee_per_gas"?: Anonymize; - "nonce"?: Anonymize; - "access_list": Anonymize; - "authorization_list": Anonymize; -}; -export type Ic4rgfgksgmm3e = (Anonymize) | undefined; -export type I1bsfec060j604 = Array<[FixedSizeBinary<20>, Anonymize]>; -export type I73q3qf5u7nnqg = { - "source": FixedSizeBinary<20>; - "init": Binary; - "value": Anonymize; - "gas_limit": bigint; - "max_fee_per_gas": Anonymize; - "max_priority_fee_per_gas"?: Anonymize; - "nonce"?: Anonymize; - "access_list": Anonymize; - "authorization_list": Anonymize; -}; -export type Idpm1bc2cr6dgj = { - "source": FixedSizeBinary<20>; - "init": Binary; - "salt": FixedSizeBinary<32>; - "value": Anonymize; - "gas_limit": bigint; - "max_fee_per_gas": Anonymize; - "max_priority_fee_per_gas"?: Anonymize; - "nonce"?: Anonymize; - "access_list": Anonymize; - "authorization_list": Anonymize; -}; -export type I837c61fc07ine = { - "new": Anonymize; -}; -export type I6m0oguilvhn8 = { - "disabled": boolean; -}; -export type I2aqcjbjlffus = AnonymousEnum<{ - "set_base_fee_per_gas": Anonymize; - "set_elasticity": Anonymize; -}>; -export type Ibdf4fkp7qcokd = AnonymousEnum<{ - /** - * Verify and write a pulse from the beacon into the runtime - */ - "write_pulse": Anonymize; - /** - * allows the root user to set the beacon configuration - * generally this would be called from an offchain worker context. - * there is no verification of configurations, so be careful with this. - * - * * `origin`: the root user - * * `config`: the beacon configuration - */ - "set_beacon_config": Anonymize; - /** - * allows the root user to set the oldest stored round - */ - "set_oldest_stored_round": Anonymize; -}>; -export type I87tlou92i0bot = { - "pulses_payload": { - "block_number": number; - "pulses": Array>; - "public": MultiSigner; - }; - "signature"?: Anonymize; -}; -export type MultiSigner = Enum<{ - "Ed25519": FixedSizeBinary<32>; - "Sr25519": FixedSizeBinary<32>; - "Ecdsa": FixedSizeBinary<33>; -}>; -export declare const MultiSigner: GetEnum; -export type I86cdjmsf3a81s = (MultiSignature) | undefined; -export type MultiSignature = Enum<{ - "Ed25519": FixedSizeBinary<64>; - "Sr25519": FixedSizeBinary<64>; - "Ecdsa": FixedSizeBinary<65>; -}>; -export declare const MultiSignature: GetEnum; -export type Ifd3mkud9g8rb1 = { - "config_payload": { - "block_number": number; - "config": Anonymize; - "public": MultiSigner; - }; - "signature"?: Anonymize; -}; -export type Iakvbbhvger3oa = { - "oldest_round": bigint; -}; -export type I6nul30pateutj = AnonymousEnum<{ - /** - * Create a crowdloan that will raise funds up to a maximum cap and if successful, - * will transfer funds to the target address if provided and dispatch the call - * (using creator origin). - * - * The initial deposit will be transfered to the crowdloan account and will be refunded - * in case the crowdloan fails to raise the cap. Additionally, the creator will pay for - * the execution of the call. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `deposit`: The initial deposit from the creator. - * - `min_contribution`: The minimum contribution required to contribute to the crowdloan. - * - `cap`: The maximum amount of funds that can be raised. - * - `end`: The block number at which the crowdloan will end. - * - `call`: The call to dispatch when the crowdloan is finalized. - * - `target_address`: The address to transfer the raised funds to if provided. - */ - "create": Anonymize; - /** - * Contribute to an active crowdloan. - * - * The contribution will be transfered to the crowdloan account and will be refunded - * if the crowdloan fails to raise the cap. If the contribution would raise the amount above the cap, - * the contribution will be set to the amount that is left to be raised. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to contribute to. - * - `amount`: The amount to contribute. - */ - "contribute": Anonymize; - /** - * Withdraw a contribution from an active (not yet finalized or dissolved) crowdloan. - * - * Only contributions over the deposit can be withdrawn by the creator. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to withdraw from. - */ - "withdraw": Anonymize; - /** - * Finalize crowdloan that has reached the cap. - * - * The call will transfer the raised amount to the target address if it was provided when the crowdloan was created - * and dispatch the call that was provided using the creator origin. The CurrentCrowdloanId will be set to the - * crowdloan id being finalized so the dispatched call can access it temporarily by accessing - * the `CurrentCrowdloanId` storage item. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to finalize. - */ - "finalize": Anonymize; - /** - * Refund contributors of a non-finalized crowdloan. - * - * The call will try to refund all contributors (excluding the creator) up to the limit defined by the `RefundContributorsLimit`. - * If the limit is reached, the call will stop and the crowdloan will be marked as partially refunded. - * It may be needed to dispatch this call multiple times to refund all contributors. - * - * The dispatch origin for this call must be _Signed_ and doesn't need to be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to refund. - */ - "refund": Anonymize; - /** - * Dissolve a crowdloan. - * - * The crowdloan will be removed from the storage. - * All contributions must have been refunded before the crowdloan can be dissolved (except the creator's one). - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to dissolve. - */ - "dissolve": Anonymize; - /** - * Update the minimum contribution of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the minimum contribution of. - * - `new_min_contribution`: The new minimum contribution. - */ - "update_min_contribution": Anonymize; - /** - * Update the end block of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the end block of. - * - `new_end`: The new end block. - */ - "update_end": Anonymize; - /** - * Update the cap of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the cap of. - * - `new_cap`: The new cap. - */ - "update_cap": Anonymize; -}>; -export type I92t98snpjjcts = { - "deposit": bigint; - "min_contribution": bigint; - "cap": bigint; - "end": number; - "call"?: (TxCallData) | undefined; - "target_address"?: Anonymize; -}; -export type Iet4pe2le7ku09 = { - "crowdloan_id": number; - "amount": bigint; -}; -export type Id0qcnu1chac12 = AnonymousEnum<{ - /** - * Set the fee rate for swaps on a specific subnet (normalized value). - * For example, 0.3% is approximately 196. - * - * Only callable by the admin origin - */ - "set_fee_rate": Anonymize; - /** - * Enable user liquidity operations for a specific subnet. This switches the - * subnet from V2 to V3 swap mode. Thereafter, adding new user liquidity can be disabled - * by toggling this flag to false, but the swap mode will remain V3 because of existing - * user liquidity until all users withdraw their liquidity. - * - * Only sudo or subnet owner can enable user liquidity. - * Only sudo can disable user liquidity. - */ - "toggle_user_liquidity": Anonymize; - /** - * Add liquidity to a specific price range for a subnet. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - tick_low: Lower bound of the price range - * - tick_high: Upper bound of the price range - * - liquidity: Amount of liquidity to add - * - * Emits `Event::LiquidityAdded` on success - */ - "add_liquidity": Anonymize; - /** - * Remove liquidity from a specific position. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - position_id: ID of the position to remove - * - * Emits `Event::LiquidityRemoved` on success - */ - "remove_liquidity": Anonymize; - /** - * Modify a liquidity position. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - position_id: ID of the position to remove - * - liquidity_delta: Liquidity to add (if positive) or remove (if negative) - * - * Emits `Event::LiquidityRemoved` on success - */ - "modify_position": Anonymize; - /** - * Disable user liquidity in all subnets. - * - * Emits `Event::UserLiquidityToggled` on success - */ - "disable_lp": undefined; -}>; -export type I3mcu79ge1e54v = { - "hotkey": SS58String; - "netuid": number; - "tick_low": number; - "tick_high": number; - "liquidity": bigint; -}; -export type Icf66vuktncksu = { - "hotkey": SS58String; - "netuid": number; - "position_id": bigint; -}; -export type Id69glo8rcjef = { - "hotkey": SS58String; - "netuid": number; - "position_id": bigint; - "liquidity_delta": bigint; -}; -export type I6jivj2j5qp8sa = AnonymousEnum<{ - /** - * Deprecated version if [`Self::call`] for use in an in-storage `Call`. - */ - "call_old_weight": Anonymize; - /** - * Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`. - */ - "instantiate_with_code_old_weight": Anonymize; - /** - * Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`. - */ - "instantiate_old_weight": Anonymize; - /** - * Upload new `code` without instantiating a contract from it. - * - * If the code does not already exist a deposit is reserved from the caller - * and unreserved only when [`Self::remove_code`] is called. The size of the reserve - * depends on the size of the supplied `code`. - * - * If the code already exists in storage it will still return `Ok` and upgrades - * the in storage version to the current - * [`InstructionWeights::version`](InstructionWeights). - * - * - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then - * the only way to use this code is to delegate call into it from an offchain execution. - * Set to [`Determinism::Enforced`] if in doubt. - * - * # Note - * - * Anyone can instantiate a contract from any uploaded code and thus prevent its removal. - * To avoid this situation a constructor could employ access control so that it can - * only be instantiated by permissioned entities. The same is true when uploading - * through [`Self::instantiate_with_code`]. - * - * Use [`Determinism::Relaxed`] exclusively for non-deterministic code. If the uploaded - * code is deterministic, specifying [`Determinism::Relaxed`] will be disregarded and - * result in higher gas costs. - */ - "upload_code": Anonymize; - /** - * Remove the code stored under `code_hash` and refund the deposit to its owner. - * - * A code can only be removed by its original uploader (its owner) and only if it is - * not used by any contract. - */ - "remove_code": Anonymize; - /** - * Privileged function that changes the code of an existing contract. - * - * This takes care of updating refcounts and all other necessary operations. Returns - * an error if either the `code_hash` or `dest` do not exist. - * - * # Note - * - * This does **not** change the address of the contract in question. This means - * that the contract address is no longer derived from its code hash after calling - * this dispatchable. - */ - "set_code": Anonymize; - /** - * Makes a call to an account, optionally transferring some balance. - * - * # Parameters - * - * * `dest`: Address of the contract to call. - * * `value`: The balance to transfer from the `origin` to `dest`. - * * `gas_limit`: The gas limit enforced when executing the constructor. - * * `storage_deposit_limit`: The maximum amount of balance that can be charged from the - * caller to pay for the storage consumed. - * * `data`: The input data to pass to the contract. - * - * * If the account is a smart-contract account, the associated code will be - * executed and any value will be transferred. - * * If the account is a regular account, any value will be transferred. - * * If no account exists and the call value is not less than `existential_deposit`, - * a regular account will be created and any value will be transferred. - */ - "call": Anonymize; - /** - * Instantiates a new contract from the supplied `code` optionally transferring - * some balance. - * - * This dispatchable has the same effect as calling [`Self::upload_code`] + - * [`Self::instantiate`]. Bundling them together provides efficiency gains. Please - * also check the documentation of [`Self::upload_code`]. - * - * # Parameters - * - * * `value`: The balance to transfer from the `origin` to the newly created contract. - * * `gas_limit`: The gas limit enforced when executing the constructor. - * * `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved - * from the caller to pay for the storage consumed. - * * `code`: The contract code to deploy in raw bytes. - * * `data`: The input data to pass to the contract constructor. - * * `salt`: Used for the address derivation. See [`Pallet::contract_address`]. - * - * Instantiation is executed as follows: - * - * - The supplied `code` is deployed, and a `code_hash` is created for that code. - * - If the `code_hash` already exists on the chain the underlying `code` will be shared. - * - The destination address is computed based on the sender, code_hash and the salt. - * - The smart-contract account is created at the computed address. - * - The `value` is transferred to the new account. - * - The `deploy` function is executed in the context of the newly-created account. - */ - "instantiate_with_code": Anonymize; - /** - * Instantiates a contract from a previously deployed wasm binary. - * - * This function is identical to [`Self::instantiate_with_code`] but without the - * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary - * must be supplied. - */ - "instantiate": Anonymize; - /** - * When a migration is in progress, this dispatchable can be used to run migration steps. - * Calls that contribute to advancing the migration have their fees waived, as it's helpful - * for the chain. Note that while the migration is in progress, the pallet will also - * leverage the `on_idle` hooks to run migration steps. - */ - "migrate": Anonymize; -}>; -export type Ia2rnh5pfua40a = { - "dest": MultiAddress; - "value": bigint; - "gas_limit": bigint; - "storage_deposit_limit"?: Anonymize; - "data": Binary; -}; -export type I3otc7e9a35k1k = { - "value": bigint; - "gas_limit": bigint; - "storage_deposit_limit"?: Anonymize; - "code": Binary; - "data": Binary; - "salt": Binary; -}; -export type I89ier5tb9ne0s = { - "value": bigint; - "gas_limit": bigint; - "storage_deposit_limit"?: Anonymize; - "code_hash": FixedSizeBinary<32>; - "data": Binary; - "salt": Binary; -}; -export type Im2f0numhevg3 = { - "code": Binary; - "storage_deposit_limit"?: Anonymize; - "determinism": Anonymize; -}; -export type I2agkcpojhkk43 = { - "dest": MultiAddress; - "code_hash": FixedSizeBinary<32>; -}; -export type I32rvg545edabm = { - "dest": MultiAddress; - "value": bigint; - "gas_limit": Anonymize; - "storage_deposit_limit"?: Anonymize; - "data": Binary; -}; -export type I83fv0vi59md7i = { - "value": bigint; - "gas_limit": Anonymize; - "storage_deposit_limit"?: Anonymize; - "code": Binary; - "data": Binary; - "salt": Binary; -}; -export type I5tjjqcdd4tae0 = { - "value": bigint; - "gas_limit": Anonymize; - "storage_deposit_limit"?: Anonymize; - "code_hash": FixedSizeBinary<32>; - "data": Binary; - "salt": Binary; -}; -export type I1894dm1lf1ae7 = { - "weight_limit": Anonymize; -}; -export type I1o2fkthdkdbjl = AnonymousEnum<{ - /** - * Announce the ML‑KEM public key that will become `CurrentKey` in - * the following block. - */ - "announce_next_key": Anonymize; - /** - * Users submit an encrypted wrapper. - * - * Client‑side: - * - * 1. Read `NextKey` (ML‑KEM public key bytes) from storage. - * 2. Sign your extrinsic so that it can be executed when added to the pool, - * i.e. you may need to increment the nonce if you submit using the same account. - * 3. `commitment = Hashing::hash(signed_extrinsic)`. - * 4. Encrypt: - * - * plaintext = signed_extrinsic - * - * with ML‑KEM‑768 + XChaCha20‑Poly1305, producing - * - * ciphertext = [u16 kem_len] || kem_ct || nonce24 || aead_ct - * - */ - "submit_encrypted": Anonymize; - /** - * Marks a submission as failed to decrypt and removes it from storage. - * - * Called by the block author when decryption fails at any stage (e.g., ML-KEM decapsulate - * failed, AEAD decrypt failed, invalid ciphertext format, etc.). This allows clients to be - * notified of decryption failures through on-chain events. - * - * # Arguments - * - * * `id` - The wrapper id (hash of (author, commitment, ciphertext)) - * * `reason` - Human-readable reason for the decryption failure (e.g., "ML-KEM decapsulate failed") - */ - "mark_decryption_failed": Anonymize; -}>; -export type Idkfsqnep2hpeb = { - "public_key": Binary; -}; -export type I2u5b4034ft9hp = { - "commitment": FixedSizeBinary<32>; - "ciphertext": Binary; -}; -export type I8vbtb6bd00lm0 = AnonymousEnum<{ - "System": Anonymize; - "Timestamp": Anonymize; - "Grandpa": Anonymize; - "Balances": Anonymize; - "SubtensorModule": Anonymize; - "Utility": Anonymize; - "Sudo": Anonymize; - "Multisig": Anonymize; - "Preimage": Anonymize; - "Scheduler": Anonymize; - "Proxy": Anonymize; - "Registry": Anonymize; - "Commitments": Anonymize; - "AdminUtils": Anonymize; - "SafeMode": Anonymize; - "Ethereum": Anonymize; - "EVM": Anonymize; - "BaseFee": Anonymize; - "Drand": Anonymize; - "Crowdloan": Anonymize; - "Swap": Anonymize; - "Contracts": Anonymize; - "MevShield": Anonymize; -}>; -export type Iaqet9jc3ihboe = { - "header": Anonymize; - "extrinsics": Anonymize; -}; -export type Ic952bubvq4k7d = { - "parent_hash": FixedSizeBinary<32>; - "number": number; - "state_root": FixedSizeBinary<32>; - "extrinsics_root": FixedSizeBinary<32>; - "digest": Anonymize; -}; -export type I2v50gu3s1aqk6 = AnonymousEnum<{ - "AllExtrinsics": undefined; - "OnlyInherents": undefined; -}>; -export type Ibmofsd95figtn = ResultPayload, Anonymize>; -export type I5nrjkj9qumobs = AnonymousEnum<{ - "Invalid": Enum<{ - "Call": undefined; - "Payment": undefined; - "Future": undefined; - "Stale": undefined; - "BadProof": undefined; - "AncientBirthBlock": undefined; - "ExhaustsResources": undefined; - "Custom": number; - "BadMandatory": undefined; - "MandatoryValidation": undefined; - "BadSigner": undefined; - "IndeterminateImplicit": undefined; - "UnknownOrigin": undefined; - }>; - "Unknown": TransactionValidityUnknownTransaction; -}>; -export type TransactionValidityUnknownTransaction = Enum<{ - "CannotLookup": undefined; - "NoUnsignedValidator": undefined; - "Custom": number; -}>; -export declare const TransactionValidityUnknownTransaction: GetEnum; -export type If7uv525tdvv7a = Array<[FixedSizeBinary<8>, Binary]>; -export type I2an1fs2eiebjp = { - "okay": boolean; - "fatal_error": boolean; - "errors": Anonymize; -}; -export type Ie9sr1iqcg3cgm = ResultPayload; -export type I1mqgk2tmnn9i2 = (string) | undefined; -export type I6lr8sctk0bi4e = Array; -export type TransactionValidityTransactionSource = Enum<{ - "InBlock": undefined; - "Local": undefined; - "External": undefined; -}>; -export declare const TransactionValidityTransactionSource: GetEnum; -export type I9ask1o4tfvcvs = ResultPayload<{ - "priority": bigint; - "requires": Anonymize; - "provides": Anonymize; - "longevity": bigint; - "propagate": boolean; -}, Anonymize>; -export type Icerf8h8pdu8ss = (Array<[Binary, FixedSizeBinary<4>]>) | undefined; -export type I6spmpef2c7svf = { - "weight": Anonymize; - "class": DispatchClass; - "partial_fee": bigint; -}; -export type Iei2mvq0mjvt81 = { - "inclusion_fee"?: ({ - "base_fee": bigint; - "len_fee": bigint; - "adjusted_weight_fee": bigint; - }) | undefined; - "tip": bigint; -}; -export type If08sfhqn8ujfr = { - "balance": Anonymize; - "nonce": Anonymize; -}; -export type I3dj14b7k3rkm5 = (Anonymize) | undefined; -export type Ic5egmm215ml6k = (Anonymize) | undefined; -export type Ibg4am9lqg35ku = ResultPayload<{ - "exit_reason": Anonymize; - "value": Binary; - "used_gas": Anonymize; - "weight_info"?: Anonymize; - "logs": Anonymize; -}, Anonymize>; -export type I8mgv59to1hjie = { - "standard": Anonymize; - "effective": Anonymize; -}; -export type Ib72ii9bshc8f5 = ({ - "ref_time_limit"?: Anonymize; - "proof_size_limit"?: Anonymize; - "ref_time_usage"?: Anonymize; - "proof_size_usage"?: Anonymize; -}) | undefined; -export type I7efspe2svrt0g = ResultPayload<{ - "exit_reason": Anonymize; - "value": FixedSizeBinary<20>; - "used_gas": Anonymize; - "weight_info"?: Anonymize; - "logs": Anonymize; -}, Anonymize>; -export type I5fvdd841odbi3 = (Anonymize) | undefined; -export type I35vouom6s9r2 = (Anonymize) | undefined; -export type Ie6kgk6f04rsvk = (Anonymize) | undefined; -export type Ifgqf2rskq94om = [Anonymize, Anonymize, Anonymize]; -export type I7aold6s47n103 = [Anonymize, Anonymize]; -export type Ifla7g8u5j9k68 = { - "gas_consumed": Anonymize; - "gas_required": Anonymize; - "storage_deposit": Anonymize; - "debug_message": Binary; - "result": ResultPayload, Anonymize>; - "events"?: Anonymize; -}; -export type If7bmpttbdmqu4 = AnonymousEnum<{ - "Refund": bigint; - "Charge": bigint; -}>; -export type I620n7irgfspm4 = { - "flags": number; - "data": Binary; -}; -export type I6taghk79roh1q = (Anonymize) | undefined; -export type I9sijb8gfrns29 = AnonymousEnum<{ - "Upload": Binary; - "Existing": FixedSizeBinary<32>; -}>; -export type I17s97pb2d5tj3 = { - "gas_consumed": Anonymize; - "gas_required": Anonymize; - "storage_deposit": Anonymize; - "debug_message": Binary; - "result": ResultPayload<{ - "result": Anonymize; - "account_id": SS58String; - }, Anonymize>; - "events"?: Anonymize; -}; -export type I4gah17u2nc33h = ResultPayload<{ - "code_hash": FixedSizeBinary<32>; - "deposit": bigint; -}, Anonymize>; -export type I9u22scd4ksrjm = ResultPayload, Enum<{ - "DoesntExist": undefined; - "KeyDecodingFailed": undefined; - "MigrationInProgress": undefined; -}>>; -export type Ibil6rvg3saeb3 = Array>; -export type I4dh58q3tkaf4j = { - "delegate_ss58": SS58String; - "take": number; - "nominators": Array<[SS58String, Anonymize]>; - "owner_ss58": SS58String; - "registrations": Anonymize; - "validator_permits": Anonymize; - "return_per_1000": bigint; - "total_daily_return": bigint; -}; -export type I97cs1i8k87lnm = (Anonymize) | undefined; -export type I874e758ge6pa9 = Array<[Anonymize, Anonymize]>; -export type I86tq0h1o8f1g5 = Array>; -export type I89nj65vjrv1i8 = { - "hotkey": SS58String; - "coldkey": SS58String; - "uid": number; - "netuid": number; - "active": boolean; - "axon_info": Anonymize; - "prometheus_info": Anonymize; - "stake": Anonymize; - "rank": number; - "emission": bigint; - "incentive": number; - "consensus": number; - "trust": number; - "validator_trust": number; - "dividends": number; - "last_update": bigint; - "validator_permit": boolean; - "weights": Anonymize; - "bonds": Anonymize; - "pruning_score": number; -}; -export type Iba9inugg1atvo = Array>; -export type I78cq8c9mego2f = (Anonymize) | undefined; -export type I64hm01ml98m4p = Array>; -export type If8j022vmi07bv = { - "hotkey": SS58String; - "coldkey": SS58String; - "uid": number; - "netuid": number; - "active": boolean; - "axon_info": Anonymize; - "prometheus_info": Anonymize; - "stake": Anonymize; - "rank": number; - "emission": bigint; - "incentive": number; - "consensus": number; - "trust": number; - "validator_trust": number; - "dividends": number; - "last_update": bigint; - "validator_permit": boolean; - "pruning_score": number; -}; -export type I3gjbugrk45her = (Anonymize) | undefined; -export type I9nvi04b7jiso4 = ({ - "netuid": number; - "rho": number; - "kappa": number; - "difficulty": bigint; - "immunity_period": number; - "max_allowed_validators": number; - "min_allowed_weights": number; - "max_weights_limit": number; - "scaling_law_power": number; - "subnetwork_n": number; - "max_allowed_uids": number; - "blocks_since_last_step": bigint; - "tempo": number; - "network_modality": number; - "network_connect": Anonymize; - "emission_values": bigint; - "burn": bigint; - "owner": SS58String; -}) | undefined; -export type I6s1052v0hl6mr = Array>; -export type I31p8sd8onusg0 = ({ - "netuid": number; - "rho": number; - "kappa": number; - "difficulty": bigint; - "immunity_period": number; - "max_allowed_validators": number; - "min_allowed_weights": number; - "max_weights_limit": number; - "scaling_law_power": number; - "subnetwork_n": number; - "max_allowed_uids": number; - "blocks_since_last_step": bigint; - "tempo": number; - "network_modality": number; - "network_connect": Anonymize; - "emission_value": bigint; - "burn": bigint; - "owner": SS58String; - "identity"?: Anonymize; -}) | undefined; -export type I2vgg418k9gfnm = Array>; -export type I7dp6t7k7a8r36 = ({ - "rho": number; - "kappa": number; - "immunity_period": number; - "min_allowed_weights": number; - "max_weights_limit": number; - "tempo": number; - "min_difficulty": bigint; - "max_difficulty": bigint; - "weights_version": bigint; - "weights_rate_limit": bigint; - "adjustment_interval": number; - "activity_cutoff": number; - "registration_allowed": boolean; - "target_regs_per_interval": number; - "min_burn": bigint; - "max_burn": bigint; - "bonds_moving_avg": bigint; - "max_regs_per_block": number; - "serving_rate_limit": bigint; - "max_validators": number; - "adjustment_alpha": bigint; - "difficulty": bigint; - "commit_reveal_period": bigint; - "commit_reveal_weights_enabled": boolean; - "alpha_high": number; - "alpha_low": number; - "liquid_alpha_enabled": boolean; -}) | undefined; -export type Ibtpedbm9ai3hp = ({ - "rho": number; - "kappa": number; - "immunity_period": number; - "min_allowed_weights": number; - "max_weights_limit": number; - "tempo": number; - "min_difficulty": bigint; - "max_difficulty": bigint; - "weights_version": bigint; - "weights_rate_limit": bigint; - "adjustment_interval": number; - "activity_cutoff": number; - "registration_allowed": boolean; - "target_regs_per_interval": number; - "min_burn": bigint; - "max_burn": bigint; - "bonds_moving_avg": bigint; - "max_regs_per_block": number; - "serving_rate_limit": bigint; - "max_validators": number; - "adjustment_alpha": bigint; - "difficulty": bigint; - "commit_reveal_period": bigint; - "commit_reveal_weights_enabled": boolean; - "alpha_high": number; - "alpha_low": number; - "liquid_alpha_enabled": boolean; - "alpha_sigmoid_steepness": bigint; - "yuma_version": number; - "subnet_is_active": boolean; - "transfers_enabled": boolean; - "bonds_reset_enabled": boolean; - "user_liquidity_enabled": boolean; -}) | undefined; -export type I8ivaf995pho4u = Array>; -export type Ibjoh8vk2j7bqd = ({ - "netuid": number; - "owner_hotkey": SS58String; - "owner_coldkey": SS58String; - "subnet_name": Anonymize; - "token_symbol": Anonymize; - "tempo": number; - "last_step": bigint; - "blocks_since_last_step": bigint; - "emission": bigint; - "alpha_in": bigint; - "alpha_out": bigint; - "tao_in": bigint; - "alpha_out_emission": bigint; - "alpha_in_emission": bigint; - "tao_in_emission": bigint; - "pending_alpha_emission": bigint; - "pending_root_emission": bigint; - "subnet_volume": bigint; - "network_registered_at": bigint; - "subnet_identity"?: Anonymize; - "moving_price": bigint; -}) | undefined; -export type Icr6rj04unermu = Array>; -export type I5gfdo8kg6rloq = ({ - "netuid": number; - "name": Anonymize; - "symbol": Anonymize; - "identity"?: Anonymize; - "network_registered_at": bigint; - "owner_hotkey": SS58String; - "owner_coldkey": SS58String; - "block": bigint; - "tempo": number; - "last_step": bigint; - "blocks_since_last_step": bigint; - "subnet_emission": bigint; - "alpha_in": bigint; - "alpha_out": bigint; - "tao_in": bigint; - "alpha_out_emission": bigint; - "alpha_in_emission": bigint; - "tao_in_emission": bigint; - "pending_alpha_emission": bigint; - "pending_root_emission": bigint; - "subnet_volume": bigint; - "moving_price": bigint; - "rho": number; - "kappa": number; - "min_allowed_weights": number; - "max_weights_limit": number; - "weights_version": bigint; - "weights_rate_limit": bigint; - "activity_cutoff": number; - "max_validators": number; - "num_uids": number; - "max_uids": number; - "burn": bigint; - "difficulty": bigint; - "registration_allowed": boolean; - "pow_registration_allowed": boolean; - "immunity_period": number; - "min_difficulty": bigint; - "max_difficulty": bigint; - "min_burn": bigint; - "max_burn": bigint; - "adjustment_alpha": bigint; - "adjustment_interval": number; - "target_regs_per_interval": number; - "max_regs_per_block": number; - "serving_rate_limit": bigint; - "commit_reveal_weights_enabled": boolean; - "commit_reveal_period": bigint; - "liquid_alpha_enabled": boolean; - "alpha_high": number; - "alpha_low": number; - "bonds_moving_avg": bigint; - "hotkeys": Anonymize; - "coldkeys": Anonymize; - "identities": Anonymize; - "axons": Anonymize; - "active": Anonymize; - "validator_permit": Anonymize; - "pruning_score": Anonymize; - "last_update": Anonymize; - "emission": Anonymize; - "dividends": Anonymize; - "incentives": Anonymize; - "consensus": Anonymize; - "trust": Anonymize; - "rank": Anonymize; - "block_at_registration": Anonymize; - "alpha_stake": Anonymize; - "tao_stake": Anonymize; - "total_stake": Anonymize; - "tao_dividends_per_hotkey": Anonymize; - "alpha_dividends_per_hotkey": Anonymize; -}) | undefined; -export type Iaf9dcc3cspgj7 = Array<(Anonymize) | undefined>; -export type Iemjgg2q8584r9 = Array>; -export type I2u4s5o1c0r3fu = ({ - "netuid": number; - "hotkeys": Anonymize; - "coldkeys": Anonymize; - "active": Anonymize; - "validator_permit": Anonymize; - "pruning_score": Anonymize; - "last_update": Anonymize; - "emission": Anonymize; - "dividends": Anonymize; - "incentives": Anonymize; - "consensus": Anonymize; - "trust": Anonymize; - "rank": Anonymize; - "block_at_registration": Anonymize; - "alpha_stake": Anonymize; - "tao_stake": Anonymize; - "total_stake": Anonymize; - "emission_history": Array>; -}) | undefined; -export type Ic0g2vnp5r296p = ({ - "netuid": number; - "name"?: Anonymize; - "symbol"?: Anonymize; - "identity"?: (Anonymize) | undefined; - "network_registered_at"?: Anonymize; - "owner_hotkey"?: Anonymize; - "owner_coldkey"?: Anonymize; - "block"?: Anonymize; - "tempo"?: Anonymize; - "last_step"?: Anonymize; - "blocks_since_last_step"?: Anonymize; - "subnet_emission"?: Anonymize; - "alpha_in"?: Anonymize; - "alpha_out"?: Anonymize; - "tao_in"?: Anonymize; - "alpha_out_emission"?: Anonymize; - "alpha_in_emission"?: Anonymize; - "tao_in_emission"?: Anonymize; - "pending_alpha_emission"?: Anonymize; - "pending_root_emission"?: Anonymize; - "subnet_volume"?: Anonymize; - "moving_price"?: Anonymize; - "rho"?: Anonymize; - "kappa"?: Anonymize; - "min_allowed_weights"?: Anonymize; - "max_weights_limit"?: Anonymize; - "weights_version"?: Anonymize; - "weights_rate_limit"?: Anonymize; - "activity_cutoff"?: Anonymize; - "max_validators"?: Anonymize; - "num_uids"?: Anonymize; - "max_uids"?: Anonymize; - "burn"?: Anonymize; - "difficulty"?: Anonymize; - "registration_allowed"?: (boolean) | undefined; - "pow_registration_allowed"?: (boolean) | undefined; - "immunity_period"?: Anonymize; - "min_difficulty"?: Anonymize; - "max_difficulty"?: Anonymize; - "min_burn"?: Anonymize; - "max_burn"?: Anonymize; - "adjustment_alpha"?: Anonymize; - "adjustment_interval"?: Anonymize; - "target_regs_per_interval"?: Anonymize; - "max_regs_per_block"?: Anonymize; - "serving_rate_limit"?: Anonymize; - "commit_reveal_weights_enabled"?: (boolean) | undefined; - "commit_reveal_period"?: Anonymize; - "liquid_alpha_enabled"?: (boolean) | undefined; - "alpha_high"?: Anonymize; - "alpha_low"?: Anonymize; - "bonds_moving_avg"?: Anonymize; - "hotkeys"?: (Anonymize) | undefined; - "coldkeys"?: (Anonymize) | undefined; - "identities"?: (Anonymize) | undefined; - "axons"?: (Anonymize) | undefined; - "active"?: (Anonymize) | undefined; - "validator_permit"?: (Anonymize) | undefined; - "pruning_score"?: Anonymize; - "last_update"?: (Anonymize) | undefined; - "emission"?: (Anonymize) | undefined; - "dividends"?: Anonymize; - "incentives"?: Anonymize; - "consensus"?: Anonymize; - "trust"?: Anonymize; - "rank"?: Anonymize; - "block_at_registration"?: (Anonymize) | undefined; - "alpha_stake"?: (Anonymize) | undefined; - "tao_stake"?: (Anonymize) | undefined; - "total_stake"?: (Anonymize) | undefined; - "tao_dividends_per_hotkey"?: (Anonymize) | undefined; - "alpha_dividends_per_hotkey"?: (Anonymize) | undefined; - "validators"?: Anonymize; - "commitments"?: (Array<[SS58String, Anonymize]>) | undefined; -}) | undefined; -export type Ic9fkrj2ggjleq = Array>; -export type I66h6oadnuebe = { - "hotkey": SS58String; - "coldkey": SS58String; - "netuid": number; - "stake": bigint; - "locked": bigint; - "emission": bigint; - "tao_emission": bigint; - "drain": bigint; - "is_registered": boolean; -}; -export type Ifi9cmevnosufh = Array<[SS58String, Anonymize]>; -export type I1i5jfmqcsjper = (Anonymize) | undefined; -export type I3pbrjdm4vnbsa = (Anonymize) | undefined; -export type Iems84l8lk2v0c = { - "slot_duration": bigint; - "epoch_length": bigint; - "c": Anonymize; - "authorities": Anonymize; - "randomness": FixedSizeBinary<32>; - "allowed_slots": BabeAllowedSlots; -}; -export type I200n1ov5tbcvr = FixedSizeArray<2, bigint>; -export type BabeAllowedSlots = Enum<{ - "PrimarySlots": undefined; - "PrimaryAndSecondaryPlainSlots": undefined; - "PrimaryAndSecondaryVRFSlots": undefined; -}>; -export declare const BabeAllowedSlots: GetEnum; -export type I1r5ke30ueqo0r = { - "epoch_index": bigint; - "start_slot": bigint; - "duration": bigint; - "authorities": Anonymize; - "randomness": FixedSizeBinary<32>; - "config": { - "c": Anonymize; - "allowed_slots": BabeAllowedSlots; - }; -}; -export type I68ii5ik8avr9o = { - "offender": FixedSizeBinary<32>; - "slot": bigint; - "first_header": Anonymize; - "second_header": Anonymize; -}; -export type I8slfm2rri67ri = Array<{ - "netuid": number; - "price": bigint; -}>; -export type I34n2itmpoq7on = { - "tao_amount": bigint; - "alpha_amount": bigint; - "tao_fee": bigint; - "alpha_fee": bigint; - "tao_slippage": bigint; - "alpha_slippage": bigint; -}; -export {}; diff --git a/contract-tests/.papi/descriptors/dist/common.d.ts b/contract-tests/.papi/descriptors/dist/common.d.ts deleted file mode 100644 index 28f5c6ce9f..0000000000 --- a/contract-tests/.papi/descriptors/dist/common.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare const toBinary: (base64: string) => Uint8Array; diff --git a/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts b/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts deleted file mode 100644 index ecf845cf6d..0000000000 --- a/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts +++ /dev/null @@ -1,187 +0,0 @@ -import type { FixedSizeBinary, SS58String, ResultPayload, Enum, Binary, FixedSizeArray } from 'polkadot-api'; -import type { InkDescriptors } from 'polkadot-api/ink'; -type AnonymousEnum = T & { - __anonymous: true; -}; -type MyTuple = [T, ...T[]]; -type SeparateUndefined = undefined extends T ? undefined | Exclude : T; -type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { - [K in keyof T]: T[K]; -} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { - [K in keyof T & string]: T[K]; -}>; -type T0 = ResultPayload>; -type T1 = Enum<{ - "CouldNotReadInput": undefined; -}>; -type T2 = Enum<{ - "ReadFailed": undefined; - "WriteFailed": undefined; -}>; -type T3 = ResultPayload>, Anonymize>; -type StorageDescriptor = { - "": { - "key": undefined; - "value": undefined; - }; -}; -type MessagesDescriptor = { - "get_stake_info_for_hotkey_coldkey_netuid": { - "message": { - "hotkey": FixedSizeBinary<32>; - "coldkey": FixedSizeBinary<32>; - "netuid": number; - }; - "response": ResultPayload>, Anonymize>; - }; - "add_stake": { - "message": { - "hotkey": FixedSizeBinary<32>; - "netuid": number; - "amount": bigint; - }; - "response": Anonymize; - }; - "remove_stake": { - "message": { - "hotkey": FixedSizeBinary<32>; - "netuid": number; - "amount": bigint; - }; - "response": Anonymize; - }; - "unstake_all": { - "message": { - "hotkey": FixedSizeBinary<32>; - }; - "response": Anonymize; - }; - "unstake_all_alpha": { - "message": { - "hotkey": FixedSizeBinary<32>; - }; - "response": Anonymize; - }; - "move_stake": { - "message": { - "origin_hotkey": FixedSizeBinary<32>; - "destination_hotkey": FixedSizeBinary<32>; - "origin_netuid": number; - "destination_netuid": number; - "amount": bigint; - }; - "response": Anonymize; - }; - "transfer_stake": { - "message": { - "destination_coldkey": FixedSizeBinary<32>; - "hotkey": FixedSizeBinary<32>; - "origin_netuid": number; - "destination_netuid": number; - "amount": bigint; - }; - "response": Anonymize; - }; - "swap_stake": { - "message": { - "hotkey": FixedSizeBinary<32>; - "origin_netuid": number; - "destination_netuid": number; - "amount": bigint; - }; - "response": Anonymize; - }; - "add_stake_limit": { - "message": { - "hotkey": FixedSizeBinary<32>; - "netuid": number; - "amount": bigint; - "limit_price": bigint; - "allow_partial": boolean; - }; - "response": Anonymize; - }; - "remove_stake_limit": { - "message": { - "hotkey": FixedSizeBinary<32>; - "netuid": number; - "amount": bigint; - "limit_price": bigint; - "allow_partial": boolean; - }; - "response": Anonymize; - }; - "swap_stake_limit": { - "message": { - "hotkey": FixedSizeBinary<32>; - "origin_netuid": number; - "destination_netuid": number; - "amount": bigint; - "limit_price": bigint; - "allow_partial": boolean; - }; - "response": Anonymize; - }; - "remove_stake_full_limit": { - "message": { - "hotkey": FixedSizeBinary<32>; - "netuid": number; - "limit_price": bigint; - }; - "response": Anonymize; - }; - "set_coldkey_auto_stake_hotkey": { - "message": { - "netuid": number; - "hotkey": FixedSizeBinary<32>; - }; - "response": Anonymize; - }; - "add_proxy": { - "message": { - "delegate": FixedSizeBinary<32>; - }; - "response": Anonymize; - }; - "remove_proxy": { - "message": { - "delegate": FixedSizeBinary<32>; - }; - "response": Anonymize; - }; - "get_alpha_price": { - "message": { - "netuid": number; - }; - "response": ResultPayload>, Anonymize>; - }; -}; -type ConstructorsDescriptor = { - /** - * Constructor - */ - "new": { - "message": {}; - "response": Anonymize; - }; - /** - * Constructor - */ - "default": { - "message": {}; - "response": Anonymize; - }; -}; -type EventDescriptor = Enum<{}>; -export declare const descriptor: InkDescriptors; -export {}; diff --git a/contract-tests/.papi/descriptors/dist/contracts/index.d.ts b/contract-tests/.papi/descriptors/dist/contracts/index.d.ts deleted file mode 100644 index cdd4a702ba..0000000000 --- a/contract-tests/.papi/descriptors/dist/contracts/index.d.ts +++ /dev/null @@ -1 +0,0 @@ -export { descriptor as bittensor } from './bittensor'; diff --git a/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs b/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs deleted file mode 100644 index 1a3dfc3a07..0000000000 --- a/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs +++ /dev/null @@ -1,29 +0,0 @@ -import "./chunk-7P6ASYW6.mjs"; - -// .papi/descriptors/src/descriptors.ts -var [minified, commonTrees, tokens] = JSON.parse(`[{"devnet":{"storage":{"2":{"0":0,"1":4,"ExtrinsicCount":1,"InherentsApplied":2,"BlockWeight":3,"AllExtrinsicsLen":1,"ExtrinsicData":5,"Number":1,"ParentHash":6,"Digest":7,"Events":8,"EventCount":1,"EventTopics":9,"LastRuntimeUpgrade":10,"UpgradedToU32RefCount":2,"UpgradedToTripleRefCount":2,"ExecutionPhase":11,"AuthorizedUpgrade":12,"ExtrinsicWeightReclaimed":13},"3":{"RandomMaterial":33},"4":{"Now":34,"DidUpdate":2},"6":{"5":33,"CurrentSlot":34},"7":{"5":40,"State":36,"PendingChange":37,"NextForced":1,"Stalled":38,"CurrentSetId":34,"SetIdSession":39},"9":{"0":44,"8":34,"InactiveIssuance":34,"Locks":45,"Reserves":46,"Holds":47,"Freezes":48},"10":{"NextFeeMultiplier":34,"StorageVersion":66},"17":{"8":34,"11":86,"12":86,"13":86,"14":86,"15":112,"16":117,"MinActivityCutoff":1,"AdminFreezeWindow":1,"OwnerHyperparamRateLimit":1,"DissolveNetworkScheduleDuration":1,"LastHotkeySwapOnNetuid":68,"NextStakeJobId":34,"TaoWeight":34,"CKBurn":34,"MaxDelegateTake":1,"MinDelegateTake":1,"MaxChildkeyTake":1,"MinChildkeyTake":1,"Owner":69,"Delegates":70,"ChildkeyTake":71,"PendingChildKeys":72,"ChildKeys":73,"ParentKeys":73,"AlphaDividendsPerSubnet":68,"RootAlphaDividendsPerSubnet":68,"BlockEmission":34,"LastHotkeyEmissionOnNetuid":74,"SubnetLimit":1,"TotalStake":34,"SubnetMovingAlpha":34,"SubnetMovingPrice":75,"RootProp":75,"SubnetVolume":75,"SubnetTAO":75,"SubnetTaoProvided":75,"SubnetAlphaInEmission":75,"SubnetAlphaOutEmission":75,"SubnetTaoInEmission":75,"SubnetAlphaIn":75,"SubnetAlphaInProvided":75,"SubnetAlphaOut":75,"StakingHotkeys":76,"OwnedHotkeys":76,"AutoStakeDestination":77,"AutoStakeDestinationColdkeys":78,"ColdkeySwapAnnouncementDelay":1,"ColdkeySwapReannouncementDelay":1,"ColdkeySwapAnnouncements":79,"ColdkeySwapDisputes":70,"TotalHotkeyAlpha":74,"TotalHotkeyAlphaLastEpoch":74,"TotalHotkeyShares":74,"Alpha":80,"AlphaMapLastKey":81,"TokenSymbol":5,"SubnetTaoFlow":75,"SubnetEmaTaoFlow":82,"TaoFlowCutoff":34,"FlowNormExponent":34,"FlowEmaSmoothingFactor":34,"UsedWork":83,"MaxRegistrationsPerBlock":84,"TotalNetworks":1,"NetworkImmunityPeriod":34,"StartCallDelay":34,"NetworkMinLockCost":34,"NetworkLastLockCost":34,"NetworkLockReductionInterval":34,"SubnetOwnerCut":1,"NetworkRateLimit":34,"NominatorMinRequiredStake":34,"WeightsVersionKeyRateLimit":34,"LastRateLimitedBlock":85,"SubnetLocked":75,"LargestLocked":75,"Tempo":84,"FirstEmissionBlockNumber":75,"SubnetMechanism":84,"SubnetworkN":84,"NetworksAdded":86,"IsNetworkMember":87,"NetworkRegistrationAllowed":86,"NetworkPowRegistrationAllowed":86,"NetworkRegisteredAt":75,"PendingServerEmission":75,"PendingValidatorEmission":75,"PendingRootAlphaDivs":75,"PendingOwnerCut":75,"BlocksSinceLastStep":75,"LastMechansimStepBlock":75,"SubnetOwner":88,"SubnetOwnerHotkey":88,"RecycleOrBurn":89,"ServingRateLimit":75,"Rho":84,"AlphaSigmoidSteepness":84,"Kappa":84,"RegistrationsThisInterval":84,"POWRegistrationsThisInterval":84,"BurnRegistrationsThisInterval":84,"MinAllowedUids":84,"MaxAllowedUids":84,"ImmunityPeriod":84,"ActivityCutoff":84,"MaxWeightsLimit":84,"WeightsVersionKey":75,"MinAllowedWeights":84,"MaxAllowedValidators":84,"AdjustmentInterval":84,"BondsMovingAverage":75,"BondsPenalty":84,"BondsResetOn":86,"WeightsSetRateLimit":75,"ValidatorPruneLen":75,"ScalingLawPower":84,"TargetRegistrationsPerInterval":84,"AdjustmentAlpha":75,"CommitRevealWeightsEnabled":86,"Burn":75,"Difficulty":75,"MinBurn":75,"MaxBurn":75,"MinDifficulty":75,"MaxDifficulty":75,"LastAdjustmentBlock":75,"RegistrationsThisBlock":84,"EMAPriceHalvingBlocks":75,"RAORecycledForRegistration":75,"TxRateLimit":34,"TxDelegateTakeRateLimit":34,"TxChildkeyTakeRateLimit":34,"AlphaValues":90,"SubtokenEnabled":86,"VotingPower":68,"VotingPowerDisableAtBlock":75,"VotingPowerEmaAlpha":75,"ImmuneOwnerUidsLimit":84,"StakeWeight":91,"Uids":92,"Keys":93,"LoadedEmission":94,"Active":95,"Rank":91,"Trust":91,"Consensus":91,"Incentive":91,"Dividends":91,"Emission":96,"LastUpdate":96,"ValidatorTrust":91,"PruningScores":91,"ValidatorPermit":95,"Weights":97,"Bonds":97,"BlockAtRegistration":98,"Axons":99,"NeuronCertificates":100,"Prometheus":101,"IdentitiesV2":102,"SubnetIdentitiesV3":103,"TransactionKeyLastBlock":104,"LastTxBlock":105,"LastTxBlockChildKeyTake":105,"LastTxBlockDelegateTake":105,"StakeThreshold":34,"WeightCommits":106,"TimelockedWeightCommits":107,"CRV3WeightCommits":108,"CRV3WeightCommitsV2":107,"RevealPeriodEpochs":75,"LastColdkeyHotkeyStakeBlock":109,"StakingOperationRateLimiter":110,"RootClaimableThreshold":75,"RootClaimable":111,"RootClaimType":113,"StakingColdkeysByIndex":114,"StakingColdkeys":105,"NumStakingColdkeys":34,"NumRootClaim":34,"AssociatedEvmAddress":115,"SubnetLeases":116,"SubnetLeaseShares":68,"SubnetUidToLeaseId":84,"NextSubnetLeaseId":1,"AccumulatedLeaseDividends":75,"CommitRevealWeightsVersion":1,"NetworkRegistrationStartBlock":34,"MinNonImmuneUids":84,"MaxMechanismCount":1,"MechanismCountCurrent":84,"MechanismEmissionSplit":91,"PendingChildKeyCooldown":34},"18":0,"19":{"Key":228},"20":{"Multisigs":234},"21":{"StatusFor":245,"RequestStatusFor":246,"PreimageFor":247},"22":{"IncompleteSince":1,"Agenda":252,"Retries":253,"Lookup":254},"23":{"Proxies":269,"Announcements":270,"LastCallResult":271},"24":{"IdentityOf":286},"25":{"TimelockedIndex":289,"CommitmentOf":290,"LastCommitment":92,"LastBondsReset":92,"RevealedCommitments":291,"UsedSpaceOf":292,"MaxSpace":1},"26":{"PrecompileEnable":297},"27":{"EnteredUntil":1,"Deposits":74},"28":{"1":371,"Pending":367,"CounterForPending":1,"CurrentBlock":368,"CurrentReceipts":369,"CurrentTransactionStatuses":370},"29":{"AccountCodes":374,"AccountCodesMetadata":375,"AccountStorages":376,"WhitelistedCreators":377,"DisableWhitelistCheck":2},"30":{"ChainId":34},"31":{"BaseFeePerGas":386,"Elasticity":1},"32":{"16":117,"BeaconConfig":391,"Pulses":392,"LastStoredRound":34,"OldestStoredRound":34,"NextUnsignedAt":1},"33":{"16":117,"Crowdloans":397,"NextCrowdloanId":1,"Contributions":68,"CurrentCrowdloanId":1},"34":{"FeeRate":84,"FeeGlobalTao":75,"FeeGlobalAlpha":75,"Ticks":411,"SwapV3Initialized":86,"AlphaSqrtPrice":75,"CurrentTick":84,"CurrentLiquidity":75,"EnabledUserLiquidity":86,"Positions":412,"LastPositionId":34,"TickIndexBitmapWords":413,"ScrapReservoirTao":75,"ScrapReservoirAlpha":75},"35":{"PristineCode":423,"CodeInfoOf":424,"Nonce":34,"ContractInfoOf":425,"DeletionQueue":5,"DeletionQueueCounter":426,"MigrationInProgress":427},"36":{"CurrentKey":427,"NextKey":427,"Submissions":447,"KeyHashByBlock":4}},"tx":{"2":{"37":20,"remark":18,"set_heap_pages":19,"set_code_without_checks":20,"set_storage":21,"kill_storage":22,"kill_prefix":23,"remark_with_event":18,"authorize_upgrade":24,"authorize_upgrade_without_checks":24,"apply_authorized_upgrade":20},"3":0,"4":{"set":35},"6":0,"7":{"report_equivocation":41,"report_equivocation_unsigned":41,"note_stalled":42},"9":{"transfer_allow_death":49,"force_transfer":50,"transfer_keep_alive":49,"transfer_all":51,"force_unreserve":52,"upgrade_accounts":53,"force_set_balance":54,"force_adjust_total_issuance":55,"burn":56},"10":0,"17":{"38":146,"set_weights":118,"set_mechanism_weights":119,"batch_set_weights":120,"commit_weights":121,"commit_mechanism_weights":122,"batch_commit_weights":123,"reveal_weights":124,"reveal_mechanism_weights":125,"commit_crv3_mechanism_weights":126,"batch_reveal_weights":127,"decrease_take":128,"increase_take":128,"add_stake":129,"remove_stake":130,"serve_axon":131,"serve_axon_tls":132,"serve_prometheus":133,"register":134,"root_register":135,"burned_register":136,"swap_hotkey":137,"swap_coldkey":138,"set_childkey_take":139,"sudo_set_tx_childkey_take_rate_limit":140,"sudo_set_min_childkey_take":141,"sudo_set_max_childkey_take":141,"register_network":135,"faucet":142,"dissolve_network":143,"set_children":144,"schedule_swap_coldkey":145,"set_subnet_identity":147,"register_network_with_identity":148,"unstake_all":135,"unstake_all_alpha":135,"move_stake":149,"transfer_stake":150,"swap_stake":151,"add_stake_limit":152,"remove_stake_limit":153,"swap_stake_limit":154,"try_associate_hotkey":135,"start_call":155,"associate_evm_key":156,"recycle_alpha":157,"burn_alpha":157,"set_pending_childkey_cooldown":158,"remove_stake_full_limit":159,"register_leased_network":160,"terminate_lease":161,"update_symbol":162,"commit_timelocked_weights":163,"set_coldkey_auto_stake_hotkey":136,"commit_timelocked_mechanism_weights":164,"root_dissolve_network":155,"claim_root":165,"set_root_claim_type":166,"sudo_set_num_root_claims":167,"sudo_set_root_claim_threshold":168,"announce_coldkey_swap":169,"swap_coldkey_announced":145,"dispute_coldkey_swap":170,"reset_coldkey_swap":171,"enable_voting_power_tracking":155,"disable_voting_power_tracking":155,"sudo_set_voting_power_ema_alpha":172,"add_stake_burn":173},"18":{"batch":219,"as_derivative":220,"batch_all":219,"dispatch_as":221,"force_batch":219,"with_weight":222,"if_else":223,"dispatch_as_fallible":221},"19":{"sudo":229,"sudo_unchecked_weight":222,"set_key":230,"sudo_as":231,"remove_key":170},"20":{"39":239,"as_multi_threshold_1":235,"as_multi":236,"approve_as_multi":237,"cancel_as_multi":238},"21":{"note_preimage":248,"unnote_preimage":249,"request_preimage":249,"unrequest_preimage":249,"ensure_updated":250},"22":{"schedule":255,"cancel":256,"schedule_named":257,"cancel_named":258,"schedule_after":259,"schedule_named_after":260,"set_retry":261,"set_retry_named":262,"cancel_retry":263,"cancel_retry_named":258},"23":{"39":170,"proxy":274,"add_proxy":275,"remove_proxy":275,"remove_proxies":170,"create_pure":276,"kill_pure":277,"announce":278,"remove_announcement":278,"reject_announcement":279,"proxy_announced":280},"24":{"38":287,"clear_identity":288},"25":{"set_commitment":293,"set_max_space":294},"26":{"swap_authorities":298,"sudo_set_default_take":299,"sudo_set_tx_rate_limit":140,"sudo_set_serving_rate_limit":300,"sudo_set_min_difficulty":301,"sudo_set_max_difficulty":302,"sudo_set_weights_version_key":303,"sudo_set_weights_set_rate_limit":304,"sudo_set_adjustment_interval":305,"sudo_set_adjustment_alpha":306,"sudo_set_immunity_period":307,"sudo_set_min_allowed_weights":308,"sudo_set_max_allowed_uids":309,"sudo_set_kappa":310,"sudo_set_rho":311,"sudo_set_activity_cutoff":312,"sudo_set_network_registration_allowed":313,"sudo_set_network_pow_registration_allowed":313,"sudo_set_target_registrations_per_interval":314,"sudo_set_min_burn":315,"sudo_set_max_burn":316,"sudo_set_difficulty":317,"sudo_set_max_allowed_validators":318,"sudo_set_bonds_moving_average":319,"sudo_set_bonds_penalty":320,"sudo_set_max_registrations_per_block":321,"sudo_set_subnet_owner_cut":322,"sudo_set_network_rate_limit":323,"sudo_set_tempo":324,"sudo_set_total_issuance":325,"sudo_set_network_immunity_period":326,"sudo_set_network_min_lock_cost":327,"sudo_set_subnet_limit":328,"sudo_set_lock_reduction_interval":329,"sudo_set_rao_recycled":330,"sudo_set_stake_threshold":331,"sudo_set_nominator_min_required_stake":331,"sudo_set_tx_delegate_take_rate_limit":140,"sudo_set_min_delegate_take":141,"sudo_set_commit_reveal_weights_enabled":332,"sudo_set_liquid_alpha_enabled":332,"sudo_set_alpha_values":333,"sudo_set_dissolve_network_schedule_duration":334,"sudo_set_commit_reveal_weights_interval":335,"sudo_set_evm_chain_id":336,"schedule_grandpa_change":337,"sudo_set_toggle_transfer":338,"sudo_set_recycle_or_burn":339,"sudo_toggle_evm_precompile":340,"sudo_set_subnet_moving_alpha":341,"sudo_set_subnet_owner_hotkey":136,"sudo_set_ema_price_halving_period":342,"sudo_set_alpha_sigmoid_steepness":343,"sudo_set_yuma3_enabled":332,"sudo_set_bonds_reset_enabled":332,"sudo_set_sn_owner_hotkey":136,"sudo_set_subtoken_enabled":344,"sudo_set_commit_reveal_version":345,"sudo_set_owner_immune_neuron_limit":346,"sudo_set_ck_burn":347,"sudo_set_admin_freeze_window":348,"sudo_set_owner_hparam_rate_limit":349,"sudo_set_mechanism_count":350,"sudo_set_mechanism_emission_split":351,"sudo_trim_to_max_allowed_uids":352,"sudo_set_min_allowed_uids":353,"sudo_set_tao_flow_cutoff":354,"sudo_set_tao_flow_normalization_exponent":355,"sudo_set_tao_flow_smoothing_factor":356,"sudo_set_max_mechanism_count":357,"sudo_set_min_non_immune_uids":358,"sudo_set_start_call_delay":359,"sudo_set_coldkey_swap_announcement_delay":334,"sudo_set_coldkey_swap_reannouncement_delay":334},"27":{"enter":170,"force_enter":170,"extend":170,"force_extend":170,"force_exit":170,"force_slash_deposit":364,"release_deposit":364,"force_release_deposit":364},"28":{"transact":372},"29":{"40":378,"41":379,"42":380,"create2":381,"set_whitelist":382,"disable_whitelist":383},"30":0,"31":{"set_base_fee_per_gas":387,"set_elasticity":388},"32":{"write_pulse":393,"set_beacon_config":394,"set_oldest_stored_round":395},"33":{"40":401,"42":399,"contribute":400,"finalize":401,"refund":401,"dissolve":401,"update_min_contribution":402,"update_end":403,"update_cap":404},"34":{"set_fee_rate":414,"toggle_user_liquidity":415,"add_liquidity":416,"remove_liquidity":417,"modify_position":418,"disable_lp":170},"35":{"37":434,"41":435,"43":433,"44":437,"call_old_weight":430,"instantiate_with_code_old_weight":431,"instantiate_old_weight":432,"remove_code":24,"instantiate_with_code":436,"migrate":438},"36":{"announce_next_key":448,"submit_encrypted":449,"mark_decryption_failed":450}},"events":{"2":{"ExtrinsicSuccess":25,"ExtrinsicFailed":26,"CodeUpdated":27,"NewAccount":28,"KilledAccount":28,"Remarked":29,"UpgradeAuthorized":30,"RejectedInvalidAuthorizedUpgrade":31},"3":0,"4":0,"6":0,"7":{"NewAuthorities":43,"Paused":27,"Resumed":27},"9":{"Endowed":57,"DustLost":58,"Transfer":59,"BalanceSet":60,"Reserved":61,"Unreserved":61,"ReserveRepatriated":62,"Deposit":61,"Withdraw":61,"Slashed":61,"Minted":61,"Burned":61,"Suspended":61,"Restored":61,"Upgraded":63,"Issued":64,"Rescinded":64,"Locked":61,"Unlocked":61,"Frozen":61,"Thawed":61,"TotalIssuanceForced":65},"10":{"TransactionFeePaid":67},"17":{"11":181,"14":214,"15":191,"45":186,"46":27,"NetworkAdded":174,"NetworkRemoved":175,"StakeAdded":176,"StakeRemoved":176,"StakeMoved":177,"WeightsSet":174,"NeuronRegistered":178,"BulkNeuronsRegistered":174,"BulkBalancesSet":174,"MaxAllowedUidsSet":174,"MaxWeightLimitSet":174,"DifficultySet":179,"AdjustmentIntervalSet":174,"RegistrationPerIntervalSet":174,"MaxRegistrationsPerBlockSet":174,"ActivityCutoffSet":174,"RhoSet":174,"AlphaSigmoidSteepnessSet":180,"KappaSet":174,"MinAllowedWeightSet":174,"ValidatorPruneLenSet":179,"ScalingLawPowerSet":174,"WeightsSetRateLimitSet":179,"ImmunityPeriodSet":174,"BondsMovingAverageSet":179,"BondsPenaltySet":174,"BondsResetOnSet":181,"MaxAllowedValidatorsSet":174,"AxonServed":182,"PrometheusServed":182,"DelegateAdded":183,"DefaultTakeSet":175,"WeightsVersionKeySet":179,"MinDifficultySet":179,"MaxDifficultySet":179,"ServingRateLimitSet":179,"BurnSet":179,"MaxBurnSet":179,"MinBurnSet":179,"TxRateLimitSet":184,"TxDelegateTakeRateLimitSet":184,"TxChildKeyTakeRateLimitSet":184,"AdminFreezeWindowSet":175,"OwnerHyperparamRateLimitSet":175,"MinChildKeyTakeSet":175,"MaxChildKeyTakeSet":175,"ChildKeyTakeSet":185,"RegistrationAllowed":181,"PowRegistrationAllowed":181,"TempoSet":174,"RAORecycledForRegistrationSet":179,"StakeThresholdSet":184,"AdjustmentAlphaSet":179,"Faucet":187,"SubnetOwnerCutSet":175,"NetworkRateLimitSet":184,"NetworkImmunityPeriodSet":184,"StartCallDelaySet":184,"NetworkMinLockCostSet":184,"SubnetLimitSet":175,"NetworkLockCostReductionIntervalSet":184,"TakeDecreased":183,"TakeIncreased":183,"HotkeySwapped":188,"MaxDelegateTakeSet":175,"MinDelegateTakeSet":175,"ColdkeySwapAnnounced":189,"ColdkeySwapReset":63,"ColdkeySwapped":190,"ColdkeySwapDisputed":191,"AllBalanceUnstakedAndTransferredToNewColdkey":192,"ArbitrationPeriodExtended":191,"SetChildrenScheduled":193,"SetChildren":194,"ChainIdentitySet":195,"SubnetIdentitySet":175,"SubnetIdentityRemoved":175,"DissolveNetworkScheduled":196,"ColdkeySwapAnnouncementDelaySet":175,"ColdkeySwapReannouncementDelaySet":175,"DissolveNetworkScheduleDurationSet":175,"CRV3WeightsCommitted":197,"WeightsCommitted":197,"WeightsRevealed":197,"WeightsBatchRevealed":198,"BatchWeightsCompleted":199,"BatchWeightItemFailed":200,"StakeTransferred":201,"StakeSwapped":202,"SubnetOwnerHotkeySet":182,"FirstEmissionBlockNumberSet":179,"AlphaRecycled":203,"AlphaBurned":203,"EvmKeyAssociated":204,"CRV3WeightsRevealed":182,"CommitRevealPeriodsSet":179,"CommitRevealEnabled":181,"HotkeySwappedOnSubnet":205,"SubnetLeaseCreated":206,"SubnetLeaseTerminated":207,"SymbolUpdated":208,"CommitRevealVersionSet":175,"TimelockedWeightsCommitted":209,"TimelockedWeightsRevealed":182,"AutoStakeAdded":210,"IncentiveAlphaEmittedToMiners":211,"MinAllowedUidsSet":174,"AutoStakeDestinationSet":212,"MinNonImmuneUidsSet":174,"RootClaimTypeSet":213,"VotingPowerTrackingDisableScheduled":215,"VotingPowerTrackingDisabled":214,"VotingPowerEmaAlphaSet":216,"SubnetLeaseDividendsDistributed":217,"AddStakeBurn":218},"18":{"46":27,"BatchInterrupted":224,"BatchCompleted":27,"ItemCompleted":27,"ItemFailed":225,"DispatchedAs":226,"IfElseMainSuccess":27,"IfElseFallbackCalled":227},"19":{"45":232,"KeyChanged":233,"KeyRemoved":27,"SudoAsDone":232},"20":{"47":244,"NewMultisig":240,"MultisigApproval":241,"MultisigExecuted":242,"MultisigCancelled":243},"21":{"Noted":251,"Requested":251,"Cleared":251},"22":{"Scheduled":264,"Canceled":264,"Dispatched":265,"RetrySet":266,"RetryCancelled":267,"CallUnavailable":267,"PeriodicFailed":267,"RetryFailed":267,"PermanentlyOverweight":267,"AgendaIncomplete":268},"23":{"47":285,"ProxyExecuted":226,"PureCreated":281,"PureKilled":282,"Announced":283,"ProxyAdded":284,"ProxyRemoved":284},"24":{"IdentitySet":63,"IdentityDissolved":63},"25":{"Commitment":295,"TimelockCommitment":296,"CommitmentRevealed":295},"26":{"PrecompileUpdated":360,"Yuma3EnableToggled":361,"BondsResetToggled":361},"27":{"Entered":365,"Extended":365,"Exited":366,"DepositPlaced":58,"DepositReleased":58,"DepositSlashed":58,"CannotDeposit":27,"CannotRelease":27},"28":{"48":373},"29":{"48":385,"49":385,"Log":384,"CreatedFailed":385,"ExecutedFailed":385},"30":0,"31":{"NewBaseFeePerGas":389,"BaseFeeOverflow":27,"NewElasticity":390},"32":{"BeaconConfigChanged":27,"NewPulse":396,"SetOldestStoredRound":184},"33":{"49":405,"Contributed":406,"Withdrew":406,"PartiallyRefunded":407,"AllRefunded":407,"Finalized":407,"Dissolved":407,"MinContributionUpdated":408,"EndUpdated":409,"CapUpdated":410},"34":{"FeeRateSet":419,"UserLiquidityToggled":420,"LiquidityAdded":421,"LiquidityRemoved":422,"LiquidityModified":422},"35":{"Instantiated":439,"Terminated":440,"CodeStored":441,"ContractEmitted":442,"CodeRemoved":443,"ContractCodeUpdated":444,"Called":445,"DelegateCalled":446,"StorageDepositTransferredAndHeld":59,"StorageDepositTransferredAndReleased":59},"36":{"EncryptedSubmitted":451,"DecryptedExecuted":452,"DecryptedRejected":453,"DecryptionFailed":454}},"constants":{"2":{"BlockWeights":14,"BlockLength":15,"BlockHashCount":1,"DbWeight":16,"Version":17,"SS58Prefix":1},"3":0,"4":{"MinimumPeriod":34},"6":{"SlotDuration":34},"7":{"MaxAuthorities":1,"MaxNominators":1,"MaxSetIdSessionEntries":34},"9":{"ExistentialDeposit":34,"MaxLocks":1,"MaxReserves":1,"MaxFreezes":1},"10":{"OperationalFeeMultiplier":1},"17":{"12":2,"13":2,"InitialIssuance":34,"InitialMinAllowedWeights":1,"InitialEmissionValue":1,"InitialTempo":1,"InitialDifficulty":34,"InitialMaxDifficulty":34,"InitialMinDifficulty":34,"InitialRAORecycledForRegistration":34,"InitialBurn":34,"InitialMaxBurn":34,"InitialMinBurn":34,"MinBurnUpperBound":34,"MaxBurnLowerBound":34,"InitialAdjustmentInterval":1,"InitialBondsMovingAverage":34,"InitialBondsPenalty":1,"InitialBondsResetOn":2,"InitialTargetRegistrationsPerInterval":1,"InitialRho":1,"InitialAlphaSigmoidSteepness":1,"InitialKappa":1,"InitialMinAllowedUids":1,"InitialMaxAllowedUids":1,"InitialValidatorPruneLen":34,"InitialScalingLawPower":1,"InitialImmunityPeriod":1,"InitialActivityCutoff":1,"InitialMaxRegistrationsPerBlock":1,"InitialPruningScore":1,"InitialMaxAllowedValidators":1,"InitialDefaultDelegateTake":1,"InitialMinDelegateTake":1,"InitialDefaultChildKeyTake":1,"InitialMinChildKeyTake":1,"InitialMaxChildKeyTake":1,"InitialWeightsVersionKey":34,"InitialServingRateLimit":34,"InitialTxRateLimit":34,"InitialTxDelegateTakeRateLimit":34,"InitialTxChildKeyTakeRateLimit":34,"InitialAdjustmentAlpha":34,"InitialNetworkImmunityPeriod":34,"InitialNetworkMinLockCost":34,"InitialSubnetOwnerCut":1,"InitialNetworkLockReductionInterval":34,"InitialNetworkRateLimit":34,"KeySwapCost":34,"AlphaHigh":1,"AlphaLow":1,"InitialColdkeySwapAnnouncementDelay":1,"InitialColdkeySwapReannouncementDelay":1,"InitialDissolveNetworkScheduleDuration":1,"InitialTaoWeight":34,"InitialEmaPriceHalvingPeriod":34,"InitialStartCallDelay":34,"KeySwapOnSubnetCost":34,"HotkeySwapOnSubnetInterval":34,"LeaseDividendsDistributionInterval":1,"MaxImmuneUidsPercentage":1},"18":{"batched_calls_limit":1},"19":0,"20":{"DepositBase":34,"DepositFactor":34,"MaxSignatories":1},"21":0,"22":{"MaximumWeight":13,"MaxScheduledPerBlock":1},"23":{"ProxyDepositBase":34,"ProxyDepositFactor":34,"MaxProxies":1,"MaxPending":1,"AnnouncementDepositBase":34,"AnnouncementDepositFactor":34},"24":{"50":34,"51":34,"MaxAdditionalFields":1},"25":{"50":34,"51":34,"MaxFields":1},"26":0,"27":{"EnterDuration":1,"ExtendDuration":1,"EnterDepositAmount":362,"ExtendDepositAmount":362,"ReleaseDelay":363},"28":0,"29":0,"30":0,"31":0,"32":{"UnsignedPriority":34,"HttpFetchTimeout":34},"33":{"PalletId":398,"MinimumDeposit":34,"AbsoluteMinimumContribution":34,"MinimumBlockDuration":1,"MaximumBlockDuration":1,"RefundContributorsLimit":1,"MaxContributors":1},"34":{"ProtocolId":398,"MaxFeeRate":1,"MaxPositions":1,"MinimumLiquidity":34,"MinimumReserve":34},"35":{"Schedule":428,"DepositPerByte":34,"DefaultDepositLimit":34,"DepositPerItem":34,"CodeHashLockupDepositPercent":1,"MaxCodeLen":1,"MaxStorageKeyLen":1,"MaxTransientStorageSize":1,"MaxDelegateDependencies":1,"UnsafeUnstableInterface":2,"MaxDebugBufferLen":1,"Environment":429,"ApiVersion":1},"36":0},"viewFns":{"2":0,"3":0,"4":0,"6":0,"7":0,"9":0,"10":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":{"check_permissions":272,"is_superset":273},"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0},"apis":{"Core":{"version":455,"execute_block":456,"initialize_block":457},"Metadata":{"metadata":458,"metadata_at_version":459,"metadata_versions":460},"BlockBuilder":{"apply_extrinsic":461,"finalize_block":462,"inherent_extrinsics":463,"check_inherents":464},"GenesisBuilder":{"build_state":465,"get_preset":466,"preset_names":467},"TaggedTransactionQueue":{"validate_transaction":468},"OffchainWorkerApi":{"offchain_worker":469},"AuraApi":{"slot_duration":470,"authorities":471},"SessionKeys":{"generate_session_keys":472,"decode_session_keys":473},"GrandpaApi":{"52":475,"53":476,"grandpa_authorities":474,"current_set_id":470},"AccountNonceApi":{"account_nonce":477},"TransactionPaymentApi":{"54":480,"55":481,"query_info":478,"query_fee_details":479},"TransactionPaymentCallApi":{"54":480,"55":481,"query_call_info":482,"query_call_fee_details":483},"EthereumRuntimeRPCApi":{"41":489,"42":490,"chain_id":470,"account_basic":484,"gas_price":485,"account_code_at":486,"author":487,"storage_at":488,"current_block":491,"current_receipts":492,"current_transaction_statuses":493,"current_all":494,"extrinsic_filter":495,"elasticity":496,"gas_limit_multiplier_support":497,"pending_block":498,"initialize_pending_block":469},"ConvertTransactionRuntimeApi":{"convert_transaction":499},"ContractsApi":{"41":500,"43":502,"44":501,"get_storage":503},"DelegateInfoRuntimeApi":{"get_delegates":504,"get_delegate":505,"get_delegated":506},"NeuronInfoRuntimeApi":{"get_neurons":507,"get_neuron":508,"get_neurons_lite":509,"get_neuron_lite":510},"SubnetInfoRuntimeApi":{"get_subnet_info":511,"get_subnets_info":512,"get_subnet_info_v2":513,"get_subnets_info_v2":514,"get_subnet_hyperparams":515,"get_subnet_hyperparams_v2":516,"get_all_dynamic_info":517,"get_all_metagraphs":518,"get_metagraph":519,"get_all_mechagraphs":518,"get_mechagraph":520,"get_dynamic_info":521,"get_subnet_state":522,"get_selective_metagraph":523,"get_coldkey_auto_stake_hotkey":524,"get_selective_mechagraph":525,"get_subnet_to_prune":496},"StakeInfoRuntimeApi":{"get_stake_info_for_coldkey":526,"get_stake_info_for_coldkeys":527,"get_stake_info_for_hotkey_coldkey_netuid":528,"get_stake_fee":529},"SubnetRegistrationRuntimeApi":{"get_network_registration_cost":470},"BabeApi":{"52":533,"53":532,"configuration":530,"current_epoch_start":470,"current_epoch":531,"next_epoch":531},"SwapRuntimeApi":{"current_alpha_price":534,"current_alpha_price_all":535,"sim_swap_tao_for_alpha":536,"sim_swap_alpha_for_tao":537}}}},[{}],["Account","BlockHash","System","RandomnessCollectiveFlip","Timestamp","Authorities","Aura","Grandpa","TotalIssuance","Balances","TransactionPayment","TransferToggle","LiquidAlphaOn","Yuma3On","VotingPowerTrackingEnabled","RootClaimed","HasMigrationRun","SubtensorModule","Utility","Sudo","Multisig","Preimage","Scheduler","Proxy","Registry","Commitments","AdminUtils","SafeMode","Ethereum","EVM","EVMChainId","BaseFee","Drand","Crowdloan","Swap","Contracts","MevShield","set_code","set_identity","poke_deposit","withdraw","call","create","upload_code","instantiate","Sudid","BatchCompletedWithErrors","DepositPoked","Executed","Created","InitialDeposit","FieldDeposit","submit_report_equivocation_unsigned_extrinsic","generate_key_ownership_proof","query_weight_to_fee","query_length_to_fee"]]`); -var replaceTokens = (obj) => Object.fromEntries( - Object.entries(obj).map(([key, value]) => { - const unwrappedValue = typeof value === "object" ? replaceTokens(value) : value; - const numericKey = Number(key); - if (Number.isNaN(numericKey)) { - return [key, unwrappedValue]; - } - return [tokens[numericKey], unwrappedValue]; - }) -); -var tokenizedCommonTrees = commonTrees.map(replaceTokens); -var unwrap = (obj, depth) => depth === 0 ? obj : Object.fromEntries( - Object.entries(obj).map(([key, value]) => [ - key, - unwrap( - typeof value === "object" ? value : tokenizedCommonTrees[value], - depth - 1 - ) - ]) -); -var getChainDescriptors = (key) => unwrap(replaceTokens(minified[key]), 2); -var Devnet = getChainDescriptors("devnet"); -export { - Devnet -}; diff --git a/contract-tests/.papi/descriptors/dist/descriptors.d.ts b/contract-tests/.papi/descriptors/dist/descriptors.d.ts deleted file mode 100644 index 406970a3f1..0000000000 --- a/contract-tests/.papi/descriptors/dist/descriptors.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare const Devnet: Record; diff --git a/contract-tests/.papi/descriptors/dist/devnet.d.ts b/contract-tests/.papi/descriptors/dist/devnet.d.ts deleted file mode 100644 index eed219964c..0000000000 --- a/contract-tests/.papi/descriptors/dist/devnet.d.ts +++ /dev/null @@ -1,8736 +0,0 @@ -import { StorageDescriptor, PlainDescriptor, TxDescriptor, RuntimeDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, FixedSizeBinary, Binary, FixedSizeArray } from "polkadot-api"; -import { I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, Icr4vaj0vrd6je, I95g6i7ilua7lq, Ieniouoqkq4icf, Phase, Ibgl04rn6nbfm6, I4q39t5hn830vp, Ic5m5lp1oioo8r, GrandpaStoredState, I7pe2me3i3vtn9, I9jd27rnpm8ttv, I3geksg000c171, I1q8tnt1cluu5j, I8ds64oj6581v0, Ia7pdug7cdsg8g, I2hnk9r4ukuj1p, I9bin2jc70qt6q, TransactionPaymentReleases, I7svnfko10tq2e, I6ouflveob4eli, Idoeu5t0dum8va, I5n8gpu725k1nu, Ia2lhg7l2hilo3, I4p5t2krb1gmvp, I7svrbkiu01iec, Iabpgqcjikia83, I2j729bmgsdiuo, Iakavvne152v30, Ib9tptuv3cggfs, Icgljjb6j82uhn, I4h6ivgjtd51lv, I9eir063evtfb6, Iafqnechp3omqg, Ibc83gdj8hi3rc, I9lpjucl20l82d, Iaap7oohdmr1sb, Ifjlj958aeheic, I4tc54pa558g5n, Id32h28hjj1tch, Icrrf4uohj5gb0, I76jd8kl1mtn5g, I4ojmnsk1dchql, I4jqk5si14p5oi, I2na29tt2afp0j, If9jidduiuq7vv, I2brm5b9jij1st, Iapm6e7vtp0l6r, I7tof95tckt2r, Ieruonr5pk2d7h, Iag146hmjgqfgj, I8uo3fpd3bcc6f, PreimageOldRequestStatus, PreimageRequestStatus, I4pact7n2e9a0i, I11tetbe8ces3o, I56u24ncejr5kt, I6tqrno2gaos08, I9p9lq3rej5bhc, Ibq6c27da62s2q, Ib6u9l1gtc5l4t, I7nkl7ntqohel8, I3m6d7ohcp5n4v, Ib9pv5dg6upo6t, I27ub49plcvb4c, I8un1ap2r4hhbj, Ic3l568el19b24, Ib0hfhkohlekcj, I32lgu058i52q9, Ie7atdsih6q14b, I4totqt881mlti, I7jidl7qnnq87c, I82cps8ng2jtug, I4gqmlq9k6jlk3, I494mq1ertfc9k, Ialchst9lgd11u, If0p9hvn3kegj1, I8ac0r18acljm6, I5g2vv0ckl2m8b, I5mi4kb05lrsa9, Icsknfl0f6r973, I1ptic1rnhda0n, I5kulbesqc1h1t, I36dvimehsh2tm, I8t4pajubp34g3, Ifdiflqufkknl8, In7a38730s6qs, If15el53dd76v9, I9s0ave7t0vnrk, I4fo08joqmcqnm, I35p85j063s0il, I4arjljr6dpflb, Ijc5n210o8bbf, I3m5sq54sjdlso, I8ofcg5rbj0g2c, I4adgbll7gku4i, I6pjjpfvhvcfru, I9pj91mj79qekl, I39uah9nss64h9, Ik64dknsq7k08, Ib51vk42m1po4n, Idcr6u6361oad9, I3a5kuu5t5jj3g, I2hviml3snvhhn, I4ktuaksf5i1gk, I9bqtpv2ii35mp, I9j7pagd6d4bda, I2h9pmio37r7fb, Ibmr18suc9ikh9, I9iq22t0burs89, I5u8olqbbvfnvf, I5utcetro501ir, Icv6ofu4lqekr4, I48embv0n659kj, I8l6dbd18t5aja, I513du23unvan, I36o6oho99gjm8, If3mvus4cmnb7l, I3qrhi1ua10nnf, I2hpc4ev2drsf2, I73q6qh9ckhm04, Idia8cmqvul6et, Idardmhchnv8aa, Icud5m8j0nlgtj, I850u7ir5o34um, Ica88a899k1afk, I4tfn6eb3ekqt2, Ia5r6mm7trbg6a, I27gr0ss2ikvqh, Ie7hipi75c7vn0, I7f38r2vt6r9k1, I6b53cjq4m9nsr, I216fvnrl9nq6l, I9n4d52k0luroe, I3gk6eeddm0hsd, I6ue7qc27uhiev, Ifp8lgrkla2dig, I30l38oi9ed9dj, Ifj9gf4ekq9snm, If2k69ql8jgivj, I4378ieh1uba9u, I8e6f7r9dtk9c1, I9d117ni3tprb, I340k0hbj1hc6r, Ibapoov2fa817a, I2eon60c4gde7f, I7egr0053sjpci, I6r22p9usi2mkl, I6cm4c5a1euio9, I96k3nrdjfd63k, Ibg3cp8vjl5u55, Ibtu1gfmdnou5k, Iaoomvri5btde, Ic80igo4eds6rq, Iflrm8un6aibtn, I62rrikn5vj0p5, Ietm4rjshhu7sf, I1v9m3ms1elitm, I2t4b7068rtebl, I7a99hd3nbic2l, Ie8hpsm3jhsvo3, Ifcj247vgfdg56, Ic21uicfit5vcu, I375tmdui1ejfc, I4guv8rii4s6je, I2t2h3sjr2mdj0, I80tnmsfsu19sl, Ib7nn1mns0usdp, I4fivl1mrn0hhc, I2ead8rm0h16hm, I25l72483lbgf9, I9okvr56cd7277, I8k3rnvpeeh4hv, I56sht7incdimf, I8hge8nrufr05f, I5v0mk7rggegmh, Ideaemvoneh309, I3d9o9d7epp66v, I6lqh1vgb4mcja, I82nfqfkd48n10, I1jm8m1rh9e20v, I3o5j3bli1pd8e, Ivqkjqsbgj1dj, I5n4sebgkfr760, Ib6bm2ug64rldc, Ifs1i5fk9cqvr6, I5q3t0hm83a58h, I2gnaqoj2eimi0, Ieg3fd8p4pkt10, I8kg5ll427kfqq, I467333262q1l9, Idlqs144rc48hk, It11trpppbc3l, Ietml13sclqs1q, Iftfic7p3uban2, I2eb501t8s6hsq, Ianmuoljk2sk1u, I7hgtlnpelk0fc, I3p6khp3nv37cu, I6pnnj50tnq448, I57v1t6776pl3a, I1il5mj68vvsms, I42mob3hqe6j7h, Icdbq0j31b3g9c, I2t2rlclb0ce3e, Iar87gdqmug5o7, I3oullii9p80a1, I8t8ta6lfbia9e, I3akfmjle982qg, Ibaje86kdit7s6, I90lra4vl5j4db, I1q480m57ftcms, Ie2bjglo51atf6, Ievma38tc25kil, I2er75v4akf5cc, I5pldh0j0v0u4l, Ifhou5p0slv68r, I9m89dnau2i4tt, Ifunpjbsc4jrrr, I85uujfpnu8gum, I7bl5t0it6ck2m, I4iope0tjiqgu4, Iptqa236frcvo, I8hbi1vrve1i2, I1v9a50gjqk26k, Idv4d3rktbigfh, I56j1e9gqlq602, Ib6k4vik9ruq8h, I9u9gu9aa92l5m, Idmd4tos09qd68, Ia0sp2p68e9k16, Ie318529rgoagk, Iam4iou8r3isc1, I21ajnsdtbutjh, I203rofi4rpmo4, I1e290fmo892vi, Ie31ro5s5e089f, I71lu4gpn88cf0, I98iornf3ajrp9, I9893mbk9nh201, I623eo8t3jrbeo, Ieo8qamskgm4dk, Ift1efpssa32g2, Ibk3v0rrpo1bio, I1sj8huj7of8mb, I6av3sq9jkhmm3, I70cd7doki8rme, Iam7j42j9f1go6, Idco9ambhipg4i, I6s1nbislhk619, I9jtu7slb30qvs, Idv3j6a15pjc16, I206qvjkjun95i, I4qhb3plq4ifmq, Ic58lhlh1ocpm1, I6uopd4b2os90n, I6idbvi8v00o5j, Ifbgbhkj74b35k, Ibt4a800kb7frq, Icb4un8h4cokoo, I1up607q6ce947, I7hktg5sccf8op, Ib1d0bomkbrqv1, Iaflrold1ds0nq, I1ssp78ejl639m, I13qib3vtm9cs3, Idcabvplu05lea, Id38gdpcotl637, I73q3qf5u7nnqg, Idpm1bc2cr6dgj, I837c61fc07ine, I6m0oguilvhn8, I7vi74gbubc8u5, I3u0knmtb1ueq7, I87tlou92i0bot, Ifd3mkud9g8rb1, Iakvbbhvger3oa, I92t98snpjjcts, Iet4pe2le7ku09, I5dueehi6i2dg9, I64ev05f6q10es, Ikc5h15joooak, Ie8f436ua5fs59, I3mkis681qg30e, I2foqo7cbqf35v, I3mcu79ge1e54v, Icf66vuktncksu, Id69glo8rcjef, Ia2rnh5pfua40a, I3otc7e9a35k1k, I89ier5tb9ne0s, Im2f0numhevg3, I2agkcpojhkk43, I32rvg545edabm, I83fv0vi59md7i, I5tjjqcdd4tae0, I1894dm1lf1ae7, Idkfsqnep2hpeb, I2u5b4034ft9hp, I602p6mm30elei, Ia82mnkmeo2rhc, I6u3ru0d29kkj0, Icbccs0ug47ilf, I855j4i3kr8ko1, Ibk0nulspilods, I5768ac424h061, Icv68aq8841478, Ic262ibdoec56a, Iflcfm9b6nlmdd, Ijrsf4mnp3eka, Id5fm4p8lj5qgi, I8tjvj9uq4b7hi, I4cbvqmqadhrea, I3qt1hgg4djhgb, I4fooe9dun9o0t, Ier2cke86dqbr2, Io45lnue7n40k, I83e4tgdv5ohg1, I6o6dmud53u1fj, I39p6ln31i4n46, I95l2k9b1re95f, Ifkgc6cte1k96e, I6kvs2mb8unk0t, Idbuci3sr3i1f7, I73drt1hl9e70v, I1dm4sip108q0g, Iajgphfb1fka7l, I4hnmf90qkrer9, Ijsohbv0raf36, I4ga01hppthoe1, I4hckkcv10tcue, Ic871mj76419vm, If2ieedn10ujdv, Iaseh340tnovdh, I8m5umt6snnmlj, I5aeg4u9kpsp8o, I3fsv5f1boeqf3, Ifoov68qt28nbm, Ib937mhlbop6j7, I838gqvljm75tj, I1cu36qostj5d8, I4r2ptfsrl017r, Ielglukq9ekcit, I1clsdhcok4nle, Iemddv6u2buvfn, Ic149bnrif7lpr, I89dsvf7sdo4ko, I804q3c12638a0, Idguve298jnare, Idi3fb8585u2lp, I1327b77famnt3, If58ibsptjm2at, I5rtkmhm2dng4u, Iep27ialq4a7o7, Iasu5jvoqr43mv, I88p4dmln8611r, I5qolde99acmd1, I8gtde5abn1g9a, I3dvon8akhmsut, Ia3c82eadg79bj, Ienusoeb625ftq, Ibtsa3docbr9el, Iek6442ldi23n3, Idpdo54rotesu2, I2ur0oeqg495j8, Ibco2bqthggul0, I1bhd210c3phjj, Idcqgi2844k5he, Iej2173ou338sm, I20e9ph536u7ti, I8kcpmsh450rp, Iea4g5ovhnolus, Ifmc9boeeia623, Itmchvgqfl28g, I5tf7b5o64mfpl, If71d2q730qf6n, If0sk51c1n7ri8, I4b2eh3b1oi815, I57q620f4fu1bl, Ie5222qfrr24ek, I28g8sphdu312k, Idqbjt2c6r46t6, I853aigjva3f0t, I9uehhems5hkqm, I7q5qk4uoanhof, Iehpbs40l3jkit, Idht9upmipvd4j, Icns2sqr5hp8s3, I9n4hs8p3rlkag, I6a8j73186lfdf, I8vbtb6bd00lm0, I8v1041j74kmaj, Iaqet9jc3ihboe, Ic952bubvq4k7d, I2v50gu3s1aqk6, Ibmofsd95figtn, If7uv525tdvv7a, Itom7fk49o0c9, I2an1fs2eiebjp, Ie9sr1iqcg3cgm, I1mqgk2tmnn9i2, I6lr8sctk0bi4e, TransactionValidityTransactionSource, I9ask1o4tfvcvs, Icerf8h8pdu8ss, I9puqgoda8ofk4, I6spmpef2c7svf, Iei2mvq0mjvt81, If08sfhqn8ujfr, Ic4rgfgksgmm3e, I3dj14b7k3rkm5, Ic5egmm215ml6k, Ibg4am9lqg35ku, I7efspe2svrt0g, I5fvdd841odbi3, I35vouom6s9r2, Ie6kgk6f04rsvk, Ifgqf2rskq94om, Ie30stbbeaul1o, I7aold6s47n103, Ibjuap2vk03rp6, Iasb8k6ash5mjn, Ifla7g8u5j9k68, I9sijb8gfrns29, I17s97pb2d5tj3, I2dfliekq1ed7e, I4gah17u2nc33h, I9u22scd4ksrjm, Ibil6rvg3saeb3, I97cs1i8k87lnm, I874e758ge6pa9, I86tq0h1o8f1g5, I78cq8c9mego2f, I64hm01ml98m4p, I3gjbugrk45her, I9nvi04b7jiso4, I6s1052v0hl6mr, I31p8sd8onusg0, I2vgg418k9gfnm, I7dp6t7k7a8r36, Ibtpedbm9ai3hp, I8ivaf995pho4u, Icr6rj04unermu, I5gfdo8kg6rloq, Ibjoh8vk2j7bqd, I2u4s5o1c0r3fu, Ic0g2vnp5r296p, Ihfphjolmsqq1, Ic9fkrj2ggjleq, Ifi9cmevnosufh, I1i5jfmqcsjper, I3pbrjdm4vnbsa, Iems84l8lk2v0c, I1r5ke30ueqo0r, I68ii5ik8avr9o, I8slfm2rri67ri, I34n2itmpoq7on } from "./common-types"; -type AnonymousEnum = T & { - __anonymous: true; -}; -type MyTuple = [T, ...T[]]; -type SeparateUndefined = undefined extends T ? undefined | Exclude : T; -type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { - [K in keyof T]: T[K]; -} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { - [K in keyof T & string]: T[K]; -}>; -type IStorage = { - System: { - /** - * The full account information for a particular account ID. - */ - Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * Total extrinsics count for the current block. - */ - ExtrinsicCount: StorageDescriptor<[], number, true, never>; - /** - * Whether all inherents have been applied. - */ - InherentsApplied: StorageDescriptor<[], boolean, false, never>; - /** - * The current weight for the block. - */ - BlockWeight: StorageDescriptor<[], Anonymize, false, never>; - /** - * Total length (in bytes) for all extrinsics put together, for the current block. - */ - AllExtrinsicsLen: StorageDescriptor<[], number, true, never>; - /** - * Map of block numbers to block hashes. - */ - BlockHash: StorageDescriptor<[Key: number], FixedSizeBinary<32>, false, never>; - /** - * Extrinsics data for the current block (maps an extrinsic's index to its data). - */ - ExtrinsicData: StorageDescriptor<[Key: number], Binary, false, never>; - /** - * The current block number being processed. Set by `execute_block`. - */ - Number: StorageDescriptor<[], number, false, never>; - /** - * Hash of the previous block. - */ - ParentHash: StorageDescriptor<[], FixedSizeBinary<32>, false, never>; - /** - * Digest of the current block, also part of the block header. - */ - Digest: StorageDescriptor<[], Anonymize, false, never>; - /** - * Events deposited for the current block. - * - * NOTE: The item is unbound and should therefore never be read on chain. - * It could otherwise inflate the PoV size of a block. - * - * Events have a large in-memory size. Box the events to not go out-of-memory - * just in case someone still reads them from within the runtime. - */ - Events: StorageDescriptor<[], Anonymize, false, never>; - /** - * The number of events in the `Events` list. - */ - EventCount: StorageDescriptor<[], number, false, never>; - /** - * Mapping between a topic (represented by T::Hash) and a vector of indexes - * of events in the `>` list. - * - * All topic vectors have deterministic storage locations depending on the topic. This - * allows light-clients to leverage the changes trie storage tracking mechanism and - * in case of changes fetch the list of events of interest. - * - * The value has the type `(BlockNumberFor, EventIndex)` because if we used only just - * the `EventIndex` then in case if the topic has the same contents on the next block - * no notification will be triggered thus the event might be lost. - */ - EventTopics: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, false, never>; - /** - * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. - */ - LastRuntimeUpgrade: StorageDescriptor<[], Anonymize, true, never>; - /** - * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. - */ - UpgradedToU32RefCount: StorageDescriptor<[], boolean, false, never>; - /** - * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False - * (default) if not. - */ - UpgradedToTripleRefCount: StorageDescriptor<[], boolean, false, never>; - /** - * The execution phase of the block. - */ - ExecutionPhase: StorageDescriptor<[], Phase, true, never>; - /** - * `Some` if a code upgrade has been authorized. - */ - AuthorizedUpgrade: StorageDescriptor<[], Anonymize, true, never>; - /** - * The weight reclaimed for the extrinsic. - * - * This information is available until the end of the extrinsic execution. - * More precisely this information is removed in `note_applied_extrinsic`. - * - * Logic doing some post dispatch weight reduction must update this storage to avoid duplicate - * reduction. - */ - ExtrinsicWeightReclaimed: StorageDescriptor<[], Anonymize, false, never>; - }; - RandomnessCollectiveFlip: { - /** - * Series of block headers from the last 81 blocks that acts as random seed material. This - * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of - * the oldest hash. - */ - RandomMaterial: StorageDescriptor<[], Anonymize, false, never>; - }; - Timestamp: { - /** - * The current time for the current block. - */ - Now: StorageDescriptor<[], bigint, false, never>; - /** - * Whether the timestamp has been updated in this block. - * - * This value is updated to `true` upon successful submission of a timestamp by a node. - * It is then checked at the end of each block execution in the `on_finalize` hook. - */ - DidUpdate: StorageDescriptor<[], boolean, false, never>; - }; - Aura: { - /** - * The current authority set. - */ - Authorities: StorageDescriptor<[], Anonymize, false, never>; - /** - * The current slot of this block. - * - * This will be set in `on_initialize`. - */ - CurrentSlot: StorageDescriptor<[], bigint, false, never>; - }; - Grandpa: { - /** - * State of the current authority set. - */ - State: StorageDescriptor<[], GrandpaStoredState, false, never>; - /** - * Pending change: (signaled at, scheduled change). - */ - PendingChange: StorageDescriptor<[], Anonymize, true, never>; - /** - * next block number where we can force a change. - */ - NextForced: StorageDescriptor<[], number, true, never>; - /** - * `true` if we are currently stalled. - */ - Stalled: StorageDescriptor<[], Anonymize, true, never>; - /** - * The number of changes (both in terms of keys and underlying economic responsibilities) - * in the "set" of Grandpa validators from genesis. - */ - CurrentSetId: StorageDescriptor<[], bigint, false, never>; - /** - * A mapping from grandpa set ID to the index of the *most recent* session for which its - * members were responsible. - * - * This is only used for validating equivocation proofs. An equivocation proof must - * contains a key-ownership proof for a given session, therefore we need a way to tie - * together sessions and GRANDPA set ids, i.e. we need to validate that a validator - * was the owner of a given key on a given session, and what the active set ID was - * during that session. - * - * TWOX-NOTE: `SetId` is not under user control. - */ - SetIdSession: StorageDescriptor<[Key: bigint], number, true, never>; - /** - * The current list of authorities. - */ - Authorities: StorageDescriptor<[], Anonymize, false, never>; - }; - Balances: { - /** - * The total units issued in the system. - */ - TotalIssuance: StorageDescriptor<[], bigint, false, never>; - /** - * The total units of outstanding deactivated balance in the system. - */ - InactiveIssuance: StorageDescriptor<[], bigint, false, never>; - /** - * The Balances pallet example of storing the balance of an account. - * - * # Example - * - * ```nocompile - * impl pallet_balances::Config for Runtime { - * type AccountStore = StorageMapShim, frame_system::Provider, AccountId, Self::AccountData> - * } - * ``` - * - * You can also store the balance of an account in the `System` pallet. - * - * # Example - * - * ```nocompile - * impl pallet_balances::Config for Runtime { - * type AccountStore = System - * } - * ``` - * - * But this comes with tradeoffs, storing account balances in the system pallet stores - * `frame_system` data alongside the account data contrary to storing account balances in the - * `Balances` pallet, which uses a `StorageMap` to store balances data only. - * NOTE: This is only used in the case that this pallet is used to store balances. - */ - Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * Any liquidity locks on some account balances. - * NOTE: Should only be accessed when setting, changing and freeing a lock. - * - * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` - */ - Locks: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * Named reserves on some account balances. - * - * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` - */ - Reserves: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * Holds on account balances. - */ - Holds: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * Freeze locks on account balances. - */ - Freezes: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - }; - TransactionPayment: { - /** - - */ - NextFeeMultiplier: StorageDescriptor<[], bigint, false, never>; - /** - - */ - StorageVersion: StorageDescriptor<[], TransactionPaymentReleases, false, never>; - }; - SubtensorModule: { - /** - - */ - MinActivityCutoff: StorageDescriptor<[], number, false, never>; - /** - * Global window (in blocks) at the end of each tempo where admin ops are disallowed - */ - AdminFreezeWindow: StorageDescriptor<[], number, false, never>; - /** - * Global number of epochs used to rate limit subnet owner hyperparameter updates - */ - OwnerHyperparamRateLimit: StorageDescriptor<[], number, false, never>; - /** - * Duration of dissolve network schedule before execution - */ - DissolveNetworkScheduleDuration: StorageDescriptor<[], number, false, never>; - /** - * --- DMap ( netuid, coldkey ) --> blocknumber | last hotkey swap on network. - */ - LastHotkeySwapOnNetuid: StorageDescriptor, bigint, false, never>; - /** - * Ensures unique IDs for StakeJobs storage map - */ - NextStakeJobId: StorageDescriptor<[], bigint, false, never>; - /** - * ============================ - * ==== Staking Variables ==== - * ============================ - * The Subtensor [`TotalIssuance`] represents the total issuance of tokens on the Bittensor network. - * - * It is comprised of three parts: - * - The total amount of issued tokens, tracked in the TotalIssuance of the Balances pallet - * - The total amount of tokens staked in the system, tracked in [`TotalStake`] - * - The total amount of tokens locked up for subnet reg, tracked in [`TotalSubnetLocked`] attained by iterating over subnet lock. - * - * Eventually, Bittensor should migrate to using Holds afterwhich time we will not require this - * separate accounting. - * --- ITEM --> Global weight - */ - TaoWeight: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM --> CK burn - */ - CKBurn: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM ( default_delegate_take ) - */ - MaxDelegateTake: StorageDescriptor<[], number, false, never>; - /** - * --- ITEM ( min_delegate_take ) - */ - MinDelegateTake: StorageDescriptor<[], number, false, never>; - /** - * --- ITEM ( default_childkey_take ) - */ - MaxChildkeyTake: StorageDescriptor<[], number, false, never>; - /** - * --- ITEM ( min_childkey_take ) - */ - MinChildkeyTake: StorageDescriptor<[], number, false, never>; - /** - * MAP ( hot ) --> cold | Returns the controlling coldkey for a hotkey - */ - Owner: StorageDescriptor<[Key: SS58String], SS58String, false, never>; - /** - * MAP ( hot ) --> take | Returns the hotkey delegation take. And signals that this key is open for delegation - */ - Delegates: StorageDescriptor<[Key: SS58String], number, false, never>; - /** - * DMAP ( hot, netuid ) --> take | Returns the hotkey childkey take for a specific subnet - */ - ChildkeyTake: StorageDescriptor, number, false, never>; - /** - * DMAP ( netuid, parent ) --> (Vec<(proportion,child)>, cool_down_block) - */ - PendingChildKeys: StorageDescriptor, Anonymize, false, never>; - /** - * DMAP ( parent, netuid ) --> Vec<(proportion,child)> - */ - ChildKeys: StorageDescriptor, Anonymize, false, never>; - /** - * DMAP ( child, netuid ) --> Vec<(proportion,parent)> - */ - ParentKeys: StorageDescriptor, Anonymize, false, never>; - /** - * --- DMAP ( netuid, hotkey ) --> u64 | Last alpha dividend this hotkey got on tempo. - */ - AlphaDividendsPerSubnet: StorageDescriptor, bigint, false, never>; - /** - * --- DMAP ( netuid, hotkey ) --> u64 | Last root alpha dividend this hotkey got on tempo. - */ - RootAlphaDividendsPerSubnet: StorageDescriptor, bigint, false, never>; - /** - * ================== - * ==== Coinbase ==== - * ================== - * --- ITEM ( global_block_emission ) - */ - BlockEmission: StorageDescriptor<[], bigint, false, never>; - /** - * --- DMap ( hot, netuid ) --> emission | last hotkey emission on network. - */ - LastHotkeyEmissionOnNetuid: StorageDescriptor, bigint, false, never>; - /** - * ========================== - * ==== Staking Counters ==== - * ========================== - * The Subtensor [`TotalIssuance`] represents the total issuance of tokens on the Bittensor network. - * - * It is comprised of three parts: - * - The total amount of issued tokens, tracked in the TotalIssuance of the Balances pallet - * - The total amount of tokens staked in the system, tracked in [`TotalStake`] - * - The total amount of tokens locked up for subnet reg, tracked in [`TotalSubnetLocked`] attained by iterating over subnet lock. - * - * Eventually, Bittensor should migrate to using Holds afterwhich time we will not require this - * separate accounting. - * --- ITEM ( maximum_number_of_networks ) - */ - SubnetLimit: StorageDescriptor<[], number, false, never>; - /** - * --- ITEM ( total_issuance ) - */ - TotalIssuance: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM ( total_stake ) - */ - TotalStake: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM ( moving_alpha ) -- subnet moving alpha. - */ - SubnetMovingAlpha: StorageDescriptor<[], bigint, false, never>; - /** - * --- MAP ( netuid ) --> moving_price | The subnet moving price. - */ - SubnetMovingPrice: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> root_prop | The subnet root proportion. - */ - RootProp: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> total_volume | The total amount of TAO bought and sold since the start of the network. - */ - SubnetVolume: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> tao_in_subnet | Returns the amount of TAO in the subnet. - */ - SubnetTAO: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> tao_in_user_subnet | Returns the amount of TAO in the subnet reserve provided by users as liquidity. - */ - SubnetTaoProvided: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> alpha_in_emission | Returns the amount of alph in emission into the pool per block. - */ - SubnetAlphaInEmission: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> alpha_out_emission | Returns the amount of alpha out emission into the network per block. - */ - SubnetAlphaOutEmission: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> tao_in_emission | Returns the amount of tao emitted into this subent on the last block. - */ - SubnetTaoInEmission: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> alpha_supply_in_pool | Returns the amount of alpha in the pool. - */ - SubnetAlphaIn: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> alpha_supply_user_in_pool | Returns the amount of alpha in the pool provided by users as liquidity. - */ - SubnetAlphaInProvided: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet. - */ - SubnetAlphaOut: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( cold ) --> Vec | Maps coldkey to hotkeys that stake to it - */ - StakingHotkeys: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * --- MAP ( cold ) --> Vec | Returns the vector of hotkeys controlled by this coldkey. - */ - OwnedHotkeys: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * --- DMAP ( cold, netuid )--> hot | Returns the hotkey a coldkey will autostake to with mining rewards. - */ - AutoStakeDestination: StorageDescriptor, SS58String, true, never>; - /** - * --- DMAP ( hot, netuid )--> Vec | Returns a list of coldkeys that are autostaking to a hotkey - */ - AutoStakeDestinationColdkeys: StorageDescriptor, Anonymize, false, never>; - /** - * The delay after an announcement before a coldkey swap can be performed. - */ - ColdkeySwapAnnouncementDelay: StorageDescriptor<[], number, false, never>; - /** - * The delay after the initial delay has passed before a new announcement can be made. - */ - ColdkeySwapReannouncementDelay: StorageDescriptor<[], number, false, never>; - /** - * A map of the coldkey swap announcements from a coldkey - * to the block number the coldkey swap can be performed. - */ - ColdkeySwapAnnouncements: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; - /** - * A map of the coldkey swap disputes from a coldkey to the - * block number the coldkey swap was disputed. - */ - ColdkeySwapDisputes: StorageDescriptor<[Key: SS58String], number, true, never>; - /** - * --- DMAP ( hot, netuid ) --> alpha | Returns the total amount of alpha a hotkey owns. - */ - TotalHotkeyAlpha: StorageDescriptor, bigint, false, never>; - /** - * --- DMAP ( hot, netuid ) --> alpha | Returns the total amount of alpha a hotkey owned in the last epoch. - */ - TotalHotkeyAlphaLastEpoch: StorageDescriptor, bigint, false, never>; - /** - * DMAP ( hot, netuid ) --> total_alpha_shares | Returns the number of alpha shares for a hotkey on a subnet. - */ - TotalHotkeyShares: StorageDescriptor, bigint, false, never>; - /** - * --- NMAP ( hot, cold, netuid ) --> alpha | Returns the alpha shares for a hotkey, coldkey, netuid triplet. - */ - Alpha: StorageDescriptor, bigint, false, never>; - /** - * Contains last Alpha storage map key to iterate (check first) - */ - AlphaMapLastKey: StorageDescriptor<[], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> token_symbol | Returns the token symbol for a subnet. - */ - TokenSymbol: StorageDescriptor<[Key: number], Binary, false, never>; - /** - * --- MAP ( netuid ) --> subnet_tao_flow | Returns the TAO inflow-outflow balance. - */ - SubnetTaoFlow: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> subnet_ema_tao_flow | Returns the EMA of TAO inflow-outflow balance. - */ - SubnetEmaTaoFlow: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * --- ITEM --> TAO Flow Cutoff - */ - TaoFlowCutoff: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM --> Flow Normalization Exponent (p) - */ - FlowNormExponent: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM --> Flow EMA smoothing factor (flow alpha), u64 normalized - */ - FlowEmaSmoothingFactor: StorageDescriptor<[], bigint, false, never>; - /** - * ============================ - * ==== Global Parameters ===== - * ============================ - * --- StorageItem Global Used Work. - */ - UsedWork: StorageDescriptor<[Key: Binary], bigint, false, never>; - /** - * --- ITEM( global_max_registrations_per_block ) - */ - MaxRegistrationsPerBlock: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- ITEM( total_number_of_existing_networks ) - */ - TotalNetworks: StorageDescriptor<[], number, false, never>; - /** - * ITEM( network_immunity_period ) - */ - NetworkImmunityPeriod: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( start_call_delay ) - */ - StartCallDelay: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( min_network_lock_cost ) - */ - NetworkMinLockCost: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( last_network_lock_cost ) - */ - NetworkLastLockCost: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( network_lock_reduction_interval ) - */ - NetworkLockReductionInterval: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( subnet_owner_cut ) - */ - SubnetOwnerCut: StorageDescriptor<[], number, false, never>; - /** - * ITEM( network_rate_limit ) - */ - NetworkRateLimit: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM( nominator_min_required_stake ) --- Factor of DefaultMinStake in per-mill format. - */ - NominatorMinRequiredStake: StorageDescriptor<[], bigint, false, never>; - /** - * ITEM( weights_version_key_rate_limit ) --- Rate limit in tempos. - */ - WeightsVersionKeyRateLimit: StorageDescriptor<[], bigint, false, never>; - /** - * ============================ - * ==== Rate Limiting ===== - * ============================ - * --- MAP ( RateLimitKey ) --> Block number in which the last rate limited operation occured - */ - LastRateLimitedBlock: StorageDescriptor<[Key: Anonymize], bigint, false, never>; - /** - * ============================ - * ==== Subnet Locks ===== - * ============================ - * --- MAP ( netuid ) --> transfer_toggle - */ - TransferToggle: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> total_subnet_locked - */ - SubnetLocked: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> largest_locked - */ - LargestLocked: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * ================= - * ==== Tempos ===== - * ================= - * --- MAP ( netuid ) --> tempo - */ - Tempo: StorageDescriptor<[Key: number], number, false, never>; - /** - * ============================ - * ==== Subnet Parameters ===== - * ============================ - * --- MAP ( netuid ) --> block number of first emission - */ - FirstEmissionBlockNumber: StorageDescriptor<[Key: number], bigint, true, never>; - /** - * --- MAP ( netuid ) --> subnet mechanism - */ - SubnetMechanism: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> subnetwork_n (Number of UIDs in the network). - */ - SubnetworkN: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> network_is_added - */ - NetworksAdded: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- DMAP ( hotkey, netuid ) --> bool - */ - IsNetworkMember: StorageDescriptor, boolean, false, never>; - /** - * --- MAP ( netuid ) --> network_registration_allowed - */ - NetworkRegistrationAllowed: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> network_pow_allowed - */ - NetworkPowRegistrationAllowed: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> block_created - */ - NetworkRegisteredAt: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> pending_server_emission - */ - PendingServerEmission: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> pending_validator_emission - */ - PendingValidatorEmission: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> pending_root_alpha_emission - */ - PendingRootAlphaDivs: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> pending_owner_cut - */ - PendingOwnerCut: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> blocks_since_last_step - */ - BlocksSinceLastStep: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> last_mechanism_step_block - */ - LastMechansimStepBlock: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> subnet_owner - */ - SubnetOwner: StorageDescriptor<[Key: number], SS58String, false, never>; - /** - * --- MAP ( netuid ) --> subnet_owner_hotkey - */ - SubnetOwnerHotkey: StorageDescriptor<[Key: number], SS58String, false, never>; - /** - * --- MAP ( netuid ) --> recycle_or_burn - */ - RecycleOrBurn: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> serving_rate_limit - */ - ServingRateLimit: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Rho - */ - Rho: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> AlphaSigmoidSteepness - */ - AlphaSigmoidSteepness: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> Kappa - */ - Kappa: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> registrations_this_interval - */ - RegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> pow_registrations_this_interval - */ - POWRegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> burn_registrations_this_interval - */ - BurnRegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> min_allowed_uids - */ - MinAllowedUids: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> max_allowed_uids - */ - MaxAllowedUids: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> immunity_period - */ - ImmunityPeriod: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> activity_cutoff - */ - ActivityCutoff: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> max_weight_limit - */ - MaxWeightsLimit: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> weights_version_key - */ - WeightsVersionKey: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> min_allowed_weights - */ - MinAllowedWeights: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> max_allowed_validators - */ - MaxAllowedValidators: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> adjustment_interval - */ - AdjustmentInterval: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> bonds_moving_average - */ - BondsMovingAverage: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> bonds_penalty - */ - BondsPenalty: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> bonds_reset - */ - BondsResetOn: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> weights_set_rate_limit - */ - WeightsSetRateLimit: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> validator_prune_len - */ - ValidatorPruneLen: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> scaling_law_power - */ - ScalingLawPower: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> target_registrations_this_interval - */ - TargetRegistrationsPerInterval: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> adjustment_alpha - */ - AdjustmentAlpha: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> commit reveal v2 weights are enabled - */ - CommitRevealWeightsEnabled: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> Burn - */ - Burn: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Difficulty - */ - Difficulty: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> MinBurn - */ - MinBurn: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> MaxBurn - */ - MaxBurn: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> MinDifficulty - */ - MinDifficulty: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> MaxDifficulty - */ - MaxDifficulty: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Block at last adjustment. - */ - LastAdjustmentBlock: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Registrations of this Block. - */ - RegistrationsThisBlock: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> Halving time of average moving price. - */ - EMAPriceHalvingBlocks: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> global_RAO_recycled_for_registration - */ - RAORecycledForRegistration: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- ITEM ( tx_rate_limit ) - */ - TxRateLimit: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM ( tx_delegate_take_rate_limit ) - */ - TxDelegateTakeRateLimit: StorageDescriptor<[], bigint, false, never>; - /** - * --- ITEM ( tx_childkey_take_rate_limit ) - */ - TxChildkeyTakeRateLimit: StorageDescriptor<[], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Whether or not Liquid Alpha is enabled - */ - LiquidAlphaOn: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> Whether or not Yuma3 is enabled - */ - Yuma3On: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * MAP ( netuid ) --> (alpha_low, alpha_high) - */ - AlphaValues: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> If subtoken trading enabled - */ - SubtokenEnabled: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- DMAP ( netuid, hotkey ) --> voting_power | EMA of stake for voting - * This tracks stake EMA updated every epoch when VotingPowerTrackingEnabled is true. - * Used by smart contracts to determine validator voting power for subnet governance. - */ - VotingPower: StorageDescriptor, bigint, false, never>; - /** - * --- MAP ( netuid ) --> bool | Whether voting power tracking is enabled for this subnet. - * When enabled, VotingPower EMA is updated every epoch. Default is false. - * When disabled with disable_at_block set, tracking continues until that block. - */ - VotingPowerTrackingEnabled: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * --- MAP ( netuid ) --> block_number | Block at which voting power tracking will be disabled. - * When set (non-zero), tracking continues until this block, then automatically disables - * and clears VotingPower entries for the subnet. Provides a 14-day grace period. - */ - VotingPowerDisableAtBlock: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> u64 | EMA alpha value for voting power calculation. - * Higher alpha = faster response to stake changes. - * Stored as u64 with 18 decimal precision (1.0 = 10^18). - * Only settable by sudo/root. - */ - VotingPowerEmaAlpha: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- MAP ( netuid ) --> Burn key limit - */ - ImmuneOwnerUidsLimit: StorageDescriptor<[Key: number], number, false, never>; - /** - * ======================================= - * ==== Subnetwork Consensus Storage ==== - * ======================================= - * --- DMAP ( netuid ) --> stake_weight | weight for stake used in YC. - */ - StakeWeight: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- DMAP ( netuid, hotkey ) --> uid - */ - Uids: StorageDescriptor, number, true, never>; - /** - * --- DMAP ( netuid, uid ) --> hotkey - */ - Keys: StorageDescriptor, SS58String, false, never>; - /** - * --- MAP ( netuid ) --> (hotkey, se, ve) - */ - LoadedEmission: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * --- MAP ( netuid ) --> active - */ - Active: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> rank - */ - Rank: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> trust - */ - Trust: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> consensus - */ - Consensus: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> incentive - */ - Incentive: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> dividends - */ - Dividends: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> emission - */ - Emission: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> last_update - */ - LastUpdate: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> validator_trust - */ - ValidatorTrust: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> pruning_scores - */ - PruningScores: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- MAP ( netuid ) --> validator_permit - */ - ValidatorPermit: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * --- DMAP ( netuid, uid ) --> weights - */ - Weights: StorageDescriptor, Anonymize, false, never>; - /** - * --- DMAP ( netuid, uid ) --> bonds - */ - Bonds: StorageDescriptor, Anonymize, false, never>; - /** - * --- DMAP ( netuid, uid ) --> block_at_registration - */ - BlockAtRegistration: StorageDescriptor, bigint, false, never>; - /** - * --- MAP ( netuid, hotkey ) --> axon_info - */ - Axons: StorageDescriptor, Anonymize, true, never>; - /** - * --- MAP ( netuid, hotkey ) --> certificate - */ - NeuronCertificates: StorageDescriptor, Anonymize, true, never>; - /** - * --- MAP ( netuid, hotkey ) --> prometheus_info - */ - Prometheus: StorageDescriptor, Anonymize, true, never>; - /** - * --- MAP ( coldkey ) --> identity - */ - IdentitiesV2: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; - /** - * --- MAP ( netuid ) --> SubnetIdentityOfV3 - */ - SubnetIdentitiesV3: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * ================================= - * ==== Axon / Promo Endpoints ===== - * ================================= - * --- NMAP ( hot, netuid, name ) --> last_block | Returns the last block of a transaction for a given key, netuid, and name. - */ - TransactionKeyLastBlock: StorageDescriptor, bigint, false, never>; - /** - * --- MAP ( key ) --> last_block - */ - LastTxBlock: StorageDescriptor<[Key: SS58String], bigint, false, never>; - /** - * --- MAP ( key ) --> last_tx_block_childkey_take - */ - LastTxBlockChildKeyTake: StorageDescriptor<[Key: SS58String], bigint, false, never>; - /** - * --- MAP ( key ) --> last_tx_block_delegate_take - */ - LastTxBlockDelegateTake: StorageDescriptor<[Key: SS58String], bigint, false, never>; - /** - * ITEM( weights_min_stake ) - */ - StakeThreshold: StorageDescriptor<[], bigint, false, never>; - /** - * --- MAP (netuid, who) --> VecDeque<(hash, commit_block, first_reveal_block, last_reveal_block)> | Stores a queue of commits for an account on a given netuid. - */ - WeightCommits: StorageDescriptor, Anonymize, true, never>; - /** - * MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)> - * Stores a queue of weight commits for an account on a given subnet. - */ - TimelockedWeightCommits: StorageDescriptor, Anonymize, false, never>; - /** - * MAP (netuid, epoch) → VecDeque<(who, ciphertext, reveal_round)> - * DEPRECATED for CRV3WeightCommitsV2 - */ - CRV3WeightCommits: StorageDescriptor, Anonymize, false, never>; - /** - * MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)> - * DEPRECATED for TimelockedWeightCommits - */ - CRV3WeightCommitsV2: StorageDescriptor, Anonymize, false, never>; - /** - * --- Map (netuid) --> Number of epochs allowed for commit reveal periods - */ - RevealPeriodEpochs: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- Map (coldkey, hotkey) --> u64 the last block at which stake was added/removed. - */ - LastColdkeyHotkeyStakeBlock: StorageDescriptor, bigint, true, never>; - /** - * DMAP ( hot, cold, netuid ) --> rate limits for staking operations - * Value contains just a marker: we use this map as a set. - */ - StakingOperationRateLimiter: StorageDescriptor, boolean, false, never>; - /** - - */ - RootClaimableThreshold: StorageDescriptor<[Key: number], bigint, false, never>; - /** - - */ - RootClaimable: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - - */ - RootClaimed: StorageDescriptor, bigint, false, never>; - /** - - */ - RootClaimType: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - - */ - StakingColdkeysByIndex: StorageDescriptor<[Key: bigint], SS58String, true, never>; - /** - - */ - StakingColdkeys: StorageDescriptor<[Key: SS58String], bigint, true, never>; - /** - - */ - NumStakingColdkeys: StorageDescriptor<[], bigint, false, never>; - /** - - */ - NumRootClaim: StorageDescriptor<[], bigint, false, never>; - /** - * ============================= - * ==== EVM related storage ==== - * ============================= - * --- DMAP (netuid, uid) --> (H160, last_block_where_ownership_was_proven) - */ - AssociatedEvmAddress: StorageDescriptor, Anonymize, true, never>; - /** - * ======================== - * ==== Subnet Leasing ==== - * ======================== - * --- MAP ( lease_id ) --> subnet lease | The subnet lease for a given lease id. - */ - SubnetLeases: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * --- DMAP ( lease_id, contributor ) --> shares | The shares of a contributor for a given lease. - */ - SubnetLeaseShares: StorageDescriptor, bigint, false, never>; - /** - * --- MAP ( netuid ) --> lease_id | The lease id for a given netuid. - */ - SubnetUidToLeaseId: StorageDescriptor<[Key: number], number, true, never>; - /** - * --- ITEM ( next_lease_id ) | The next lease id. - */ - NextSubnetLeaseId: StorageDescriptor<[], number, false, never>; - /** - * --- MAP ( lease_id ) --> accumulated_dividends | The accumulated dividends for a given lease that needs to be distributed. - */ - AccumulatedLeaseDividends: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * --- ITEM ( CommitRevealWeightsVersion ) - */ - CommitRevealWeightsVersion: StorageDescriptor<[], number, false, never>; - /** - * ITEM( NetworkRegistrationStartBlock ) - */ - NetworkRegistrationStartBlock: StorageDescriptor<[], bigint, false, never>; - /** - * --- MAP ( netuid ) --> minimum required number of non-immortal & non-immune UIDs - */ - MinNonImmuneUids: StorageDescriptor<[Key: number], number, false, never>; - /** - * ITEM( max_mechanism_count ) - */ - MaxMechanismCount: StorageDescriptor<[], number, false, never>; - /** - * --- MAP ( netuid ) --> Current number of subnet mechanisms - */ - MechanismCountCurrent: StorageDescriptor<[Key: number], number, false, never>; - /** - * --- MAP ( netuid ) --> Normalized vector of emission split proportion between subnet mechanisms - */ - MechanismEmissionSplit: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * ================== - * ==== Genesis ===== - * ================== - * --- Storage for migration run status - */ - HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; - /** - * Storage value for pending childkey cooldown, settable by root. - */ - PendingChildKeyCooldown: StorageDescriptor<[], bigint, false, never>; - }; - Sudo: { - /** - * The `AccountId` of the sudo key. - */ - Key: StorageDescriptor<[], SS58String, true, never>; - }; - Multisig: { - /** - * The set of open multisig operations. - */ - Multisigs: StorageDescriptor, Anonymize, true, never>; - }; - Preimage: { - /** - * The request status of a given hash. - */ - StatusFor: StorageDescriptor<[Key: FixedSizeBinary<32>], PreimageOldRequestStatus, true, never>; - /** - * The request status of a given hash. - */ - RequestStatusFor: StorageDescriptor<[Key: FixedSizeBinary<32>], PreimageRequestStatus, true, never>; - /** - - */ - PreimageFor: StorageDescriptor<[Key: Anonymize], Binary, true, never>; - }; - Scheduler: { - /** - * Block number at which the agenda began incomplete execution. - */ - IncompleteSince: StorageDescriptor<[], number, true, never>; - /** - * Items to be executed, indexed by the block number that they should be executed on. - */ - Agenda: StorageDescriptor<[Key: number], Anonymize, false, never>; - /** - * Retry configurations for items to be executed, indexed by task address. - */ - Retries: StorageDescriptor<[Key: Anonymize], Anonymize, true, never>; - /** - * Lookup from a name to the block number and index of the task. - * - * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4 - * identities. - */ - Lookup: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; - }; - Proxy: { - /** - * The set of account proxies. Maps the account which has delegated to the accounts - * which are being delegated to, together with the amount held on deposit. - */ - Proxies: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * The announcements made by the proxy (key). - */ - Announcements: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; - /** - * The result of the last call made by the proxy (key). - */ - LastCallResult: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; - }; - Registry: { - /** - * Identity data by account - */ - IdentityOf: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; - }; - Commitments: { - /** - * Tracks all CommitmentOf that have at least one timelocked field. - */ - TimelockedIndex: StorageDescriptor<[], Anonymize, false, never>; - /** - * Identity data by account - */ - CommitmentOf: StorageDescriptor, Anonymize, true, never>; - /** - - */ - LastCommitment: StorageDescriptor, number, true, never>; - /** - - */ - LastBondsReset: StorageDescriptor, number, true, never>; - /** - - */ - RevealedCommitments: StorageDescriptor, Anonymize, true, never>; - /** - * Maps (netuid, who) -> usage (how many “bytes” they've committed) - * in the RateLimit window - */ - UsedSpaceOf: StorageDescriptor, Anonymize, true, never>; - /** - - */ - MaxSpace: StorageDescriptor<[], number, false, never>; - }; - AdminUtils: { - /** - * Map PrecompileEnum --> enabled - */ - PrecompileEnable: StorageDescriptor<[Key: Anonymize], boolean, false, never>; - }; - SafeMode: { - /** - * Contains the last block number that the safe-mode will remain entered in. - * - * Set to `None` when safe-mode is exited. - * - * Safe-mode is automatically exited when the current block number exceeds this value. - */ - EnteredUntil: StorageDescriptor<[], number, true, never>; - /** - * Holds the reserve that was taken from an account at a specific block number. - * - * This helps governance to have an overview of outstanding deposits that should be returned or - * slashed. - */ - Deposits: StorageDescriptor, bigint, true, never>; - }; - Ethereum: { - /** - * Mapping from transaction index to transaction in the current building block. - */ - Pending: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * Counter for the related counted storage map - */ - CounterForPending: StorageDescriptor<[], number, false, never>; - /** - * The current Ethereum block. - */ - CurrentBlock: StorageDescriptor<[], Anonymize, true, never>; - /** - * The current Ethereum receipts. - */ - CurrentReceipts: StorageDescriptor<[], Anonymize, true, never>; - /** - * The current transaction statuses. - */ - CurrentTransactionStatuses: StorageDescriptor<[], Anonymize, true, never>; - /** - - */ - BlockHash: StorageDescriptor<[Key: Anonymize], FixedSizeBinary<32>, false, never>; - }; - EVM: { - /** - - */ - AccountCodes: StorageDescriptor<[Key: FixedSizeBinary<20>], Binary, false, never>; - /** - - */ - AccountCodesMetadata: StorageDescriptor<[Key: FixedSizeBinary<20>], Anonymize, true, never>; - /** - - */ - AccountStorages: StorageDescriptor, FixedSizeBinary<32>, false, never>; - /** - - */ - WhitelistedCreators: StorageDescriptor<[], Anonymize, false, never>; - /** - - */ - DisableWhitelistCheck: StorageDescriptor<[], boolean, false, never>; - }; - EVMChainId: { - /** - * The EVM chain ID. - */ - ChainId: StorageDescriptor<[], bigint, false, never>; - }; - BaseFee: { - /** - - */ - BaseFeePerGas: StorageDescriptor<[], Anonymize, false, never>; - /** - - */ - Elasticity: StorageDescriptor<[], number, false, never>; - }; - Drand: { - /** - * the drand beacon configuration - */ - BeaconConfig: StorageDescriptor<[], Anonymize, false, never>; - /** - * Storage for migration run status - */ - HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; - /** - * map round number to pulse - */ - Pulses: StorageDescriptor<[Key: bigint], Anonymize, true, never>; - /** - - */ - LastStoredRound: StorageDescriptor<[], bigint, false, never>; - /** - * oldest stored round - */ - OldestStoredRound: StorageDescriptor<[], bigint, false, never>; - /** - * Defines the block when next unsigned transaction will be accepted. - * - * To prevent spam of unsigned (and unpaid!) transactions on the network, - * we only allow one transaction per block. - * This storage entry defines when new transaction is going to be accepted. - */ - NextUnsignedAt: StorageDescriptor<[], number, false, never>; - }; - Crowdloan: { - /** - * A map of crowdloan ids to their information. - */ - Crowdloans: StorageDescriptor<[Key: number], Anonymize, true, never>; - /** - * The next incrementing crowdloan id. - */ - NextCrowdloanId: StorageDescriptor<[], number, false, never>; - /** - * A map of crowdloan ids to their contributors and their contributions. - */ - Contributions: StorageDescriptor, bigint, true, never>; - /** - * The current crowdloan id that will be set during the finalize call, making it - * temporarily accessible to the dispatched call. - */ - CurrentCrowdloanId: StorageDescriptor<[], number, true, never>; - /** - * Storage for the migration run status. - */ - HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; - }; - Swap: { - /** - * The fee rate applied to swaps per subnet, normalized value between 0 and u16::MAX - */ - FeeRate: StorageDescriptor<[Key: number], number, false, never>; - /** - - */ - FeeGlobalTao: StorageDescriptor<[Key: number], bigint, false, never>; - /** - - */ - FeeGlobalAlpha: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * Storage for all ticks, using subnet ID as the primary key and tick index as the secondary key - */ - Ticks: StorageDescriptor, Anonymize, true, never>; - /** - * Storage to determine whether swap V3 was initialized for a specific subnet. - */ - SwapV3Initialized: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * Storage for the square root price of Alpha token for each subnet. - */ - AlphaSqrtPrice: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * Storage for the current price tick. - */ - CurrentTick: StorageDescriptor<[Key: number], number, false, never>; - /** - * Storage for the current liquidity amount for each subnet. - */ - CurrentLiquidity: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * Indicates whether a subnet has been switched to V3 swap from V2. - * If `true`, the subnet is permanently on V3 swap mode allowing add/remove liquidity - * operations. Once set to `true` for a subnet, it cannot be changed back to `false`. - */ - EnabledUserLiquidity: StorageDescriptor<[Key: number], boolean, false, never>; - /** - * Storage for user positions, using subnet ID and account ID as keys - * The value is a bounded vector of Position structs with details about the liquidity positions - */ - Positions: StorageDescriptor, Anonymize, true, never>; - /** - * Position ID counter. - */ - LastPositionId: StorageDescriptor<[], bigint, false, never>; - /** - * Tick index bitmap words storage - */ - TickIndexBitmapWords: StorageDescriptor, bigint, false, never>; - /** - * TAO reservoir for scraps of protocol claimed fees. - */ - ScrapReservoirTao: StorageDescriptor<[Key: number], bigint, false, never>; - /** - * Alpha reservoir for scraps of protocol claimed fees. - */ - ScrapReservoirAlpha: StorageDescriptor<[Key: number], bigint, false, never>; - }; - Contracts: { - /** - * A mapping from a contract's code hash to its code. - */ - PristineCode: StorageDescriptor<[Key: FixedSizeBinary<32>], Binary, true, never>; - /** - * A mapping from a contract's code hash to its code info. - */ - CodeInfoOf: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; - /** - * This is a **monotonic** counter incremented on contract instantiation. - * - * This is used in order to generate unique trie ids for contracts. - * The trie id of a new contract is calculated from hash(account_id, nonce). - * The nonce is required because otherwise the following sequence would lead to - * a possible collision of storage: - * - * 1. Create a new contract. - * 2. Terminate the contract. - * 3. Immediately recreate the contract with the same account_id. - * - * This is bad because the contents of a trie are deleted lazily and there might be - * storage of the old instantiation still in it when the new contract is created. Please - * note that we can't replace the counter by the block number because the sequence above - * can happen in the same block. We also can't keep the account counter in memory only - * because storage is the only way to communicate across different extrinsics in the - * same block. - * - * # Note - * - * Do not use it to determine the number of contracts. It won't be decremented if - * a contract is destroyed. - */ - Nonce: StorageDescriptor<[], bigint, false, never>; - /** - * The code associated with a given account. - * - * TWOX-NOTE: SAFE since `AccountId` is a secure hash. - */ - ContractInfoOf: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; - /** - * Evicted contracts that await child trie deletion. - * - * Child trie deletion is a heavy operation depending on the amount of storage items - * stored in said trie. Therefore this operation is performed lazily in `on_idle`. - */ - DeletionQueue: StorageDescriptor<[Key: number], Binary, true, never>; - /** - * A pair of monotonic counters used to track the latest contract marked for deletion - * and the latest deleted contract in queue. - */ - DeletionQueueCounter: StorageDescriptor<[], Anonymize, false, never>; - /** - * A migration can span across multiple blocks. This storage defines a cursor to track the - * progress of the migration, enabling us to resume from the last completed position. - */ - MigrationInProgress: StorageDescriptor<[], Binary, true, never>; - }; - MevShield: { - /** - * Current ML‑KEM‑768 public key bytes (encoded form). - */ - CurrentKey: StorageDescriptor<[], Binary, true, never>; - /** - * Next ML‑KEM‑768 public key bytes, announced by the block author. - */ - NextKey: StorageDescriptor<[], Binary, true, never>; - /** - * Buffered encrypted submissions, indexed by wrapper id. - */ - Submissions: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; - /** - * Hash(CurrentKey) per block, used to bind `key_hash` to the epoch at submit time. - */ - KeyHashByBlock: StorageDescriptor<[Key: number], FixedSizeBinary<32>, true, never>; - }; -}; -type ICalls = { - System: { - /** - * Make some on-chain remark. - * - * Can be executed by every `origin`. - */ - remark: TxDescriptor>; - /** - * Set the number of pages in the WebAssembly environment's heap. - */ - set_heap_pages: TxDescriptor>; - /** - * Set the new runtime code. - */ - set_code: TxDescriptor>; - /** - * Set the new runtime code without doing any checks of the given `code`. - * - * Note that runtime upgrades will not run if this is called with a not-increasing spec - * version! - */ - set_code_without_checks: TxDescriptor>; - /** - * Set some items of storage. - */ - set_storage: TxDescriptor>; - /** - * Kill some items from storage. - */ - kill_storage: TxDescriptor>; - /** - * Kill all storage items with a key that starts with the given prefix. - * - * **NOTE:** We rely on the Root origin to provide us the number of subkeys under - * the prefix we are removing to accurately calculate the weight of this function. - */ - kill_prefix: TxDescriptor>; - /** - * Make some on-chain remark and emit event. - */ - remark_with_event: TxDescriptor>; - /** - * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied - * later. - * - * This call requires Root origin. - */ - authorize_upgrade: TxDescriptor>; - /** - * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied - * later. - * - * WARNING: This authorizes an upgrade that will take place without any safety checks, for - * example that the spec name remains the same and that the version number increases. Not - * recommended for normal use. Use `authorize_upgrade` instead. - * - * This call requires Root origin. - */ - authorize_upgrade_without_checks: TxDescriptor>; - /** - * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. - * - * If the authorization required a version check, this call will ensure the spec name - * remains unchanged and that the spec version has increased. - * - * Depending on the runtime's `OnSetCode` configuration, this function may directly apply - * the new `code` in the same block or attempt to schedule the upgrade. - * - * All origins are allowed. - */ - apply_authorized_upgrade: TxDescriptor>; - }; - Timestamp: { - /** - * Set the current time. - * - * This call should be invoked exactly once per block. It will panic at the finalization - * phase, if this call hasn't been invoked by that time. - * - * The timestamp should be greater than the previous one by the amount specified by - * [`Config::MinimumPeriod`]. - * - * The dispatch origin for this call must be _None_. - * - * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware - * that changing the complexity of this call could result exhausting the resources in a - * block to execute any other calls. - * - * ## Complexity - * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) - * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in - * `on_finalize`) - * - 1 event handler `on_timestamp_set`. Must be `O(1)`. - */ - set: TxDescriptor>; - }; - Grandpa: { - /** - * Report voter equivocation/misbehavior. This method will verify the - * equivocation proof and validate the given key ownership proof - * against the extracted offender. If both are valid, the offence - * will be reported. - */ - report_equivocation: TxDescriptor>; - /** - * Report voter equivocation/misbehavior. This method will verify the - * equivocation proof and validate the given key ownership proof - * against the extracted offender. If both are valid, the offence - * will be reported. - * - * This extrinsic must be called unsigned and it is expected that only - * block authors will call it (validated in `ValidateUnsigned`), as such - * if the block author is defined it will be defined as the equivocation - * reporter. - */ - report_equivocation_unsigned: TxDescriptor>; - /** - * Note that the current authority set of the GRANDPA finality gadget has stalled. - * - * This will trigger a forced authority set change at the beginning of the next session, to - * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume - * that the block signalling the forced change will not be re-orged e.g. 1000 blocks. - * The block production rate (which may be slowed down because of finality lagging) should - * be taken into account when choosing the `delay`. The GRANDPA voters based on the new - * authority will start voting on top of `best_finalized_block_number` for new finalized - * blocks. `best_finalized_block_number` should be the highest of the latest finalized - * block of all validators of the new authority set. - * - * Only callable by root. - */ - note_stalled: TxDescriptor>; - }; - Balances: { - /** - * Transfer some liquid free balance to another account. - * - * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. - * If the sender's account is below the existential deposit as a result - * of the transfer, the account will be reaped. - * - * The dispatch origin for this call must be `Signed` by the transactor. - */ - transfer_allow_death: TxDescriptor>; - /** - * Exactly as `transfer_allow_death`, except the origin must be root and the source account - * may be specified. - */ - force_transfer: TxDescriptor>; - /** - * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not - * kill the origin account. - * - * 99% of the time you want [`transfer_allow_death`] instead. - * - * [`transfer_allow_death`]: struct.Pallet.html#method.transfer - */ - transfer_keep_alive: TxDescriptor>; - /** - * Transfer the entire transferable balance from the caller account. - * - * NOTE: This function only attempts to transfer _transferable_ balances. This means that - * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be - * transferred by this function. To ensure that this function results in a killed account, - * you might need to prepare the account by removing any reference counters, storage - * deposits, etc... - * - * The dispatch origin of this call must be Signed. - * - * - `dest`: The recipient of the transfer. - * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all - * of the funds the account has, causing the sender account to be killed (false), or - * transfer everything except at least the existential deposit, which will guarantee to - * keep the sender account alive (true). - */ - transfer_all: TxDescriptor>; - /** - * Unreserve some balance from a user by force. - * - * Can only be called by ROOT. - */ - force_unreserve: TxDescriptor>; - /** - * Upgrade a specified account. - * - * - `origin`: Must be `Signed`. - * - `who`: The account to be upgraded. - * - * This will waive the transaction fee if at least all but 10% of the accounts needed to - * be upgraded. (We let some not have to be upgraded just in order to allow for the - * possibility of churn). - */ - upgrade_accounts: TxDescriptor>; - /** - * Set the regular balance of a given account. - * - * The dispatch origin for this call is `root`. - */ - force_set_balance: TxDescriptor>; - /** - * Adjust the total issuance in a saturating way. - * - * Can only be called by root and always needs a positive `delta`. - * - * # Example - */ - force_adjust_total_issuance: TxDescriptor>; - /** - * Burn the specified liquid free balance from the origin account. - * - * If the origin's account ends up below the existential deposit as a result - * of the burn and `keep_alive` is false, the account will be reaped. - * - * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible, - * this `burn` operation will reduce total issuance by the amount _burned_. - */ - burn: TxDescriptor>; - }; - SubtensorModule: { - /** - * --- Sets the caller weights for the incentive mechanism. The call can be - * made from the hotkey account so is potentially insecure, however, the damage - * of changing weights is minimal if caught early. This function includes all the - * checks that the passed weights meet the requirements. Stored as u16s they represent - * rational values in the range [0,1] which sum to 1 and can be interpreted as - * probabilities. The specific weights determine how inflation propagates outward - * from this peer. - * - * Note: The 16 bit integers weights should represent 1.0 as the max u16. - * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all - * elements is larger or smaller than the amount of elements * u16_max, all elements - * will be corrected for this deviation. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuid` (u16): - * - The network uid we are setting these weights on. - * - * * `dests` (Vec): - * - The edge endpoint for the weight, i.e. j for w_ij. - * - * * 'weights' (Vec): - * - The u16 integer encoded weights. Interpreted as rational - * values in the range [0,1]. They must sum to in32::MAX. - * - * * 'version_key' ( u64 ): - * - The network version key to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'WeightVecNotEqualSize': - * - Attempting to set weights with uids not of same length. - * - * * 'DuplicateUids': - * - Attempting to set weights with duplicate uids. - * - * * 'UidsLengthExceedUidsInSubNet': - * - Attempting to set weights above the max allowed uids. - * - * * 'UidVecContainInvalidOne': - * - Attempting to set weights with invalid uids. - * - * * 'WeightVecLengthIsLow': - * - Attempting to set weights with fewer weights than min. - * - * * 'MaxWeightExceeded': - * - Attempting to set weights with max value exceeding limit. - */ - set_weights: TxDescriptor>; - /** - * --- Sets the caller weights for the incentive mechanism for mechanisms. The call - * can be made from the hotkey account so is potentially insecure, however, the damage - * of changing weights is minimal if caught early. This function includes all the - * checks that the passed weights meet the requirements. Stored as u16s they represent - * rational values in the range [0,1] which sum to 1 and can be interpreted as - * probabilities. The specific weights determine how inflation propagates outward - * from this peer. - * - * Note: The 16 bit integers weights should represent 1.0 as the max u16. - * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all - * elements is larger or smaller than the amount of elements * u16_max, all elements - * will be corrected for this deviation. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuid` (u16): - * - The network uid we are setting these weights on. - * - * * `mecid` (`u8`): - * - The u8 mechnism identifier. - * - * * `dests` (Vec): - * - The edge endpoint for the weight, i.e. j for w_ij. - * - * * 'weights' (Vec): - * - The u16 integer encoded weights. Interpreted as rational - * values in the range [0,1]. They must sum to in32::MAX. - * - * * 'version_key' ( u64 ): - * - The network version key to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'WeightVecNotEqualSize': - * - Attempting to set weights with uids not of same length. - * - * * 'DuplicateUids': - * - Attempting to set weights with duplicate uids. - * - * * 'UidsLengthExceedUidsInSubNet': - * - Attempting to set weights above the max allowed uids. - * - * * 'UidVecContainInvalidOne': - * - Attempting to set weights with invalid uids. - * - * * 'WeightVecLengthIsLow': - * - Attempting to set weights with fewer weights than min. - * - * * 'MaxWeightExceeded': - * - Attempting to set weights with max value exceeding limit. - */ - set_mechanism_weights: TxDescriptor>; - /** - * --- Allows a hotkey to set weights for multiple netuids as a batch. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuids` (Vec>): - * - The network uids we are setting these weights on. - * - * * `weights` (Vec, Compact)>): - * - The weights to set for each network. [(uid, weight), ...] - * - * * `version_keys` (Vec>): - * - The network version keys to check if the validator is up to date. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * * BatchWeightsCompleted; - * - On success of the batch. - * * BatchCompletedWithErrors; - * - On failure of any of the weights in the batch. - * * BatchWeightItemFailed; - * - On failure for each failed item in the batch. - * - */ - batch_set_weights: TxDescriptor>; - /** - * ---- Used to commit a hash of your weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit_hash` (`H256`): - * - The hash representing the committed weights. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - commit_weights: TxDescriptor>; - /** - * ---- Used to commit a hash of your weight values to later be revealed for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit_hash` (`H256`): - * - The hash representing the committed weights. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - commit_mechanism_weights: TxDescriptor>; - /** - * --- Allows a hotkey to commit weight hashes for multiple netuids as a batch. - * - * # Args: - * * `origin`: (Origin): - * - The caller, a hotkey who wishes to set their weights. - * - * * `netuids` (Vec>): - * - The network uids we are setting these weights on. - * - * * `commit_hashes` (Vec): - * - The commit hashes to commit. - * - * # Event: - * * WeightsSet; - * - On successfully setting the weights on chain. - * * BatchWeightsCompleted; - * - On success of the batch. - * * BatchCompletedWithErrors; - * - On failure of any of the weights in the batch. - * * BatchWeightItemFailed; - * - On failure for each failed item in the batch. - * - */ - batch_commit_weights: TxDescriptor>; - /** - * ---- Used to reveal the weights for a previously committed hash. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `uids` (`Vec`): - * - The uids for the weights being revealed. - * - * * `values` (`Vec`): - * - The values of the weights being revealed. - * - * * `salt` (`Vec`): - * - The salt used to generate the commit hash. - * - * * `version_key` (`u64`): - * - The network version key. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - */ - reveal_weights: TxDescriptor>; - /** - * ---- Used to reveal the weights for a previously committed hash for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `uids` (`Vec`): - * - The uids for the weights being revealed. - * - * * `values` (`Vec`): - * - The values of the weights being revealed. - * - * * `salt` (`Vec`): - * - The salt used to generate the commit hash. - * - * * `version_key` (`u64`): - * - The network version key. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - */ - reveal_mechanism_weights: TxDescriptor>; - /** - * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * # Raises: - * * `CommitRevealV3Disabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed for mechanisms. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * # Raises: - * * `CommitRevealV3Disabled`: - * - Attempting to commit when the commit-reveal mechanism is disabled. - * - * * `TooManyUnrevealedCommits`: - * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. - * - */ - commit_crv3_mechanism_weights: TxDescriptor>; - /** - * ---- The implementation for batch revealing committed weights. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The signature of the revealing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `uids_list` (`Vec>`): - * - A list of uids for each set of weights being revealed. - * - * * `values_list` (`Vec>`): - * - A list of values for each set of weights being revealed. - * - * * `salts_list` (`Vec>`): - * - A list of salts used to generate the commit hashes. - * - * * `version_keys` (`Vec`): - * - A list of network version keys. - * - * # Raises: - * * `CommitRevealDisabled`: - * - Attempting to reveal weights when the commit-reveal mechanism is disabled. - * - * * `NoWeightsCommitFound`: - * - Attempting to reveal weights without an existing commit. - * - * * `ExpiredWeightCommit`: - * - Attempting to reveal a weight commit that has expired. - * - * * `RevealTooEarly`: - * - Attempting to reveal weights outside the valid reveal period. - * - * * `InvalidRevealCommitHashNotMatch`: - * - The revealed hash does not match any committed hash. - * - * * `InvalidInputLengths`: - * - The input vectors are of mismatched lengths. - */ - batch_reveal_weights: TxDescriptor>; - /** - * --- Allows delegates to decrease its take value. - * - * # Args: - * * 'origin': (::Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The hotkey we are delegating (must be owned by the coldkey.) - * - * * 'netuid' (u16): - * - Subnet ID to decrease take for - * - * * 'take' (u16): - * - The new stake proportion that this hotkey takes from delegations. - * The new value can be between 0 and 11_796 and should be strictly - * lower than the previous value. It T is the new value (rational number), - * the the parameter is calculated as [65535 * T]. For example, 1% would be - * [0.01 * 65535] = [655.35] = 655 - * - * # Event: - * * TakeDecreased; - * - On successfully setting a decreased take for this hotkey. - * - * # Raises: - * * 'NotRegistered': - * - The hotkey we are delegating is not registered on the network. - * - * * 'NonAssociatedColdKey': - * - The hotkey we are delegating is not owned by the calling coldkey. - * - * * 'DelegateTakeTooLow': - * - The delegate is setting a take which is not lower than the previous. - * - */ - decrease_take: TxDescriptor>; - /** - * --- Allows delegates to increase its take value. This call is rate-limited. - * - * # Args: - * * 'origin': (::Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The hotkey we are delegating (must be owned by the coldkey.) - * - * * 'take' (u16): - * - The new stake proportion that this hotkey takes from delegations. - * The new value can be between 0 and 11_796 and should be strictly - * greater than the previous value. T is the new value (rational number), - * the the parameter is calculated as [65535 * T]. For example, 1% would be - * [0.01 * 65535] = [655.35] = 655 - * - * # Event: - * * TakeIncreased; - * - On successfully setting a increased take for this hotkey. - * - * # Raises: - * * 'NotRegistered': - * - The hotkey we are delegating is not registered on the network. - * - * * 'NonAssociatedColdKey': - * - The hotkey we are delegating is not owned by the calling coldkey. - * - * * 'DelegateTakeTooHigh': - * - The delegate is setting a take which is not greater than the previous. - * - */ - increase_take: TxDescriptor>; - /** - * --- Adds stake to a hotkey. The call is made from a coldkey account. - * This delegates stake to the hotkey. - * - * Note: the coldkey account may own the hotkey, in which case they are - * delegating to themselves. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_staked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * # Event: - * * StakeAdded; - * - On the successfully adding stake to a global account. - * - * # Raises: - * * 'NotEnoughBalanceToStake': - * - Not enough balance on the coldkey to add onto the global account. - * - * * 'NonAssociatedColdKey': - * - The calling coldkey is not associated with this hotkey. - * - * * 'BalanceWithdrawalError': - * - Errors stemming from transaction pallet. - * - */ - add_stake: TxDescriptor>; - /** - * Remove stake from the staking account. The call must be made - * from the coldkey account attached to the neuron metadata. Only this key - * has permission to make staking and unstaking requests. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_unstaked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * 'NotRegistered': - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * 'NonAssociatedColdKey': - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * 'NotEnoughStakeToWithdraw': - * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. - * - */ - remove_stake: TxDescriptor>; - /** - * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is - * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u64): - * - The bittensor version identifier. - * - * * 'ip' (u64): - * - The endpoint ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The endpoint port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The endpoint ip version as a u8, 4 or 6. - * - * * 'protocol' (u8): - * - UDP:1 or TCP:0 - * - * * 'placeholder1' (u8): - * - Placeholder for further extra params. - * - * * 'placeholder2' (u8): - * - Placeholder for further extra params. - * - * # Event: - * * AxonServed; - * - On successfully serving the axon info. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'InvalidIpType': - * - The ip type is not 4 or 6. - * - * * 'InvalidIpAddress': - * - The numerically encoded ip address does not resolve to a proper ip. - * - * * 'ServingRateLimitExceeded': - * - Attempting to set prometheus information withing the rate limit min. - * - */ - serve_axon: TxDescriptor>; - /** - * Same as `serve_axon` but takes a certificate as an extra optional argument. - * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is - * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u64): - * - The bittensor version identifier. - * - * * 'ip' (u64): - * - The endpoint ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The endpoint port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The endpoint ip version as a u8, 4 or 6. - * - * * 'protocol' (u8): - * - UDP:1 or TCP:0 - * - * * 'placeholder1' (u8): - * - Placeholder for further extra params. - * - * * 'placeholder2' (u8): - * - Placeholder for further extra params. - * - * * 'certificate' (Vec): - * - TLS certificate for inter neuron communitation. - * - * # Event: - * * AxonServed; - * - On successfully serving the axon info. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to set weights on a non-existent network. - * - * * 'NotRegistered': - * - Attempting to set weights from a non registered account. - * - * * 'InvalidIpType': - * - The ip type is not 4 or 6. - * - * * 'InvalidIpAddress': - * - The numerically encoded ip address does not resolve to a proper ip. - * - * * 'ServingRateLimitExceeded': - * - Attempting to set prometheus information withing the rate limit min. - * - */ - serve_axon_tls: TxDescriptor>; - /** - * ---- Set prometheus information for the neuron. - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u16): - * - The bittensor version identifier. - * - * * 'ip' (u128): - * - The prometheus ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The prometheus port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The ip type v4 or v6. - * - */ - serve_prometheus: TxDescriptor>; - /** - * ---- Registers a new neuron to the subnetwork. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'block_number' ( u64 ): - * - Block hash used to prove work done. - * - * * 'nonce' ( u64 ): - * - Positive integer nonce used in POW. - * - * * 'work' ( Vec ): - * - Vector encoded bytes representing work done. - * - * * 'hotkey' ( T::AccountId ): - * - Hotkey to be registered to the network. - * - * * 'coldkey' ( T::AccountId ): - * - Associated coldkey account. - * - * # Event: - * * NeuronRegistered; - * - On successfully registering a uid to a neuron slot on a subnetwork. - * - * # Raises: - * * 'MechanismDoesNotExist': - * - Attempting to register to a non existent network. - * - * * 'TooManyRegistrationsThisBlock': - * - This registration exceeds the total allowed on this network this block. - * - * * 'HotKeyAlreadyRegisteredInSubNet': - * - The hotkey is already registered on this network. - * - * * 'InvalidWorkBlock': - * - The work has been performed on a stale, future, or non existent block. - * - * * 'InvalidDifficulty': - * - The work does not match the difficulty. - * - * * 'InvalidSeal': - * - The seal is incorrect. - * - */ - register: TxDescriptor>; - /** - * Register the hotkey to root network - */ - root_register: TxDescriptor>; - /** - * User register a new subnetwork via burning token - */ - burned_register: TxDescriptor>; - /** - * The extrinsic for user to change its hotkey in subnet or all subnets. - */ - swap_hotkey: TxDescriptor>; - /** - * Performs an arbitrary coldkey swap for any coldkey. - * - * Only callable by root as it doesn't require an announcement and can be used to swap any coldkey. - */ - swap_coldkey: TxDescriptor>; - /** - * Sets the childkey take for a given hotkey. - * - * This function allows a coldkey to set the childkey take for a given hotkey. - * The childkey take determines the proportion of stake that the hotkey keeps for itself - * when distributing stake to its children. - * - * # Arguments: - * * `origin` (::RuntimeOrigin): - * - The signature of the calling coldkey. Setting childkey take can only be done by the coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey for which the childkey take will be set. - * - * * `take` (u16): - * - The new childkey take value. This is a percentage represented as a value between 0 and 10000, - * where 10000 represents 100%. - * - * # Events: - * * `ChildkeyTakeSet`: - * - On successfully setting the childkey take for a hotkey. - * - * # Errors: - * * `NonAssociatedColdKey`: - * - The coldkey does not own the hotkey. - * * `InvalidChildkeyTake`: - * - The provided take value is invalid (greater than the maximum allowed take). - * * `TxChildkeyTakeRateLimitExceeded`: - * - The rate limit for changing childkey take has been exceeded. - * - */ - set_childkey_take: TxDescriptor>; - /** - * Sets the transaction rate limit for changing childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `tx_rate_limit` - The new rate limit in blocks. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - sudo_set_tx_childkey_take_rate_limit: TxDescriptor>; - /** - * Sets the minimum allowed childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `take` - The new minimum childkey take value. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - sudo_set_min_childkey_take: TxDescriptor>; - /** - * Sets the maximum allowed childkey take. - * - * This function can only be called by the root origin. - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `take` - The new maximum childkey take value. - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * - */ - sudo_set_max_childkey_take: TxDescriptor>; - /** - * User register a new subnetwork - */ - register_network: TxDescriptor>; - /** - * Facility extrinsic for user to get taken from faucet - * It is only available when pow-faucet feature enabled - * Just deployed in testnet and devnet for testing purpose - */ - faucet: TxDescriptor>; - /** - * Remove a user's subnetwork - * The caller must be the owner of the network - */ - dissolve_network: TxDescriptor>; - /** - * Set a single child for a given hotkey on a specified network. - * - * This function allows a coldkey to set a single child for a given hotkey on a specified network. - * The proportion of the hotkey's stake to be allocated to the child is also specified. - * - * # Arguments: - * * `origin` (::RuntimeOrigin): - * - The signature of the calling coldkey. Setting a hotkey child can only be done by the coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey which will be assigned the child. - * - * * `child` (T::AccountId): - * - The child which will be assigned to the hotkey. - * - * * `netuid` (u16): - * - The u16 network identifier where the childkey will exist. - * - * * `proportion` (u64): - * - Proportion of the hotkey's stake to be given to the child, the value must be u64 normalized. - * - * # Events: - * * `ChildAddedSingular`: - * - On successfully registering a child to a hotkey. - * - * # Errors: - * * `MechanismDoesNotExist`: - * - Attempting to register to a non-existent network. - * * `RegistrationNotPermittedOnRootSubnet`: - * - Attempting to register a child on the root network. - * * `NonAssociatedColdKey`: - * - The coldkey does not own the hotkey or the child is the same as the hotkey. - * * `HotKeyAccountNotExists`: - * - The hotkey account does not exist. - * - * # Detailed Explanation of Checks: - * 1. **Signature Verification**: Ensures that the caller has signed the transaction, verifying the coldkey. - * 2. **Root Network Check**: Ensures that the delegation is not on the root network, as child hotkeys are not valid on the root. - * 3. **Network Existence Check**: Ensures that the specified network exists. - * 4. **Ownership Verification**: Ensures that the coldkey owns the hotkey. - * 5. **Hotkey Account Existence Check**: Ensures that the hotkey account already exists. - * 6. **Child-Hotkey Distinction**: Ensures that the child is not the same as the hotkey. - * 7. **Old Children Cleanup**: Removes the hotkey from the parent list of its old children. - * 8. **New Children Assignment**: Assigns the new child to the hotkey and updates the parent list for the new child. - */ - set_children: TxDescriptor>; - /** - * Schedules a coldkey swap operation to be executed at a future block. - * - * WARNING: This function is deprecated, please migrate to `announce_coldkey_swap`/`coldkey_swap` - */ - schedule_swap_coldkey: TxDescriptor>; - /** - * ---- Set prometheus information for the neuron. - * # Args: - * * 'origin': (Origin): - * - The signature of the calling hotkey. - * - * * 'netuid' (u16): - * - The u16 network identifier. - * - * * 'version' (u16): - * - The bittensor version identifier. - * - * * 'ip' (u128): - * - The prometheus ip information as a u128 encoded integer. - * - * * 'port' (u16): - * - The prometheus port information as a u16 encoded integer. - * - * * 'ip_type' (u8): - * - The ip type v4 or v6. - * - */ - set_identity: TxDescriptor>; - /** - * ---- Set the identity information for a subnet. - * # Args: - * * `origin` - (::Origin): - * - The signature of the calling coldkey, which must be the owner of the subnet. - * - * * `netuid` (u16): - * - The unique network identifier of the subnet. - * - * * `subnet_name` (Vec): - * - The name of the subnet. - * - * * `github_repo` (Vec): - * - The GitHub repository associated with the subnet identity. - * - * * `subnet_contact` (Vec): - * - The contact information for the subnet. - */ - set_subnet_identity: TxDescriptor>; - /** - * User register a new subnetwork - */ - register_network_with_identity: TxDescriptor>; - /** - * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The associated hotkey account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * `NotRegistered`: - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * `NonAssociatedColdKey`: - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * `NotEnoughStakeToWithdraw`: - * - Thrown if there is not enough stake on the hotkey to withdraw this amount. - * - * * `TxRateLimitExceeded`: - * - Thrown if key has hit transaction rate limit - */ - unstake_all: TxDescriptor>; - /** - * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The associated hotkey account. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * `NotRegistered`: - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * `NonAssociatedColdKey`: - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * `NotEnoughStakeToWithdraw`: - * - Thrown if there is not enough stake on the hotkey to withdraw this amount. - * - * * `TxRateLimitExceeded`: - * - Thrown if key has hit transaction rate limit - */ - unstake_all_alpha: TxDescriptor>; - /** - * ---- The implementation for the extrinsic move_stake: Moves specified amount of stake from a hotkey to another across subnets. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `origin_hotkey` (T::AccountId): - * - The hotkey account to move stake from. - * - * * `destination_hotkey` (T::AccountId): - * - The hotkey account to move stake to. - * - * * `origin_netuid` (T::AccountId): - * - The subnet ID to move stake from. - * - * * `destination_netuid` (T::AccountId): - * - The subnet ID to move stake to. - * - * * `alpha_amount` (T::AccountId): - * - The alpha stake amount to move. - * - */ - move_stake: TxDescriptor>; - /** - * Transfers a specified amount of stake from one coldkey to another, optionally across subnets, - * while keeping the same hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`. - * * `destination_coldkey` - The coldkey to which the stake is transferred. - * * `hotkey` - The hotkey associated with the stake. - * * `origin_netuid` - The network/subnet ID to move stake from. - * * `destination_netuid` - The network/subnet ID to move stake to (for cross-subnet transfer). - * * `alpha_amount` - The amount of stake to transfer. - * - * # Errors - * Returns an error if: - * * The origin is not signed by the correct coldkey. - * * Either subnet does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(origin_coldkey, hotkey, origin_netuid)`. - * * The transfer amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeTransferred` event on success. - */ - transfer_stake: TxDescriptor>; - /** - * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey whose stake is being swapped. - * * `origin_netuid` - The network/subnet ID from which stake is removed. - * * `destination_netuid` - The network/subnet ID to which stake is added. - * * `alpha_amount` - The amount of stake to swap. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). - * * Either `origin_netuid` or `destination_netuid` does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. - * * The swap amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeSwapped` event on success. - */ - swap_stake: TxDescriptor>; - /** - * --- Adds stake to a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (lower) the staking should execute. - * - * In case if slippage occurs and the price shall move beyond the limit - * price, the staking order may execute only partially or not execute - * at all. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_staked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * * 'limit_price' (u64): - * - The limit price expressed in units of RAO per one Alpha. - * - * * 'allow_partial' (bool): - * - Allows partial execution of the amount. If set to false, this becomes - * fill or kill type or order. - * - * # Event: - * * StakeAdded; - * - On the successfully adding stake to a global account. - * - * # Raises: - * * 'NotEnoughBalanceToStake': - * - Not enough balance on the coldkey to add onto the global account. - * - * * 'NonAssociatedColdKey': - * - The calling coldkey is not associated with this hotkey. - * - * * 'BalanceWithdrawalError': - * - Errors stemming from transaction pallet. - * - */ - add_stake_limit: TxDescriptor>; - /** - * --- Removes stake from a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (higher) the staking should execute. - * - * In case if slippage occurs and the price shall move beyond the limit - * price, the staking order may execute only partially or not execute - * at all. - * - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * * 'hotkey' (T::AccountId): - * - The associated hotkey account. - * - * * 'netuid' (u16): - * - Subnetwork UID - * - * * 'amount_unstaked' (u64): - * - The amount of stake to be added to the hotkey staking account. - * - * * 'limit_price' (u64): - * - The limit price expressed in units of RAO per one Alpha. - * - * * 'allow_partial' (bool): - * - Allows partial execution of the amount. If set to false, this becomes - * fill or kill type or order. - * - * # Event: - * * StakeRemoved; - * - On the successfully removing stake from the hotkey account. - * - * # Raises: - * * 'NotRegistered': - * - Thrown if the account we are attempting to unstake from is non existent. - * - * * 'NonAssociatedColdKey': - * - Thrown if the coldkey does not own the hotkey we are unstaking from. - * - * * 'NotEnoughStakeToWithdraw': - * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. - * - */ - remove_stake_limit: TxDescriptor>; - /** - * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey whose stake is being swapped. - * * `origin_netuid` - The network/subnet ID from which stake is removed. - * * `destination_netuid` - The network/subnet ID to which stake is added. - * * `alpha_amount` - The amount of stake to swap. - * * `limit_price` - The limit price expressed in units of RAO per one Alpha. - * * `allow_partial` - Allows partial execution of the amount. If set to false, this becomes fill or kill type or order. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). - * * Either `origin_netuid` or `destination_netuid` does not exist. - * * The hotkey does not exist. - * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. - * * The swap amount is below the minimum stake requirement. - * - * # Events - * May emit a `StakeSwapped` event on success. - */ - swap_stake_limit: TxDescriptor>; - /** - * Attempts to associate a hotkey with a coldkey. - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. - * * `hotkey` - The hotkey to associate with the coldkey. - * - * # Note - * Will charge based on the weight even if the hotkey is already associated with a coldkey. - */ - try_associate_hotkey: TxDescriptor>; - /** - * Initiates a call on a subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be signed by the subnet owner. - * * `netuid` - The unique identifier of the subnet on which the call is being initiated. - * - * # Events - * Emits a `FirstEmissionBlockNumberSet` event on success. - */ - start_call: TxDescriptor>; - /** - * Attempts to associate a hotkey with an EVM key. - * - * The signature will be checked to see if the recovered public key matches the `evm_key` provided. - * - * The EVM key is expected to sign the message according to this formula to produce the signature: - * ```text - * keccak_256(hotkey ++ keccak_256(block_number)) - * ``` - * - * # Arguments - * * `origin` - The origin of the transaction, which must be signed by the `hotkey`. - * * `netuid` - The netuid that the `hotkey` belongs to. - * * `evm_key` - The EVM key to associate with the `hotkey`. - * * `block_number` - The block number used in the `signature`. - * * `signature` - A signed message by the `evm_key` containing the `hotkey` and the hashed `block_number`. - * - * # Errors - * Returns an error if: - * * The transaction is not signed. - * * The hotkey does not belong to the subnet identified by the netuid. - * * The EVM key cannot be recovered from the signature. - * * The EVM key recovered from the signature does not match the given EVM key. - * - * # Events - * May emit a `EvmKeyAssociated` event on success - */ - associate_evm_key: TxDescriptor>; - /** - * Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet - * - * # Arguments - * * `origin` - The origin of the call (must be signed by the coldkey) - * * `hotkey` - The hotkey account - * * `amount` - The amount of alpha to recycle - * * `netuid` - The subnet ID - * - * # Events - * Emits a `TokensRecycled` event on success. - */ - recycle_alpha: TxDescriptor>; - /** - * Burns alpha from a cold/hot key pair without reducing `AlphaOut` - * - * # Arguments - * * `origin` - The origin of the call (must be signed by the coldkey) - * * `hotkey` - The hotkey account - * * `amount` - The amount of alpha to burn - * * `netuid` - The subnet ID - * - * # Events - * Emits a `TokensBurned` event on success. - */ - burn_alpha: TxDescriptor>; - /** - * Sets the pending childkey cooldown (in blocks). Root only. - */ - set_pending_childkey_cooldown: TxDescriptor>; - /** - * Removes all stake from a hotkey on a subnet with a price limit. - * This extrinsic allows to specify the limit price for alpha token - * at which or better (higher) the staking should execute. - * Without limit_price it remove all the stake similar to `remove_stake` extrinsic - */ - remove_stake_full_limit: TxDescriptor>; - /** - * Register a new leased network. - * - * The crowdloan's contributions are used to compute the share of the emissions that the contributors - * will receive as dividends. - * - * The leftover cap is refunded to the contributors and the beneficiary. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `emissions_share` (Percent): - * - The share of the emissions that the contributors will receive as dividends. - * - * * `end_block` (Option>): - * - The block at which the lease will end. If not defined, the lease is perpetual. - */ - register_leased_network: TxDescriptor>; - /** - * Terminate a lease. - * - * The beneficiary can terminate the lease after the end block has passed and get the subnet ownership. - * The subnet is transferred to the beneficiary and the lease is removed from storage. - * - * **The hotkey must be owned by the beneficiary coldkey.** - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `lease_id` (LeaseId): - * - The ID of the lease to terminate. - * - * * `hotkey` (T::AccountId): - * - The hotkey of the beneficiary to mark as subnet owner hotkey. - */ - terminate_lease: TxDescriptor>; - /** - * Updates the symbol for a subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or root. - * * `netuid` - The unique identifier of the subnet on which the symbol is being set. - * * `symbol` - The symbol to set for the subnet. - * - * # Errors - * Returns an error if: - * * The transaction is not signed by the subnet owner. - * * The symbol does not exist. - * * The symbol is already in use by another subnet. - * - * # Events - * Emits a `SymbolUpdated` event on success. - */ - update_symbol: TxDescriptor>; - /** - * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * * commit_reveal_version (`u16`): - * - The client (bittensor-drand) version - */ - commit_timelocked_weights: TxDescriptor>; - /** - * Set the autostake destination hotkey for a coldkey. - * - * The caller selects a hotkey where all future rewards - * will be automatically staked. - * - * # Args: - * * `origin` - (::Origin): - * - The signature of the caller's coldkey. - * - * * `hotkey` (T::AccountId): - * - The hotkey account to designate as the autostake destination. - */ - set_coldkey_auto_stake_hotkey: TxDescriptor>; - /** - * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed for - * a mechanism. - * - * # Args: - * * `origin`: (`::RuntimeOrigin`): - * - The committing hotkey. - * - * * `netuid` (`u16`): - * - The u16 network identifier. - * - * * `mecid` (`u8`): - * - The u8 mechanism identifier. - * - * * `commit` (`Vec`): - * - The encrypted compressed commit. - * The steps for this are: - * 1. Instantiate [`WeightsTlockPayload`] - * 2. Serialize it using the `parity_scale_codec::Encode` trait - * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] - * to produce a [`TLECiphertext`] type. - * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. - * - * * reveal_round (`u64`): - * - The drand reveal round which will be avaliable during epoch `n+1` from the current - * epoch. - * - * * commit_reveal_version (`u16`): - * - The client (bittensor-drand) version - */ - commit_timelocked_mechanism_weights: TxDescriptor>; - /** - * Remove a subnetwork - * The caller must be root - */ - root_dissolve_network: TxDescriptor>; - /** - * --- Claims the root emissions for a coldkey. - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * # Event: - * * RootClaimed; - * - On the successfully claiming the root emissions for a coldkey. - * - * # Raises: - * - */ - claim_root: TxDescriptor>; - /** - * --- Sets the root claim type for the coldkey. - * # Args: - * * 'origin': (Origin): - * - The signature of the caller's coldkey. - * - * # Event: - * * RootClaimTypeSet; - * - On the successfully setting the root claim type for the coldkey. - * - */ - set_root_claim_type: TxDescriptor>; - /** - * --- Sets root claim number (sudo extrinsic). Zero disables auto-claim. - */ - sudo_set_num_root_claims: TxDescriptor>; - /** - * --- Sets root claim threshold for subnet (sudo or owner origin). - */ - sudo_set_root_claim_threshold: TxDescriptor>; - /** - * Announces a coldkey swap using BlakeTwo256 hash of the new coldkey. - * - * This is required before the coldkey swap can be performed - * after the delay period. - * - * It can be reannounced after a delay of `ColdkeySwapReannouncementDelay` following - * the first valid execution block of the original announcement. - * - * The dispatch origin of this call must be the original coldkey that made the announcement. - * - * - `new_coldkey_hash`: The hash of the new coldkey using BlakeTwo256. - * - * The `ColdkeySwapAnnounced` event is emitted on successful announcement. - * - */ - announce_coldkey_swap: TxDescriptor>; - /** - * Performs a coldkey swap if an announcement has been made. - * - * The dispatch origin of this call must be the original coldkey that made the announcement. - * - * - `new_coldkey`: The new coldkey to swap to. The BlakeTwo256 hash of the new coldkey must be - * the same as the announced coldkey hash. - * - * The `ColdkeySwapped` event is emitted on successful swap. - */ - swap_coldkey_announced: TxDescriptor>; - /** - * Dispute a coldkey swap. - * - * This will prevent any further actions on the coldkey swap - * until triumvirate step in to resolve the issue. - * - * - `coldkey`: The coldkey to dispute the swap for. - * - */ - dispute_coldkey_swap: TxDescriptor; - /** - * Reset a coldkey swap by clearing the announcement and dispute status. - * - * The dispatch origin of this call must be root. - * - * - `coldkey`: The coldkey to reset the swap for. - * - */ - reset_coldkey_swap: TxDescriptor>; - /** - * Enables voting power tracking for a subnet. - * - * This function can be called by the subnet owner or root. - * When enabled, voting power EMA is updated every epoch for all validators. - * Voting power starts at 0 and increases over epochs. - * - * # Arguments: - * * `origin` - The origin of the call, must be subnet owner or root. - * * `netuid` - The subnet to enable voting power tracking for. - * - * # Errors: - * * `SubnetNotExist` - If the subnet does not exist. - * * `NotSubnetOwner` - If the caller is not the subnet owner or root. - */ - enable_voting_power_tracking: TxDescriptor>; - /** - * Schedules disabling of voting power tracking for a subnet. - * - * This function can be called by the subnet owner or root. - * Voting power tracking will continue for 14 days (grace period) after this call, - * then automatically disable and clear all VotingPower entries for the subnet. - * - * # Arguments: - * * `origin` - The origin of the call, must be subnet owner or root. - * * `netuid` - The subnet to schedule disabling voting power tracking for. - * - * # Errors: - * * `SubnetNotExist` - If the subnet does not exist. - * * `NotSubnetOwner` - If the caller is not the subnet owner or root. - * * `VotingPowerTrackingNotEnabled` - If voting power tracking is not enabled. - */ - disable_voting_power_tracking: TxDescriptor>; - /** - * Sets the EMA alpha value for voting power calculation on a subnet. - * - * This function can only be called by root (sudo). - * Higher alpha = faster response to stake changes. - * Alpha is stored as u64 with 18 decimal precision (1.0 = 10^18). - * - * # Arguments: - * * `origin` - The origin of the call, must be root. - * * `netuid` - The subnet to set the alpha for. - * * `alpha` - The new alpha value (u64 with 18 decimal precision). - * - * # Errors: - * * `BadOrigin` - If the origin is not root. - * * `SubnetNotExist` - If the subnet does not exist. - * * `InvalidVotingPowerEmaAlpha` - If alpha is greater than 10^18 (1.0). - */ - sudo_set_voting_power_ema_alpha: TxDescriptor>; - /** - * --- The extrinsic is a combination of add_stake(add_stake_limit) and burn_alpha. We buy - * alpha token first and immediately burn the acquired amount of alpha (aka Subnet buyback). - */ - add_stake_burn: TxDescriptor>; - }; - Utility: { - /** - * Send a batch of dispatch calls. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatched without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - * - * This will return `Ok` in all circumstances. To determine the success of the batch, an - * event is deposited. If a call failed and the batch was interrupted, then the - * `BatchInterrupted` event is deposited, along with the number of successful calls made - * and the error of the failed call. If all were successful, then the `BatchCompleted` - * event is deposited. - */ - batch: TxDescriptor>; - /** - * Send a call through an indexed pseudonym of the sender. - * - * Filter from origin are passed along. The call will be dispatched with an origin which - * use the same filter as the origin of this call. - * - * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. - * because you expect `proxy` to have been used prior in the call stack and you do not want - * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` - * in the Multisig pallet instead. - * - * NOTE: Prior to version *12, this was called `as_limited_sub`. - * - * The dispatch origin for this call must be _Signed_. - */ - as_derivative: TxDescriptor>; - /** - * Send a batch of dispatch calls and atomically execute them. - * The whole transaction will rollback and fail if any of the calls failed. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatched without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - */ - batch_all: TxDescriptor>; - /** - * Dispatches a function call with a provided origin. - * - * The dispatch origin for this call must be _Root_. - * - * ## Complexity - * - O(1). - */ - dispatch_as: TxDescriptor>; - /** - * Send a batch of dispatch calls. - * Unlike `batch`, it allows errors and won't interrupt. - * - * May be called from any origin except `None`. - * - * - `calls`: The calls to be dispatched from the same origin. The number of call must not - * exceed the constant: `batched_calls_limit` (available in constant metadata). - * - * If origin is root then the calls are dispatch without checking origin filter. (This - * includes bypassing `frame_system::Config::BaseCallFilter`). - * - * ## Complexity - * - O(C) where C is the number of calls to be batched. - */ - force_batch: TxDescriptor>; - /** - * Dispatch a function call with a specified weight. - * - * This function does not check the weight of the call, and instead allows the - * Root origin to specify the weight of the call. - * - * The dispatch origin for this call must be _Root_. - */ - with_weight: TxDescriptor>; - /** - * Dispatch a fallback call in the event the main call fails to execute. - * May be called from any origin except `None`. - * - * This function first attempts to dispatch the `main` call. - * If the `main` call fails, the `fallback` is attemted. - * if the fallback is successfully dispatched, the weights of both calls - * are accumulated and an event containing the main call error is deposited. - * - * In the event of a fallback failure the whole call fails - * with the weights returned. - * - * - `main`: The main call to be dispatched. This is the primary action to execute. - * - `fallback`: The fallback call to be dispatched in case the `main` call fails. - * - * ## Dispatch Logic - * - If the origin is `root`, both the main and fallback calls are executed without - * applying any origin filters. - * - If the origin is not `root`, the origin filter is applied to both the `main` and - * `fallback` calls. - * - * ## Use Case - * - Some use cases might involve submitting a `batch` type call in either main, fallback - * or both. - */ - if_else: TxDescriptor>; - /** - * Dispatches a function call with a provided origin. - * - * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call. - * - * The dispatch origin for this call must be _Root_. - */ - dispatch_as_fallible: TxDescriptor>; - }; - Sudo: { - /** - * Authenticates the sudo key and dispatches a function call with `Root` origin. - */ - sudo: TxDescriptor>; - /** - * Authenticates the sudo key and dispatches a function call with `Root` origin. - * This function does not check the weight of the call, and instead allows the - * Sudo user to specify the weight of the call. - * - * The dispatch origin for this call must be _Signed_. - */ - sudo_unchecked_weight: TxDescriptor>; - /** - * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo - * key. - */ - set_key: TxDescriptor>; - /** - * Authenticates the sudo key and dispatches a function call with `Signed` origin from - * a given account. - * - * The dispatch origin for this call must be _Signed_. - */ - sudo_as: TxDescriptor>; - /** - * Permanently removes the sudo key. - * - * **This cannot be un-done.** - */ - remove_key: TxDescriptor; - }; - Multisig: { - /** - * Immediately dispatch a multi-signature call using a single approval from the caller. - * - * The dispatch origin for this call must be _Signed_. - * - * - `other_signatories`: The accounts (other than the sender) who are part of the - * multi-signature, but do not participate in the approval process. - * - `call`: The call to be executed. - * - * Result is equivalent to the dispatched result. - * - * ## Complexity - * O(Z + C) where Z is the length of the call and C its execution weight. - */ - as_multi_threshold_1: TxDescriptor>; - /** - * Register approval for a dispatch to be made from a deterministic composite account if - * approved by a total of `threshold - 1` of `other_signatories`. - * - * If there are enough, then dispatch the call. - * - * Payment: `DepositBase` will be reserved if this is the first approval, plus - * `threshold` times `DepositFactor`. It is returned once this dispatch happens or - * is cancelled. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is - * not the first approval, then it must be `Some`, with the timepoint (block number and - * transaction index) of the first approval transaction. - * - `call`: The call to be executed. - * - * NOTE: Unless this is the final approval, you will generally want to use - * `approve_as_multi` instead, since it only requires a hash of the call. - * - * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise - * on success, result is `Ok` and the result from the interior call, if it was executed, - * may be found in the deposited `MultisigExecuted` event. - * - * ## Complexity - * - `O(S + Z + Call)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. - * - One encode & hash, both of complexity `O(S)`. - * - Up to one binary search and insert (`O(logS + S)`). - * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. - * - One event. - * - The weight of the `call`. - * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit - * taken for its lifetime of `DepositBase + threshold * DepositFactor`. - */ - as_multi: TxDescriptor>; - /** - * Register approval for a dispatch to be made from a deterministic composite account if - * approved by a total of `threshold - 1` of `other_signatories`. - * - * Payment: `DepositBase` will be reserved if this is the first approval, plus - * `threshold` times `DepositFactor`. It is returned once this dispatch happens or - * is cancelled. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is - * not the first approval, then it must be `Some`, with the timepoint (block number and - * transaction index) of the first approval transaction. - * - `call_hash`: The hash of the call to be executed. - * - * NOTE: If this is the final approval, you will want to use `as_multi` instead. - * - * ## Complexity - * - `O(S)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One encode & hash, both of complexity `O(S)`. - * - Up to one binary search and insert (`O(logS + S)`). - * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. - * - One event. - * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit - * taken for its lifetime of `DepositBase + threshold * DepositFactor`. - */ - approve_as_multi: TxDescriptor>; - /** - * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously - * for this operation will be unreserved on success. - * - * The dispatch origin for this call must be _Signed_. - * - * - `threshold`: The total number of approvals for this dispatch before it is executed. - * - `other_signatories`: The accounts (other than the sender) who can approve this - * dispatch. May not be empty. - * - `timepoint`: The timepoint (block number and transaction index) of the first approval - * transaction for this dispatch. - * - `call_hash`: The hash of the call to be executed. - * - * ## Complexity - * - `O(S)`. - * - Up to one balance-reserve or unreserve operation. - * - One passthrough operation, one insert, both `O(S)` where `S` is the number of - * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. - * - One encode & hash, both of complexity `O(S)`. - * - One event. - * - I/O: 1 read `O(S)`, one remove. - * - Storage: removes one item. - */ - cancel_as_multi: TxDescriptor>; - /** - * Poke the deposit reserved for an existing multisig operation. - * - * The dispatch origin for this call must be _Signed_ and must be the original depositor of - * the multisig operation. - * - * The transaction fee is waived if the deposit amount has changed. - * - * - `threshold`: The total number of approvals needed for this multisig. - * - `other_signatories`: The accounts (other than the sender) who are part of the - * multisig. - * - `call_hash`: The hash of the call this deposit is reserved for. - * - * Emits `DepositPoked` if successful. - */ - poke_deposit: TxDescriptor>; - }; - Preimage: { - /** - * Register a preimage on-chain. - * - * If the preimage was previously requested, no fees or deposits are taken for providing - * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. - */ - note_preimage: TxDescriptor>; - /** - * Clear an unrequested preimage from the runtime storage. - * - * If `len` is provided, then it will be a much cheaper operation. - * - * - `hash`: The hash of the preimage to be removed from the store. - * - `len`: The length of the preimage of `hash`. - */ - unnote_preimage: TxDescriptor>; - /** - * Request a preimage be uploaded to the chain without paying any fees or deposits. - * - * If the preimage requests has already been provided on-chain, we unreserve any deposit - * a user may have paid, and take the control of the preimage out of their hands. - */ - request_preimage: TxDescriptor>; - /** - * Clear a previously made request for a preimage. - * - * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. - */ - unrequest_preimage: TxDescriptor>; - /** - * Ensure that the bulk of pre-images is upgraded. - * - * The caller pays no fee if at least 90% of pre-images were successfully updated. - */ - ensure_updated: TxDescriptor>; - }; - Scheduler: { - /** - * Anonymously schedule a task. - */ - schedule: TxDescriptor>; - /** - * Cancel an anonymously scheduled task. - */ - cancel: TxDescriptor>; - /** - * Schedule a named task. - */ - schedule_named: TxDescriptor>; - /** - * Cancel a named scheduled task. - */ - cancel_named: TxDescriptor>; - /** - * Anonymously schedule a task after a delay. - */ - schedule_after: TxDescriptor>; - /** - * Schedule a named task after a delay. - */ - schedule_named_after: TxDescriptor>; - /** - * Set a retry configuration for a task so that, in case its scheduled run fails, it will - * be retried after `period` blocks, for a total amount of `retries` retries or until it - * succeeds. - * - * Tasks which need to be scheduled for a retry are still subject to weight metering and - * agenda space, same as a regular task. If a periodic task fails, it will be scheduled - * normally while the task is retrying. - * - * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic - * clones of the original task. Their retry configuration will be derived from the - * original task's configuration, but will have a lower value for `remaining` than the - * original `total_retries`. - */ - set_retry: TxDescriptor>; - /** - * Set a retry configuration for a named task so that, in case its scheduled run fails, it - * will be retried after `period` blocks, for a total amount of `retries` retries or until - * it succeeds. - * - * Tasks which need to be scheduled for a retry are still subject to weight metering and - * agenda space, same as a regular task. If a periodic task fails, it will be scheduled - * normally while the task is retrying. - * - * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic - * clones of the original task. Their retry configuration will be derived from the - * original task's configuration, but will have a lower value for `remaining` than the - * original `total_retries`. - */ - set_retry_named: TxDescriptor>; - /** - * Removes the retry configuration of a task. - */ - cancel_retry: TxDescriptor>; - /** - * Cancel the retry configuration of a named task. - */ - cancel_retry_named: TxDescriptor>; - }; - Proxy: { - /** - * Dispatch the given `call` from an account that the sender is authorised for through - * `add_proxy`. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. - * - `call`: The call to be made by the `real` account. - */ - proxy: TxDescriptor>; - /** - * Register a proxy account for the sender that is able to make calls on its behalf. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `proxy`: The account that the `caller` would like to make a proxy. - * - `proxy_type`: The permissions allowed for this proxy account. - * - `delay`: The announcement period required of the initial proxy. Will generally be - * zero. - */ - add_proxy: TxDescriptor>; - /** - * Unregister a proxy account for the sender. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `proxy`: The account that the `caller` would like to remove as a proxy. - * - `proxy_type`: The permissions currently enabled for the removed proxy account. - */ - remove_proxy: TxDescriptor>; - /** - * Unregister all proxy accounts for the sender. - * - * The dispatch origin for this call must be _Signed_. - * - * WARNING: This may be called on accounts created by `create_pure`, however if done, then - * the unreserved fees will be inaccessible. **All access to this account will be lost.** - */ - remove_proxies: TxDescriptor; - /** - * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and - * initialize it with a proxy of `proxy_type` for `origin` sender. - * - * Requires a `Signed` origin. - * - * - `proxy_type`: The type of the proxy that the sender will be registered as over the - * new account. This will almost always be the most permissive `ProxyType` possible to - * allow for maximum flexibility. - * - `index`: A disambiguation index, in case this is called multiple times in the same - * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just - * want to use `0`. - * - `delay`: The announcement period required of the initial proxy. Will generally be - * zero. - * - * Fails with `Duplicate` if this has already been called in this transaction, from the - * same sender, with the same parameters. - * - * Fails if there are insufficient funds to pay for deposit. - */ - create_pure: TxDescriptor>; - /** - * Removes a previously spawned pure proxy. - * - * WARNING: **All access to this account will be lost.** Any funds held in it will be - * inaccessible. - * - * Requires a `Signed` origin, and the sender account must have been created by a call to - * `create_pure` with corresponding parameters. - * - * - `spawner`: The account that originally called `create_pure` to create this account. - * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`. - * - `proxy_type`: The proxy type originally passed to `create_pure`. - * - `height`: The height of the chain when the call to `create_pure` was processed. - * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed. - * - * Fails with `NoPermission` in case the caller is not a previously created pure - * account whose `create_pure` call has corresponding parameters. - */ - kill_pure: TxDescriptor>; - /** - * Publish the hash of a proxy-call that will be made in the future. - * - * This must be called some number of blocks before the corresponding `proxy` is attempted - * if the delay associated with the proxy relationship is greater than zero. - * - * No more than `MaxPending` announcements may be made at any one time. - * - * This will take a deposit of `AnnouncementDepositFactor` as well as - * `AnnouncementDepositBase` if there are no other pending announcements. - * - * The dispatch origin for this call must be _Signed_ and a proxy of `real`. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `call_hash`: The hash of the call to be made by the `real` account. - */ - announce: TxDescriptor>; - /** - * Remove a given announcement. - * - * May be called by a proxy account to remove a call they previously announced and return - * the deposit. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `call_hash`: The hash of the call to be made by the `real` account. - */ - remove_announcement: TxDescriptor>; - /** - * Remove the given announcement of a delegate. - * - * May be called by a target (proxied) account to remove a call that one of their delegates - * (`delegate`) has announced they want to execute. The deposit is returned. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `delegate`: The account that previously announced the call. - * - `call_hash`: The hash of the call to be made. - */ - reject_announcement: TxDescriptor>; - /** - * Dispatch the given `call` from an account that the sender is authorized for through - * `add_proxy`. - * - * Removes any corresponding announcement(s). - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `real`: The account that the proxy will make a call on behalf of. - * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. - * - `call`: The call to be made by the `real` account. - */ - proxy_announced: TxDescriptor>; - /** - * Poke / Adjust deposits made for proxies and announcements based on current values. - * This can be used by accounts to possibly lower their locked amount. - * - * The dispatch origin for this call must be _Signed_. - * - * The transaction fee is waived if the deposit amount has changed. - * - * Emits `DepositPoked` if successful. - */ - poke_deposit: TxDescriptor; - }; - Registry: { - /** - * Register an identity for an account. This will overwrite any existing identity. - */ - set_identity: TxDescriptor>; - /** - * Clear the identity of an account. - */ - clear_identity: TxDescriptor>; - }; - Commitments: { - /** - * Set the commitment for a given netuid - */ - set_commitment: TxDescriptor>; - /** - * Sudo-set MaxSpace - */ - set_max_space: TxDescriptor>; - }; - AdminUtils: { - /** - * The extrinsic sets the new authorities for Aura consensus. - * It is only callable by the root account. - * The extrinsic will call the Aura pallet to change the authorities. - */ - swap_authorities: TxDescriptor>; - /** - * The extrinsic sets the default take for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the default take. - */ - sudo_set_default_take: TxDescriptor>; - /** - * The extrinsic sets the transaction rate limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the transaction rate limit. - */ - sudo_set_tx_rate_limit: TxDescriptor>; - /** - * The extrinsic sets the serving rate limit for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the serving rate limit. - */ - sudo_set_serving_rate_limit: TxDescriptor>; - /** - * The extrinsic sets the minimum difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum difficulty. - */ - sudo_set_min_difficulty: TxDescriptor>; - /** - * The extrinsic sets the maximum difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum difficulty. - */ - sudo_set_max_difficulty: TxDescriptor>; - /** - * The extrinsic sets the weights version key for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the weights version key. - */ - sudo_set_weights_version_key: TxDescriptor>; - /** - * The extrinsic sets the weights set rate limit for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the weights set rate limit. - */ - sudo_set_weights_set_rate_limit: TxDescriptor>; - /** - * The extrinsic sets the adjustment interval for a subnet. - * It is only callable by the root account, not changeable by the subnet owner. - * The extrinsic will call the Subtensor pallet to set the adjustment interval. - */ - sudo_set_adjustment_interval: TxDescriptor>; - /** - * The extrinsic sets the adjustment alpha for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the adjustment alpha. - */ - sudo_set_adjustment_alpha: TxDescriptor>; - /** - * The extrinsic sets the immunity period for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the immunity period. - */ - sudo_set_immunity_period: TxDescriptor>; - /** - * The extrinsic sets the minimum allowed weights for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum allowed weights. - */ - sudo_set_min_allowed_weights: TxDescriptor>; - /** - * The extrinsic sets the maximum allowed UIDs for a subnet. - * It is only callable by the root account and subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum allowed UIDs for a subnet. - */ - sudo_set_max_allowed_uids: TxDescriptor>; - /** - * The extrinsic sets the kappa for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the kappa. - */ - sudo_set_kappa: TxDescriptor>; - /** - * The extrinsic sets the rho for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the rho. - */ - sudo_set_rho: TxDescriptor>; - /** - * The extrinsic sets the activity cutoff for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the activity cutoff. - */ - sudo_set_activity_cutoff: TxDescriptor>; - /** - * The extrinsic sets the network registration allowed for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the network registration allowed. - */ - sudo_set_network_registration_allowed: TxDescriptor>; - /** - * The extrinsic sets the network PoW registration allowed for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the network PoW registration allowed. - */ - sudo_set_network_pow_registration_allowed: TxDescriptor>; - /** - * The extrinsic sets the target registrations per interval for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the target registrations per interval. - */ - sudo_set_target_registrations_per_interval: TxDescriptor>; - /** - * The extrinsic sets the minimum burn for a subnet. - * It is only callable by root and subnet owner. - * The extrinsic will call the Subtensor pallet to set the minimum burn. - */ - sudo_set_min_burn: TxDescriptor>; - /** - * The extrinsic sets the maximum burn for a subnet. - * It is only callable by root and subnet owner. - * The extrinsic will call the Subtensor pallet to set the maximum burn. - */ - sudo_set_max_burn: TxDescriptor>; - /** - * The extrinsic sets the difficulty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the difficulty. - */ - sudo_set_difficulty: TxDescriptor>; - /** - * The extrinsic sets the maximum allowed validators for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the maximum allowed validators. - */ - sudo_set_max_allowed_validators: TxDescriptor>; - /** - * The extrinsic sets the bonds moving average for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the bonds moving average. - */ - sudo_set_bonds_moving_average: TxDescriptor>; - /** - * The extrinsic sets the bonds penalty for a subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the bonds penalty. - */ - sudo_set_bonds_penalty: TxDescriptor>; - /** - * The extrinsic sets the maximum registrations per block for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the maximum registrations per block. - */ - sudo_set_max_registrations_per_block: TxDescriptor>; - /** - * The extrinsic sets the subnet owner cut for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the subnet owner cut. - */ - sudo_set_subnet_owner_cut: TxDescriptor>; - /** - * The extrinsic sets the network rate limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the network rate limit. - */ - sudo_set_network_rate_limit: TxDescriptor>; - /** - * The extrinsic sets the tempo for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the tempo. - */ - sudo_set_tempo: TxDescriptor>; - /** - * The extrinsic sets the total issuance for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the issuance for the network. - */ - sudo_set_total_issuance: TxDescriptor>; - /** - * The extrinsic sets the immunity period for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the immunity period for the network. - */ - sudo_set_network_immunity_period: TxDescriptor>; - /** - * The extrinsic sets the min lock cost for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the min lock cost for the network. - */ - sudo_set_network_min_lock_cost: TxDescriptor>; - /** - * The extrinsic sets the subnet limit for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the subnet limit. - */ - sudo_set_subnet_limit: TxDescriptor>; - /** - * The extrinsic sets the lock reduction interval for the network. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the lock reduction interval. - */ - sudo_set_lock_reduction_interval: TxDescriptor>; - /** - * The extrinsic sets the recycled RAO for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the recycled RAO. - */ - sudo_set_rao_recycled: TxDescriptor>; - /** - * The extrinsic sets the weights min stake. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the weights min stake. - */ - sudo_set_stake_threshold: TxDescriptor>; - /** - * The extrinsic sets the minimum stake required for nominators. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the minimum stake required for nominators. - */ - sudo_set_nominator_min_required_stake: TxDescriptor>; - /** - * The extrinsic sets the rate limit for delegate take transactions. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the rate limit for delegate take transactions. - */ - sudo_set_tx_delegate_take_rate_limit: TxDescriptor>; - /** - * The extrinsic sets the minimum delegate take. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the minimum delegate take. - */ - sudo_set_min_delegate_take: TxDescriptor>; - /** - * The extrinsic enabled/disables commit/reaveal for a given subnet. - * It is only callable by the root account or subnet owner. - * The extrinsic will call the Subtensor pallet to set the value. - */ - sudo_set_commit_reveal_weights_enabled: TxDescriptor>; - /** - * Enables or disables Liquid Alpha for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Liquid Alpha. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - sudo_set_liquid_alpha_enabled: TxDescriptor>; - /** - * Sets values for liquid alpha - */ - sudo_set_alpha_values: TxDescriptor>; - /** - * Sets the duration of the dissolve network schedule. - * - * This extrinsic allows the root account to set the duration for the dissolve network schedule. - * The dissolve network schedule determines how long it takes for a network dissolution operation to complete. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `duration` - The new duration for the dissolve network schedule, in number of blocks. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_dissolve_network_schedule_duration: TxDescriptor>; - /** - * Sets the commit-reveal weights periods for a specific subnet. - * - * This extrinsic allows the subnet owner or root account to set the duration (in epochs) during which committed weights must be revealed. - * The commit-reveal mechanism ensures that users commit weights in advance and reveal them only within a specified period. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or the root account. - * * `netuid` - The unique identifier of the subnet for which the periods are being set. - * * `periods` - The number of epochs that define the commit-reveal period. - * - * # Errors - * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. - * * `SubnetDoesNotExist` - If the specified subnet does not exist. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_commit_reveal_weights_interval: TxDescriptor>; - /** - * Sets the EVM ChainID. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner or the root account. - * * `chainId` - The u64 chain ID - * - * # Errors - * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_evm_chain_id: TxDescriptor>; - /** - * A public interface for `pallet_grandpa::Pallet::schedule_grandpa_change`. - * - * Schedule a change in the authorities. - * - * The change will be applied at the end of execution of the block `in_blocks` after the - * current block. This value may be 0, in which case the change is applied at the end of - * the current block. - * - * If the `forced` parameter is defined, this indicates that the current set has been - * synchronously determined to be offline and that after `in_blocks` the given change - * should be applied. The given block number indicates the median last finalized block - * number and it should be used as the canon block when starting the new grandpa voter. - * - * No change should be signaled while any change is pending. Returns an error if a change - * is already pending. - */ - schedule_grandpa_change: TxDescriptor>; - /** - * Enable or disable atomic alpha transfers for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Liquid Alpha. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - sudo_set_toggle_transfer: TxDescriptor>; - /** - * Set the behaviour of the "burn" UID(s) for a given subnet. - * If set to `Burn`, the miner emission sent to the burn UID(s) will be burned. - * If set to `Recycle`, the miner emission sent to the burn UID(s) will be recycled. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `recycle_or_burn`: The desired behaviour of the "burn" UID(s) for the subnet. - * - */ - sudo_set_recycle_or_burn: TxDescriptor>; - /** - * Toggles the enablement of an EVM precompile. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `precompile_id` - The identifier of the EVM precompile to toggle. - * * `enabled` - The new enablement state of the precompile. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_toggle_evm_precompile: TxDescriptor>; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `alpha` - The new moving alpha value for the SubnetMovingAlpha. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_subnet_moving_alpha: TxDescriptor>; - /** - * Change the SubnetOwnerHotkey for a given subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the subnet owner. - * * `netuid` - The unique identifier for the subnet. - * * `hotkey` - The new hotkey for the subnet owner. - * - * # Errors - * * `BadOrigin` - If the caller is not the subnet owner or root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_subnet_owner_hotkey: TxDescriptor>; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `ema_alpha_period` - Number of blocks for EMA price to halve - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_ema_price_halving_period: TxDescriptor>; - /** - * - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `netuid` - The unique identifier for the subnet. - * * `steepness` - The Steepness for the alpha sigmoid function. (range is 0-int16::MAX, - * negative values are reserved for future use) - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * * `SubnetDoesNotExist` - If the specified subnet does not exist. - * * `NegativeSigmoidSteepness` - If the steepness is negative and the caller is - * root. - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_alpha_sigmoid_steepness: TxDescriptor>; - /** - * Enables or disables Yuma3 for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Yuma3. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - sudo_set_yuma3_enabled: TxDescriptor>; - /** - * Enables or disables Bonds Reset for a given subnet. - * - * # Parameters - * - `origin`: The origin of the call, which must be the root account or subnet owner. - * - `netuid`: The unique identifier for the subnet. - * - `enabled`: A boolean flag to enable or disable Bonds Reset. - * - * # Weight - * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. - */ - sudo_set_bonds_reset_enabled: TxDescriptor>; - /** - * Sets or updates the hotkey account associated with the owner of a specific subnet. - * - * This function allows either the root origin or the current subnet owner to set or update - * the hotkey for a given subnet. The subnet must already exist. To prevent abuse, the call is - * rate-limited to once per configured interval (default: one week) per subnet. - * - * # Parameters - * - `origin`: The dispatch origin of the call. Must be either root or the current owner of the subnet. - * - `netuid`: The unique identifier of the subnet whose owner hotkey is being set. - * - `hotkey`: The new hotkey account to associate with the subnet owner. - * - * # Returns - * - `DispatchResult`: Returns `Ok(())` if the hotkey was successfully set, or an appropriate error otherwise. - * - * # Errors - * - `Error::SubnetNotExists`: If the specified subnet does not exist. - * - `Error::TxRateLimitExceeded`: If the function is called more frequently than the allowed rate limit. - * - * # Access Control - * Only callable by: - * - Root origin, or - * - The coldkey account that owns the subnet. - * - * # Storage - * - Updates [`SubnetOwnerHotkey`] for the given `netuid`. - * - Reads and updates [`LastRateLimitedBlock`] for rate-limiting. - * - Reads [`DefaultSetSNOwnerHotkeyRateLimit`] to determine the interval between allowed updates. - * - * # Rate Limiting - * This function is rate-limited to one call per subnet per interval (e.g., one week). - */ - sudo_set_sn_owner_hotkey: TxDescriptor>; - /** - * Enables or disables subtoken trading for a given subnet. - * - * # Arguments - * * `origin` - The origin of the call, which must be the root account. - * * `netuid` - The unique identifier of the subnet. - * * `subtoken_enabled` - A boolean indicating whether subtoken trading should be enabled or disabled. - * - * # Errors - * * `BadOrigin` - If the caller is not the root account. - * - * # Weight - * Weight is handled by the `#[pallet::weight]` attribute. - */ - sudo_set_subtoken_enabled: TxDescriptor>; - /** - * Sets the commit-reveal weights version for all subnets - */ - sudo_set_commit_reveal_version: TxDescriptor>; - /** - * Sets the number of immune owner neurons - */ - sudo_set_owner_immune_neuron_limit: TxDescriptor>; - /** - * Sets the childkey burn for a subnet. - * It is only callable by the root account. - * The extrinsic will call the Subtensor pallet to set the childkey burn. - */ - sudo_set_ck_burn: TxDescriptor>; - /** - * Sets the admin freeze window length (in blocks) at the end of a tempo. - * Only callable by root. - */ - sudo_set_admin_freeze_window: TxDescriptor>; - /** - * Sets the owner hyperparameter rate limit in epochs (global multiplier). - * Only callable by root. - */ - sudo_set_owner_hparam_rate_limit: TxDescriptor>; - /** - * Sets the desired number of mechanisms in a subnet - */ - sudo_set_mechanism_count: TxDescriptor>; - /** - * Sets the emission split between mechanisms in a subnet - */ - sudo_set_mechanism_emission_split: TxDescriptor>; - /** - * Trims the maximum number of UIDs for a subnet. - * - * The trimming is done by sorting the UIDs by emission descending and then trimming - * the lowest emitters while preserving temporally and owner immune UIDs. The UIDs are - * then compressed to the left and storage is migrated to the new compressed UIDs. - */ - sudo_trim_to_max_allowed_uids: TxDescriptor>; - /** - * The extrinsic sets the minimum allowed UIDs for a subnet. - * It is only callable by the root account. - */ - sudo_set_min_allowed_uids: TxDescriptor>; - /** - * Sets TAO flow cutoff value (A) - */ - sudo_set_tao_flow_cutoff: TxDescriptor>; - /** - * Sets TAO flow normalization exponent (p) - */ - sudo_set_tao_flow_normalization_exponent: TxDescriptor>; - /** - * Sets TAO flow smoothing factor (alpha) - */ - sudo_set_tao_flow_smoothing_factor: TxDescriptor>; - /** - * Sets the global maximum number of mechanisms in a subnet - */ - sudo_set_max_mechanism_count: TxDescriptor>; - /** - * Sets the minimum number of non-immortal & non-immune UIDs that must remain in a subnet - */ - sudo_set_min_non_immune_uids: TxDescriptor>; - /** - * Sets the delay before a subnet can call start - */ - sudo_set_start_call_delay: TxDescriptor>; - /** - * Sets the announcement delay for coldkey swap. - */ - sudo_set_coldkey_swap_announcement_delay: TxDescriptor>; - /** - * Sets the coldkey swap reannouncement delay. - */ - sudo_set_coldkey_swap_reannouncement_delay: TxDescriptor>; - }; - SafeMode: { - /** - * Enter safe-mode permissionlessly for [`Config::EnterDuration`] blocks. - * - * Reserves [`Config::EnterDepositAmount`] from the caller's account. - * Emits an [`Event::Entered`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is already entered. - * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. - */ - enter: TxDescriptor; - /** - * Enter safe-mode by force for a per-origin configured number of blocks. - * - * Emits an [`Event::Entered`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is already entered. - * - * Can only be called by the [`Config::ForceEnterOrigin`] origin. - */ - force_enter: TxDescriptor; - /** - * Extend the safe-mode permissionlessly for [`Config::ExtendDuration`] blocks. - * - * This accumulates on top of the current remaining duration. - * Reserves [`Config::ExtendDepositAmount`] from the caller's account. - * Emits an [`Event::Extended`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is entered. - * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. - * - * This may be called by any signed origin with [`Config::ExtendDepositAmount`] free - * currency to reserve. This call can be disabled for all origins by configuring - * [`Config::ExtendDepositAmount`] to `None`. - */ - extend: TxDescriptor; - /** - * Extend the safe-mode by force for a per-origin configured number of blocks. - * - * Emits an [`Event::Extended`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is inactive. - * - * Can only be called by the [`Config::ForceExtendOrigin`] origin. - */ - force_extend: TxDescriptor; - /** - * Exit safe-mode by force. - * - * Emits an [`Event::Exited`] with [`ExitReason::Force`] event on success. - * Errors with [`Error::Exited`] if the safe-mode is inactive. - * - * Note: `safe-mode` will be automatically deactivated by [`Pallet::on_initialize`] hook - * after the block height is greater than the [`EnteredUntil`] storage item. - * Emits an [`Event::Exited`] with [`ExitReason::Timeout`] event when deactivated in the - * hook. - */ - force_exit: TxDescriptor; - /** - * Slash a deposit for an account that entered or extended safe-mode at a given - * historical block. - * - * This can only be called while safe-mode is entered. - * - * Emits a [`Event::DepositSlashed`] event on success. - * Errors with [`Error::Entered`] if safe-mode is entered. - * - * Can only be called by the [`Config::ForceDepositOrigin`] origin. - */ - force_slash_deposit: TxDescriptor>; - /** - * Permissionlessly release a deposit for an account that entered safe-mode at a - * given historical block. - * - * The call can be completely disabled by setting [`Config::ReleaseDelay`] to `None`. - * This cannot be called while safe-mode is entered and not until - * [`Config::ReleaseDelay`] blocks have passed since safe-mode was entered. - * - * Emits a [`Event::DepositReleased`] event on success. - * Errors with [`Error::Entered`] if the safe-mode is entered. - * Errors with [`Error::CannotReleaseYet`] if [`Config::ReleaseDelay`] block have not - * passed since safe-mode was entered. Errors with [`Error::NoDeposit`] if the payee has no - * reserved currency at the block specified. - */ - release_deposit: TxDescriptor>; - /** - * Force to release a deposit for an account that entered safe-mode at a given - * historical block. - * - * This can be called while safe-mode is still entered. - * - * Emits a [`Event::DepositReleased`] event on success. - * Errors with [`Error::Entered`] if safe-mode is entered. - * Errors with [`Error::NoDeposit`] if the payee has no reserved currency at the - * specified block. - * - * Can only be called by the [`Config::ForceDepositOrigin`] origin. - */ - force_release_deposit: TxDescriptor>; - }; - Ethereum: { - /** - * Transact an Ethereum transaction. - */ - transact: TxDescriptor>; - }; - EVM: { - /** - * Withdraw balance from EVM into currency/balances pallet. - */ - withdraw: TxDescriptor>; - /** - * Issue an EVM call operation. This is similar to a message call transaction in Ethereum. - */ - call: TxDescriptor>; - /** - * Issue an EVM create operation. This is similar to a contract creation transaction in - * Ethereum. - */ - create: TxDescriptor>; - /** - * Issue an EVM create2 operation. - */ - create2: TxDescriptor>; - /** - - */ - set_whitelist: TxDescriptor>; - /** - - */ - disable_whitelist: TxDescriptor>; - }; - BaseFee: { - /** - - */ - set_base_fee_per_gas: TxDescriptor>; - /** - - */ - set_elasticity: TxDescriptor>; - }; - Drand: { - /** - * Verify and write a pulse from the beacon into the runtime - */ - write_pulse: TxDescriptor>; - /** - * allows the root user to set the beacon configuration - * generally this would be called from an offchain worker context. - * there is no verification of configurations, so be careful with this. - * - * * `origin`: the root user - * * `config`: the beacon configuration - */ - set_beacon_config: TxDescriptor>; - /** - * allows the root user to set the oldest stored round - */ - set_oldest_stored_round: TxDescriptor>; - }; - Crowdloan: { - /** - * Create a crowdloan that will raise funds up to a maximum cap and if successful, - * will transfer funds to the target address if provided and dispatch the call - * (using creator origin). - * - * The initial deposit will be transfered to the crowdloan account and will be refunded - * in case the crowdloan fails to raise the cap. Additionally, the creator will pay for - * the execution of the call. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `deposit`: The initial deposit from the creator. - * - `min_contribution`: The minimum contribution required to contribute to the crowdloan. - * - `cap`: The maximum amount of funds that can be raised. - * - `end`: The block number at which the crowdloan will end. - * - `call`: The call to dispatch when the crowdloan is finalized. - * - `target_address`: The address to transfer the raised funds to if provided. - */ - create: TxDescriptor>; - /** - * Contribute to an active crowdloan. - * - * The contribution will be transfered to the crowdloan account and will be refunded - * if the crowdloan fails to raise the cap. If the contribution would raise the amount above the cap, - * the contribution will be set to the amount that is left to be raised. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to contribute to. - * - `amount`: The amount to contribute. - */ - contribute: TxDescriptor>; - /** - * Withdraw a contribution from an active (not yet finalized or dissolved) crowdloan. - * - * Only contributions over the deposit can be withdrawn by the creator. - * - * The dispatch origin for this call must be _Signed_. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to withdraw from. - */ - withdraw: TxDescriptor>; - /** - * Finalize crowdloan that has reached the cap. - * - * The call will transfer the raised amount to the target address if it was provided when the crowdloan was created - * and dispatch the call that was provided using the creator origin. The CurrentCrowdloanId will be set to the - * crowdloan id being finalized so the dispatched call can access it temporarily by accessing - * the `CurrentCrowdloanId` storage item. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to finalize. - */ - finalize: TxDescriptor>; - /** - * Refund contributors of a non-finalized crowdloan. - * - * The call will try to refund all contributors (excluding the creator) up to the limit defined by the `RefundContributorsLimit`. - * If the limit is reached, the call will stop and the crowdloan will be marked as partially refunded. - * It may be needed to dispatch this call multiple times to refund all contributors. - * - * The dispatch origin for this call must be _Signed_ and doesn't need to be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to refund. - */ - refund: TxDescriptor>; - /** - * Dissolve a crowdloan. - * - * The crowdloan will be removed from the storage. - * All contributions must have been refunded before the crowdloan can be dissolved (except the creator's one). - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to dissolve. - */ - dissolve: TxDescriptor>; - /** - * Update the minimum contribution of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the minimum contribution of. - * - `new_min_contribution`: The new minimum contribution. - */ - update_min_contribution: TxDescriptor>; - /** - * Update the end block of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the end block of. - * - `new_end`: The new end block. - */ - update_end: TxDescriptor>; - /** - * Update the cap of a non-finalized crowdloan. - * - * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. - * - * Parameters: - * - `crowdloan_id`: The id of the crowdloan to update the cap of. - * - `new_cap`: The new cap. - */ - update_cap: TxDescriptor>; - }; - Swap: { - /** - * Set the fee rate for swaps on a specific subnet (normalized value). - * For example, 0.3% is approximately 196. - * - * Only callable by the admin origin - */ - set_fee_rate: TxDescriptor>; - /** - * Enable user liquidity operations for a specific subnet. This switches the - * subnet from V2 to V3 swap mode. Thereafter, adding new user liquidity can be disabled - * by toggling this flag to false, but the swap mode will remain V3 because of existing - * user liquidity until all users withdraw their liquidity. - * - * Only sudo or subnet owner can enable user liquidity. - * Only sudo can disable user liquidity. - */ - toggle_user_liquidity: TxDescriptor>; - /** - * Add liquidity to a specific price range for a subnet. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - tick_low: Lower bound of the price range - * - tick_high: Upper bound of the price range - * - liquidity: Amount of liquidity to add - * - * Emits `Event::LiquidityAdded` on success - */ - add_liquidity: TxDescriptor>; - /** - * Remove liquidity from a specific position. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - position_id: ID of the position to remove - * - * Emits `Event::LiquidityRemoved` on success - */ - remove_liquidity: TxDescriptor>; - /** - * Modify a liquidity position. - * - * Parameters: - * - origin: The origin of the transaction - * - netuid: Subnet ID - * - position_id: ID of the position to remove - * - liquidity_delta: Liquidity to add (if positive) or remove (if negative) - * - * Emits `Event::LiquidityRemoved` on success - */ - modify_position: TxDescriptor>; - /** - * Disable user liquidity in all subnets. - * - * Emits `Event::UserLiquidityToggled` on success - */ - disable_lp: TxDescriptor; - }; - Contracts: { - /** - * Deprecated version if [`Self::call`] for use in an in-storage `Call`. - */ - call_old_weight: TxDescriptor>; - /** - * Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`. - */ - instantiate_with_code_old_weight: TxDescriptor>; - /** - * Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`. - */ - instantiate_old_weight: TxDescriptor>; - /** - * Upload new `code` without instantiating a contract from it. - * - * If the code does not already exist a deposit is reserved from the caller - * and unreserved only when [`Self::remove_code`] is called. The size of the reserve - * depends on the size of the supplied `code`. - * - * If the code already exists in storage it will still return `Ok` and upgrades - * the in storage version to the current - * [`InstructionWeights::version`](InstructionWeights). - * - * - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then - * the only way to use this code is to delegate call into it from an offchain execution. - * Set to [`Determinism::Enforced`] if in doubt. - * - * # Note - * - * Anyone can instantiate a contract from any uploaded code and thus prevent its removal. - * To avoid this situation a constructor could employ access control so that it can - * only be instantiated by permissioned entities. The same is true when uploading - * through [`Self::instantiate_with_code`]. - * - * Use [`Determinism::Relaxed`] exclusively for non-deterministic code. If the uploaded - * code is deterministic, specifying [`Determinism::Relaxed`] will be disregarded and - * result in higher gas costs. - */ - upload_code: TxDescriptor>; - /** - * Remove the code stored under `code_hash` and refund the deposit to its owner. - * - * A code can only be removed by its original uploader (its owner) and only if it is - * not used by any contract. - */ - remove_code: TxDescriptor>; - /** - * Privileged function that changes the code of an existing contract. - * - * This takes care of updating refcounts and all other necessary operations. Returns - * an error if either the `code_hash` or `dest` do not exist. - * - * # Note - * - * This does **not** change the address of the contract in question. This means - * that the contract address is no longer derived from its code hash after calling - * this dispatchable. - */ - set_code: TxDescriptor>; - /** - * Makes a call to an account, optionally transferring some balance. - * - * # Parameters - * - * * `dest`: Address of the contract to call. - * * `value`: The balance to transfer from the `origin` to `dest`. - * * `gas_limit`: The gas limit enforced when executing the constructor. - * * `storage_deposit_limit`: The maximum amount of balance that can be charged from the - * caller to pay for the storage consumed. - * * `data`: The input data to pass to the contract. - * - * * If the account is a smart-contract account, the associated code will be - * executed and any value will be transferred. - * * If the account is a regular account, any value will be transferred. - * * If no account exists and the call value is not less than `existential_deposit`, - * a regular account will be created and any value will be transferred. - */ - call: TxDescriptor>; - /** - * Instantiates a new contract from the supplied `code` optionally transferring - * some balance. - * - * This dispatchable has the same effect as calling [`Self::upload_code`] + - * [`Self::instantiate`]. Bundling them together provides efficiency gains. Please - * also check the documentation of [`Self::upload_code`]. - * - * # Parameters - * - * * `value`: The balance to transfer from the `origin` to the newly created contract. - * * `gas_limit`: The gas limit enforced when executing the constructor. - * * `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved - * from the caller to pay for the storage consumed. - * * `code`: The contract code to deploy in raw bytes. - * * `data`: The input data to pass to the contract constructor. - * * `salt`: Used for the address derivation. See [`Pallet::contract_address`]. - * - * Instantiation is executed as follows: - * - * - The supplied `code` is deployed, and a `code_hash` is created for that code. - * - If the `code_hash` already exists on the chain the underlying `code` will be shared. - * - The destination address is computed based on the sender, code_hash and the salt. - * - The smart-contract account is created at the computed address. - * - The `value` is transferred to the new account. - * - The `deploy` function is executed in the context of the newly-created account. - */ - instantiate_with_code: TxDescriptor>; - /** - * Instantiates a contract from a previously deployed wasm binary. - * - * This function is identical to [`Self::instantiate_with_code`] but without the - * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary - * must be supplied. - */ - instantiate: TxDescriptor>; - /** - * When a migration is in progress, this dispatchable can be used to run migration steps. - * Calls that contribute to advancing the migration have their fees waived, as it's helpful - * for the chain. Note that while the migration is in progress, the pallet will also - * leverage the `on_idle` hooks to run migration steps. - */ - migrate: TxDescriptor>; - }; - MevShield: { - /** - * Announce the ML‑KEM public key that will become `CurrentKey` in - * the following block. - */ - announce_next_key: TxDescriptor>; - /** - * Users submit an encrypted wrapper. - * - * Client‑side: - * - * 1. Read `NextKey` (ML‑KEM public key bytes) from storage. - * 2. Sign your extrinsic so that it can be executed when added to the pool, - * i.e. you may need to increment the nonce if you submit using the same account. - * 3. `commitment = Hashing::hash(signed_extrinsic)`. - * 4. Encrypt: - * - * plaintext = signed_extrinsic - * - * with ML‑KEM‑768 + XChaCha20‑Poly1305, producing - * - * ciphertext = [u16 kem_len] || kem_ct || nonce24 || aead_ct - * - */ - submit_encrypted: TxDescriptor>; - /** - * Marks a submission as failed to decrypt and removes it from storage. - * - * Called by the block author when decryption fails at any stage (e.g., ML-KEM decapsulate - * failed, AEAD decrypt failed, invalid ciphertext format, etc.). This allows clients to be - * notified of decryption failures through on-chain events. - * - * # Arguments - * - * * `id` - The wrapper id (hash of (author, commitment, ciphertext)) - * * `reason` - Human-readable reason for the decryption failure (e.g., "ML-KEM decapsulate failed") - */ - mark_decryption_failed: TxDescriptor>; - }; -}; -type IEvent = { - System: { - /** - * An extrinsic completed successfully. - */ - ExtrinsicSuccess: PlainDescriptor>; - /** - * An extrinsic failed. - */ - ExtrinsicFailed: PlainDescriptor>; - /** - * `:code` was updated. - */ - CodeUpdated: PlainDescriptor; - /** - * A new account was created. - */ - NewAccount: PlainDescriptor>; - /** - * An account was reaped. - */ - KilledAccount: PlainDescriptor>; - /** - * On on-chain remark happened. - */ - Remarked: PlainDescriptor>; - /** - * An upgrade was authorized. - */ - UpgradeAuthorized: PlainDescriptor>; - /** - * An invalid authorized upgrade was rejected while trying to apply it. - */ - RejectedInvalidAuthorizedUpgrade: PlainDescriptor>; - }; - Grandpa: { - /** - * New authority set has been applied. - */ - NewAuthorities: PlainDescriptor>; - /** - * Current authority set has been paused. - */ - Paused: PlainDescriptor; - /** - * Current authority set has been resumed. - */ - Resumed: PlainDescriptor; - }; - Balances: { - /** - * An account was created with some free balance. - */ - Endowed: PlainDescriptor>; - /** - * An account was removed whose balance was non-zero but below ExistentialDeposit, - * resulting in an outright loss. - */ - DustLost: PlainDescriptor>; - /** - * Transfer succeeded. - */ - Transfer: PlainDescriptor>; - /** - * A balance was set by root. - */ - BalanceSet: PlainDescriptor>; - /** - * Some balance was reserved (moved from free to reserved). - */ - Reserved: PlainDescriptor>; - /** - * Some balance was unreserved (moved from reserved to free). - */ - Unreserved: PlainDescriptor>; - /** - * Some balance was moved from the reserve of the first account to the second account. - * Final argument indicates the destination balance type. - */ - ReserveRepatriated: PlainDescriptor>; - /** - * Some amount was deposited (e.g. for transaction fees). - */ - Deposit: PlainDescriptor>; - /** - * Some amount was withdrawn from the account (e.g. for transaction fees). - */ - Withdraw: PlainDescriptor>; - /** - * Some amount was removed from the account (e.g. for misbehavior). - */ - Slashed: PlainDescriptor>; - /** - * Some amount was minted into an account. - */ - Minted: PlainDescriptor>; - /** - * Some amount was burned from an account. - */ - Burned: PlainDescriptor>; - /** - * Some amount was suspended from an account (it can be restored later). - */ - Suspended: PlainDescriptor>; - /** - * Some amount was restored into an account. - */ - Restored: PlainDescriptor>; - /** - * An account was upgraded. - */ - Upgraded: PlainDescriptor>; - /** - * Total issuance was increased by `amount`, creating a credit to be balanced. - */ - Issued: PlainDescriptor>; - /** - * Total issuance was decreased by `amount`, creating a debt to be balanced. - */ - Rescinded: PlainDescriptor>; - /** - * Some balance was locked. - */ - Locked: PlainDescriptor>; - /** - * Some balance was unlocked. - */ - Unlocked: PlainDescriptor>; - /** - * Some balance was frozen. - */ - Frozen: PlainDescriptor>; - /** - * Some balance was thawed. - */ - Thawed: PlainDescriptor>; - /** - * The `TotalIssuance` was forcefully changed. - */ - TotalIssuanceForced: PlainDescriptor>; - }; - TransactionPayment: { - /** - * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, - * has been paid by `who`. - */ - TransactionFeePaid: PlainDescriptor>; - }; - SubtensorModule: { - /** - * a new network is added. - */ - NetworkAdded: PlainDescriptor>; - /** - * a network is removed. - */ - NetworkRemoved: PlainDescriptor; - /** - * stake has been transferred from the a coldkey account onto the hotkey staking account. - */ - StakeAdded: PlainDescriptor>; - /** - * stake has been removed from the hotkey staking account onto the coldkey account. - */ - StakeRemoved: PlainDescriptor>; - /** - * stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO). - */ - StakeMoved: PlainDescriptor>; - /** - * a caller successfully sets their weights on a subnetwork. - */ - WeightsSet: PlainDescriptor>; - /** - * a new neuron account has been registered to the chain. - */ - NeuronRegistered: PlainDescriptor>; - /** - * multiple uids have been concurrently registered. - */ - BulkNeuronsRegistered: PlainDescriptor>; - /** - * FIXME: Not used yet - */ - BulkBalancesSet: PlainDescriptor>; - /** - * max allowed uids has been set for a subnetwork. - */ - MaxAllowedUidsSet: PlainDescriptor>; - /** - * DEPRECATED: max weight limit updates are no longer supported. - */ - MaxWeightLimitSet: PlainDescriptor>; - /** - * the difficulty has been set for a subnet. - */ - DifficultySet: PlainDescriptor>; - /** - * the adjustment interval is set for a subnet. - */ - AdjustmentIntervalSet: PlainDescriptor>; - /** - * registration per interval is set for a subnet. - */ - RegistrationPerIntervalSet: PlainDescriptor>; - /** - * we set max registrations per block. - */ - MaxRegistrationsPerBlockSet: PlainDescriptor>; - /** - * an activity cutoff is set for a subnet. - */ - ActivityCutoffSet: PlainDescriptor>; - /** - * Rho value is set. - */ - RhoSet: PlainDescriptor>; - /** - * steepness of the sigmoid used to compute alpha values. - */ - AlphaSigmoidSteepnessSet: PlainDescriptor>; - /** - * Kappa is set for a subnet. - */ - KappaSet: PlainDescriptor>; - /** - * minimum allowed weight is set for a subnet. - */ - MinAllowedWeightSet: PlainDescriptor>; - /** - * the validator pruning length has been set. - */ - ValidatorPruneLenSet: PlainDescriptor>; - /** - * the scaling law power has been set for a subnet. - */ - ScalingLawPowerSet: PlainDescriptor>; - /** - * weights set rate limit has been set for a subnet. - */ - WeightsSetRateLimitSet: PlainDescriptor>; - /** - * immunity period is set for a subnet. - */ - ImmunityPeriodSet: PlainDescriptor>; - /** - * bonds moving average is set for a subnet. - */ - BondsMovingAverageSet: PlainDescriptor>; - /** - * bonds penalty is set for a subnet. - */ - BondsPenaltySet: PlainDescriptor>; - /** - * bonds reset is set for a subnet. - */ - BondsResetOnSet: PlainDescriptor>; - /** - * setting the max number of allowed validators on a subnet. - */ - MaxAllowedValidatorsSet: PlainDescriptor>; - /** - * the axon server information is added to the network. - */ - AxonServed: PlainDescriptor>; - /** - * the prometheus server information is added to the network. - */ - PrometheusServed: PlainDescriptor>; - /** - * a hotkey has become a delegate. - */ - DelegateAdded: PlainDescriptor>; - /** - * the default take is set. - */ - DefaultTakeSet: PlainDescriptor; - /** - * weights version key is set for a network. - */ - WeightsVersionKeySet: PlainDescriptor>; - /** - * setting min difficulty on a network. - */ - MinDifficultySet: PlainDescriptor>; - /** - * setting max difficulty on a network. - */ - MaxDifficultySet: PlainDescriptor>; - /** - * setting the prometheus serving rate limit. - */ - ServingRateLimitSet: PlainDescriptor>; - /** - * setting burn on a network. - */ - BurnSet: PlainDescriptor>; - /** - * setting max burn on a network. - */ - MaxBurnSet: PlainDescriptor>; - /** - * setting min burn on a network. - */ - MinBurnSet: PlainDescriptor>; - /** - * setting the transaction rate limit. - */ - TxRateLimitSet: PlainDescriptor; - /** - * setting the delegate take transaction rate limit. - */ - TxDelegateTakeRateLimitSet: PlainDescriptor; - /** - * setting the childkey take transaction rate limit. - */ - TxChildKeyTakeRateLimitSet: PlainDescriptor; - /** - * setting the admin freeze window length (last N blocks of tempo) - */ - AdminFreezeWindowSet: PlainDescriptor; - /** - * setting the owner hyperparameter rate limit in epochs - */ - OwnerHyperparamRateLimitSet: PlainDescriptor; - /** - * minimum childkey take set - */ - MinChildKeyTakeSet: PlainDescriptor; - /** - * maximum childkey take set - */ - MaxChildKeyTakeSet: PlainDescriptor; - /** - * childkey take set - */ - ChildKeyTakeSet: PlainDescriptor>; - /** - * a sudo call is done. - */ - Sudid: PlainDescriptor>; - /** - * registration is allowed/disallowed for a subnet. - */ - RegistrationAllowed: PlainDescriptor>; - /** - * POW registration is allowed/disallowed for a subnet. - */ - PowRegistrationAllowed: PlainDescriptor>; - /** - * setting tempo on a network - */ - TempoSet: PlainDescriptor>; - /** - * setting the RAO recycled for registration. - */ - RAORecycledForRegistrationSet: PlainDescriptor>; - /** - * min stake is set for validators to set weights. - */ - StakeThresholdSet: PlainDescriptor; - /** - * setting the adjustment alpha on a subnet. - */ - AdjustmentAlphaSet: PlainDescriptor>; - /** - * the faucet it called on the test net. - */ - Faucet: PlainDescriptor>; - /** - * the subnet owner cut is set. - */ - SubnetOwnerCutSet: PlainDescriptor; - /** - * the network creation rate limit is set. - */ - NetworkRateLimitSet: PlainDescriptor; - /** - * the network immunity period is set. - */ - NetworkImmunityPeriodSet: PlainDescriptor; - /** - * the start call delay is set. - */ - StartCallDelaySet: PlainDescriptor; - /** - * the network minimum locking cost is set. - */ - NetworkMinLockCostSet: PlainDescriptor; - /** - * the maximum number of subnets is set - */ - SubnetLimitSet: PlainDescriptor; - /** - * the lock cost reduction is set - */ - NetworkLockCostReductionIntervalSet: PlainDescriptor; - /** - * the take for a delegate is decreased. - */ - TakeDecreased: PlainDescriptor>; - /** - * the take for a delegate is increased. - */ - TakeIncreased: PlainDescriptor>; - /** - * the hotkey is swapped - */ - HotkeySwapped: PlainDescriptor>; - /** - * maximum delegate take is set by sudo/admin transaction - */ - MaxDelegateTakeSet: PlainDescriptor; - /** - * minimum delegate take is set by sudo/admin transaction - */ - MinDelegateTakeSet: PlainDescriptor; - /** - * A coldkey swap announcement has been made. - */ - ColdkeySwapAnnounced: PlainDescriptor>; - /** - * A coldkey swap has been reset. - */ - ColdkeySwapReset: PlainDescriptor>; - /** - * A coldkey has been swapped. - */ - ColdkeySwapped: PlainDescriptor>; - /** - * A coldkey swap has been disputed. - */ - ColdkeySwapDisputed: PlainDescriptor>; - /** - * All balance of a hotkey has been unstaked and transferred to a new coldkey - */ - AllBalanceUnstakedAndTransferredToNewColdkey: PlainDescriptor>; - /** - * The arbitration period has been extended - */ - ArbitrationPeriodExtended: PlainDescriptor>; - /** - * Setting of children of a hotkey have been scheduled - */ - SetChildrenScheduled: PlainDescriptor>; - /** - * The children of a hotkey have been set - */ - SetChildren: PlainDescriptor>; - /** - * The identity of a coldkey has been set - */ - ChainIdentitySet: PlainDescriptor; - /** - * The identity of a subnet has been set - */ - SubnetIdentitySet: PlainDescriptor; - /** - * The identity of a subnet has been removed - */ - SubnetIdentityRemoved: PlainDescriptor; - /** - * A dissolve network extrinsic scheduled. - */ - DissolveNetworkScheduled: PlainDescriptor>; - /** - * The coldkey swap announcement delay has been set. - */ - ColdkeySwapAnnouncementDelaySet: PlainDescriptor; - /** - * The coldkey swap reannouncement delay has been set. - */ - ColdkeySwapReannouncementDelaySet: PlainDescriptor; - /** - * The duration of dissolve network has been set - */ - DissolveNetworkScheduleDurationSet: PlainDescriptor; - /** - * Commit-reveal v3 weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - */ - CRV3WeightsCommitted: PlainDescriptor>; - /** - * Weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - */ - WeightsCommitted: PlainDescriptor>; - /** - * Weights have been successfully revealed. - * - * - **who**: The account ID of the user revealing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash of the revealed weights. - */ - WeightsRevealed: PlainDescriptor>; - /** - * Weights have been successfully batch revealed. - * - * - **who**: The account ID of the user revealing the weights. - * - **netuid**: The network identifier. - * - **revealed_hashes**: A vector of hashes representing each revealed weight set. - */ - WeightsBatchRevealed: PlainDescriptor>; - /** - * A batch of weights (or commits) have been force-set. - * - * - **netuids**: The netuids these weights were successfully set/committed for. - * - **who**: The hotkey that set this batch. - */ - BatchWeightsCompleted: PlainDescriptor>; - /** - * A batch extrinsic completed but with some errors. - */ - BatchCompletedWithErrors: PlainDescriptor; - /** - * A weight set among a batch of weights failed. - * - * - **error**: The dispatch error emitted by the failed item. - */ - BatchWeightItemFailed: PlainDescriptor>; - /** - * Stake has been transferred from one coldkey to another on the same subnet. - * Parameters: - * (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount) - */ - StakeTransferred: PlainDescriptor>; - /** - * Stake has been swapped from one subnet to another for the same coldkey-hotkey pair. - * - * Parameters: - * (coldkey, hotkey, origin_netuid, destination_netuid, amount) - */ - StakeSwapped: PlainDescriptor>; - /** - * Event called when transfer is toggled on a subnet. - * - * Parameters: - * (netuid, bool) - */ - TransferToggle: PlainDescriptor>; - /** - * The owner hotkey for a subnet has been set. - * - * Parameters: - * (netuid, new_hotkey) - */ - SubnetOwnerHotkeySet: PlainDescriptor>; - /** - * FirstEmissionBlockNumber is set via start call extrinsic - * - * Parameters: - * netuid - * block number - */ - FirstEmissionBlockNumberSet: PlainDescriptor>; - /** - * Alpha has been recycled, reducing AlphaOut on a subnet. - * - * Parameters: - * (coldkey, hotkey, amount, subnet_id) - */ - AlphaRecycled: PlainDescriptor>; - /** - * Alpha have been burned without reducing AlphaOut. - * - * Parameters: - * (coldkey, hotkey, amount, subnet_id) - */ - AlphaBurned: PlainDescriptor>; - /** - * An EVM key has been associated with a hotkey. - */ - EvmKeyAssociated: PlainDescriptor>; - /** - * CRV3 Weights have been successfully revealed. - * - * - **netuid**: The network identifier. - * - **who**: The account ID of the user revealing the weights. - */ - CRV3WeightsRevealed: PlainDescriptor>; - /** - * Commit-Reveal periods has been successfully set. - * - * - **netuid**: The network identifier. - * - **periods**: The number of epochs before the reveal. - */ - CommitRevealPeriodsSet: PlainDescriptor>; - /** - * Commit-Reveal has been successfully toggled. - * - * - **netuid**: The network identifier. - * - **Enabled**: Is Commit-Reveal enabled. - */ - CommitRevealEnabled: PlainDescriptor>; - /** - * the hotkey is swapped - */ - HotkeySwappedOnSubnet: PlainDescriptor>; - /** - * A subnet lease has been created. - */ - SubnetLeaseCreated: PlainDescriptor>; - /** - * A subnet lease has been terminated. - */ - SubnetLeaseTerminated: PlainDescriptor>; - /** - * The symbol for a subnet has been updated. - */ - SymbolUpdated: PlainDescriptor>; - /** - * Commit Reveal Weights version has been updated. - * - * - **version**: The required version. - */ - CommitRevealVersionSet: PlainDescriptor; - /** - * Timelocked weights have been successfully committed. - * - * - **who**: The account ID of the user committing the weights. - * - **netuid**: The network identifier. - * - **commit_hash**: The hash representing the committed weights. - * - **reveal_round**: The round at which weights can be revealed. - */ - TimelockedWeightsCommitted: PlainDescriptor>; - /** - * Timelocked Weights have been successfully revealed. - * - * - **netuid**: The network identifier. - * - **who**: The account ID of the user revealing the weights. - */ - TimelockedWeightsRevealed: PlainDescriptor>; - /** - * Auto-staking hotkey received stake - */ - AutoStakeAdded: PlainDescriptor>; - /** - * End-of-epoch miner incentive alpha by UID - */ - IncentiveAlphaEmittedToMiners: PlainDescriptor>; - /** - * The minimum allowed UIDs for a subnet have been set. - */ - MinAllowedUidsSet: PlainDescriptor>; - /** - * The auto stake destination has been set. - * - * - **coldkey**: The account ID of the coldkey. - * - **netuid**: The network identifier. - * - **hotkey**: The account ID of the hotkey. - */ - AutoStakeDestinationSet: PlainDescriptor>; - /** - * The minimum allowed non-Immune UIDs has been set. - */ - MinNonImmuneUidsSet: PlainDescriptor>; - /** - * Root emissions have been claimed for a coldkey on all subnets and hotkeys. - * Parameters: - * (coldkey) - */ - RootClaimed: PlainDescriptor>; - /** - * Root claim type for a coldkey has been set. - * Parameters: - * (coldkey, u8) - */ - RootClaimTypeSet: PlainDescriptor>; - /** - * Voting power tracking has been enabled for a subnet. - */ - VotingPowerTrackingEnabled: PlainDescriptor>; - /** - * Voting power tracking has been scheduled for disabling. - * Tracking will continue until disable_at_block, then stop and clear entries. - */ - VotingPowerTrackingDisableScheduled: PlainDescriptor>; - /** - * Voting power tracking has been fully disabled and entries cleared. - */ - VotingPowerTrackingDisabled: PlainDescriptor>; - /** - * Voting power EMA alpha has been set for a subnet. - */ - VotingPowerEmaAlphaSet: PlainDescriptor>; - /** - * Subnet lease dividends have been distributed. - */ - SubnetLeaseDividendsDistributed: PlainDescriptor>; - /** - * "Add stake and burn" event: alpha token was purchased and burned. - */ - AddStakeBurn: PlainDescriptor>; - }; - Utility: { - /** - * Batch of dispatches did not complete fully. Index of first failing dispatch given, as - * well as the error. - */ - BatchInterrupted: PlainDescriptor>; - /** - * Batch of dispatches completed fully with no error. - */ - BatchCompleted: PlainDescriptor; - /** - * Batch of dispatches completed but has errors. - */ - BatchCompletedWithErrors: PlainDescriptor; - /** - * A single item within a Batch of dispatches has completed with no error. - */ - ItemCompleted: PlainDescriptor; - /** - * A single item within a Batch of dispatches has completed with error. - */ - ItemFailed: PlainDescriptor>; - /** - * A call was dispatched. - */ - DispatchedAs: PlainDescriptor>; - /** - * Main call was dispatched. - */ - IfElseMainSuccess: PlainDescriptor; - /** - * The fallback call was dispatched. - */ - IfElseFallbackCalled: PlainDescriptor>; - }; - Sudo: { - /** - * A sudo call just took place. - */ - Sudid: PlainDescriptor>; - /** - * The sudo key has been updated. - */ - KeyChanged: PlainDescriptor>; - /** - * The key was permanently removed. - */ - KeyRemoved: PlainDescriptor; - /** - * A [sudo_as](Pallet::sudo_as) call just took place. - */ - SudoAsDone: PlainDescriptor>; - }; - Multisig: { - /** - * A new multisig operation has begun. - */ - NewMultisig: PlainDescriptor>; - /** - * A multisig operation has been approved by someone. - */ - MultisigApproval: PlainDescriptor>; - /** - * A multisig operation has been executed. - */ - MultisigExecuted: PlainDescriptor>; - /** - * A multisig operation has been cancelled. - */ - MultisigCancelled: PlainDescriptor>; - /** - * The deposit for a multisig operation has been updated/poked. - */ - DepositPoked: PlainDescriptor>; - }; - Preimage: { - /** - * A preimage has been noted. - */ - Noted: PlainDescriptor>; - /** - * A preimage has been requested. - */ - Requested: PlainDescriptor>; - /** - * A preimage has ben cleared. - */ - Cleared: PlainDescriptor>; - }; - Scheduler: { - /** - * Scheduled some task. - */ - Scheduled: PlainDescriptor>; - /** - * Canceled some task. - */ - Canceled: PlainDescriptor>; - /** - * Dispatched some task. - */ - Dispatched: PlainDescriptor>; - /** - * Set a retry configuration for some task. - */ - RetrySet: PlainDescriptor>; - /** - * Cancel a retry configuration for some task. - */ - RetryCancelled: PlainDescriptor>; - /** - * The call for the provided hash was not found so the task has been aborted. - */ - CallUnavailable: PlainDescriptor>; - /** - * The given task was unable to be renewed since the agenda is full at that block. - */ - PeriodicFailed: PlainDescriptor>; - /** - * The given task was unable to be retried since the agenda is full at that block or there - * was not enough weight to reschedule it. - */ - RetryFailed: PlainDescriptor>; - /** - * The given task can never be executed since it is overweight. - */ - PermanentlyOverweight: PlainDescriptor>; - /** - * Agenda is incomplete from `when`. - */ - AgendaIncomplete: PlainDescriptor>; - }; - Proxy: { - /** - * A proxy was executed correctly, with the given. - */ - ProxyExecuted: PlainDescriptor>; - /** - * A pure account has been created by new proxy with given - * disambiguation index and proxy type. - */ - PureCreated: PlainDescriptor>; - /** - * A pure proxy was killed by its spawner. - */ - PureKilled: PlainDescriptor>; - /** - * An announcement was placed to make a call in the future. - */ - Announced: PlainDescriptor>; - /** - * A proxy was added. - */ - ProxyAdded: PlainDescriptor>; - /** - * A proxy was removed. - */ - ProxyRemoved: PlainDescriptor>; - /** - * A deposit stored for proxies or announcements was poked / updated. - */ - DepositPoked: PlainDescriptor>; - }; - Registry: { - /** - * Emitted when a user registers an identity - */ - IdentitySet: PlainDescriptor>; - /** - * Emitted when a user dissolves an identity - */ - IdentityDissolved: PlainDescriptor>; - }; - Commitments: { - /** - * A commitment was set - */ - Commitment: PlainDescriptor>; - /** - * A timelock-encrypted commitment was set - */ - TimelockCommitment: PlainDescriptor>; - /** - * A timelock-encrypted commitment was auto-revealed - */ - CommitmentRevealed: PlainDescriptor>; - }; - AdminUtils: { - /** - * Event emitted when a precompile operation is updated. - */ - PrecompileUpdated: PlainDescriptor>; - /** - * Event emitted when the Yuma3 enable is toggled. - */ - Yuma3EnableToggled: PlainDescriptor>; - /** - * Event emitted when Bonds Reset is toggled. - */ - BondsResetToggled: PlainDescriptor>; - }; - SafeMode: { - /** - * The safe-mode was entered until inclusively this block. - */ - Entered: PlainDescriptor>; - /** - * The safe-mode was extended until inclusively this block. - */ - Extended: PlainDescriptor>; - /** - * Exited the safe-mode for a specific reason. - */ - Exited: PlainDescriptor>; - /** - * An account reserved funds for either entering or extending the safe-mode. - */ - DepositPlaced: PlainDescriptor>; - /** - * An account had a reserve released that was reserved. - */ - DepositReleased: PlainDescriptor>; - /** - * An account had reserve slashed that was reserved. - */ - DepositSlashed: PlainDescriptor>; - /** - * Could not hold funds for entering or extending the safe-mode. - * - * This error comes from the underlying `Currency`. - */ - CannotDeposit: PlainDescriptor; - /** - * Could not release funds for entering or extending the safe-mode. - * - * This error comes from the underlying `Currency`. - */ - CannotRelease: PlainDescriptor; - }; - Ethereum: { - /** - * An ethereum transaction was successfully executed. - */ - Executed: PlainDescriptor>; - }; - EVM: { - /** - * Ethereum events from contracts. - */ - Log: PlainDescriptor>; - /** - * A contract has been created at given address. - */ - Created: PlainDescriptor>; - /** - * A contract was attempted to be created, but the execution failed. - */ - CreatedFailed: PlainDescriptor>; - /** - * A contract has been executed successfully with states applied. - */ - Executed: PlainDescriptor>; - /** - * A contract has been executed with errors. States are reverted with only gas fees applied. - */ - ExecutedFailed: PlainDescriptor>; - }; - BaseFee: { - /** - - */ - NewBaseFeePerGas: PlainDescriptor>; - /** - - */ - BaseFeeOverflow: PlainDescriptor; - /** - - */ - NewElasticity: PlainDescriptor>; - }; - Drand: { - /** - * Beacon Configuration has changed. - */ - BeaconConfigChanged: PlainDescriptor; - /** - * Successfully set a new pulse(s). - */ - NewPulse: PlainDescriptor>; - /** - * Oldest Stored Round has been set. - */ - SetOldestStoredRound: PlainDescriptor; - }; - Crowdloan: { - /** - * A crowdloan was created. - */ - Created: PlainDescriptor>; - /** - * A contribution was made to an active crowdloan. - */ - Contributed: PlainDescriptor>; - /** - * A contribution was withdrawn from a failed crowdloan. - */ - Withdrew: PlainDescriptor>; - /** - * A refund was partially processed for a failed crowdloan. - */ - PartiallyRefunded: PlainDescriptor>; - /** - * A refund was fully processed for a failed crowdloan. - */ - AllRefunded: PlainDescriptor>; - /** - * A crowdloan was finalized, funds were transferred and the call was dispatched. - */ - Finalized: PlainDescriptor>; - /** - * A crowdloan was dissolved. - */ - Dissolved: PlainDescriptor>; - /** - * The minimum contribution was updated. - */ - MinContributionUpdated: PlainDescriptor>; - /** - * The end was updated. - */ - EndUpdated: PlainDescriptor>; - /** - * The cap was updated. - */ - CapUpdated: PlainDescriptor>; - }; - Swap: { - /** - * Event emitted when the fee rate has been updated for a subnet - */ - FeeRateSet: PlainDescriptor>; - /** - * Event emitted when user liquidity operations are enabled for a subnet. - * First enable even indicates a switch from V2 to V3 swap. - */ - UserLiquidityToggled: PlainDescriptor>; - /** - * Event emitted when a liquidity position is added to a subnet's liquidity pool. - */ - LiquidityAdded: PlainDescriptor>; - /** - * Event emitted when a liquidity position is removed from a subnet's liquidity pool. - */ - LiquidityRemoved: PlainDescriptor>; - /** - * Event emitted when a liquidity position is modified in a subnet's liquidity pool. - * Modifying causes the fees to be claimed. - */ - LiquidityModified: PlainDescriptor>; - }; - Contracts: { - /** - * Contract deployed by address at the specified address. - */ - Instantiated: PlainDescriptor>; - /** - * Contract has been removed. - * - * # Note - * - * The only way for a contract to be removed and emitting this event is by calling - * `seal_terminate`. - */ - Terminated: PlainDescriptor>; - /** - * Code with the specified hash has been stored. - */ - CodeStored: PlainDescriptor>; - /** - * A custom event emitted by the contract. - */ - ContractEmitted: PlainDescriptor>; - /** - * A code with the specified hash was removed. - */ - CodeRemoved: PlainDescriptor>; - /** - * A contract's code was updated. - */ - ContractCodeUpdated: PlainDescriptor>; - /** - * A contract was called either by a plain account or another contract. - * - * # Note - * - * Please keep in mind that like all events this is only emitted for successful - * calls. This is because on failure all storage changes including events are - * rolled back. - */ - Called: PlainDescriptor>; - /** - * A contract delegate called a code hash. - * - * # Note - * - * Please keep in mind that like all events this is only emitted for successful - * calls. This is because on failure all storage changes including events are - * rolled back. - */ - DelegateCalled: PlainDescriptor>; - /** - * Some funds have been transferred and held as storage deposit. - */ - StorageDepositTransferredAndHeld: PlainDescriptor>; - /** - * Some storage deposit funds have been transferred and released. - */ - StorageDepositTransferredAndReleased: PlainDescriptor>; - }; - MevShield: { - /** - * Encrypted wrapper accepted. - */ - EncryptedSubmitted: PlainDescriptor>; - /** - * Decrypted call executed. - */ - DecryptedExecuted: PlainDescriptor>; - /** - * Decrypted execution rejected. - */ - DecryptedRejected: PlainDescriptor>; - /** - * Decryption failed - validator could not decrypt the submission. - */ - DecryptionFailed: PlainDescriptor>; - }; -}; -type IError = { - System: { - /** - * The name of specification does not match between the current runtime - * and the new runtime. - */ - InvalidSpecName: PlainDescriptor; - /** - * The specification version is not allowed to decrease between the current runtime - * and the new runtime. - */ - SpecVersionNeedsToIncrease: PlainDescriptor; - /** - * Failed to extract the runtime version from the new runtime. - * - * Either calling `Core_version` or decoding `RuntimeVersion` failed. - */ - FailedToExtractRuntimeVersion: PlainDescriptor; - /** - * Suicide called when the account has non-default composite data. - */ - NonDefaultComposite: PlainDescriptor; - /** - * There is a non-zero reference count preventing the account from being purged. - */ - NonZeroRefCount: PlainDescriptor; - /** - * The origin filter prevent the call to be dispatched. - */ - CallFiltered: PlainDescriptor; - /** - * A multi-block migration is ongoing and prevents the current code from being replaced. - */ - MultiBlockMigrationsOngoing: PlainDescriptor; - /** - * No upgrade authorized. - */ - NothingAuthorized: PlainDescriptor; - /** - * The submitted code is not authorized. - */ - Unauthorized: PlainDescriptor; - }; - Grandpa: { - /** - * Attempt to signal GRANDPA pause when the authority set isn't live - * (either paused or already pending pause). - */ - PauseFailed: PlainDescriptor; - /** - * Attempt to signal GRANDPA resume when the authority set isn't paused - * (either live or already pending resume). - */ - ResumeFailed: PlainDescriptor; - /** - * Attempt to signal GRANDPA change with one already pending. - */ - ChangePending: PlainDescriptor; - /** - * Cannot signal forced change so soon after last. - */ - TooSoon: PlainDescriptor; - /** - * A key ownership proof provided as part of an equivocation report is invalid. - */ - InvalidKeyOwnershipProof: PlainDescriptor; - /** - * An equivocation proof provided as part of an equivocation report is invalid. - */ - InvalidEquivocationProof: PlainDescriptor; - /** - * A given equivocation report is valid but already previously reported. - */ - DuplicateOffenceReport: PlainDescriptor; - }; - Balances: { - /** - * Vesting balance too high to send value. - */ - VestingBalance: PlainDescriptor; - /** - * Account liquidity restrictions prevent withdrawal. - */ - LiquidityRestrictions: PlainDescriptor; - /** - * Balance too low to send value. - */ - InsufficientBalance: PlainDescriptor; - /** - * Value too low to create account due to existential deposit. - */ - ExistentialDeposit: PlainDescriptor; - /** - * Transfer/payment would kill account. - */ - Expendability: PlainDescriptor; - /** - * A vesting schedule already exists for this account. - */ - ExistingVestingSchedule: PlainDescriptor; - /** - * Beneficiary account must pre-exist. - */ - DeadAccount: PlainDescriptor; - /** - * Number of named reserves exceed `MaxReserves`. - */ - TooManyReserves: PlainDescriptor; - /** - * Number of holds exceed `VariantCountOf`. - */ - TooManyHolds: PlainDescriptor; - /** - * Number of freezes exceed `MaxFreezes`. - */ - TooManyFreezes: PlainDescriptor; - /** - * The issuance cannot be modified since it is already deactivated. - */ - IssuanceDeactivated: PlainDescriptor; - /** - * The delta cannot be zero. - */ - DeltaZero: PlainDescriptor; - }; - SubtensorModule: { - /** - * The root network does not exist. - */ - RootNetworkDoesNotExist: PlainDescriptor; - /** - * The user is trying to serve an axon which is not of type 4 (IPv4) or 6 (IPv6). - */ - InvalidIpType: PlainDescriptor; - /** - * An invalid IP address is passed to the serve function. - */ - InvalidIpAddress: PlainDescriptor; - /** - * An invalid port is passed to the serve function. - */ - InvalidPort: PlainDescriptor; - /** - * The hotkey is not registered in subnet - */ - HotKeyNotRegisteredInSubNet: PlainDescriptor; - /** - * The hotkey does not exists - */ - HotKeyAccountNotExists: PlainDescriptor; - /** - * The hotkey is not registered in any subnet. - */ - HotKeyNotRegisteredInNetwork: PlainDescriptor; - /** - * Request to stake, unstake or subscribe is made by a coldkey that is not associated with - * the hotkey account. - */ - NonAssociatedColdKey: PlainDescriptor; - /** - * DEPRECATED: Stake amount to withdraw is zero. - * The caller does not have enought stake to perform this action. - */ - NotEnoughStake: PlainDescriptor; - /** - * The caller is requesting removing more stake than there exists in the staking account. - * See: "[remove_stake()]". - */ - NotEnoughStakeToWithdraw: PlainDescriptor; - /** - * The caller is requesting to set weights but the caller has less than minimum stake - * required to set weights (less than WeightsMinStake). - */ - NotEnoughStakeToSetWeights: PlainDescriptor; - /** - * The parent hotkey doesn't have enough own stake to set childkeys. - */ - NotEnoughStakeToSetChildkeys: PlainDescriptor; - /** - * The caller is requesting adding more stake than there exists in the coldkey account. - * See: "[add_stake()]" - */ - NotEnoughBalanceToStake: PlainDescriptor; - /** - * The caller is trying to add stake, but for some reason the requested amount could not be - * withdrawn from the coldkey account. - */ - BalanceWithdrawalError: PlainDescriptor; - /** - * Unsuccessfully withdraw, balance could be zero (can not make account exist) after - * withdrawal. - */ - ZeroBalanceAfterWithdrawn: PlainDescriptor; - /** - * The caller is attempting to set non-self weights without being a permitted validator. - */ - NeuronNoValidatorPermit: PlainDescriptor; - /** - * The caller is attempting to set the weight keys and values but these vectors have - * different size. - */ - WeightVecNotEqualSize: PlainDescriptor; - /** - * The caller is attempting to set weights with duplicate UIDs in the weight matrix. - */ - DuplicateUids: PlainDescriptor; - /** - * The caller is attempting to set weight to at least one UID that does not exist in the - * metagraph. - */ - UidVecContainInvalidOne: PlainDescriptor; - /** - * The dispatch is attempting to set weights on chain with fewer elements than are allowed. - */ - WeightVecLengthIsLow: PlainDescriptor; - /** - * Number of registrations in this block exceeds the allowed number (i.e., exceeds the - * subnet hyperparameter "max_regs_per_block"). - */ - TooManyRegistrationsThisBlock: PlainDescriptor; - /** - * The caller is requesting registering a neuron which already exists in the active set. - */ - HotKeyAlreadyRegisteredInSubNet: PlainDescriptor; - /** - * The new hotkey is the same as old one - */ - NewHotKeyIsSameWithOld: PlainDescriptor; - /** - * The supplied PoW hash block is in the future or negative. - */ - InvalidWorkBlock: PlainDescriptor; - /** - * The supplied PoW hash block does not meet the network difficulty. - */ - InvalidDifficulty: PlainDescriptor; - /** - * The supplied PoW hash seal does not match the supplied work. - */ - InvalidSeal: PlainDescriptor; - /** - * The dispatch is attempting to set weights on chain with weight value exceeding the - * configured max weight limit (currently `u16::MAX`). - */ - MaxWeightExceeded: PlainDescriptor; - /** - * The hotkey is attempting to become a delegate when the hotkey is already a delegate. - */ - HotKeyAlreadyDelegate: PlainDescriptor; - /** - * A transactor exceeded the rate limit for setting weights. - */ - SettingWeightsTooFast: PlainDescriptor; - /** - * A validator is attempting to set weights from a validator with incorrect weight version. - */ - IncorrectWeightVersionKey: PlainDescriptor; - /** - * An axon or prometheus serving exceeded the rate limit for a registered neuron. - */ - ServingRateLimitExceeded: PlainDescriptor; - /** - * The caller is attempting to set weights with more UIDs than allowed. - */ - UidsLengthExceedUidsInSubNet: PlainDescriptor; - /** - * A transactor exceeded the rate limit for add network transaction. - */ - NetworkTxRateLimitExceeded: PlainDescriptor; - /** - * A transactor exceeded the rate limit for delegate transaction. - */ - DelegateTxRateLimitExceeded: PlainDescriptor; - /** - * A transactor exceeded the rate limit for setting or swapping hotkey. - */ - HotKeySetTxRateLimitExceeded: PlainDescriptor; - /** - * A transactor exceeded the rate limit for staking. - */ - StakingRateLimitExceeded: PlainDescriptor; - /** - * Registration is disabled. - */ - SubNetRegistrationDisabled: PlainDescriptor; - /** - * The number of registration attempts exceeded the allowed number in the interval. - */ - TooManyRegistrationsThisInterval: PlainDescriptor; - /** - * The hotkey is required to be the origin. - */ - TransactorAccountShouldBeHotKey: PlainDescriptor; - /** - * Faucet is disabled. - */ - FaucetDisabled: PlainDescriptor; - /** - * Not a subnet owner. - */ - NotSubnetOwner: PlainDescriptor; - /** - * Operation is not permitted on the root subnet. - */ - RegistrationNotPermittedOnRootSubnet: PlainDescriptor; - /** - * A hotkey with too little stake is attempting to join the root subnet. - */ - StakeTooLowForRoot: PlainDescriptor; - /** - * All subnets are in the immunity period. - */ - AllNetworksInImmunity: PlainDescriptor; - /** - * Not enough balance to pay swapping hotkey. - */ - NotEnoughBalanceToPaySwapHotKey: PlainDescriptor; - /** - * Netuid does not match for setting root network weights. - */ - NotRootSubnet: PlainDescriptor; - /** - * Can not set weights for the root network. - */ - CanNotSetRootNetworkWeights: PlainDescriptor; - /** - * No neuron ID is available. - */ - NoNeuronIdAvailable: PlainDescriptor; - /** - * Delegate take is too low. - */ - DelegateTakeTooLow: PlainDescriptor; - /** - * Delegate take is too high. - */ - DelegateTakeTooHigh: PlainDescriptor; - /** - * No commit found for the provided hotkey+netuid combination when attempting to reveal the - * weights. - */ - NoWeightsCommitFound: PlainDescriptor; - /** - * Committed hash does not equal the hashed reveal data. - */ - InvalidRevealCommitHashNotMatch: PlainDescriptor; - /** - * Attempting to call set_weights when commit/reveal is enabled - */ - CommitRevealEnabled: PlainDescriptor; - /** - * Attemtping to commit/reveal weights when disabled. - */ - CommitRevealDisabled: PlainDescriptor; - /** - * Attempting to set alpha high/low while disabled - */ - LiquidAlphaDisabled: PlainDescriptor; - /** - * Alpha high is too low: alpha_high > 0.8 - */ - AlphaHighTooLow: PlainDescriptor; - /** - * Alpha low is out of range: alpha_low > 0 && alpha_low < 0.8 - */ - AlphaLowOutOfRange: PlainDescriptor; - /** - * The coldkey has already been swapped - */ - ColdKeyAlreadyAssociated: PlainDescriptor; - /** - * The coldkey balance is not enough to pay for the swap - */ - NotEnoughBalanceToPaySwapColdKey: PlainDescriptor; - /** - * Attempting to set an invalid child for a hotkey on a network. - */ - InvalidChild: PlainDescriptor; - /** - * Duplicate child when setting children. - */ - DuplicateChild: PlainDescriptor; - /** - * Proportion overflow when setting children. - */ - ProportionOverflow: PlainDescriptor; - /** - * Too many children MAX 5. - */ - TooManyChildren: PlainDescriptor; - /** - * Default transaction rate limit exceeded. - */ - TxRateLimitExceeded: PlainDescriptor; - /** - * Coldkey swap announcement not found - */ - ColdkeySwapAnnouncementNotFound: PlainDescriptor; - /** - * Coldkey swap too early. - */ - ColdkeySwapTooEarly: PlainDescriptor; - /** - * Coldkey swap reannounced too early. - */ - ColdkeySwapReannouncedTooEarly: PlainDescriptor; - /** - * The announced coldkey hash does not match the new coldkey hash. - */ - AnnouncedColdkeyHashDoesNotMatch: PlainDescriptor; - /** - * Coldkey swap already disputed - */ - ColdkeySwapAlreadyDisputed: PlainDescriptor; - /** - * New coldkey is hotkey - */ - NewColdKeyIsHotkey: PlainDescriptor; - /** - * Childkey take is invalid. - */ - InvalidChildkeyTake: PlainDescriptor; - /** - * Childkey take rate limit exceeded. - */ - TxChildkeyTakeRateLimitExceeded: PlainDescriptor; - /** - * Invalid identity. - */ - InvalidIdentity: PlainDescriptor; - /** - * Subnet mechanism does not exist. - */ - MechanismDoesNotExist: PlainDescriptor; - /** - * Trying to unstake your lock amount. - */ - CannotUnstakeLock: PlainDescriptor; - /** - * Trying to perform action on non-existent subnet. - */ - SubnetNotExists: PlainDescriptor; - /** - * Maximum commit limit reached - */ - TooManyUnrevealedCommits: PlainDescriptor; - /** - * Attempted to reveal weights that are expired. - */ - ExpiredWeightCommit: PlainDescriptor; - /** - * Attempted to reveal weights too early. - */ - RevealTooEarly: PlainDescriptor; - /** - * Attempted to batch reveal weights with mismatched vector input lenghts. - */ - InputLengthsUnequal: PlainDescriptor; - /** - * A transactor exceeded the rate limit for setting weights. - */ - CommittingWeightsTooFast: PlainDescriptor; - /** - * Stake amount is too low. - */ - AmountTooLow: PlainDescriptor; - /** - * Not enough liquidity. - */ - InsufficientLiquidity: PlainDescriptor; - /** - * Slippage is too high for the transaction. - */ - SlippageTooHigh: PlainDescriptor; - /** - * Subnet disallows transfer. - */ - TransferDisallowed: PlainDescriptor; - /** - * Activity cutoff is being set too low. - */ - ActivityCutoffTooLow: PlainDescriptor; - /** - * Call is disabled - */ - CallDisabled: PlainDescriptor; - /** - * FirstEmissionBlockNumber is already set. - */ - FirstEmissionBlockNumberAlreadySet: PlainDescriptor; - /** - * need wait for more blocks to accept the start call extrinsic. - */ - NeedWaitingMoreBlocksToStarCall: PlainDescriptor; - /** - * Not enough AlphaOut on the subnet to recycle - */ - NotEnoughAlphaOutToRecycle: PlainDescriptor; - /** - * Cannot burn or recycle TAO from root subnet - */ - CannotBurnOrRecycleOnRootSubnet: PlainDescriptor; - /** - * Public key cannot be recovered. - */ - UnableToRecoverPublicKey: PlainDescriptor; - /** - * Recovered public key is invalid. - */ - InvalidRecoveredPublicKey: PlainDescriptor; - /** - * SubToken disabled now - */ - SubtokenDisabled: PlainDescriptor; - /** - * Too frequent hotkey swap on subnet - */ - HotKeySwapOnSubnetIntervalNotPassed: PlainDescriptor; - /** - * Zero max stake amount - */ - ZeroMaxStakeAmount: PlainDescriptor; - /** - * Invalid netuid duplication - */ - SameNetuid: PlainDescriptor; - /** - * The caller does not have enough balance for the operation. - */ - InsufficientBalance: PlainDescriptor; - /** - * Too frequent staking operations - */ - StakingOperationRateLimitExceeded: PlainDescriptor; - /** - * Invalid lease beneficiary to register the leased network. - */ - InvalidLeaseBeneficiary: PlainDescriptor; - /** - * Lease cannot end in the past. - */ - LeaseCannotEndInThePast: PlainDescriptor; - /** - * Couldn't find the lease netuid. - */ - LeaseNetuidNotFound: PlainDescriptor; - /** - * Lease does not exist. - */ - LeaseDoesNotExist: PlainDescriptor; - /** - * Lease has no end block. - */ - LeaseHasNoEndBlock: PlainDescriptor; - /** - * Lease has not ended. - */ - LeaseHasNotEnded: PlainDescriptor; - /** - * An overflow occurred. - */ - Overflow: PlainDescriptor; - /** - * Beneficiary does not own hotkey. - */ - BeneficiaryDoesNotOwnHotkey: PlainDescriptor; - /** - * Expected beneficiary origin. - */ - ExpectedBeneficiaryOrigin: PlainDescriptor; - /** - * Admin operation is prohibited during the protected weights window - */ - AdminActionProhibitedDuringWeightsWindow: PlainDescriptor; - /** - * Symbol does not exist. - */ - SymbolDoesNotExist: PlainDescriptor; - /** - * Symbol already in use. - */ - SymbolAlreadyInUse: PlainDescriptor; - /** - * Incorrect commit-reveal version. - */ - IncorrectCommitRevealVersion: PlainDescriptor; - /** - * Reveal period is too large. - */ - RevealPeriodTooLarge: PlainDescriptor; - /** - * Reveal period is too small. - */ - RevealPeriodTooSmall: PlainDescriptor; - /** - * Generic error for out-of-range parameter value - */ - InvalidValue: PlainDescriptor; - /** - * Subnet limit reached & there is no eligible subnet to prune - */ - SubnetLimitReached: PlainDescriptor; - /** - * Insufficient funds to meet the subnet lock cost - */ - CannotAffordLockCost: PlainDescriptor; - /** - * exceeded the rate limit for associating an EVM key. - */ - EvmKeyAssociateRateLimitExceeded: PlainDescriptor; - /** - * Same auto stake hotkey already set - */ - SameAutoStakeHotkeyAlreadySet: PlainDescriptor; - /** - * The UID map for the subnet could not be cleared - */ - UidMapCouldNotBeCleared: PlainDescriptor; - /** - * Trimming would exceed the max immune neurons percentage - */ - TrimmingWouldExceedMaxImmunePercentage: PlainDescriptor; - /** - * Violating the rules of Childkey-Parentkey consistency - */ - ChildParentInconsistency: PlainDescriptor; - /** - * Invalid number of root claims - */ - InvalidNumRootClaim: PlainDescriptor; - /** - * Invalid value of root claim threshold - */ - InvalidRootClaimThreshold: PlainDescriptor; - /** - * Exceeded subnet limit number or zero. - */ - InvalidSubnetNumber: PlainDescriptor; - /** - * The maximum allowed UIDs times mechanism count should not exceed 256. - */ - TooManyUIDsPerMechanism: PlainDescriptor; - /** - * Voting power tracking is not enabled for this subnet. - */ - VotingPowerTrackingNotEnabled: PlainDescriptor; - /** - * Invalid voting power EMA alpha value (must be <= 10^18). - */ - InvalidVotingPowerEmaAlpha: PlainDescriptor; - /** - * Unintended precision loss when unstaking alpha - */ - PrecisionLoss: PlainDescriptor; - /** - * Deprecated call. - */ - Deprecated: PlainDescriptor; - /** - * "Add stake and burn" exceeded the operation rate limit - */ - AddStakeBurnRateLimitExceeded: PlainDescriptor; - }; - Utility: { - /** - * Too many calls batched. - */ - TooManyCalls: PlainDescriptor; - /** - * Bad input data for derived account ID - */ - InvalidDerivedAccount: PlainDescriptor; - }; - Sudo: { - /** - * Sender must be the Sudo account. - */ - RequireSudo: PlainDescriptor; - }; - Multisig: { - /** - * Threshold must be 2 or greater. - */ - MinimumThreshold: PlainDescriptor; - /** - * Call is already approved by this signatory. - */ - AlreadyApproved: PlainDescriptor; - /** - * Call doesn't need any (more) approvals. - */ - NoApprovalsNeeded: PlainDescriptor; - /** - * There are too few signatories in the list. - */ - TooFewSignatories: PlainDescriptor; - /** - * There are too many signatories in the list. - */ - TooManySignatories: PlainDescriptor; - /** - * The signatories were provided out of order; they should be ordered. - */ - SignatoriesOutOfOrder: PlainDescriptor; - /** - * The sender was contained in the other signatories; it shouldn't be. - */ - SenderInSignatories: PlainDescriptor; - /** - * Multisig operation not found in storage. - */ - NotFound: PlainDescriptor; - /** - * Only the account that originally created the multisig is able to cancel it or update - * its deposits. - */ - NotOwner: PlainDescriptor; - /** - * No timepoint was given, yet the multisig operation is already underway. - */ - NoTimepoint: PlainDescriptor; - /** - * A different timepoint was given to the multisig operation that is underway. - */ - WrongTimepoint: PlainDescriptor; - /** - * A timepoint was given, yet no multisig operation is underway. - */ - UnexpectedTimepoint: PlainDescriptor; - /** - * The maximum weight information provided was too low. - */ - MaxWeightTooLow: PlainDescriptor; - /** - * The data to be stored is already stored. - */ - AlreadyStored: PlainDescriptor; - }; - Preimage: { - /** - * Preimage is too large to store on-chain. - */ - TooBig: PlainDescriptor; - /** - * Preimage has already been noted on-chain. - */ - AlreadyNoted: PlainDescriptor; - /** - * The user is not authorized to perform this action. - */ - NotAuthorized: PlainDescriptor; - /** - * The preimage cannot be removed since it has not yet been noted. - */ - NotNoted: PlainDescriptor; - /** - * A preimage may not be removed when there are outstanding requests. - */ - Requested: PlainDescriptor; - /** - * The preimage request cannot be removed since no outstanding requests exist. - */ - NotRequested: PlainDescriptor; - /** - * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once. - */ - TooMany: PlainDescriptor; - /** - * Too few hashes were requested to be upgraded (i.e. zero). - */ - TooFew: PlainDescriptor; - }; - Scheduler: { - /** - * Failed to schedule a call - */ - FailedToSchedule: PlainDescriptor; - /** - * Cannot find the scheduled call. - */ - NotFound: PlainDescriptor; - /** - * Given target block number is in the past. - */ - TargetBlockNumberInPast: PlainDescriptor; - /** - * Reschedule failed because it does not change scheduled time. - */ - RescheduleNoChange: PlainDescriptor; - /** - * Attempt to use a non-named function on a named task. - */ - Named: PlainDescriptor; - }; - Proxy: { - /** - * There are too many proxies registered or too many announcements pending. - */ - TooMany: PlainDescriptor; - /** - * Proxy registration not found. - */ - NotFound: PlainDescriptor; - /** - * Sender is not a proxy of the account to be proxied. - */ - NotProxy: PlainDescriptor; - /** - * A call which is incompatible with the proxy type's filter was attempted. - */ - Unproxyable: PlainDescriptor; - /** - * Account is already a proxy. - */ - Duplicate: PlainDescriptor; - /** - * Call may not be made by proxy because it may escalate its privileges. - */ - NoPermission: PlainDescriptor; - /** - * Announcement, if made at all, was made too recently. - */ - Unannounced: PlainDescriptor; - /** - * Cannot add self as proxy. - */ - NoSelfProxy: PlainDescriptor; - /** - * Invariant violated: deposit recomputation returned None after updating announcements. - */ - AnnouncementDepositInvariantViolated: PlainDescriptor; - /** - * Failed to derive a valid account id from the provided entropy. - */ - InvalidDerivedAccountId: PlainDescriptor; - }; - Registry: { - /** - * Account attempted to register an identity but does not meet the requirements. - */ - CannotRegister: PlainDescriptor; - /** - * Account passed too many additional fields to their identity - */ - TooManyFieldsInIdentityInfo: PlainDescriptor; - /** - * Account doesn't have a registered identity - */ - NotRegistered: PlainDescriptor; - }; - Commitments: { - /** - * Account passed too many additional fields to their commitment - */ - TooManyFieldsInCommitmentInfo: PlainDescriptor; - /** - * Account is not allowed to make commitments to the chain - */ - AccountNotAllowedCommit: PlainDescriptor; - /** - * Space Limit Exceeded for the current interval - */ - SpaceLimitExceeded: PlainDescriptor; - /** - * Indicates that unreserve returned a leftover, which is unexpected. - */ - UnexpectedUnreserveLeftover: PlainDescriptor; - }; - AdminUtils: { - /** - * The subnet does not exist, check the netuid parameter - */ - SubnetDoesNotExist: PlainDescriptor; - /** - * The maximum number of subnet validators must be less than the maximum number of allowed UIDs in the subnet. - */ - MaxValidatorsLargerThanMaxUIds: PlainDescriptor; - /** - * The maximum number of subnet validators must be more than the current number of UIDs already in the subnet. - */ - MaxAllowedUIdsLessThanCurrentUIds: PlainDescriptor; - /** - * The maximum value for bonds moving average is reached - */ - BondsMovingAverageMaxReached: PlainDescriptor; - /** - * Only root can set negative sigmoid steepness values - */ - NegativeSigmoidSteepness: PlainDescriptor; - /** - * Value not in allowed bounds. - */ - ValueNotInBounds: PlainDescriptor; - /** - * The minimum allowed UIDs must be less than the current number of UIDs in the subnet. - */ - MinAllowedUidsGreaterThanCurrentUids: PlainDescriptor; - /** - * The minimum allowed UIDs must be less than the maximum allowed UIDs. - */ - MinAllowedUidsGreaterThanMaxAllowedUids: PlainDescriptor; - /** - * The maximum allowed UIDs must be greater than the minimum allowed UIDs. - */ - MaxAllowedUidsLessThanMinAllowedUids: PlainDescriptor; - /** - * The maximum allowed UIDs must be less than the default maximum allowed UIDs. - */ - MaxAllowedUidsGreaterThanDefaultMaxAllowedUids: PlainDescriptor; - /** - * Bad parameter value - */ - InvalidValue: PlainDescriptor; - }; - SafeMode: { - /** - * The safe-mode is (already or still) entered. - */ - Entered: PlainDescriptor; - /** - * The safe-mode is (already or still) exited. - */ - Exited: PlainDescriptor; - /** - * This functionality of the pallet is disabled by the configuration. - */ - NotConfigured: PlainDescriptor; - /** - * There is no balance reserved. - */ - NoDeposit: PlainDescriptor; - /** - * The account already has a deposit reserved and can therefore not enter or extend again. - */ - AlreadyDeposited: PlainDescriptor; - /** - * This deposit cannot be released yet. - */ - CannotReleaseYet: PlainDescriptor; - /** - * An error from the underlying `Currency`. - */ - CurrencyError: PlainDescriptor; - }; - Ethereum: { - /** - * Signature is invalid. - */ - InvalidSignature: PlainDescriptor; - /** - * Pre-log is present, therefore transact is not allowed. - */ - PreLogExists: PlainDescriptor; - }; - EVM: { - /** - * Not enough balance to perform action - */ - BalanceLow: PlainDescriptor; - /** - * Calculating total fee overflowed - */ - FeeOverflow: PlainDescriptor; - /** - * Calculating total payment overflowed - */ - PaymentOverflow: PlainDescriptor; - /** - * Withdraw fee failed - */ - WithdrawFailed: PlainDescriptor; - /** - * Gas price is too low. - */ - GasPriceTooLow: PlainDescriptor; - /** - * Nonce is invalid - */ - InvalidNonce: PlainDescriptor; - /** - * Gas limit is too low. - */ - GasLimitTooLow: PlainDescriptor; - /** - * Gas limit is too high. - */ - GasLimitTooHigh: PlainDescriptor; - /** - * The chain id is invalid. - */ - InvalidChainId: PlainDescriptor; - /** - * the signature is invalid. - */ - InvalidSignature: PlainDescriptor; - /** - * EVM reentrancy - */ - Reentrancy: PlainDescriptor; - /** - * EIP-3607, - */ - TransactionMustComeFromEOA: PlainDescriptor; - /** - * Undefined error. - */ - Undefined: PlainDescriptor; - /** - * Origin is not allowed to perform the operation. - */ - NotAllowed: PlainDescriptor; - /** - * Address not allowed to deploy contracts either via CREATE or CALL(CREATE). - */ - CreateOriginNotAllowed: PlainDescriptor; - }; - Drand: { - /** - * The value retrieved was `None` as no value was previously set. - */ - NoneValue: PlainDescriptor; - /** - * There was an attempt to increment the value in storage over `u32::MAX`. - */ - StorageOverflow: PlainDescriptor; - /** - * failed to connect to the - */ - DrandConnectionFailure: PlainDescriptor; - /** - * the pulse is invalid - */ - UnverifiedPulse: PlainDescriptor; - /** - * the round number did not increment - */ - InvalidRoundNumber: PlainDescriptor; - /** - * the pulse could not be verified - */ - PulseVerificationError: PlainDescriptor; - }; - Crowdloan: { - /** - * The crowdloan initial deposit is too low. - */ - DepositTooLow: PlainDescriptor; - /** - * The crowdloan cap is too low. - */ - CapTooLow: PlainDescriptor; - /** - * The minimum contribution is too low. - */ - MinimumContributionTooLow: PlainDescriptor; - /** - * The crowdloan cannot end in the past. - */ - CannotEndInPast: PlainDescriptor; - /** - * The crowdloan block duration is too short. - */ - BlockDurationTooShort: PlainDescriptor; - /** - * The block duration is too long. - */ - BlockDurationTooLong: PlainDescriptor; - /** - * The account does not have enough balance to pay for the initial deposit/contribution. - */ - InsufficientBalance: PlainDescriptor; - /** - * An overflow occurred. - */ - Overflow: PlainDescriptor; - /** - * The crowdloan id is invalid. - */ - InvalidCrowdloanId: PlainDescriptor; - /** - * The crowdloan cap has been fully raised. - */ - CapRaised: PlainDescriptor; - /** - * The contribution period has ended. - */ - ContributionPeriodEnded: PlainDescriptor; - /** - * The contribution is too low. - */ - ContributionTooLow: PlainDescriptor; - /** - * The origin of this call is invalid. - */ - InvalidOrigin: PlainDescriptor; - /** - * The crowdloan has already been finalized. - */ - AlreadyFinalized: PlainDescriptor; - /** - * The crowdloan contribution period has not ended yet. - */ - ContributionPeriodNotEnded: PlainDescriptor; - /** - * The contributor has no contribution for this crowdloan. - */ - NoContribution: PlainDescriptor; - /** - * The crowdloan cap has not been raised. - */ - CapNotRaised: PlainDescriptor; - /** - * An underflow occurred. - */ - Underflow: PlainDescriptor; - /** - * Call to dispatch was not found in the preimage storage. - */ - CallUnavailable: PlainDescriptor; - /** - * The crowdloan is not ready to be dissolved, it still has contributions. - */ - NotReadyToDissolve: PlainDescriptor; - /** - * The deposit cannot be withdrawn from the crowdloan. - */ - DepositCannotBeWithdrawn: PlainDescriptor; - /** - * The maximum number of contributors has been reached. - */ - MaxContributorsReached: PlainDescriptor; - }; - Swap: { - /** - * The fee rate is too high - */ - FeeRateTooHigh: PlainDescriptor; - /** - * The provided amount is insufficient for the swap. - */ - InsufficientInputAmount: PlainDescriptor; - /** - * The provided liquidity is insufficient for the operation. - */ - InsufficientLiquidity: PlainDescriptor; - /** - * The operation would exceed the price limit. - */ - PriceLimitExceeded: PlainDescriptor; - /** - * The caller does not have enough balance for the operation. - */ - InsufficientBalance: PlainDescriptor; - /** - * Attempted to remove liquidity that does not exist. - */ - LiquidityNotFound: PlainDescriptor; - /** - * The provided tick range is invalid. - */ - InvalidTickRange: PlainDescriptor; - /** - * Maximum user positions exceeded - */ - MaxPositionsExceeded: PlainDescriptor; - /** - * Too many swap steps - */ - TooManySwapSteps: PlainDescriptor; - /** - * Provided liquidity parameter is invalid (likely too small) - */ - InvalidLiquidityValue: PlainDescriptor; - /** - * Reserves too low for operation. - */ - ReservesTooLow: PlainDescriptor; - /** - * The subnet does not exist. - */ - MechanismDoesNotExist: PlainDescriptor; - /** - * User liquidity operations are disabled for this subnet - */ - UserLiquidityDisabled: PlainDescriptor; - /** - * The subnet does not have subtoken enabled - */ - SubtokenDisabled: PlainDescriptor; - }; - Contracts: { - /** - * Invalid schedule supplied, e.g. with zero weight of a basic operation. - */ - InvalidSchedule: PlainDescriptor; - /** - * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`. - */ - InvalidCallFlags: PlainDescriptor; - /** - * The executed contract exhausted its gas limit. - */ - OutOfGas: PlainDescriptor; - /** - * The output buffer supplied to a contract API call was too small. - */ - OutputBufferTooSmall: PlainDescriptor; - /** - * Performing the requested transfer failed. Probably because there isn't enough - * free balance in the sender's account. - */ - TransferFailed: PlainDescriptor; - /** - * Performing a call was denied because the calling depth reached the limit - * of what is specified in the schedule. - */ - MaxCallDepthReached: PlainDescriptor; - /** - * No contract was found at the specified address. - */ - ContractNotFound: PlainDescriptor; - /** - * The code supplied to `instantiate_with_code` exceeds the limit specified in the - * current schedule. - */ - CodeTooLarge: PlainDescriptor; - /** - * No code could be found at the supplied code hash. - */ - CodeNotFound: PlainDescriptor; - /** - * No code info could be found at the supplied code hash. - */ - CodeInfoNotFound: PlainDescriptor; - /** - * A buffer outside of sandbox memory was passed to a contract API function. - */ - OutOfBounds: PlainDescriptor; - /** - * Input passed to a contract API function failed to decode as expected type. - */ - DecodingFailed: PlainDescriptor; - /** - * Contract trapped during execution. - */ - ContractTrapped: PlainDescriptor; - /** - * The size defined in `T::MaxValueSize` was exceeded. - */ - ValueTooLarge: PlainDescriptor; - /** - * Termination of a contract is not allowed while the contract is already - * on the call stack. Can be triggered by `seal_terminate`. - */ - TerminatedWhileReentrant: PlainDescriptor; - /** - * `seal_call` forwarded this contracts input. It therefore is no longer available. - */ - InputForwarded: PlainDescriptor; - /** - * The subject passed to `seal_random` exceeds the limit. - */ - RandomSubjectTooLong: PlainDescriptor; - /** - * The amount of topics passed to `seal_deposit_events` exceeds the limit. - */ - TooManyTopics: PlainDescriptor; - /** - * The chain does not provide a chain extension. Calling the chain extension results - * in this error. Note that this usually shouldn't happen as deploying such contracts - * is rejected. - */ - NoChainExtension: PlainDescriptor; - /** - * Failed to decode the XCM program. - */ - XCMDecodeFailed: PlainDescriptor; - /** - * A contract with the same AccountId already exists. - */ - DuplicateContract: PlainDescriptor; - /** - * A contract self destructed in its constructor. - * - * This can be triggered by a call to `seal_terminate`. - */ - TerminatedInConstructor: PlainDescriptor; - /** - * A call tried to invoke a contract that is flagged as non-reentrant. - * The only other cause is that a call from a contract into the runtime tried to call back - * into `pallet-contracts`. This would make the whole pallet reentrant with regard to - * contract code execution which is not supported. - */ - ReentranceDenied: PlainDescriptor; - /** - * A contract attempted to invoke a state modifying API while being in read-only mode. - */ - StateChangeDenied: PlainDescriptor; - /** - * Origin doesn't have enough balance to pay the required storage deposits. - */ - StorageDepositNotEnoughFunds: PlainDescriptor; - /** - * More storage was created than allowed by the storage deposit limit. - */ - StorageDepositLimitExhausted: PlainDescriptor; - /** - * Code removal was denied because the code is still in use by at least one contract. - */ - CodeInUse: PlainDescriptor; - /** - * The contract ran to completion but decided to revert its storage changes. - * Please note that this error is only returned from extrinsics. When called directly - * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags - * to determine whether a reversion has taken place. - */ - ContractReverted: PlainDescriptor; - /** - * The contract's code was found to be invalid during validation. - * - * The most likely cause of this is that an API was used which is not supported by the - * node. This happens if an older node is used with a new version of ink!. Try updating - * your node to the newest available version. - * - * A more detailed error can be found on the node console if debug messages are enabled - * by supplying `-lruntime::contracts=debug`. - */ - CodeRejected: PlainDescriptor; - /** - * An indeterministic code was used in a context where this is not permitted. - */ - Indeterministic: PlainDescriptor; - /** - * A pending migration needs to complete before the extrinsic can be called. - */ - MigrationInProgress: PlainDescriptor; - /** - * Migrate dispatch call was attempted but no migration was performed. - */ - NoMigrationPerformed: PlainDescriptor; - /** - * The contract has reached its maximum number of delegate dependencies. - */ - MaxDelegateDependenciesReached: PlainDescriptor; - /** - * The dependency was not found in the contract's delegate dependencies. - */ - DelegateDependencyNotFound: PlainDescriptor; - /** - * The contract already depends on the given delegate dependency. - */ - DelegateDependencyAlreadyExists: PlainDescriptor; - /** - * Can not add a delegate dependency to the code hash of the contract itself. - */ - CannotAddSelfAsDelegateDependency: PlainDescriptor; - /** - * Can not add more data to transient storage. - */ - OutOfTransientStorage: PlainDescriptor; - }; - MevShield: { - /** - * A submission with the same id already exists in `Submissions`. - */ - SubmissionAlreadyExists: PlainDescriptor; - /** - * The referenced submission id does not exist in `Submissions`. - */ - MissingSubmission: PlainDescriptor; - /** - * The recomputed commitment does not match the stored commitment. - */ - CommitmentMismatch: PlainDescriptor; - /** - * The provided signature over the payload is invalid. - */ - SignatureInvalid: PlainDescriptor; - /** - * The announced ML‑KEM public key length is invalid. - */ - BadPublicKeyLen: PlainDescriptor; - /** - * The MEV‑Shield key epoch for this submission has expired and is no longer accepted. - */ - KeyExpired: PlainDescriptor; - /** - * The provided `key_hash` does not match the expected epoch key hash. - */ - KeyHashMismatch: PlainDescriptor; - }; -}; -type IConstants = { - System: { - /** - * Block & extrinsics weights: base values and limits. - */ - BlockWeights: PlainDescriptor>; - /** - * The maximum length of a block (in bytes). - */ - BlockLength: PlainDescriptor>; - /** - * Maximum number of block number to block hash mappings to keep (oldest pruned first). - */ - BlockHashCount: PlainDescriptor; - /** - * The weight of runtime database operations the runtime can invoke. - */ - DbWeight: PlainDescriptor>; - /** - * Get the chain's in-code version. - */ - Version: PlainDescriptor>; - /** - * The designated SS58 prefix of this chain. - * - * This replaces the "ss58Format" property declared in the chain spec. Reason is - * that the runtime should know about the prefix in order to make use of it as - * an identifier of the chain. - */ - SS58Prefix: PlainDescriptor; - }; - Timestamp: { - /** - * The minimum period between blocks. - * - * Be aware that this is different to the *expected* period that the block production - * apparatus provides. Your chosen consensus system will generally work with this to - * determine a sensible block time. For example, in the Aura pallet it will be double this - * period on default settings. - */ - MinimumPeriod: PlainDescriptor; - }; - Aura: { - /** - * The slot duration Aura should run with, expressed in milliseconds. - * The effective value of this type should not change while the chain is running. - * - * For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const. - */ - SlotDuration: PlainDescriptor; - }; - Grandpa: { - /** - * Max Authorities in use - */ - MaxAuthorities: PlainDescriptor; - /** - * The maximum number of nominators for each validator. - */ - MaxNominators: PlainDescriptor; - /** - * The maximum number of entries to keep in the set id to session index mapping. - * - * Since the `SetIdSession` map is only used for validating equivocations this - * value should relate to the bonding duration of whatever staking system is - * being used (if any). If equivocation handling is not enabled then this value - * can be zero. - */ - MaxSetIdSessionEntries: PlainDescriptor; - }; - Balances: { - /** - * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO! - * - * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for - * this pallet. However, you do so at your own risk: this will open up a major DoS vector. - * In case you have multiple sources of provider references, you may also get unexpected - * behaviour if you set this to zero. - * - * Bottom line: Do yourself a favour and make it at least one! - */ - ExistentialDeposit: PlainDescriptor; - /** - * The maximum number of locks that should exist on an account. - * Not strictly enforced, but used for weight estimation. - * - * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` - */ - MaxLocks: PlainDescriptor; - /** - * The maximum number of named reserves that can exist on an account. - * - * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` - */ - MaxReserves: PlainDescriptor; - /** - * The maximum number of individual freeze locks that can exist on an account at any time. - */ - MaxFreezes: PlainDescriptor; - }; - TransactionPayment: { - /** - * A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their - * `priority` - * - * This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later - * added to a tip component in regular `priority` calculations. - * It means that a `Normal` transaction can front-run a similarly-sized `Operational` - * extrinsic (with no tip), by including a tip value greater than the virtual tip. - * - * ```rust,ignore - * // For `Normal` - * let priority = priority_calc(tip); - * - * // For `Operational` - * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; - * let priority = priority_calc(tip + virtual_tip); - * ``` - * - * Note that since we use `final_fee` the multiplier applies also to the regular `tip` - * sent with the transaction. So, not only does the transaction get a priority bump based - * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` - * transactions. - */ - OperationalFeeMultiplier: PlainDescriptor; - }; - SubtensorModule: { - /** - * ================================= - * ==== Initial Value Constants ==== - * ================================= - * Initial currency issuance. - */ - InitialIssuance: PlainDescriptor; - /** - * Initial min allowed weights setting. - */ - InitialMinAllowedWeights: PlainDescriptor; - /** - * Initial Emission Ratio. - */ - InitialEmissionValue: PlainDescriptor; - /** - * Tempo for each network. - */ - InitialTempo: PlainDescriptor; - /** - * Initial Difficulty. - */ - InitialDifficulty: PlainDescriptor; - /** - * Initial Max Difficulty. - */ - InitialMaxDifficulty: PlainDescriptor; - /** - * Initial Min Difficulty. - */ - InitialMinDifficulty: PlainDescriptor; - /** - * Initial RAO Recycled. - */ - InitialRAORecycledForRegistration: PlainDescriptor; - /** - * Initial Burn. - */ - InitialBurn: PlainDescriptor; - /** - * Initial Max Burn. - */ - InitialMaxBurn: PlainDescriptor; - /** - * Initial Min Burn. - */ - InitialMinBurn: PlainDescriptor; - /** - * Min burn upper bound. - */ - MinBurnUpperBound: PlainDescriptor; - /** - * Max burn lower bound. - */ - MaxBurnLowerBound: PlainDescriptor; - /** - * Initial adjustment interval. - */ - InitialAdjustmentInterval: PlainDescriptor; - /** - * Initial bonds moving average. - */ - InitialBondsMovingAverage: PlainDescriptor; - /** - * Initial bonds penalty. - */ - InitialBondsPenalty: PlainDescriptor; - /** - * Initial bonds reset. - */ - InitialBondsResetOn: PlainDescriptor; - /** - * Initial target registrations per interval. - */ - InitialTargetRegistrationsPerInterval: PlainDescriptor; - /** - * Rho constant. - */ - InitialRho: PlainDescriptor; - /** - * AlphaSigmoidSteepness constant. - */ - InitialAlphaSigmoidSteepness: PlainDescriptor; - /** - * Kappa constant. - */ - InitialKappa: PlainDescriptor; - /** - * Initial minimum allowed network UIDs - */ - InitialMinAllowedUids: PlainDescriptor; - /** - * Initial maximum allowed network UIDs - */ - InitialMaxAllowedUids: PlainDescriptor; - /** - * Initial validator context pruning length. - */ - InitialValidatorPruneLen: PlainDescriptor; - /** - * Initial scaling law power. - */ - InitialScalingLawPower: PlainDescriptor; - /** - * Immunity Period Constant. - */ - InitialImmunityPeriod: PlainDescriptor; - /** - * Activity constant. - */ - InitialActivityCutoff: PlainDescriptor; - /** - * Initial max registrations per block. - */ - InitialMaxRegistrationsPerBlock: PlainDescriptor; - /** - * Initial pruning score for each neuron. - */ - InitialPruningScore: PlainDescriptor; - /** - * Initial maximum allowed validators per network. - */ - InitialMaxAllowedValidators: PlainDescriptor; - /** - * Initial default delegation take. - */ - InitialDefaultDelegateTake: PlainDescriptor; - /** - * Initial minimum delegation take. - */ - InitialMinDelegateTake: PlainDescriptor; - /** - * Initial default childkey take. - */ - InitialDefaultChildKeyTake: PlainDescriptor; - /** - * Initial minimum childkey take. - */ - InitialMinChildKeyTake: PlainDescriptor; - /** - * Initial maximum childkey take. - */ - InitialMaxChildKeyTake: PlainDescriptor; - /** - * Initial weights version key. - */ - InitialWeightsVersionKey: PlainDescriptor; - /** - * Initial serving rate limit. - */ - InitialServingRateLimit: PlainDescriptor; - /** - * Initial transaction rate limit. - */ - InitialTxRateLimit: PlainDescriptor; - /** - * Initial delegate take transaction rate limit. - */ - InitialTxDelegateTakeRateLimit: PlainDescriptor; - /** - * Initial childkey take transaction rate limit. - */ - InitialTxChildKeyTakeRateLimit: PlainDescriptor; - /** - * Initial adjustment alpha on burn and pow. - */ - InitialAdjustmentAlpha: PlainDescriptor; - /** - * Initial network immunity period - */ - InitialNetworkImmunityPeriod: PlainDescriptor; - /** - * Initial network minimum burn cost - */ - InitialNetworkMinLockCost: PlainDescriptor; - /** - * Initial network subnet cut. - */ - InitialSubnetOwnerCut: PlainDescriptor; - /** - * Initial lock reduction interval. - */ - InitialNetworkLockReductionInterval: PlainDescriptor; - /** - * Initial network creation rate limit - */ - InitialNetworkRateLimit: PlainDescriptor; - /** - * Cost of swapping a hotkey. - */ - KeySwapCost: PlainDescriptor; - /** - * The upper bound for the alpha parameter. Used for Liquid Alpha. - */ - AlphaHigh: PlainDescriptor; - /** - * The lower bound for the alpha parameter. Used for Liquid Alpha. - */ - AlphaLow: PlainDescriptor; - /** - * A flag to indicate if Liquid Alpha is enabled. - */ - LiquidAlphaOn: PlainDescriptor; - /** - * A flag to indicate if Yuma3 is enabled. - */ - Yuma3On: PlainDescriptor; - /** - * Coldkey swap announcement delay. - */ - InitialColdkeySwapAnnouncementDelay: PlainDescriptor; - /** - * Coldkey swap reannouncement delay. - */ - InitialColdkeySwapReannouncementDelay: PlainDescriptor; - /** - * Dissolve network schedule duration - */ - InitialDissolveNetworkScheduleDuration: PlainDescriptor; - /** - * Initial TAO weight. - */ - InitialTaoWeight: PlainDescriptor; - /** - * Initial EMA price halving period - */ - InitialEmaPriceHalvingPeriod: PlainDescriptor; - /** - * Delay after which a new subnet can dispatch start call extrinsic. - */ - InitialStartCallDelay: PlainDescriptor; - /** - * Cost of swapping a hotkey in a subnet. - */ - KeySwapOnSubnetCost: PlainDescriptor; - /** - * Block number for a coldkey swap the hotkey in specific subnet. - */ - HotkeySwapOnSubnetInterval: PlainDescriptor; - /** - * Number of blocks between dividends distribution. - */ - LeaseDividendsDistributionInterval: PlainDescriptor; - /** - * Maximum percentage of immune UIDs. - */ - MaxImmuneUidsPercentage: PlainDescriptor; - }; - Utility: { - /** - * The limit on the number of batched calls. - */ - batched_calls_limit: PlainDescriptor; - }; - Multisig: { - /** - * The base amount of currency needed to reserve for creating a multisig execution or to - * store a dispatch call for later. - * - * This is held for an additional storage item whose value size is - * `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is - * `32 + sizeof(AccountId)` bytes. - */ - DepositBase: PlainDescriptor; - /** - * The amount of currency needed per unit threshold when creating a multisig execution. - * - * This is held for adding 32 bytes more into a pre-existing storage value. - */ - DepositFactor: PlainDescriptor; - /** - * The maximum amount of signatories allowed in the multisig. - */ - MaxSignatories: PlainDescriptor; - }; - Scheduler: { - /** - * The maximum weight that may be scheduled per block for any dispatchables. - */ - MaximumWeight: PlainDescriptor>; - /** - * The maximum number of scheduled calls in the queue for a single block. - * - * NOTE: - * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a - * higher limit under `runtime-benchmarks` feature. - */ - MaxScheduledPerBlock: PlainDescriptor; - }; - Proxy: { - /** - * The base amount of currency needed to reserve for creating a proxy. - * - * This is held for an additional storage item whose value size is - * `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes. - */ - ProxyDepositBase: PlainDescriptor; - /** - * The amount of currency needed per proxy added. - * - * This is held for adding 32 bytes plus an instance of `ProxyType` more into a - * pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take - * into account `32 + proxy_type.encode().len()` bytes of data. - */ - ProxyDepositFactor: PlainDescriptor; - /** - * The maximum amount of proxies allowed for a single account. - */ - MaxProxies: PlainDescriptor; - /** - * The maximum amount of time-delayed announcements that are allowed to be pending. - */ - MaxPending: PlainDescriptor; - /** - * The base amount of currency needed to reserve for creating an announcement. - * - * This is held when a new storage item holding a `Balance` is created (typically 16 - * bytes). - */ - AnnouncementDepositBase: PlainDescriptor; - /** - * The amount of currency needed per announcement made. - * - * This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes) - * into a pre-existing storage value. - */ - AnnouncementDepositFactor: PlainDescriptor; - }; - Registry: { - /** - * Configuration fields - * Maximum user-configured additional fields - */ - MaxAdditionalFields: PlainDescriptor; - /** - * The amount held on deposit for a registered identity - */ - InitialDeposit: PlainDescriptor; - /** - * The amount held on deposit per additional field for a registered identity. - */ - FieldDeposit: PlainDescriptor; - }; - Commitments: { - /** - * The maximum number of additional fields that can be added to a commitment - */ - MaxFields: PlainDescriptor; - /** - * The amount held on deposit for a registered identity - */ - InitialDeposit: PlainDescriptor; - /** - * The amount held on deposit per additional field for a registered identity. - */ - FieldDeposit: PlainDescriptor; - }; - SafeMode: { - /** - * For how many blocks the safe-mode will be entered by [`Pallet::enter`]. - */ - EnterDuration: PlainDescriptor; - /** - * For how many blocks the safe-mode can be extended by each [`Pallet::extend`] call. - * - * This does not impose a hard limit as the safe-mode can be extended multiple times. - */ - ExtendDuration: PlainDescriptor; - /** - * The amount that will be reserved upon calling [`Pallet::enter`]. - * - * `None` disallows permissionlessly enabling the safe-mode and is a sane default. - */ - EnterDepositAmount: PlainDescriptor>; - /** - * The amount that will be reserved upon calling [`Pallet::extend`]. - * - * `None` disallows permissionlessly extending the safe-mode and is a sane default. - */ - ExtendDepositAmount: PlainDescriptor>; - /** - * The minimal duration a deposit will remain reserved after safe-mode is entered or - * extended, unless [`Pallet::force_release_deposit`] is successfully called sooner. - * - * Every deposit is tied to a specific activation or extension, thus each deposit can be - * released independently after the delay for it has passed. - * - * `None` disallows permissionlessly releasing the safe-mode deposits and is a sane - * default. - */ - ReleaseDelay: PlainDescriptor>; - }; - Drand: { - /** - * A configuration for base priority of unsigned transactions. - * - * This is exposed so that it can be tuned for particular runtime, when - * multiple pallets send unsigned transactions. - */ - UnsignedPriority: PlainDescriptor; - /** - * The maximum number of milliseconds we are willing to wait for the HTTP request to - * complete. - */ - HttpFetchTimeout: PlainDescriptor; - }; - Crowdloan: { - /** - * The pallet id that will be used to derive crowdloan account ids. - */ - PalletId: PlainDescriptor>; - /** - * The minimum deposit required to create a crowdloan. - */ - MinimumDeposit: PlainDescriptor; - /** - * The absolute minimum contribution required to contribute to a crowdloan. - */ - AbsoluteMinimumContribution: PlainDescriptor; - /** - * The minimum block duration for a crowdloan. - */ - MinimumBlockDuration: PlainDescriptor; - /** - * The maximum block duration for a crowdloan. - */ - MaximumBlockDuration: PlainDescriptor; - /** - * The maximum number of contributors that can be refunded in a single refund. - */ - RefundContributorsLimit: PlainDescriptor; - /** - - */ - MaxContributors: PlainDescriptor; - }; - Swap: { - /** - * This type is used to derive protocol accoun ID. - */ - ProtocolId: PlainDescriptor>; - /** - * The maximum fee rate that can be set - */ - MaxFeeRate: PlainDescriptor; - /** - * The maximum number of positions a user can have - */ - MaxPositions: PlainDescriptor; - /** - * Minimum liquidity that is safe for rounding and integer math. - */ - MinimumLiquidity: PlainDescriptor; - /** - * Minimum reserve for tao and alpha - */ - MinimumReserve: PlainDescriptor; - }; - Contracts: { - /** - * Cost schedule and limits. - */ - Schedule: PlainDescriptor>; - /** - * The amount of balance a caller has to pay for each byte of storage. - * - * # Note - * - * Changing this value for an existing chain might need a storage migration. - */ - DepositPerByte: PlainDescriptor; - /** - * Fallback value to limit the storage deposit if it's not being set by the caller. - */ - DefaultDepositLimit: PlainDescriptor; - /** - * The amount of balance a caller has to pay for each storage item. - * - * # Note - * - * Changing this value for an existing chain might need a storage migration. - */ - DepositPerItem: PlainDescriptor; - /** - * The percentage of the storage deposit that should be held for using a code hash. - * Instantiating a contract, or calling [`chain_extension::Ext::lock_delegate_dependency`] - * protects the code from being removed. In order to prevent abuse these actions are - * protected with a percentage of the code deposit. - */ - CodeHashLockupDepositPercent: PlainDescriptor; - /** - * The maximum length of a contract code in bytes. - * - * The value should be chosen carefully taking into the account the overall memory limit - * your runtime has, as well as the [maximum allowed callstack - * depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights. - */ - MaxCodeLen: PlainDescriptor; - /** - * The maximum allowable length in bytes for storage keys. - */ - MaxStorageKeyLen: PlainDescriptor; - /** - * The maximum size of the transient storage in bytes. - * This includes keys, values, and previous entries used for storage rollback. - */ - MaxTransientStorageSize: PlainDescriptor; - /** - * The maximum number of delegate_dependencies that a contract can lock with - * [`chain_extension::Ext::lock_delegate_dependency`]. - */ - MaxDelegateDependencies: PlainDescriptor; - /** - * Make contract callable functions marked as `#[unstable]` available. - * - * Contracts that use `#[unstable]` functions won't be able to be uploaded unless - * this is set to `true`. This is only meant for testnets and dev nodes in order to - * experiment with new features. - * - * # Warning - * - * Do **not** set to `true` on productions chains. - */ - UnsafeUnstableInterface: PlainDescriptor; - /** - * The maximum length of the debug buffer in bytes. - */ - MaxDebugBufferLen: PlainDescriptor; - /** - * Type that bundles together all the runtime configurable interface types. - * - * This is not a real config. We just mention the type here as constant so that - * its type appears in the metadata. Only valid value is `()`. - */ - Environment: PlainDescriptor>; - /** - * The version of the HostFn APIs that are available in the runtime. - * - * Only valid value is `()`. - */ - ApiVersion: PlainDescriptor; - }; -}; -type IViewFns = { - Proxy: { - /** - * Check if a `RuntimeCall` is allowed for a given `ProxyType`. - */ - check_permissions: RuntimeDescriptor<[call: Anonymize, proxy_type: Anonymize], boolean>; - /** - * Check if one `ProxyType` is a subset of another `ProxyType`. - */ - is_superset: RuntimeDescriptor<[to_check: Anonymize, against: Anonymize], boolean>; - }; -}; -type IRuntimeCalls = { - /** - * The `Core` runtime api that every Substrate runtime needs to implement. - */ - Core: { - /** - * Returns the version of the runtime. - */ - version: RuntimeDescriptor<[], Anonymize>; - /** - * Execute the given block. - */ - execute_block: RuntimeDescriptor<[block: Anonymize], undefined>; - /** - * Initialize a block with the given header and return the runtime executive mode. - */ - initialize_block: RuntimeDescriptor<[header: Anonymize], Anonymize>; - }; - /** - * The `Metadata` api trait that returns metadata for the runtime. - */ - Metadata: { - /** - * Returns the metadata of a runtime. - */ - metadata: RuntimeDescriptor<[], Binary>; - /** - * Returns the metadata at a given version. - * - * If the given `version` isn't supported, this will return `None`. - * Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime. - */ - metadata_at_version: RuntimeDescriptor<[version: number], Anonymize>; - /** - * Returns the supported metadata versions. - * - * This can be used to call `metadata_at_version`. - */ - metadata_versions: RuntimeDescriptor<[], Anonymize>; - }; - /** - * The `BlockBuilder` api trait that provides the required functionality for building a block. - */ - BlockBuilder: { - /** - * Apply the given extrinsic. - * - * Returns an inclusion outcome which specifies if this extrinsic is included in - * this block or not. - */ - apply_extrinsic: RuntimeDescriptor<[extrinsic: Binary], Anonymize>; - /** - * Finish the current block. - */ - finalize_block: RuntimeDescriptor<[], Anonymize>; - /** - * Generate inherent extrinsics. The inherent data will vary from chain to chain. - */ - inherent_extrinsics: RuntimeDescriptor<[inherent: Anonymize], Anonymize>; - /** - * Check that the inherents are valid. The inherent data will vary from chain to chain. - */ - check_inherents: RuntimeDescriptor<[block: Anonymize, data: Anonymize], Anonymize>; - }; - /** - * API to interact with `RuntimeGenesisConfig` for the runtime - */ - GenesisBuilder: { - /** - * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the - * storage. - * - * In the case of a FRAME-based runtime, this function deserializes the full - * `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage. If the - * provided JSON blob is incorrect or incomplete or the deserialization fails, an error - * is returned. - * - * Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no - * defaults will be used. - */ - build_state: RuntimeDescriptor<[json: Binary], Anonymize>; - /** - * Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by - * `id`. - * - * If `id` is `None` the function should return JSON blob representation of the default - * `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default - * `RuntimeGenesisConfig`. - * - * Otherwise function returns a JSON representation of the built-in, named - * `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does not - * exist. Returned `Vec` contains bytes of JSON blob (patch) which comprises a list of - * (potentially nested) key-value pairs that are intended for customizing the default - * runtime genesis config. The patch shall be merged (rfc7386) with the JSON representation - * of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can - * be used in `build_state` method. - */ - get_preset: RuntimeDescriptor<[id: Anonymize], Anonymize>; - /** - * Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets. - * - * The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If - * no named presets are provided by the runtime the list is empty. - */ - preset_names: RuntimeDescriptor<[], Anonymize>; - }; - /** - * The `TaggedTransactionQueue` api trait for interfering with the transaction queue. - */ - TaggedTransactionQueue: { - /** - * Validate the transaction. - * - * This method is invoked by the transaction pool to learn details about given transaction. - * The implementation should make sure to verify the correctness of the transaction - * against current state. The given `block_hash` corresponds to the hash of the block - * that is used as current state. - * - * Note that this call may be performed by the pool multiple times and transactions - * might be verified in any possible order. - */ - validate_transaction: RuntimeDescriptor<[source: TransactionValidityTransactionSource, tx: Binary, block_hash: FixedSizeBinary<32>], Anonymize>; - }; - /** - * The offchain worker api. - */ - OffchainWorkerApi: { - /** - * Starts the off-chain task for given block header. - */ - offchain_worker: RuntimeDescriptor<[header: Anonymize], undefined>; - }; - /** - * API necessary for block authorship with aura. - */ - AuraApi: { - /** - * Returns the slot duration for Aura. - * - * Currently, only the value provided by this type at genesis will be used. - */ - slot_duration: RuntimeDescriptor<[], bigint>; - /** - * Return the current set of authorities. - */ - authorities: RuntimeDescriptor<[], Anonymize>; - }; - /** - * Session keys runtime api. - */ - SessionKeys: { - /** - * Generate a set of session keys with optionally using the given seed. - * The keys should be stored within the keystore exposed via runtime - * externalities. - * - * The seed needs to be a valid `utf8` string. - * - * Returns the concatenated SCALE encoded public keys. - */ - generate_session_keys: RuntimeDescriptor<[seed: Anonymize], Binary>; - /** - * Decode the given public session keys. - * - * Returns the list of public raw public keys + key type. - */ - decode_session_keys: RuntimeDescriptor<[encoded: Binary], Anonymize>; - }; - /** - * APIs for integrating the GRANDPA finality gadget into runtimes. - * This should be implemented on the runtime side. - * - * This is primarily used for negotiating authority-set changes for the - * gadget. GRANDPA uses a signaling model of changing authority sets: - * changes should be signaled with a delay of N blocks, and then automatically - * applied in the runtime after those N blocks have passed. - * - * The consensus protocol will coordinate the handoff externally. - */ - GrandpaApi: { - /** - * Get the current GRANDPA authorities and weights. This should not change except - * for when changes are scheduled and the corresponding delay has passed. - * - * When called at block B, it will return the set of authorities that should be - * used to finalize descendants of this block (B+1, B+2, ...). The block B itself - * is finalized by the authorities from block B-1. - */ - grandpa_authorities: RuntimeDescriptor<[], Anonymize>; - /** - * Submits an unsigned extrinsic to report an equivocation. The caller - * must provide the equivocation proof and a key ownership proof - * (should be obtained using `generate_key_ownership_proof`). The - * extrinsic will be unsigned and should only be accepted for local - * authorship (not to be broadcast to the network). This method returns - * `None` when creation of the extrinsic fails, e.g. if equivocation - * reporting is disabled for the given runtime (i.e. this method is - * hardcoded to return `None`). Only useful in an offchain context. - */ - submit_report_equivocation_unsigned_extrinsic: RuntimeDescriptor<[equivocation_proof: Anonymize, key_owner_proof: Binary], boolean>; - /** - * Generates a proof of key ownership for the given authority in the - * given set. An example usage of this module is coupled with the - * session historical module to prove that a given authority key is - * tied to a given staking identity during a specific session. Proofs - * of key ownership are necessary for submitting equivocation reports. - * NOTE: even though the API takes a `set_id` as parameter the current - * implementations ignore this parameter and instead rely on this - * method being called at the correct block height, i.e. any point at - * which the given set id is live on-chain. Future implementations will - * instead use indexed data through an offchain worker, not requiring - * older states to be available. - */ - generate_key_ownership_proof: RuntimeDescriptor<[set_id: bigint, authority_id: FixedSizeBinary<32>], Anonymize>; - /** - * Get current GRANDPA authority set id. - */ - current_set_id: RuntimeDescriptor<[], bigint>; - }; - /** - * The API to query account nonce. - */ - AccountNonceApi: { - /** - * Get current account nonce of given `AccountId`. - */ - account_nonce: RuntimeDescriptor<[account: SS58String], number>; - }; - /** - - */ - TransactionPaymentApi: { - /** - - */ - query_info: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; - /** - - */ - query_fee_details: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; - /** - - */ - query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; - /** - - */ - query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; - }; - /** - - */ - TransactionPaymentCallApi: { - /** - * Query information of a dispatch class, weight, and fee of a given encoded `Call`. - */ - query_call_info: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; - /** - * Query fee details of a given encoded `Call`. - */ - query_call_fee_details: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; - /** - * Query the output of the current `WeightToFee` given some input. - */ - query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; - /** - * Query the output of the current `LengthToFee` given some input. - */ - query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; - }; - /** - * API necessary for Ethereum-compatibility layer. - */ - EthereumRuntimeRPCApi: { - /** - * Returns runtime defined pallet_evm::ChainId. - */ - chain_id: RuntimeDescriptor<[], bigint>; - /** - * Returns pallet_evm::Accounts by address. - */ - account_basic: RuntimeDescriptor<[address: FixedSizeBinary<20>], Anonymize>; - /** - * Returns FixedGasPrice::min_gas_price - */ - gas_price: RuntimeDescriptor<[], Anonymize>; - /** - * For a given account address, returns pallet_evm::AccountCodes. - */ - account_code_at: RuntimeDescriptor<[address: FixedSizeBinary<20>], Binary>; - /** - * Returns the converted FindAuthor::find_author authority id. - */ - author: RuntimeDescriptor<[], FixedSizeBinary<20>>; - /** - * For a given account address and index, returns pallet_evm::AccountStorages. - */ - storage_at: RuntimeDescriptor<[address: FixedSizeBinary<20>, index: Anonymize], FixedSizeBinary<32>>; - /** - - */ - call: RuntimeDescriptor<[from: FixedSizeBinary<20>, to: FixedSizeBinary<20>, data: Binary, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; - /** - - */ - create: RuntimeDescriptor<[from: FixedSizeBinary<20>, data: Binary, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; - /** - * Return the current block. - */ - current_block: RuntimeDescriptor<[], Anonymize>; - /** - * Return the current receipt. - */ - current_receipts: RuntimeDescriptor<[], Anonymize>; - /** - * Return the current transaction status. - */ - current_transaction_statuses: RuntimeDescriptor<[], Anonymize>; - /** - - */ - current_all: RuntimeDescriptor<[], Anonymize>; - /** - * Receives a `Vec` and filters all the ethereum transactions. - */ - extrinsic_filter: RuntimeDescriptor<[xts: Anonymize], Anonymize>; - /** - * Return the elasticity multiplier. - */ - elasticity: RuntimeDescriptor<[], Anonymize>; - /** - * Used to determine if gas limit multiplier for non-transactional calls (eth_call/estimateGas) - * is supported. - */ - gas_limit_multiplier_support: RuntimeDescriptor<[], undefined>; - /** - * Return the pending block. - */ - pending_block: RuntimeDescriptor<[xts: Anonymize], Anonymize>; - /** - * Initialize the pending block. - * The behavior should be the same as the runtime api Core_initialize_block but - * for a "pending" block. - * If your project don't need to have a different behavior to initialize "pending" blocks, - * you can copy your Core_initialize_block implementation. - */ - initialize_pending_block: RuntimeDescriptor<[header: Anonymize], undefined>; - }; - /** - - */ - ConvertTransactionRuntimeApi: { - /** - - */ - convert_transaction: RuntimeDescriptor<[transaction: Anonymize], Binary>; - }; - /** - * The API used to dry-run contract interactions. - */ - ContractsApi: { - /** - * Perform a call from a specified account to a given contract. - * - * See [`crate::Pallet::bare_call`]. - */ - call: RuntimeDescriptor<[origin: SS58String, dest: SS58String, value: bigint, gas_limit: Anonymize, storage_deposit_limit: Anonymize, input_data: Binary], Anonymize>; - /** - * Instantiate a new contract. - * - * See `[crate::Pallet::bare_instantiate]`. - */ - instantiate: RuntimeDescriptor<[origin: SS58String, value: bigint, gas_limit: Anonymize, storage_deposit_limit: Anonymize, code: Anonymize, data: Binary, salt: Binary], Anonymize>; - /** - * Upload new code without instantiating a contract from it. - * - * See [`crate::Pallet::bare_upload_code`]. - */ - upload_code: RuntimeDescriptor<[origin: SS58String, code: Binary, storage_deposit_limit: Anonymize, determinism: Anonymize], Anonymize>; - /** - * Query a given storage key in a given contract. - * - * Returns `Ok(Some(Vec))` if the storage value exists under the given key in the - * specified account and `Ok(None)` if it doesn't. If the account specified by the address - * doesn't exist, or doesn't have a contract then `Err` is returned. - */ - get_storage: RuntimeDescriptor<[address: SS58String, key: Binary], Anonymize>; - }; - /** - - */ - DelegateInfoRuntimeApi: { - /** - - */ - get_delegates: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_delegate: RuntimeDescriptor<[delegate_account: SS58String], Anonymize>; - /** - - */ - get_delegated: RuntimeDescriptor<[delegatee_account: SS58String], Anonymize>; - }; - /** - - */ - NeuronInfoRuntimeApi: { - /** - - */ - get_neurons: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_neuron: RuntimeDescriptor<[netuid: number, uid: number], Anonymize>; - /** - - */ - get_neurons_lite: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_neuron_lite: RuntimeDescriptor<[netuid: number, uid: number], Anonymize>; - }; - /** - - */ - SubnetInfoRuntimeApi: { - /** - - */ - get_subnet_info: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_subnets_info: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_subnet_info_v2: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_subnets_info_v2: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_subnet_hyperparams: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_subnet_hyperparams_v2: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_all_dynamic_info: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_all_metagraphs: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_metagraph: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_all_mechagraphs: RuntimeDescriptor<[], Anonymize>; - /** - - */ - get_mechagraph: RuntimeDescriptor<[netuid: number, mecid: number], Anonymize>; - /** - - */ - get_dynamic_info: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_subnet_state: RuntimeDescriptor<[netuid: number], Anonymize>; - /** - - */ - get_selective_metagraph: RuntimeDescriptor<[netuid: number, metagraph_indexes: Anonymize], Anonymize>; - /** - - */ - get_coldkey_auto_stake_hotkey: RuntimeDescriptor<[coldkey: SS58String, netuid: number], Anonymize>; - /** - - */ - get_selective_mechagraph: RuntimeDescriptor<[netuid: number, subid: number, metagraph_indexes: Anonymize], Anonymize>; - /** - - */ - get_subnet_to_prune: RuntimeDescriptor<[], Anonymize>; - }; - /** - - */ - StakeInfoRuntimeApi: { - /** - - */ - get_stake_info_for_coldkey: RuntimeDescriptor<[coldkey_account: SS58String], Anonymize>; - /** - - */ - get_stake_info_for_coldkeys: RuntimeDescriptor<[coldkey_accounts: Anonymize], Anonymize>; - /** - - */ - get_stake_info_for_hotkey_coldkey_netuid: RuntimeDescriptor<[hotkey_account: SS58String, coldkey_account: SS58String, netuid: number], Anonymize>; - /** - - */ - get_stake_fee: RuntimeDescriptor<[origin: Anonymize, origin_coldkey_account: SS58String, destination: Anonymize, destination_coldkey_account: SS58String, amount: bigint], bigint>; - }; - /** - - */ - SubnetRegistrationRuntimeApi: { - /** - - */ - get_network_registration_cost: RuntimeDescriptor<[], bigint>; - }; - /** - * API necessary for block authorship with BABE. - */ - BabeApi: { - /** - * Return the configuration for BABE. - */ - configuration: RuntimeDescriptor<[], Anonymize>; - /** - * Returns the slot that started the current epoch. - */ - current_epoch_start: RuntimeDescriptor<[], bigint>; - /** - * Returns information regarding the current epoch. - */ - current_epoch: RuntimeDescriptor<[], Anonymize>; - /** - * Returns information regarding the next epoch (which was already - * previously announced). - */ - next_epoch: RuntimeDescriptor<[], Anonymize>; - /** - * Generates a proof of key ownership for the given authority in the - * current epoch. An example usage of this module is coupled with the - * session historical module to prove that a given authority key is - * tied to a given staking identity during a specific session. Proofs - * of key ownership are necessary for submitting equivocation reports. - * NOTE: even though the API takes a `slot` as parameter the current - * implementations ignores this parameter and instead relies on this - * method being called at the correct block height, i.e. any point at - * which the epoch for the given slot is live on-chain. Future - * implementations will instead use indexed data through an offchain - * worker, not requiring older states to be available. - */ - generate_key_ownership_proof: RuntimeDescriptor<[slot: bigint, authority_id: FixedSizeBinary<32>], Anonymize>; - /** - * Submits an unsigned extrinsic to report an equivocation. The caller - * must provide the equivocation proof and a key ownership proof - * (should be obtained using `generate_key_ownership_proof`). The - * extrinsic will be unsigned and should only be accepted for local - * authorship (not to be broadcast to the network). This method returns - * `None` when creation of the extrinsic fails, e.g. if equivocation - * reporting is disabled for the given runtime (i.e. this method is - * hardcoded to return `None`). Only useful in an offchain context. - */ - submit_report_equivocation_unsigned_extrinsic: RuntimeDescriptor<[equivocation_proof: Anonymize, key_owner_proof: Binary], boolean>; - }; - /** - - */ - SwapRuntimeApi: { - /** - - */ - current_alpha_price: RuntimeDescriptor<[netuid: number], bigint>; - /** - - */ - current_alpha_price_all: RuntimeDescriptor<[], Anonymize>; - /** - - */ - sim_swap_tao_for_alpha: RuntimeDescriptor<[netuid: number, tao: bigint], Anonymize>; - /** - - */ - sim_swap_alpha_for_tao: RuntimeDescriptor<[netuid: number, alpha: bigint], Anonymize>; - }; -}; -export type DevnetDispatchError = Anonymize; -type IAsset = PlainDescriptor; -export type DevnetExtensions = {}; -type PalletsTypedef = { - __storage: IStorage; - __tx: ICalls; - __event: IEvent; - __error: IError; - __const: IConstants; - __view: IViewFns; -}; -export type Devnet = { - descriptors: { - pallets: PalletsTypedef; - apis: IRuntimeCalls; - } & Promise; - metadataTypes: Promise; - asset: IAsset; - extensions: DevnetExtensions; - getMetadata: () => Promise; - genesis: string | undefined; -}; -declare const _allDescriptors: Devnet; -export default _allDescriptors; -export type DevnetApis = ApisFromDef; -export type DevnetQueries = QueryFromPalletsDef; -export type DevnetCalls = TxFromPalletsDef; -export type DevnetEvents = EventsFromPalletsDef; -export type DevnetErrors = ErrorsFromPalletsDef; -export type DevnetConstants = ConstFromPalletsDef; -export type DevnetViewFns = ViewFnsFromPalletsDef; -export type DevnetCallData = Anonymize & { - value: { - type: string; - }; -}; -export type DevnetWhitelistEntry = PalletKey | ApiKey | `query.${NestedKey}` | `tx.${NestedKey}` | `event.${NestedKey}` | `error.${NestedKey}` | `const.${NestedKey}` | `view.${NestedKey}`; -type PalletKey = `*.${keyof (IStorage & ICalls & IEvent & IError & IConstants & IRuntimeCalls & IViewFns)}`; -type NestedKey>> = "*" | { - [P in keyof D & string]: `${P}.*` | { - [N in keyof D[P] & string]: `${P}.${N}`; - }[keyof D[P] & string]; -}[keyof D & string]; -type ApiKey>> = "api.*" | { - [P in keyof D & string]: `api.${P}.*` | { - [N in keyof D[P] & string]: `api.${P}.${N}`; - }[keyof D[P] & string]; -}[keyof D & string]; diff --git a/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs b/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs deleted file mode 100644 index 22a3f78b0e..0000000000 --- a/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs +++ /dev/null @@ -1,8 +0,0 @@ -import "./chunk-7P6ASYW6.mjs"; - -// .papi/descriptors/src/devnet_metadata.ts -var binMeta = "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"; -var devnet_metadata_default = binMeta; -export { - devnet_metadata_default as default -}; diff --git a/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts b/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts deleted file mode 100644 index e54c947520..0000000000 --- a/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts +++ /dev/null @@ -1,2 +0,0 @@ -declare const binMeta: string; -export default binMeta; diff --git a/contract-tests/.papi/descriptors/dist/index.d.ts b/contract-tests/.papi/descriptors/dist/index.d.ts deleted file mode 100644 index 2eb940c203..0000000000 --- a/contract-tests/.papi/descriptors/dist/index.d.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { default as devnet } from "./devnet"; -export { devnet }; -export type * from "./devnet"; -export { DigestItem, Phase, DispatchClass, TokenError, ArithmeticError, TransactionalError, GrandpaEvent, BalanceStatus, TransactionPaymentEvent, PreimageEvent, GrandpaStoredState, BalancesTypesReasons, PreimagePalletHoldReason, TransactionPaymentReleases, PreimageOldRequestStatus, PreimageRequestStatus, PreimagesBounded, GrandpaEquivocation, MultiAddress, BalancesAdjustmentDirection, MultiSigner, MultiSignature, TransactionValidityUnknownTransaction, TransactionValidityTransactionSource, BabeAllowedSlots } from './common-types'; -export declare const getMetadata: (codeHash: string) => Promise; -export * as contracts from './contracts'; diff --git a/contract-tests/.papi/descriptors/dist/index.js b/contract-tests/.papi/descriptors/dist/index.js deleted file mode 100644 index 3ffecd8693..0000000000 --- a/contract-tests/.papi/descriptors/dist/index.js +++ /dev/null @@ -1,194 +0,0 @@ -"use strict"; -var __defProp = Object.defineProperty; -var __getOwnPropDesc = Object.getOwnPropertyDescriptor; -var __getOwnPropNames = Object.getOwnPropertyNames; -var __hasOwnProp = Object.prototype.hasOwnProperty; -var __esm = (fn, res) => function __init() { - return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; -}; -var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); -}; -var __copyProps = (to, from, except, desc) => { - if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); - } - return to; -}; -var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); - -// .papi/descriptors/src/descriptors.ts -var descriptors_exports = {}; -__export(descriptors_exports, { - Devnet: () => Devnet -}); -var minified, commonTrees, tokens, replaceTokens, tokenizedCommonTrees, unwrap, getChainDescriptors, Devnet; -var init_descriptors = __esm({ - ".papi/descriptors/src/descriptors.ts"() { - "use strict"; - [minified, commonTrees, tokens] = JSON.parse(`[{"devnet":{"storage":{"2":{"0":0,"1":4,"ExtrinsicCount":1,"InherentsApplied":2,"BlockWeight":3,"AllExtrinsicsLen":1,"ExtrinsicData":5,"Number":1,"ParentHash":6,"Digest":7,"Events":8,"EventCount":1,"EventTopics":9,"LastRuntimeUpgrade":10,"UpgradedToU32RefCount":2,"UpgradedToTripleRefCount":2,"ExecutionPhase":11,"AuthorizedUpgrade":12,"ExtrinsicWeightReclaimed":13},"3":{"RandomMaterial":33},"4":{"Now":34,"DidUpdate":2},"6":{"5":33,"CurrentSlot":34},"7":{"5":40,"State":36,"PendingChange":37,"NextForced":1,"Stalled":38,"CurrentSetId":34,"SetIdSession":39},"9":{"0":44,"8":34,"InactiveIssuance":34,"Locks":45,"Reserves":46,"Holds":47,"Freezes":48},"10":{"NextFeeMultiplier":34,"StorageVersion":66},"17":{"8":34,"11":86,"12":86,"13":86,"14":86,"15":112,"16":117,"MinActivityCutoff":1,"AdminFreezeWindow":1,"OwnerHyperparamRateLimit":1,"DissolveNetworkScheduleDuration":1,"LastHotkeySwapOnNetuid":68,"NextStakeJobId":34,"TaoWeight":34,"CKBurn":34,"MaxDelegateTake":1,"MinDelegateTake":1,"MaxChildkeyTake":1,"MinChildkeyTake":1,"Owner":69,"Delegates":70,"ChildkeyTake":71,"PendingChildKeys":72,"ChildKeys":73,"ParentKeys":73,"AlphaDividendsPerSubnet":68,"RootAlphaDividendsPerSubnet":68,"BlockEmission":34,"LastHotkeyEmissionOnNetuid":74,"SubnetLimit":1,"TotalStake":34,"SubnetMovingAlpha":34,"SubnetMovingPrice":75,"RootProp":75,"SubnetVolume":75,"SubnetTAO":75,"SubnetTaoProvided":75,"SubnetAlphaInEmission":75,"SubnetAlphaOutEmission":75,"SubnetTaoInEmission":75,"SubnetAlphaIn":75,"SubnetAlphaInProvided":75,"SubnetAlphaOut":75,"StakingHotkeys":76,"OwnedHotkeys":76,"AutoStakeDestination":77,"AutoStakeDestinationColdkeys":78,"ColdkeySwapAnnouncementDelay":1,"ColdkeySwapReannouncementDelay":1,"ColdkeySwapAnnouncements":79,"ColdkeySwapDisputes":70,"TotalHotkeyAlpha":74,"TotalHotkeyAlphaLastEpoch":74,"TotalHotkeyShares":74,"Alpha":80,"AlphaMapLastKey":81,"TokenSymbol":5,"SubnetTaoFlow":75,"SubnetEmaTaoFlow":82,"TaoFlowCutoff":34,"FlowNormExponent":34,"FlowEmaSmoothingFactor":34,"UsedWork":83,"MaxRegistrationsPerBlock":84,"TotalNetworks":1,"NetworkImmunityPeriod":34,"StartCallDelay":34,"NetworkMinLockCost":34,"NetworkLastLockCost":34,"NetworkLockReductionInterval":34,"SubnetOwnerCut":1,"NetworkRateLimit":34,"NominatorMinRequiredStake":34,"WeightsVersionKeyRateLimit":34,"LastRateLimitedBlock":85,"SubnetLocked":75,"LargestLocked":75,"Tempo":84,"FirstEmissionBlockNumber":75,"SubnetMechanism":84,"SubnetworkN":84,"NetworksAdded":86,"IsNetworkMember":87,"NetworkRegistrationAllowed":86,"NetworkPowRegistrationAllowed":86,"NetworkRegisteredAt":75,"PendingServerEmission":75,"PendingValidatorEmission":75,"PendingRootAlphaDivs":75,"PendingOwnerCut":75,"BlocksSinceLastStep":75,"LastMechansimStepBlock":75,"SubnetOwner":88,"SubnetOwnerHotkey":88,"RecycleOrBurn":89,"ServingRateLimit":75,"Rho":84,"AlphaSigmoidSteepness":84,"Kappa":84,"RegistrationsThisInterval":84,"POWRegistrationsThisInterval":84,"BurnRegistrationsThisInterval":84,"MinAllowedUids":84,"MaxAllowedUids":84,"ImmunityPeriod":84,"ActivityCutoff":84,"MaxWeightsLimit":84,"WeightsVersionKey":75,"MinAllowedWeights":84,"MaxAllowedValidators":84,"AdjustmentInterval":84,"BondsMovingAverage":75,"BondsPenalty":84,"BondsResetOn":86,"WeightsSetRateLimit":75,"ValidatorPruneLen":75,"ScalingLawPower":84,"TargetRegistrationsPerInterval":84,"AdjustmentAlpha":75,"CommitRevealWeightsEnabled":86,"Burn":75,"Difficulty":75,"MinBurn":75,"MaxBurn":75,"MinDifficulty":75,"MaxDifficulty":75,"LastAdjustmentBlock":75,"RegistrationsThisBlock":84,"EMAPriceHalvingBlocks":75,"RAORecycledForRegistration":75,"TxRateLimit":34,"TxDelegateTakeRateLimit":34,"TxChildkeyTakeRateLimit":34,"AlphaValues":90,"SubtokenEnabled":86,"VotingPower":68,"VotingPowerDisableAtBlock":75,"VotingPowerEmaAlpha":75,"ImmuneOwnerUidsLimit":84,"StakeWeight":91,"Uids":92,"Keys":93,"LoadedEmission":94,"Active":95,"Rank":91,"Trust":91,"Consensus":91,"Incentive":91,"Dividends":91,"Emission":96,"LastUpdate":96,"ValidatorTrust":91,"PruningScores":91,"ValidatorPermit":95,"Weights":97,"Bonds":97,"BlockAtRegistration":98,"Axons":99,"NeuronCertificates":100,"Prometheus":101,"IdentitiesV2":102,"SubnetIdentitiesV3":103,"TransactionKeyLastBlock":104,"LastTxBlock":105,"LastTxBlockChildKeyTake":105,"LastTxBlockDelegateTake":105,"StakeThreshold":34,"WeightCommits":106,"TimelockedWeightCommits":107,"CRV3WeightCommits":108,"CRV3WeightCommitsV2":107,"RevealPeriodEpochs":75,"LastColdkeyHotkeyStakeBlock":109,"StakingOperationRateLimiter":110,"RootClaimableThreshold":75,"RootClaimable":111,"RootClaimType":113,"StakingColdkeysByIndex":114,"StakingColdkeys":105,"NumStakingColdkeys":34,"NumRootClaim":34,"AssociatedEvmAddress":115,"SubnetLeases":116,"SubnetLeaseShares":68,"SubnetUidToLeaseId":84,"NextSubnetLeaseId":1,"AccumulatedLeaseDividends":75,"CommitRevealWeightsVersion":1,"NetworkRegistrationStartBlock":34,"MinNonImmuneUids":84,"MaxMechanismCount":1,"MechanismCountCurrent":84,"MechanismEmissionSplit":91,"PendingChildKeyCooldown":34},"18":0,"19":{"Key":228},"20":{"Multisigs":234},"21":{"StatusFor":245,"RequestStatusFor":246,"PreimageFor":247},"22":{"IncompleteSince":1,"Agenda":252,"Retries":253,"Lookup":254},"23":{"Proxies":269,"Announcements":270,"LastCallResult":271},"24":{"IdentityOf":286},"25":{"TimelockedIndex":289,"CommitmentOf":290,"LastCommitment":92,"LastBondsReset":92,"RevealedCommitments":291,"UsedSpaceOf":292,"MaxSpace":1},"26":{"PrecompileEnable":297},"27":{"EnteredUntil":1,"Deposits":74},"28":{"1":371,"Pending":367,"CounterForPending":1,"CurrentBlock":368,"CurrentReceipts":369,"CurrentTransactionStatuses":370},"29":{"AccountCodes":374,"AccountCodesMetadata":375,"AccountStorages":376,"WhitelistedCreators":377,"DisableWhitelistCheck":2},"30":{"ChainId":34},"31":{"BaseFeePerGas":386,"Elasticity":1},"32":{"16":117,"BeaconConfig":391,"Pulses":392,"LastStoredRound":34,"OldestStoredRound":34,"NextUnsignedAt":1},"33":{"16":117,"Crowdloans":397,"NextCrowdloanId":1,"Contributions":68,"CurrentCrowdloanId":1},"34":{"FeeRate":84,"FeeGlobalTao":75,"FeeGlobalAlpha":75,"Ticks":411,"SwapV3Initialized":86,"AlphaSqrtPrice":75,"CurrentTick":84,"CurrentLiquidity":75,"EnabledUserLiquidity":86,"Positions":412,"LastPositionId":34,"TickIndexBitmapWords":413,"ScrapReservoirTao":75,"ScrapReservoirAlpha":75},"35":{"PristineCode":423,"CodeInfoOf":424,"Nonce":34,"ContractInfoOf":425,"DeletionQueue":5,"DeletionQueueCounter":426,"MigrationInProgress":427},"36":{"CurrentKey":427,"NextKey":427,"Submissions":447,"KeyHashByBlock":4}},"tx":{"2":{"37":20,"remark":18,"set_heap_pages":19,"set_code_without_checks":20,"set_storage":21,"kill_storage":22,"kill_prefix":23,"remark_with_event":18,"authorize_upgrade":24,"authorize_upgrade_without_checks":24,"apply_authorized_upgrade":20},"3":0,"4":{"set":35},"6":0,"7":{"report_equivocation":41,"report_equivocation_unsigned":41,"note_stalled":42},"9":{"transfer_allow_death":49,"force_transfer":50,"transfer_keep_alive":49,"transfer_all":51,"force_unreserve":52,"upgrade_accounts":53,"force_set_balance":54,"force_adjust_total_issuance":55,"burn":56},"10":0,"17":{"38":146,"set_weights":118,"set_mechanism_weights":119,"batch_set_weights":120,"commit_weights":121,"commit_mechanism_weights":122,"batch_commit_weights":123,"reveal_weights":124,"reveal_mechanism_weights":125,"commit_crv3_mechanism_weights":126,"batch_reveal_weights":127,"decrease_take":128,"increase_take":128,"add_stake":129,"remove_stake":130,"serve_axon":131,"serve_axon_tls":132,"serve_prometheus":133,"register":134,"root_register":135,"burned_register":136,"swap_hotkey":137,"swap_coldkey":138,"set_childkey_take":139,"sudo_set_tx_childkey_take_rate_limit":140,"sudo_set_min_childkey_take":141,"sudo_set_max_childkey_take":141,"register_network":135,"faucet":142,"dissolve_network":143,"set_children":144,"schedule_swap_coldkey":145,"set_subnet_identity":147,"register_network_with_identity":148,"unstake_all":135,"unstake_all_alpha":135,"move_stake":149,"transfer_stake":150,"swap_stake":151,"add_stake_limit":152,"remove_stake_limit":153,"swap_stake_limit":154,"try_associate_hotkey":135,"start_call":155,"associate_evm_key":156,"recycle_alpha":157,"burn_alpha":157,"set_pending_childkey_cooldown":158,"remove_stake_full_limit":159,"register_leased_network":160,"terminate_lease":161,"update_symbol":162,"commit_timelocked_weights":163,"set_coldkey_auto_stake_hotkey":136,"commit_timelocked_mechanism_weights":164,"root_dissolve_network":155,"claim_root":165,"set_root_claim_type":166,"sudo_set_num_root_claims":167,"sudo_set_root_claim_threshold":168,"announce_coldkey_swap":169,"swap_coldkey_announced":145,"dispute_coldkey_swap":170,"reset_coldkey_swap":171,"enable_voting_power_tracking":155,"disable_voting_power_tracking":155,"sudo_set_voting_power_ema_alpha":172,"add_stake_burn":173},"18":{"batch":219,"as_derivative":220,"batch_all":219,"dispatch_as":221,"force_batch":219,"with_weight":222,"if_else":223,"dispatch_as_fallible":221},"19":{"sudo":229,"sudo_unchecked_weight":222,"set_key":230,"sudo_as":231,"remove_key":170},"20":{"39":239,"as_multi_threshold_1":235,"as_multi":236,"approve_as_multi":237,"cancel_as_multi":238},"21":{"note_preimage":248,"unnote_preimage":249,"request_preimage":249,"unrequest_preimage":249,"ensure_updated":250},"22":{"schedule":255,"cancel":256,"schedule_named":257,"cancel_named":258,"schedule_after":259,"schedule_named_after":260,"set_retry":261,"set_retry_named":262,"cancel_retry":263,"cancel_retry_named":258},"23":{"39":170,"proxy":274,"add_proxy":275,"remove_proxy":275,"remove_proxies":170,"create_pure":276,"kill_pure":277,"announce":278,"remove_announcement":278,"reject_announcement":279,"proxy_announced":280},"24":{"38":287,"clear_identity":288},"25":{"set_commitment":293,"set_max_space":294},"26":{"swap_authorities":298,"sudo_set_default_take":299,"sudo_set_tx_rate_limit":140,"sudo_set_serving_rate_limit":300,"sudo_set_min_difficulty":301,"sudo_set_max_difficulty":302,"sudo_set_weights_version_key":303,"sudo_set_weights_set_rate_limit":304,"sudo_set_adjustment_interval":305,"sudo_set_adjustment_alpha":306,"sudo_set_immunity_period":307,"sudo_set_min_allowed_weights":308,"sudo_set_max_allowed_uids":309,"sudo_set_kappa":310,"sudo_set_rho":311,"sudo_set_activity_cutoff":312,"sudo_set_network_registration_allowed":313,"sudo_set_network_pow_registration_allowed":313,"sudo_set_target_registrations_per_interval":314,"sudo_set_min_burn":315,"sudo_set_max_burn":316,"sudo_set_difficulty":317,"sudo_set_max_allowed_validators":318,"sudo_set_bonds_moving_average":319,"sudo_set_bonds_penalty":320,"sudo_set_max_registrations_per_block":321,"sudo_set_subnet_owner_cut":322,"sudo_set_network_rate_limit":323,"sudo_set_tempo":324,"sudo_set_total_issuance":325,"sudo_set_network_immunity_period":326,"sudo_set_network_min_lock_cost":327,"sudo_set_subnet_limit":328,"sudo_set_lock_reduction_interval":329,"sudo_set_rao_recycled":330,"sudo_set_stake_threshold":331,"sudo_set_nominator_min_required_stake":331,"sudo_set_tx_delegate_take_rate_limit":140,"sudo_set_min_delegate_take":141,"sudo_set_commit_reveal_weights_enabled":332,"sudo_set_liquid_alpha_enabled":332,"sudo_set_alpha_values":333,"sudo_set_dissolve_network_schedule_duration":334,"sudo_set_commit_reveal_weights_interval":335,"sudo_set_evm_chain_id":336,"schedule_grandpa_change":337,"sudo_set_toggle_transfer":338,"sudo_set_recycle_or_burn":339,"sudo_toggle_evm_precompile":340,"sudo_set_subnet_moving_alpha":341,"sudo_set_subnet_owner_hotkey":136,"sudo_set_ema_price_halving_period":342,"sudo_set_alpha_sigmoid_steepness":343,"sudo_set_yuma3_enabled":332,"sudo_set_bonds_reset_enabled":332,"sudo_set_sn_owner_hotkey":136,"sudo_set_subtoken_enabled":344,"sudo_set_commit_reveal_version":345,"sudo_set_owner_immune_neuron_limit":346,"sudo_set_ck_burn":347,"sudo_set_admin_freeze_window":348,"sudo_set_owner_hparam_rate_limit":349,"sudo_set_mechanism_count":350,"sudo_set_mechanism_emission_split":351,"sudo_trim_to_max_allowed_uids":352,"sudo_set_min_allowed_uids":353,"sudo_set_tao_flow_cutoff":354,"sudo_set_tao_flow_normalization_exponent":355,"sudo_set_tao_flow_smoothing_factor":356,"sudo_set_max_mechanism_count":357,"sudo_set_min_non_immune_uids":358,"sudo_set_start_call_delay":359,"sudo_set_coldkey_swap_announcement_delay":334,"sudo_set_coldkey_swap_reannouncement_delay":334},"27":{"enter":170,"force_enter":170,"extend":170,"force_extend":170,"force_exit":170,"force_slash_deposit":364,"release_deposit":364,"force_release_deposit":364},"28":{"transact":372},"29":{"40":378,"41":379,"42":380,"create2":381,"set_whitelist":382,"disable_whitelist":383},"30":0,"31":{"set_base_fee_per_gas":387,"set_elasticity":388},"32":{"write_pulse":393,"set_beacon_config":394,"set_oldest_stored_round":395},"33":{"40":401,"42":399,"contribute":400,"finalize":401,"refund":401,"dissolve":401,"update_min_contribution":402,"update_end":403,"update_cap":404},"34":{"set_fee_rate":414,"toggle_user_liquidity":415,"add_liquidity":416,"remove_liquidity":417,"modify_position":418,"disable_lp":170},"35":{"37":434,"41":435,"43":433,"44":437,"call_old_weight":430,"instantiate_with_code_old_weight":431,"instantiate_old_weight":432,"remove_code":24,"instantiate_with_code":436,"migrate":438},"36":{"announce_next_key":448,"submit_encrypted":449,"mark_decryption_failed":450}},"events":{"2":{"ExtrinsicSuccess":25,"ExtrinsicFailed":26,"CodeUpdated":27,"NewAccount":28,"KilledAccount":28,"Remarked":29,"UpgradeAuthorized":30,"RejectedInvalidAuthorizedUpgrade":31},"3":0,"4":0,"6":0,"7":{"NewAuthorities":43,"Paused":27,"Resumed":27},"9":{"Endowed":57,"DustLost":58,"Transfer":59,"BalanceSet":60,"Reserved":61,"Unreserved":61,"ReserveRepatriated":62,"Deposit":61,"Withdraw":61,"Slashed":61,"Minted":61,"Burned":61,"Suspended":61,"Restored":61,"Upgraded":63,"Issued":64,"Rescinded":64,"Locked":61,"Unlocked":61,"Frozen":61,"Thawed":61,"TotalIssuanceForced":65},"10":{"TransactionFeePaid":67},"17":{"11":181,"14":214,"15":191,"45":186,"46":27,"NetworkAdded":174,"NetworkRemoved":175,"StakeAdded":176,"StakeRemoved":176,"StakeMoved":177,"WeightsSet":174,"NeuronRegistered":178,"BulkNeuronsRegistered":174,"BulkBalancesSet":174,"MaxAllowedUidsSet":174,"MaxWeightLimitSet":174,"DifficultySet":179,"AdjustmentIntervalSet":174,"RegistrationPerIntervalSet":174,"MaxRegistrationsPerBlockSet":174,"ActivityCutoffSet":174,"RhoSet":174,"AlphaSigmoidSteepnessSet":180,"KappaSet":174,"MinAllowedWeightSet":174,"ValidatorPruneLenSet":179,"ScalingLawPowerSet":174,"WeightsSetRateLimitSet":179,"ImmunityPeriodSet":174,"BondsMovingAverageSet":179,"BondsPenaltySet":174,"BondsResetOnSet":181,"MaxAllowedValidatorsSet":174,"AxonServed":182,"PrometheusServed":182,"DelegateAdded":183,"DefaultTakeSet":175,"WeightsVersionKeySet":179,"MinDifficultySet":179,"MaxDifficultySet":179,"ServingRateLimitSet":179,"BurnSet":179,"MaxBurnSet":179,"MinBurnSet":179,"TxRateLimitSet":184,"TxDelegateTakeRateLimitSet":184,"TxChildKeyTakeRateLimitSet":184,"AdminFreezeWindowSet":175,"OwnerHyperparamRateLimitSet":175,"MinChildKeyTakeSet":175,"MaxChildKeyTakeSet":175,"ChildKeyTakeSet":185,"RegistrationAllowed":181,"PowRegistrationAllowed":181,"TempoSet":174,"RAORecycledForRegistrationSet":179,"StakeThresholdSet":184,"AdjustmentAlphaSet":179,"Faucet":187,"SubnetOwnerCutSet":175,"NetworkRateLimitSet":184,"NetworkImmunityPeriodSet":184,"StartCallDelaySet":184,"NetworkMinLockCostSet":184,"SubnetLimitSet":175,"NetworkLockCostReductionIntervalSet":184,"TakeDecreased":183,"TakeIncreased":183,"HotkeySwapped":188,"MaxDelegateTakeSet":175,"MinDelegateTakeSet":175,"ColdkeySwapAnnounced":189,"ColdkeySwapReset":63,"ColdkeySwapped":190,"ColdkeySwapDisputed":191,"AllBalanceUnstakedAndTransferredToNewColdkey":192,"ArbitrationPeriodExtended":191,"SetChildrenScheduled":193,"SetChildren":194,"ChainIdentitySet":195,"SubnetIdentitySet":175,"SubnetIdentityRemoved":175,"DissolveNetworkScheduled":196,"ColdkeySwapAnnouncementDelaySet":175,"ColdkeySwapReannouncementDelaySet":175,"DissolveNetworkScheduleDurationSet":175,"CRV3WeightsCommitted":197,"WeightsCommitted":197,"WeightsRevealed":197,"WeightsBatchRevealed":198,"BatchWeightsCompleted":199,"BatchWeightItemFailed":200,"StakeTransferred":201,"StakeSwapped":202,"SubnetOwnerHotkeySet":182,"FirstEmissionBlockNumberSet":179,"AlphaRecycled":203,"AlphaBurned":203,"EvmKeyAssociated":204,"CRV3WeightsRevealed":182,"CommitRevealPeriodsSet":179,"CommitRevealEnabled":181,"HotkeySwappedOnSubnet":205,"SubnetLeaseCreated":206,"SubnetLeaseTerminated":207,"SymbolUpdated":208,"CommitRevealVersionSet":175,"TimelockedWeightsCommitted":209,"TimelockedWeightsRevealed":182,"AutoStakeAdded":210,"IncentiveAlphaEmittedToMiners":211,"MinAllowedUidsSet":174,"AutoStakeDestinationSet":212,"MinNonImmuneUidsSet":174,"RootClaimTypeSet":213,"VotingPowerTrackingDisableScheduled":215,"VotingPowerTrackingDisabled":214,"VotingPowerEmaAlphaSet":216,"SubnetLeaseDividendsDistributed":217,"AddStakeBurn":218},"18":{"46":27,"BatchInterrupted":224,"BatchCompleted":27,"ItemCompleted":27,"ItemFailed":225,"DispatchedAs":226,"IfElseMainSuccess":27,"IfElseFallbackCalled":227},"19":{"45":232,"KeyChanged":233,"KeyRemoved":27,"SudoAsDone":232},"20":{"47":244,"NewMultisig":240,"MultisigApproval":241,"MultisigExecuted":242,"MultisigCancelled":243},"21":{"Noted":251,"Requested":251,"Cleared":251},"22":{"Scheduled":264,"Canceled":264,"Dispatched":265,"RetrySet":266,"RetryCancelled":267,"CallUnavailable":267,"PeriodicFailed":267,"RetryFailed":267,"PermanentlyOverweight":267,"AgendaIncomplete":268},"23":{"47":285,"ProxyExecuted":226,"PureCreated":281,"PureKilled":282,"Announced":283,"ProxyAdded":284,"ProxyRemoved":284},"24":{"IdentitySet":63,"IdentityDissolved":63},"25":{"Commitment":295,"TimelockCommitment":296,"CommitmentRevealed":295},"26":{"PrecompileUpdated":360,"Yuma3EnableToggled":361,"BondsResetToggled":361},"27":{"Entered":365,"Extended":365,"Exited":366,"DepositPlaced":58,"DepositReleased":58,"DepositSlashed":58,"CannotDeposit":27,"CannotRelease":27},"28":{"48":373},"29":{"48":385,"49":385,"Log":384,"CreatedFailed":385,"ExecutedFailed":385},"30":0,"31":{"NewBaseFeePerGas":389,"BaseFeeOverflow":27,"NewElasticity":390},"32":{"BeaconConfigChanged":27,"NewPulse":396,"SetOldestStoredRound":184},"33":{"49":405,"Contributed":406,"Withdrew":406,"PartiallyRefunded":407,"AllRefunded":407,"Finalized":407,"Dissolved":407,"MinContributionUpdated":408,"EndUpdated":409,"CapUpdated":410},"34":{"FeeRateSet":419,"UserLiquidityToggled":420,"LiquidityAdded":421,"LiquidityRemoved":422,"LiquidityModified":422},"35":{"Instantiated":439,"Terminated":440,"CodeStored":441,"ContractEmitted":442,"CodeRemoved":443,"ContractCodeUpdated":444,"Called":445,"DelegateCalled":446,"StorageDepositTransferredAndHeld":59,"StorageDepositTransferredAndReleased":59},"36":{"EncryptedSubmitted":451,"DecryptedExecuted":452,"DecryptedRejected":453,"DecryptionFailed":454}},"constants":{"2":{"BlockWeights":14,"BlockLength":15,"BlockHashCount":1,"DbWeight":16,"Version":17,"SS58Prefix":1},"3":0,"4":{"MinimumPeriod":34},"6":{"SlotDuration":34},"7":{"MaxAuthorities":1,"MaxNominators":1,"MaxSetIdSessionEntries":34},"9":{"ExistentialDeposit":34,"MaxLocks":1,"MaxReserves":1,"MaxFreezes":1},"10":{"OperationalFeeMultiplier":1},"17":{"12":2,"13":2,"InitialIssuance":34,"InitialMinAllowedWeights":1,"InitialEmissionValue":1,"InitialTempo":1,"InitialDifficulty":34,"InitialMaxDifficulty":34,"InitialMinDifficulty":34,"InitialRAORecycledForRegistration":34,"InitialBurn":34,"InitialMaxBurn":34,"InitialMinBurn":34,"MinBurnUpperBound":34,"MaxBurnLowerBound":34,"InitialAdjustmentInterval":1,"InitialBondsMovingAverage":34,"InitialBondsPenalty":1,"InitialBondsResetOn":2,"InitialTargetRegistrationsPerInterval":1,"InitialRho":1,"InitialAlphaSigmoidSteepness":1,"InitialKappa":1,"InitialMinAllowedUids":1,"InitialMaxAllowedUids":1,"InitialValidatorPruneLen":34,"InitialScalingLawPower":1,"InitialImmunityPeriod":1,"InitialActivityCutoff":1,"InitialMaxRegistrationsPerBlock":1,"InitialPruningScore":1,"InitialMaxAllowedValidators":1,"InitialDefaultDelegateTake":1,"InitialMinDelegateTake":1,"InitialDefaultChildKeyTake":1,"InitialMinChildKeyTake":1,"InitialMaxChildKeyTake":1,"InitialWeightsVersionKey":34,"InitialServingRateLimit":34,"InitialTxRateLimit":34,"InitialTxDelegateTakeRateLimit":34,"InitialTxChildKeyTakeRateLimit":34,"InitialAdjustmentAlpha":34,"InitialNetworkImmunityPeriod":34,"InitialNetworkMinLockCost":34,"InitialSubnetOwnerCut":1,"InitialNetworkLockReductionInterval":34,"InitialNetworkRateLimit":34,"KeySwapCost":34,"AlphaHigh":1,"AlphaLow":1,"InitialColdkeySwapAnnouncementDelay":1,"InitialColdkeySwapReannouncementDelay":1,"InitialDissolveNetworkScheduleDuration":1,"InitialTaoWeight":34,"InitialEmaPriceHalvingPeriod":34,"InitialStartCallDelay":34,"KeySwapOnSubnetCost":34,"HotkeySwapOnSubnetInterval":34,"LeaseDividendsDistributionInterval":1,"MaxImmuneUidsPercentage":1},"18":{"batched_calls_limit":1},"19":0,"20":{"DepositBase":34,"DepositFactor":34,"MaxSignatories":1},"21":0,"22":{"MaximumWeight":13,"MaxScheduledPerBlock":1},"23":{"ProxyDepositBase":34,"ProxyDepositFactor":34,"MaxProxies":1,"MaxPending":1,"AnnouncementDepositBase":34,"AnnouncementDepositFactor":34},"24":{"50":34,"51":34,"MaxAdditionalFields":1},"25":{"50":34,"51":34,"MaxFields":1},"26":0,"27":{"EnterDuration":1,"ExtendDuration":1,"EnterDepositAmount":362,"ExtendDepositAmount":362,"ReleaseDelay":363},"28":0,"29":0,"30":0,"31":0,"32":{"UnsignedPriority":34,"HttpFetchTimeout":34},"33":{"PalletId":398,"MinimumDeposit":34,"AbsoluteMinimumContribution":34,"MinimumBlockDuration":1,"MaximumBlockDuration":1,"RefundContributorsLimit":1,"MaxContributors":1},"34":{"ProtocolId":398,"MaxFeeRate":1,"MaxPositions":1,"MinimumLiquidity":34,"MinimumReserve":34},"35":{"Schedule":428,"DepositPerByte":34,"DefaultDepositLimit":34,"DepositPerItem":34,"CodeHashLockupDepositPercent":1,"MaxCodeLen":1,"MaxStorageKeyLen":1,"MaxTransientStorageSize":1,"MaxDelegateDependencies":1,"UnsafeUnstableInterface":2,"MaxDebugBufferLen":1,"Environment":429,"ApiVersion":1},"36":0},"viewFns":{"2":0,"3":0,"4":0,"6":0,"7":0,"9":0,"10":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":{"check_permissions":272,"is_superset":273},"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0},"apis":{"Core":{"version":455,"execute_block":456,"initialize_block":457},"Metadata":{"metadata":458,"metadata_at_version":459,"metadata_versions":460},"BlockBuilder":{"apply_extrinsic":461,"finalize_block":462,"inherent_extrinsics":463,"check_inherents":464},"GenesisBuilder":{"build_state":465,"get_preset":466,"preset_names":467},"TaggedTransactionQueue":{"validate_transaction":468},"OffchainWorkerApi":{"offchain_worker":469},"AuraApi":{"slot_duration":470,"authorities":471},"SessionKeys":{"generate_session_keys":472,"decode_session_keys":473},"GrandpaApi":{"52":475,"53":476,"grandpa_authorities":474,"current_set_id":470},"AccountNonceApi":{"account_nonce":477},"TransactionPaymentApi":{"54":480,"55":481,"query_info":478,"query_fee_details":479},"TransactionPaymentCallApi":{"54":480,"55":481,"query_call_info":482,"query_call_fee_details":483},"EthereumRuntimeRPCApi":{"41":489,"42":490,"chain_id":470,"account_basic":484,"gas_price":485,"account_code_at":486,"author":487,"storage_at":488,"current_block":491,"current_receipts":492,"current_transaction_statuses":493,"current_all":494,"extrinsic_filter":495,"elasticity":496,"gas_limit_multiplier_support":497,"pending_block":498,"initialize_pending_block":469},"ConvertTransactionRuntimeApi":{"convert_transaction":499},"ContractsApi":{"41":500,"43":502,"44":501,"get_storage":503},"DelegateInfoRuntimeApi":{"get_delegates":504,"get_delegate":505,"get_delegated":506},"NeuronInfoRuntimeApi":{"get_neurons":507,"get_neuron":508,"get_neurons_lite":509,"get_neuron_lite":510},"SubnetInfoRuntimeApi":{"get_subnet_info":511,"get_subnets_info":512,"get_subnet_info_v2":513,"get_subnets_info_v2":514,"get_subnet_hyperparams":515,"get_subnet_hyperparams_v2":516,"get_all_dynamic_info":517,"get_all_metagraphs":518,"get_metagraph":519,"get_all_mechagraphs":518,"get_mechagraph":520,"get_dynamic_info":521,"get_subnet_state":522,"get_selective_metagraph":523,"get_coldkey_auto_stake_hotkey":524,"get_selective_mechagraph":525,"get_subnet_to_prune":496},"StakeInfoRuntimeApi":{"get_stake_info_for_coldkey":526,"get_stake_info_for_coldkeys":527,"get_stake_info_for_hotkey_coldkey_netuid":528,"get_stake_fee":529},"SubnetRegistrationRuntimeApi":{"get_network_registration_cost":470},"BabeApi":{"52":533,"53":532,"configuration":530,"current_epoch_start":470,"current_epoch":531,"next_epoch":531},"SwapRuntimeApi":{"current_alpha_price":534,"current_alpha_price_all":535,"sim_swap_tao_for_alpha":536,"sim_swap_alpha_for_tao":537}}}},[{}],["Account","BlockHash","System","RandomnessCollectiveFlip","Timestamp","Authorities","Aura","Grandpa","TotalIssuance","Balances","TransactionPayment","TransferToggle","LiquidAlphaOn","Yuma3On","VotingPowerTrackingEnabled","RootClaimed","HasMigrationRun","SubtensorModule","Utility","Sudo","Multisig","Preimage","Scheduler","Proxy","Registry","Commitments","AdminUtils","SafeMode","Ethereum","EVM","EVMChainId","BaseFee","Drand","Crowdloan","Swap","Contracts","MevShield","set_code","set_identity","poke_deposit","withdraw","call","create","upload_code","instantiate","Sudid","BatchCompletedWithErrors","DepositPoked","Executed","Created","InitialDeposit","FieldDeposit","submit_report_equivocation_unsigned_extrinsic","generate_key_ownership_proof","query_weight_to_fee","query_length_to_fee"]]`); - replaceTokens = (obj) => Object.fromEntries( - Object.entries(obj).map(([key, value]) => { - const unwrappedValue = typeof value === "object" ? replaceTokens(value) : value; - const numericKey = Number(key); - if (Number.isNaN(numericKey)) { - return [key, unwrappedValue]; - } - return [tokens[numericKey], unwrappedValue]; - }) - ); - tokenizedCommonTrees = commonTrees.map(replaceTokens); - unwrap = (obj, depth) => depth === 0 ? obj : Object.fromEntries( - Object.entries(obj).map(([key, value]) => [ - key, - unwrap( - typeof value === "object" ? value : tokenizedCommonTrees[value], - depth - 1 - ) - ]) - ); - getChainDescriptors = (key) => unwrap(replaceTokens(minified[key]), 2); - Devnet = getChainDescriptors("devnet"); - } -}); - -// .papi/descriptors/src/metadataTypes.ts -var metadataTypes_exports = {}; -__export(metadataTypes_exports, { - default: () => metadataTypes_default -}); -var content, metadataTypes_default; -var init_metadataTypes = __esm({ - ".papi/descriptors/src/metadataTypes.ts"() { - "use strict"; - content = "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"; - metadataTypes_default = content; - } -}); - -// .papi/descriptors/src/devnet_metadata.ts -var devnet_metadata_exports = {}; -__export(devnet_metadata_exports, { - default: () => devnet_metadata_default -}); -var binMeta, devnet_metadata_default; -var init_devnet_metadata = __esm({ - ".papi/descriptors/src/devnet_metadata.ts"() { - "use strict"; - binMeta = "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"; - devnet_metadata_default = binMeta; - } -}); - -// .papi/descriptors/src/index.ts -var index_exports = {}; -__export(index_exports, { - ArithmeticError: () => ArithmeticError, - BabeAllowedSlots: () => BabeAllowedSlots, - BalanceStatus: () => BalanceStatus, - BalancesAdjustmentDirection: () => BalancesAdjustmentDirection, - BalancesTypesReasons: () => BalancesTypesReasons, - DigestItem: () => DigestItem, - DispatchClass: () => DispatchClass, - GrandpaEquivocation: () => GrandpaEquivocation, - GrandpaEvent: () => GrandpaEvent, - GrandpaStoredState: () => GrandpaStoredState, - MultiAddress: () => MultiAddress, - MultiSignature: () => MultiSignature, - MultiSigner: () => MultiSigner, - Phase: () => Phase, - PreimageEvent: () => PreimageEvent, - PreimageOldRequestStatus: () => PreimageOldRequestStatus, - PreimagePalletHoldReason: () => PreimagePalletHoldReason, - PreimageRequestStatus: () => PreimageRequestStatus, - PreimagesBounded: () => PreimagesBounded, - TokenError: () => TokenError, - TransactionPaymentEvent: () => TransactionPaymentEvent, - TransactionPaymentReleases: () => TransactionPaymentReleases, - TransactionValidityTransactionSource: () => TransactionValidityTransactionSource, - TransactionValidityUnknownTransaction: () => TransactionValidityUnknownTransaction, - TransactionalError: () => TransactionalError, - contracts: () => contracts_exports, - devnet: () => devnet_default, - getMetadata: () => getMetadata2 -}); -module.exports = __toCommonJS(index_exports); - -// .papi/descriptors/src/common.ts -var table = new Uint8Array(128); -for (let i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i; -var toBinary = (base64) => { - const n = base64.length, bytes = new Uint8Array((n - Number(base64[n - 1] === "=") - Number(base64[n - 2] === "=")) * 3 / 4 | 0); - for (let i2 = 0, j = 0; i2 < n; ) { - const c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)]; - const c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)]; - bytes[j++] = c0 << 2 | c1 >> 4; - bytes[j++] = c1 << 4 | c2 >> 2; - bytes[j++] = c2 << 6 | c3; - } - return bytes; -}; - -// .papi/descriptors/src/devnet.ts -var descriptorValues = Promise.resolve().then(() => (init_descriptors(), descriptors_exports)).then((module2) => module2["Devnet"]); -var metadataTypes = Promise.resolve().then(() => (init_metadataTypes(), metadataTypes_exports)).then( - (module2) => toBinary("default" in module2 ? module2.default : module2) -); -var asset = {}; -var extensions = {}; -var getMetadata = () => Promise.resolve().then(() => (init_devnet_metadata(), devnet_metadata_exports)).then( - (module2) => toBinary("default" in module2 ? module2.default : module2) -); -var genesis = "0x56c04ae0094e08e671ff781eb7122ffca041a55d208befc4603bd441b44e8e3a"; -var _allDescriptors = { descriptors: descriptorValues, metadataTypes, asset, extensions, getMetadata, genesis }; -var devnet_default = _allDescriptors; - -// .papi/descriptors/src/common-types.ts -var import_polkadot_api = require("polkadot-api"); -var DigestItem = import_polkadot_api._Enum; -var Phase = import_polkadot_api._Enum; -var DispatchClass = import_polkadot_api._Enum; -var TokenError = import_polkadot_api._Enum; -var ArithmeticError = import_polkadot_api._Enum; -var TransactionalError = import_polkadot_api._Enum; -var GrandpaEvent = import_polkadot_api._Enum; -var BalanceStatus = import_polkadot_api._Enum; -var TransactionPaymentEvent = import_polkadot_api._Enum; -var PreimageEvent = import_polkadot_api._Enum; -var GrandpaStoredState = import_polkadot_api._Enum; -var BalancesTypesReasons = import_polkadot_api._Enum; -var PreimagePalletHoldReason = import_polkadot_api._Enum; -var TransactionPaymentReleases = import_polkadot_api._Enum; -var PreimageOldRequestStatus = import_polkadot_api._Enum; -var PreimageRequestStatus = import_polkadot_api._Enum; -var PreimagesBounded = import_polkadot_api._Enum; -var GrandpaEquivocation = import_polkadot_api._Enum; -var MultiAddress = import_polkadot_api._Enum; -var BalancesAdjustmentDirection = import_polkadot_api._Enum; -var MultiSigner = import_polkadot_api._Enum; -var MultiSignature = import_polkadot_api._Enum; -var TransactionValidityUnknownTransaction = import_polkadot_api._Enum; -var TransactionValidityTransactionSource = import_polkadot_api._Enum; -var BabeAllowedSlots = import_polkadot_api._Enum; - -// .papi/descriptors/src/contracts/index.ts -var contracts_exports = {}; -__export(contracts_exports, { - bittensor: () => descriptor -}); - -// .papi/descriptors/src/contracts/bittensor.ts -var descriptor = { metadata: { "source": { "hash": "0xd15a29edfb7134dface2e0b6c704c173d47d3b48f1afc87193922ff8114e457d", "language": "ink! 5.1.1", "compiler": "rustc 1.89.0", "build_info": { "build_mode": "Release", "cargo_contract_version": "5.0.3", "rust_toolchain": "stable-aarch64-apple-darwin", "wasm_opt_settings": { "keep_debug_symbols": false, "optimization_passes": "Z" } } }, "contract": { "name": "bittensor", "version": "0.1.0", "authors": ["[your_name] <[your_email]>"] }, "image": null, "spec": { "constructors": [{ "args": [], "default": false, "docs": ["Constructor"], "label": "new", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0x9bae9d5e" }, { "args": [], "default": false, "docs": ["Constructor"], "label": "default", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0xed4b9d1b" }], "docs": [], "environment": { "accountId": { "displayName": ["AccountId"], "type": 11 }, "balance": { "displayName": ["Balance"], "type": 14 }, "blockNumber": { "displayName": ["BlockNumber"], "type": 24 }, "chainExtension": { "displayName": ["ChainExtension"], "type": 25 }, "hash": { "displayName": ["Hash"], "type": 23 }, "maxEventTopics": 4, "staticBufferSize": 16384, "timestamp": { "displayName": ["Timestamp"], "type": 14 } }, "events": [], "lang_error": { "displayName": ["ink", "LangError"], "type": 3 }, "messages": [{ "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_stake_info_for_hotkey_coldkey_netuid", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 7 }, "selector": "0x5b73b8b9" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "add_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3a656e31" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x7758d434" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3f525cc7" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all_alpha", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xab74c422" }, { "args": [{ "label": "origin_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "destination_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "move_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa06b0c55" }, { "args": [{ "label": "destination_coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "transfer_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3528ef5e" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "swap_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x04f7ca30" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "add_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x30013b98" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "remove_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xc3ce39c8" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "swap_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x212ef7ad" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake_full_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa6d6ea64" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "set_coldkey_auto_stake_hotkey", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xe24f0d8a" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "add_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x528b6757" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "remove_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x129d4f75" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_alpha_price", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 21 }, "selector": "0x08adc2e2" }] }, "storage": { "root": { "layout": { "struct": { "fields": [], "name": "Bittensor" } }, "root_key": "0x00000000", "ty": 0 } }, "types": [{ "id": 0, "type": { "def": { "composite": {} }, "path": ["bittensor", "bittensor", "Bittensor"] } }, { "id": 1, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 2, "type": { "def": { "tuple": [] } } }, { "id": 3, "type": { "def": { "variant": { "variants": [{ "index": 1, "name": "CouldNotReadInput" }] } }, "path": ["ink_primitives", "LangError"] } }, { "id": 4, "type": { "def": { "array": { "len": 32, "type": 5 } } } }, { "id": 5, "type": { "def": { "primitive": "u8" } } }, { "id": 6, "type": { "def": { "primitive": "u16" } } }, { "id": 7, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 8 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 8 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 8, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 9 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 9 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 9, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "None" }, { "fields": [{ "type": 10 }], "index": 1, "name": "Some" }] } }, "params": [{ "name": "T", "type": 10 }], "path": ["Option"] } }, { "id": 10, "type": { "def": { "composite": { "fields": [{ "name": "hotkey", "type": 11, "typeName": "AccountId" }, { "name": "coldkey", "type": 11, "typeName": "AccountId" }, { "name": "netuid", "type": 12, "typeName": "Compact" }, { "name": "stake", "type": 13, "typeName": "Compact" }, { "name": "locked", "type": 15, "typeName": "Compact" }, { "name": "emission", "type": 13, "typeName": "Compact" }, { "name": "tao_emission", "type": 16, "typeName": "Compact" }, { "name": "drain", "type": 15, "typeName": "Compact" }, { "name": "is_registered", "type": 17, "typeName": "bool" }] } }, "params": [{ "name": "AccountId", "type": 11 }], "path": ["bittensor", "StakeInfo"] } }, { "id": 11, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "AccountId"] } }, { "id": 12, "type": { "def": { "compact": { "type": 6 } } } }, { "id": 13, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 14, "type": { "def": { "primitive": "u64" } } }, { "id": 15, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 16, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 17, "type": { "def": { "primitive": "bool" } } }, { "id": 18, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "ReadFailed" }, { "index": 1, "name": "WriteFailed" }] } }, "path": ["bittensor", "ReadWriteErrorCode"] } }, { "id": 19, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 20 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 20 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 20, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 21, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 22 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 22 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 22, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 14 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 14 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 23, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "Hash"] } }, { "id": 24, "type": { "def": { "primitive": "u32" } } }, { "id": 25, "type": { "def": { "variant": {} }, "path": ["bittensor", "RuntimeReadWrite"] } }], "version": 5 } }; - -// .papi/descriptors/src/index.ts -var metadatas = { ["0xf3fc94ee2cf40e8a3e48a4d88d4880d606a706312512f6e0317eba65e032a0d8"]: devnet_default }; -var getMetadata2 = async (codeHash) => { - try { - return await metadatas[codeHash].getMetadata(); - } catch { - } - return null; -}; diff --git a/contract-tests/.papi/descriptors/dist/index.mjs b/contract-tests/.papi/descriptors/dist/index.mjs deleted file mode 100644 index ed55d00497..0000000000 --- a/contract-tests/.papi/descriptors/dist/index.mjs +++ /dev/null @@ -1,109 +0,0 @@ -import { - __export -} from "./chunk-7P6ASYW6.mjs"; - -// .papi/descriptors/src/common.ts -var table = new Uint8Array(128); -for (let i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i; -var toBinary = (base64) => { - const n = base64.length, bytes = new Uint8Array((n - Number(base64[n - 1] === "=") - Number(base64[n - 2] === "=")) * 3 / 4 | 0); - for (let i2 = 0, j = 0; i2 < n; ) { - const c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)]; - const c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)]; - bytes[j++] = c0 << 2 | c1 >> 4; - bytes[j++] = c1 << 4 | c2 >> 2; - bytes[j++] = c2 << 6 | c3; - } - return bytes; -}; - -// .papi/descriptors/src/devnet.ts -var descriptorValues = import("./descriptors-UMN7HDMZ.mjs").then((module) => module["Devnet"]); -var metadataTypes = import("./metadataTypes-4SGFT3Q5.mjs").then( - (module) => toBinary("default" in module ? module.default : module) -); -var asset = {}; -var extensions = {}; -var getMetadata = () => import("./devnet_metadata-NGDS3DPZ.mjs").then( - (module) => toBinary("default" in module ? module.default : module) -); -var genesis = "0x56c04ae0094e08e671ff781eb7122ffca041a55d208befc4603bd441b44e8e3a"; -var _allDescriptors = { descriptors: descriptorValues, metadataTypes, asset, extensions, getMetadata, genesis }; -var devnet_default = _allDescriptors; - -// .papi/descriptors/src/common-types.ts -import { _Enum } from "polkadot-api"; -var DigestItem = _Enum; -var Phase = _Enum; -var DispatchClass = _Enum; -var TokenError = _Enum; -var ArithmeticError = _Enum; -var TransactionalError = _Enum; -var GrandpaEvent = _Enum; -var BalanceStatus = _Enum; -var TransactionPaymentEvent = _Enum; -var PreimageEvent = _Enum; -var GrandpaStoredState = _Enum; -var BalancesTypesReasons = _Enum; -var PreimagePalletHoldReason = _Enum; -var TransactionPaymentReleases = _Enum; -var PreimageOldRequestStatus = _Enum; -var PreimageRequestStatus = _Enum; -var PreimagesBounded = _Enum; -var GrandpaEquivocation = _Enum; -var MultiAddress = _Enum; -var BalancesAdjustmentDirection = _Enum; -var MultiSigner = _Enum; -var MultiSignature = _Enum; -var TransactionValidityUnknownTransaction = _Enum; -var TransactionValidityTransactionSource = _Enum; -var BabeAllowedSlots = _Enum; - -// .papi/descriptors/src/contracts/index.ts -var contracts_exports = {}; -__export(contracts_exports, { - bittensor: () => descriptor -}); - -// .papi/descriptors/src/contracts/bittensor.ts -var descriptor = { metadata: { "source": { "hash": "0xd15a29edfb7134dface2e0b6c704c173d47d3b48f1afc87193922ff8114e457d", "language": "ink! 5.1.1", "compiler": "rustc 1.89.0", "build_info": { "build_mode": "Release", "cargo_contract_version": "5.0.3", "rust_toolchain": "stable-aarch64-apple-darwin", "wasm_opt_settings": { "keep_debug_symbols": false, "optimization_passes": "Z" } } }, "contract": { "name": "bittensor", "version": "0.1.0", "authors": ["[your_name] <[your_email]>"] }, "image": null, "spec": { "constructors": [{ "args": [], "default": false, "docs": ["Constructor"], "label": "new", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0x9bae9d5e" }, { "args": [], "default": false, "docs": ["Constructor"], "label": "default", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0xed4b9d1b" }], "docs": [], "environment": { "accountId": { "displayName": ["AccountId"], "type": 11 }, "balance": { "displayName": ["Balance"], "type": 14 }, "blockNumber": { "displayName": ["BlockNumber"], "type": 24 }, "chainExtension": { "displayName": ["ChainExtension"], "type": 25 }, "hash": { "displayName": ["Hash"], "type": 23 }, "maxEventTopics": 4, "staticBufferSize": 16384, "timestamp": { "displayName": ["Timestamp"], "type": 14 } }, "events": [], "lang_error": { "displayName": ["ink", "LangError"], "type": 3 }, "messages": [{ "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_stake_info_for_hotkey_coldkey_netuid", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 7 }, "selector": "0x5b73b8b9" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "add_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3a656e31" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x7758d434" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3f525cc7" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all_alpha", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xab74c422" }, { "args": [{ "label": "origin_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "destination_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "move_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa06b0c55" }, { "args": [{ "label": "destination_coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "transfer_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3528ef5e" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "swap_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x04f7ca30" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "add_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x30013b98" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "remove_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xc3ce39c8" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "swap_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x212ef7ad" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake_full_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa6d6ea64" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "set_coldkey_auto_stake_hotkey", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xe24f0d8a" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "add_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x528b6757" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "remove_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x129d4f75" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_alpha_price", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 21 }, "selector": "0x08adc2e2" }] }, "storage": { "root": { "layout": { "struct": { "fields": [], "name": "Bittensor" } }, "root_key": "0x00000000", "ty": 0 } }, "types": [{ "id": 0, "type": { "def": { "composite": {} }, "path": ["bittensor", "bittensor", "Bittensor"] } }, { "id": 1, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 2, "type": { "def": { "tuple": [] } } }, { "id": 3, "type": { "def": { "variant": { "variants": [{ "index": 1, "name": "CouldNotReadInput" }] } }, "path": ["ink_primitives", "LangError"] } }, { "id": 4, "type": { "def": { "array": { "len": 32, "type": 5 } } } }, { "id": 5, "type": { "def": { "primitive": "u8" } } }, { "id": 6, "type": { "def": { "primitive": "u16" } } }, { "id": 7, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 8 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 8 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 8, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 9 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 9 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 9, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "None" }, { "fields": [{ "type": 10 }], "index": 1, "name": "Some" }] } }, "params": [{ "name": "T", "type": 10 }], "path": ["Option"] } }, { "id": 10, "type": { "def": { "composite": { "fields": [{ "name": "hotkey", "type": 11, "typeName": "AccountId" }, { "name": "coldkey", "type": 11, "typeName": "AccountId" }, { "name": "netuid", "type": 12, "typeName": "Compact" }, { "name": "stake", "type": 13, "typeName": "Compact" }, { "name": "locked", "type": 15, "typeName": "Compact" }, { "name": "emission", "type": 13, "typeName": "Compact" }, { "name": "tao_emission", "type": 16, "typeName": "Compact" }, { "name": "drain", "type": 15, "typeName": "Compact" }, { "name": "is_registered", "type": 17, "typeName": "bool" }] } }, "params": [{ "name": "AccountId", "type": 11 }], "path": ["bittensor", "StakeInfo"] } }, { "id": 11, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "AccountId"] } }, { "id": 12, "type": { "def": { "compact": { "type": 6 } } } }, { "id": 13, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 14, "type": { "def": { "primitive": "u64" } } }, { "id": 15, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 16, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 17, "type": { "def": { "primitive": "bool" } } }, { "id": 18, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "ReadFailed" }, { "index": 1, "name": "WriteFailed" }] } }, "path": ["bittensor", "ReadWriteErrorCode"] } }, { "id": 19, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 20 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 20 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 20, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 21, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 22 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 22 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 22, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 14 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 14 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 23, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "Hash"] } }, { "id": 24, "type": { "def": { "primitive": "u32" } } }, { "id": 25, "type": { "def": { "variant": {} }, "path": ["bittensor", "RuntimeReadWrite"] } }], "version": 5 } }; - -// .papi/descriptors/src/index.ts -var metadatas = { ["0xf3fc94ee2cf40e8a3e48a4d88d4880d606a706312512f6e0317eba65e032a0d8"]: devnet_default }; -var getMetadata2 = async (codeHash) => { - try { - return await metadatas[codeHash].getMetadata(); - } catch { - } - return null; -}; -export { - ArithmeticError, - BabeAllowedSlots, - BalanceStatus, - BalancesAdjustmentDirection, - BalancesTypesReasons, - DigestItem, - DispatchClass, - GrandpaEquivocation, - GrandpaEvent, - GrandpaStoredState, - MultiAddress, - MultiSignature, - MultiSigner, - Phase, - PreimageEvent, - PreimageOldRequestStatus, - PreimagePalletHoldReason, - PreimageRequestStatus, - PreimagesBounded, - TokenError, - TransactionPaymentEvent, - TransactionPaymentReleases, - TransactionValidityTransactionSource, - TransactionValidityUnknownTransaction, - TransactionalError, - contracts_exports as contracts, - devnet_default as devnet, - getMetadata2 as getMetadata -}; diff --git a/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs b/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs deleted file mode 100644 index 797b0fcb7b..0000000000 --- a/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs +++ /dev/null @@ -1,8 +0,0 @@ -import "./chunk-7P6ASYW6.mjs"; - -// .papi/descriptors/src/metadataTypes.ts -var content = "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"; -var metadataTypes_default = content; -export { - metadataTypes_default as default -}; diff --git a/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts b/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts deleted file mode 100644 index fa22880cac..0000000000 --- a/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts +++ /dev/null @@ -1,2 +0,0 @@ -declare const content = "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"; -export default content; diff --git a/contract-tests/.papi/descriptors/package.json b/contract-tests/.papi/descriptors/package.json deleted file mode 100644 index da4dce4e81..0000000000 --- a/contract-tests/.papi/descriptors/package.json +++ /dev/null @@ -1,24 +0,0 @@ -{ - "version": "0.1.0-autogenerated.15753407080843946085", - "name": "@polkadot-api/descriptors", - "files": [ - "dist" - ], - "exports": { - ".": { - "types": "./dist/index.d.ts", - "module": "./dist/index.mjs", - "import": "./dist/index.mjs", - "require": "./dist/index.js" - }, - "./package.json": "./package.json" - }, - "main": "./dist/index.js", - "module": "./dist/index.mjs", - "browser": "./dist/index.mjs", - "types": "./dist/index.d.ts", - "sideEffects": false, - "peerDependencies": { - "polkadot-api": ">=1.21.0" - } -} diff --git a/contract-tests/.papi/metadata/devnet.scale b/contract-tests/.papi/metadata/devnet.scale deleted file mode 100644 index 1ddd844aae6d0c9e66f46bdf2b00db118db60549..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 312629 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 z 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 diff --git a/contract-tests/.papi/polkadot-api.json b/contract-tests/.papi/polkadot-api.json deleted file mode 100644 index 020d9cdb7f..0000000000 --- a/contract-tests/.papi/polkadot-api.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "version": 0, - "descriptorPath": ".papi/descriptors", - "entries": { - "devnet": { - "wsUrl": "ws://localhost:9944", - "metadata": ".papi/metadata/devnet.scale", - "genesis": "0x56c04ae0094e08e671ff781eb7122ffca041a55d208befc4603bd441b44e8e3a", - "codeHash": "0xf3fc94ee2cf40e8a3e48a4d88d4880d606a706312512f6e0317eba65e032a0d8" - } - }, - "ink": { - "bittensor": ".papi/contracts/bittensor.json" - } -} From c291db6826c76a21b3d26322c0b91356a055e69c Mon Sep 17 00:00:00 2001 From: Greg Zaitsev Date: Tue, 7 Jul 2026 13:35:42 +0300 Subject: [PATCH 46/48] clippy --- pallets/subtensor/src/tests/coinbase.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 5fb22625f9..d6fa24b444 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -1,5 +1,6 @@ #![allow( unused, + clippy::arithmetic_side_effects, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used, @@ -13,12 +14,9 @@ use alloc::collections::BTreeMap; use approx::assert_abs_diff_eq; use frame_support::assert_ok; use sp_core::U256; -use substrate_fixed::{ - transcendental::sqrt, - types::{I64F64, I96F32, U64F64, U96F32}, -}; +use substrate_fixed::types::{I64F64, I96F32, U64F64, U96F32}; use subtensor_runtime_common::{AlphaBalance, NetUidStorageIndex}; -use subtensor_swap_interface::{SwapEngine, SwapHandler}; +use subtensor_swap_interface::SwapHandler; #[allow(clippy::arithmetic_side_effects)] fn close(value: u64, target: u64, eps: u64) { From 330137d8ec3dcbc69666fe910112934fd715ce02 Mon Sep 17 00:00:00 2001 From: UnarbosFour Date: Fri, 10 Jul 2026 17:04:25 +0300 Subject: [PATCH 47/48] cleanup merge --- pallets/subtensor/src/coinbase/root.rs | 301 ------------------------ pallets/subtensor/src/tests/networks.rs | 14 ++ 2 files changed, 14 insertions(+), 301 deletions(-) diff --git a/pallets/subtensor/src/coinbase/root.rs b/pallets/subtensor/src/coinbase/root.rs index 68445e3bc0..02df14c6b5 100644 --- a/pallets/subtensor/src/coinbase/root.rs +++ b/pallets/subtensor/src/coinbase/root.rs @@ -187,307 +187,6 @@ impl Pallet { Ok(()) } - /// Facilitates the removal of a user's subnetwork. - /// - /// # Args: - /// * 'origin': ('T::RuntimeOrigin'): The calling origin. Must be signed. - /// * 'netuid': ('u16'): The unique identifier of the network to be removed. - /// - /// # Event: - /// * 'NetworkRemoved': Emitted when a network is successfully removed. - /// - /// # Raises: - /// * 'MechanismDoesNotExist': If the specified network does not exist. - /// * 'NotSubnetOwner': If the caller does not own the specified subnet. - /// - pub fn do_dissolve_network(netuid: NetUid) -> dispatch::DispatchResult { - // --- The network exists? - ensure!( - Self::if_subnet_exist(netuid) && netuid != NetUid::ROOT, - Error::::SubnetNotExists - ); - - let reservoir_tao = T::SwapInterface::protocol_tao_reservoir(netuid); - let reservoir_alpha = T::SwapInterface::protocol_alpha_reservoir(netuid); - T::SwapInterface::clear_protocol_liquidity_reservoirs(netuid); - Self::increase_provided_tao_reserve(netuid, reservoir_tao); - Self::increase_provided_alpha_reserve(netuid, reservoir_alpha); - if !reservoir_tao.is_zero() { - TotalStake::::mutate(|total| { - *total = total.saturating_add(reservoir_tao); - }); - } - - Self::finalize_all_subnet_root_dividends(netuid); - - // --- Perform the cleanup before removing the network. - Self::destroy_alpha_in_out_stakes(netuid)?; - T::SwapInterface::clear_protocol_liquidity(netuid); - T::CommitmentsInterface::purge_netuid(netuid); - - // --- Remove the network - Self::remove_network(netuid); - - // --- Emit the NetworkRemoved event - log::info!("NetworkRemoved( netuid:{netuid:?} )"); - Self::deposit_event(Event::NetworkRemoved(netuid)); - - Ok(()) - } - - pub fn remove_network(netuid: NetUid) { - // --- 1. Get the owner and remove from SubnetOwner. - let owner_coldkey: T::AccountId = SubnetOwner::::get(netuid); - SubnetOwner::::remove(netuid); - - // --- 2. Remove network count. - SubnetworkN::::remove(netuid); - - // --- 3. Remove netuid from added networks. - NetworksAdded::::remove(netuid); - - // --- 4. Decrement the network counter. - TotalNetworks::::mutate(|n: &mut u16| *n = n.saturating_sub(1)); - - // --- 5. Remove various network-related storages. - NetworkRegisteredAt::::remove(netuid); - - // --- 6. Remove incentive mechanism memory. - let _ = Uids::::clear_prefix(netuid, u32::MAX, None); - let keys = Keys::::iter_prefix(netuid).collect::>(); - let _ = Keys::::clear_prefix(netuid, u32::MAX, None); - - // --- 8. Iterate over stored weights and fill the matrix. - for (uid_i, weights_i) in Weights::::iter_prefix(NetUidStorageIndex::ROOT) { - // Create a new vector to hold modified weights. - let mut modified_weights = weights_i.clone(); - for (subnet_id, weight) in modified_weights.iter_mut() { - // If the root network had a weight pointing to this netuid, set it to 0 - if subnet_id == &u16::from(netuid) { - *weight = 0; - } - } - Weights::::insert(NetUidStorageIndex::ROOT, uid_i, modified_weights); - } - - // --- 9. Remove various network-related parameters. - Active::::remove(netuid); - Emission::::remove(netuid); - - Consensus::::remove(netuid); - Dividends::::remove(netuid); - ValidatorPermit::::remove(netuid); - ValidatorTrust::::remove(netuid); - - for (_uid, key) in keys { - IsNetworkMember::::remove(key, netuid); - } - - // --- 10. Erase network parameters. - Tempo::::remove(netuid); - Kappa::::remove(netuid); - Difficulty::::remove(netuid); - MaxAllowedUids::::remove(netuid); - ImmunityPeriod::::remove(netuid); - ActivityCutoff::::remove(netuid); - ActivityCutoffFactorMilli::::remove(netuid); - LastEpochBlock::::remove(netuid); - PendingEpochAt::::remove(netuid); - SubnetEpochIndex::::remove(netuid); - MinAllowedWeights::::remove(netuid); - RegistrationsThisInterval::::remove(netuid); - POWRegistrationsThisInterval::::remove(netuid); - BurnRegistrationsThisInterval::::remove(netuid); - - // --- 11. AMM / price / accounting. - // SubnetTAO, SubnetAlpha{In,InProvided,Out} are already cleared during dissolve/destroy. - SubnetAlphaInEmission::::remove(netuid); - SubnetAlphaOutEmission::::remove(netuid); - SubnetTaoInEmission::::remove(netuid); - SubnetVolume::::remove(netuid); - SubnetMovingPrice::::remove(netuid); - SubnetTaoFlow::::remove(netuid); - SubnetEmaTaoFlow::::remove(netuid); - SubnetProtocolFlow::::remove(netuid); - SubnetEmaProtocolFlow::::remove(netuid); - SubnetExcessTao::::remove(netuid); - SubnetRootSellTao::::remove(netuid); - - // --- 13. Token / mechanism / registration toggles. - TokenSymbol::::remove(netuid); - SubnetMechanism::::remove(netuid); - SubnetOwnerHotkey::::remove(netuid); - NetworkRegistrationAllowed::::remove(netuid); - NetworkPowRegistrationAllowed::::remove(netuid); - - // --- 14. Locks & toggles. - TransferToggle::::remove(netuid); - SubnetLocked::::remove(netuid); - LargestLocked::::remove(netuid); - - // --- 15. Mechanism step / emissions bookkeeping. - FirstEmissionBlockNumber::::remove(netuid); - PendingValidatorEmission::::remove(netuid); - PendingServerEmission::::remove(netuid); - PendingRootAlphaDivs::::remove(netuid); - PendingOwnerCut::::remove(netuid); - MinerBurned::::remove(netuid); - BlocksSinceLastStep::::remove(netuid); - LastMechansimStepBlock::::remove(netuid); - LastAdjustmentBlock::::remove(netuid); - - // --- 16. Serving / rho / curves, and other per-net controls. - ServingRateLimit::::remove(netuid); - Rho::::remove(netuid); - AlphaSigmoidSteepness::::remove(netuid); - - MaxAllowedValidators::::remove(netuid); - BondsMovingAverage::::remove(netuid); - BondsPenalty::::remove(netuid); - BondsResetOn::::remove(netuid); - WeightsSetRateLimit::::remove(netuid); - ValidatorPruneLen::::remove(netuid); - ScalingLawPower::::remove(netuid); - TargetRegistrationsPerInterval::::remove(netuid); - CommitRevealWeightsEnabled::::remove(netuid); - - BurnHalfLife::::remove(netuid); - BurnIncreaseMult::::remove(netuid); - - Burn::::remove(netuid); - MinBurn::::remove(netuid); - MaxBurn::::remove(netuid); - MinDifficulty::::remove(netuid); - MaxDifficulty::::remove(netuid); - RegistrationsThisBlock::::remove(netuid); - EMAPriceHalvingBlocks::::remove(netuid); - RAORecycledForRegistration::::remove(netuid); - MaxRegistrationsPerBlock::::remove(netuid); - WeightsVersionKey::::remove(netuid); - - // --- 17. Subtoken / feature flags. - LiquidAlphaOn::::remove(netuid); - Yuma3On::::remove(netuid); - AlphaValues::::remove(netuid); - SubtokenEnabled::::remove(netuid); - OwnerCutAutoLockEnabled::::remove(netuid); - ImmuneOwnerUidsLimit::::remove(netuid); - - // --- 18. Consensus aux vectors. - StakeWeight::::remove(netuid); - LoadedEmission::::remove(netuid); - - // --- 19. DMAPs where netuid is the FIRST key: clear by prefix. - let _ = BlockAtRegistration::::clear_prefix(netuid, u32::MAX, None); - let _ = Axons::::clear_prefix(netuid, u32::MAX, None); - let _ = NeuronCertificates::::clear_prefix(netuid, u32::MAX, None); - let _ = Prometheus::::clear_prefix(netuid, u32::MAX, None); - let _ = AlphaDividendsPerSubnet::::clear_prefix(netuid, u32::MAX, None); - let _ = PendingChildKeys::::clear_prefix(netuid, u32::MAX, None); - let _ = AssociatedEvmAddress::::clear_prefix(netuid, u32::MAX, None); - - // Commit-reveal / weights commits (all per-net prefixes): - let mechanisms: u8 = MechanismCountCurrent::::get(netuid).into(); - for subid in 0..mechanisms { - let netuid_index = Self::get_mechanism_storage_index(netuid, subid.into()); - LastUpdate::::remove(netuid_index); - Incentive::::remove(netuid_index); - let _ = WeightCommits::::clear_prefix(netuid_index, u32::MAX, None); - let _ = TimelockedWeightCommits::::clear_prefix(netuid_index, u32::MAX, None); - let _ = CRV3WeightCommits::::clear_prefix(netuid_index, u32::MAX, None); - let _ = CRV3WeightCommitsV2::::clear_prefix(netuid_index, u32::MAX, None); - let _ = Bonds::::clear_prefix(netuid_index, u32::MAX, None); - let _ = Weights::::clear_prefix(netuid_index, u32::MAX, None); - } - RevealPeriodEpochs::::remove(netuid); - MechanismCountCurrent::::remove(netuid); - MechanismEmissionSplit::::remove(netuid); - - // Last hotkey swap (DMAP where netuid is FIRST key → easy) - let _ = LastHotkeySwapOnNetuid::::clear_prefix(netuid, u32::MAX, None); - - // --- 20. Identity maps across versions (netuid-scoped). - if SubnetIdentitiesV3::::contains_key(netuid) { - SubnetIdentitiesV3::::remove(netuid); - Self::deposit_event(Event::SubnetIdentityRemoved(netuid)); - } - - // --- 21. DMAP / NMAP where netuid is NOT the first key → iterate & remove. - - // ChildkeyTake: (hot, netuid) → u16 - { - let to_rm: sp_std::vec::Vec = ChildkeyTake::::iter() - .filter_map(|(hot, n, _)| if n == netuid { Some(hot) } else { None }) - .collect(); - for hot in to_rm { - ChildkeyTake::::remove(&hot, netuid); - } - } - // ChildKeys: (parent, netuid) → Vec<...> - { - let to_rm: sp_std::vec::Vec = ChildKeys::::iter() - .filter_map(|(parent, n, _)| if n == netuid { Some(parent) } else { None }) - .collect(); - for parent in to_rm { - ChildKeys::::remove(&parent, netuid); - } - } - // ParentKeys: (child, netuid) → Vec<...> - { - let to_rm: sp_std::vec::Vec = ParentKeys::::iter() - .filter_map(|(child, n, _)| if n == netuid { Some(child) } else { None }) - .collect(); - for child in to_rm { - ParentKeys::::remove(&child, netuid); - } - } - // LastHotkeyEmissionOnNetuid: (hot, netuid) → α - { - let to_rm: sp_std::vec::Vec = LastHotkeyEmissionOnNetuid::::iter() - .filter_map(|(hot, n, _)| if n == netuid { Some(hot) } else { None }) - .collect(); - for hot in to_rm { - LastHotkeyEmissionOnNetuid::::remove(&hot, netuid); - } - } - // TotalHotkeyAlphaLastEpoch: (hot, netuid) → ... - // (TotalHotkeyAlpha and TotalHotkeyShares were already removed during dissolve.) - { - let to_rm_alpha_last: sp_std::vec::Vec = - TotalHotkeyAlphaLastEpoch::::iter() - .filter_map(|(hot, n, _)| if n == netuid { Some(hot) } else { None }) - .collect(); - for hot in to_rm_alpha_last { - TotalHotkeyAlphaLastEpoch::::remove(&hot, netuid); - } - } - // TransactionKeyLastBlock NMAP: (hot, netuid, name) → u64 - { - let to_rm: sp_std::vec::Vec<(T::AccountId, u16)> = TransactionKeyLastBlock::::iter() - .filter_map( - |((hot, n, name), _)| if n == netuid { Some((hot, name)) } else { None }, - ) - .collect(); - for (hot, name) in to_rm { - TransactionKeyLastBlock::::remove((hot, netuid, name)); - } - } - // --- 22. Subnet leasing: remove mapping and any lease-scoped state linked to this netuid. - if let Some(lease_id) = SubnetUidToLeaseId::::take(netuid) { - SubnetLeases::::remove(lease_id); - let _ = SubnetLeaseShares::::clear_prefix(lease_id, u32::MAX, None); - AccumulatedLeaseDividends::::remove(lease_id); - } - - // --- 23: Locks cleanup - Self::destroy_lock_maps(netuid); - - // --- Final removal logging. - log::debug!( - "remove_network: netuid={netuid}, owner={owner_coldkey:?} removed successfully" - ); - } - #[allow(clippy::arithmetic_side_effects)] /// This function calculates the lock cost for a network based on the last lock amount, minimum lock cost, last lock block, and current block. /// The lock cost is calculated using the formula: diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs index f6161383be..90f150b923 100644 --- a/pallets/subtensor/src/tests/networks.rs +++ b/pallets/subtensor/src/tests/networks.rs @@ -732,6 +732,20 @@ fn dissolve_materializes_nonzero_protocol_reservoirs_before_cleanup() { assert_ok!(SubtensorModule::do_dissolve_network(net)); + // do_dissolve_network only queues the destructive cleanup, but it must + // materialize pending protocol reservoirs before the queued cleanup can + // compute stake payouts. + assert!(!pallet_subtensor_swap::BalancerTaoReservoir::::contains_key(net)); + assert!(!pallet_subtensor_swap::BalancerAlphaReservoir::::contains_key(net)); + assert_eq!(SubnetTAO::::get(net), reservoir_tao); + assert_eq!(SubnetAlphaIn::::get(net), reservoir_alpha); + assert_eq!( + SubtensorModule::get_coldkey_balance(&staker_cold), + staker_before + ); + + run_block_idle(); + // Reservoir alpha is treated like materialized protocol pool alpha. // The staker owns half the denominator, so receives half the reservoir // TAO pot; the protocol share is recycled. From 8ef2f3df1699218728c3ef08d698d74a605ebbdf Mon Sep 17 00:00:00 2001 From: unarbos Date: Fri, 10 Jul 2026 09:57:10 -0600 Subject: [PATCH 48/48] Review fixes: bump spec_version to 428, enable dead refund-path test, restore HotKeyAlreadyRegisteredInSubNet coverage - spec_version 427 -> 428: this PR changes consensus behavior (DustRemoval wiring, new balancer reservoir storage, coinbase injection, Pays::Yes on take extrinsics) but repeated devnet-ready merges neutralized the branch's earlier spec bumps. - test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failure was missing #[test] and never ran (masked by the file's allow(unused)); it passes once enabled. - test_swap_owner_new_hotkey_already_exists had been rewired to assert NonAssociatedColdKey, silently dropping coverage of the already-registered-in-subnet guard; the foreign-coldkey case is now its own test and the original coverage is restored. Co-authored-by: Cursor --- pallets/subtensor/src/tests/coinbase.rs | 1 + .../src/tests/swap_hotkey_with_subnet.rs | 42 +++++++++++++++++-- runtime/src/lib.rs | 2 +- 3 files changed, 40 insertions(+), 5 deletions(-) diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index d6fa24b444..240cf4b096 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -3763,6 +3763,7 @@ fn test_alpha_reservoir_counts_toward_subnet_issuance_across_blocks() { }); } +#[test] fn test_coinbase_inject_and_maybe_swap_reverts_excess_tao_deposit_on_swap_failure() { new_test_ext(1).execute_with(|| { let zero = U96F32::saturating_from_num(0); diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index c022c87a51..385c3c0e83 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -837,9 +837,9 @@ fn test_swap_owner_old_hotkey_not_exist() { }); } -// SKIP_WASM_BUILD=1 cargo test --package pallet-subtensor --lib -- tests::swap_hotkey_with_subnet::test_swap_owner_new_hotkey_already_exists --exact --nocapture +// SKIP_WASM_BUILD=1 cargo test --package pallet-subtensor --lib -- tests::swap_hotkey_with_subnet::test_swap_owner_new_hotkey_owned_by_another_coldkey --exact --nocapture #[test] -fn test_swap_owner_new_hotkey_already_exists() { +fn test_swap_owner_new_hotkey_owned_by_another_coldkey() { new_test_ext(1).execute_with(|| { let old_hotkey = U256::from(1); let new_hotkey = U256::from(2); @@ -849,11 +849,45 @@ fn test_swap_owner_new_hotkey_already_exists() { let netuid = add_dynamic_network(&old_hotkey, &coldkey); add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); + // new_hotkey already exists globally and is owned by a foreign coldkey, + // so the new-hotkey ownership check must reject the swap. + Owner::::insert(new_hotkey, another_coldkey); + + // Perform the swap + System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); + assert_err!( + SubtensorModule::do_swap_hotkey( + RuntimeOrigin::signed(coldkey), + &old_hotkey, + &new_hotkey, + Some(netuid), + false + ), + Error::::NonAssociatedColdKey + ); + + // Verify the swap + assert_eq!(Owner::::get(old_hotkey), coldkey); + assert!(Owner::::contains_key(old_hotkey)); + }); +} + +// SKIP_WASM_BUILD=1 cargo test --package pallet-subtensor --lib -- tests::swap_hotkey_with_subnet::test_swap_owner_new_hotkey_already_exists --exact --nocapture +#[test] +fn test_swap_owner_new_hotkey_already_exists() { + new_test_ext(1).execute_with(|| { + let old_hotkey = U256::from(1); + let new_hotkey = U256::from(2); + let coldkey = U256::from(3); + + let netuid = add_dynamic_network(&new_hotkey, &coldkey); + add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); + // old_hotkey is owned by coldkey; new_hotkey was already registered on `netuid` // by add_dynamic_network (the condition under test). Do NOT reassign new_hotkey to // a foreign coldkey — the new_hotkey-ownership check (NonAssociatedColdKey) would // then fire before the already-registered-in-subnet check this test targets. - Owner::::insert(new_hotkey, another_coldkey); + Owner::::insert(old_hotkey, coldkey); // Perform the swap System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); @@ -865,7 +899,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::NonAssociatedColdKey + Error::::HotKeyAlreadyRegisteredInSubNet ); // Verify the swap diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 10c3b45fa7..48106b0fdf 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -235,7 +235,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 427, + spec_version: 428, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1,