From e0134a31fd4244a7694583163ee10cfa3d2ee78a Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 24 Apr 2025 12:56:52 -0700 Subject: [PATCH 1/5] add one more attempt --- .github/workflows/e2e-subtensor-tests.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/e2e-subtensor-tests.yaml b/.github/workflows/e2e-subtensor-tests.yaml index 08e8c2606f..81576ffeef 100644 --- a/.github/workflows/e2e-subtensor-tests.yaml +++ b/.github/workflows/e2e-subtensor-tests.yaml @@ -107,7 +107,7 @@ jobs: - name: Run tests with retry run: | set +e - for i in 1 2; do + for i in 1 2 3; do echo "🔁 Attempt $i: Running tests" uv run pytest ${{ matrix.test-file }} -s status=$? @@ -116,8 +116,8 @@ jobs: break else echo "❌ Tests failed on attempt $i" - if [ $i -eq 2 ]; then - echo "Tests failed after 2 attempts" + if [ $i -eq 3 ]; then + echo "Tests failed after 3 attempts" exit 1 fi echo "Retrying..." From 49637640349b621f0784ca9149d710e61df1040f Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 24 Apr 2025 14:33:31 -0700 Subject: [PATCH 2/5] single test + logging --- .github/workflows/e2e-subtensor-tests.yaml | 3 ++- tests/e2e_tests/test_staking.py | 15 ++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/.github/workflows/e2e-subtensor-tests.yaml b/.github/workflows/e2e-subtensor-tests.yaml index 81576ffeef..2f62fab24e 100644 --- a/.github/workflows/e2e-subtensor-tests.yaml +++ b/.github/workflows/e2e-subtensor-tests.yaml @@ -38,9 +38,10 @@ jobs: - name: Find test files id: get-tests run: | - test_files=$(find tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))') + # test_files=$(find tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))') # keep it here for future debug # test_files=$(find tests/e2e_tests -type f -name "test*.py" | grep -E 'test_(incentive|commit_weights|set_weights)\.py$' | jq -R -s -c 'split("\n") | map(select(. != ""))') + test_files=$(find tests/e2e_tests -type f -name "test*.py" | grep -E 'test_staking.py$' | jq -R -s -c 'split("\n") | map(select(. != ""))') echo "test-files=$test_files" >> "$GITHUB_OUTPUT" shell: bash diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py index 55afa58beb..ae687ccbc8 100644 --- a/tests/e2e_tests/test_staking.py +++ b/tests/e2e_tests/test_staking.py @@ -354,7 +354,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.005, # 0.5% + rate_tolerance=0.001, # 0.5% allow_partial_stake=False, ) assert success is False @@ -375,7 +375,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.005, # 0.5% + rate_tolerance=0.001, # 0.5% allow_partial_stake=True, ) assert success is True @@ -424,13 +424,17 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): rate_tolerance=0.005, # 0.5% allow_partial_stake=False, ) - assert success is False + assert success is False, "Unstake should fail." current_stake = subtensor.get_stake( alice_wallet.coldkey.ss58_address, bob_wallet.hotkey.ss58_address, netuid=alice_subnet_netuid, ) + + logging.console.info(f"[orange]Current stake: {current_stake}[orange]") + logging.console.info(f"[orange]Full stake: {full_stake}[orange]") + assert current_stake == full_stake, ( "Stake should not change after failed unstake attempt" ) @@ -444,7 +448,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.005, # 0.5% + rate_tolerance=0.001, # 0.5% allow_partial_stake=True, ) assert success is True @@ -454,6 +458,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): bob_wallet.hotkey.ss58_address, netuid=alice_subnet_netuid, ) + logging.console.info(f"[orange]Partial unstake: {partial_unstake}[orange]") assert partial_unstake > Balance(0), "Some stake should remain" # 3. Higher threshold - should succeed fully @@ -468,7 +473,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): rate_tolerance=0.3, # 30% allow_partial_stake=False, ) - assert success is True + assert success is True, "Unstake should succeed" def test_safe_swap_stake_scenarios(subtensor, alice_wallet, bob_wallet): From 120e64458b659f611b3142b3f0449580c529d0ed Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 24 Apr 2025 14:46:06 -0700 Subject: [PATCH 3/5] just one test --- tests/e2e_tests/test_staking.py | 1204 +++++++++++++++---------------- 1 file changed, 602 insertions(+), 602 deletions(-) diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py index ae687ccbc8..f0673c7532 100644 --- a/tests/e2e_tests/test_staking.py +++ b/tests/e2e_tests/test_staking.py @@ -8,298 +8,298 @@ logging.enable_info() -def test_single_operation(subtensor, alice_wallet, bob_wallet): - """ - Tests: - - Staking using `add_stake` - - Unstaking using `unstake` - - Checks StakeInfo - """ - alice_subnet_netuid = subtensor.get_total_subnets() # 2 - - # Register root as Alice - the subnet owner and validator - assert subtensor.register_subnet(alice_wallet, True, True) - - # Verify subnet created successfully - assert subtensor.subnet_exists(alice_subnet_netuid), ( - "Subnet wasn't created successfully" - ) - - assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) - - subtensor.burned_register( - alice_wallet, - netuid=alice_subnet_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - subtensor.burned_register( - bob_wallet, - netuid=alice_subnet_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - ) - - assert stake == Balance(0).set_unit(alice_subnet_netuid) - - success = subtensor.add_stake( - alice_wallet, - bob_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - amount=Balance.from_tao(1), - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - assert success is True - - stake_alice = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - alice_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - ) - - stake_bob = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - ) - - assert stake_bob > Balance(0).set_unit(alice_subnet_netuid) - - stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), - locked=Balance(0).set_unit(alice_subnet_netuid), - emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), - locked=Balance(0).set_unit(alice_subnet_netuid), - emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - ] - - stakes = subtensor.get_stake_info_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), - locked=Balance(0).set_unit(alice_subnet_netuid), - emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), - locked=Balance(0).set_unit(alice_subnet_netuid), - emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - ] - - stakes = subtensor.get_stake_for_coldkey_and_hotkey( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - ) - - assert stakes == { - 0: StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=0, - stake=Balance(0), - locked=Balance(0), - emission=Balance(0), - drain=0, - is_registered=False, - ), - 1: StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=1, - stake=stake.set_unit(1), - locked=Balance.from_tao(0, netuid=1), - emission=Balance.from_tao(0, netuid=1), - drain=0, - is_registered=False, - ), - 2: StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[2].stake.rao, alice_subnet_netuid), - locked=Balance.from_tao(0, netuid=alice_subnet_netuid), - emission=get_dynamic_balance(stakes[2].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - } - - success = subtensor.unstake( - alice_wallet, - bob_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - amount=stake_bob, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - assert success is True - - stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - ) - - assert stake == Balance(0).set_unit(alice_subnet_netuid) - - -def test_batch_operations(subtensor, alice_wallet, bob_wallet): - """ - Tests: - - Staking using `add_stake_multiple` - - Unstaking using `unstake_multiple` - - Checks StakeInfo - - Checks Accounts Balance - """ - - netuids = [ - 2, - 3, - ] - - for _ in netuids: - subtensor.register_subnet( - alice_wallet, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - # make sure we passed start_call limit for both subnets - for netuid in netuids: - assert wait_to_start_call(subtensor, alice_wallet, netuid) - - for netuid in netuids: - subtensor.burned_register( - bob_wallet, - netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - for netuid in netuids: - stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=netuid, - ) - - assert stake == Balance(0), f"netuid={netuid} stake={stake}" - - balances = subtensor.get_balances( - alice_wallet.coldkey.ss58_address, - bob_wallet.coldkey.ss58_address, - ) - - assert balances == { - alice_wallet.coldkey.ss58_address: get_dynamic_balance( - balances[alice_wallet.coldkey.ss58_address].rao, 2 - ), - bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998).set_unit(3), - } - - alice_balance = balances[alice_wallet.coldkey.ss58_address] - - success = subtensor.add_stake_multiple( - alice_wallet, - hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], - netuids=netuids, - amounts=[Balance.from_tao(10_000) for _ in netuids], - ) - - assert success is True - - stakes = [ - subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=netuid, - ) - for netuid in netuids - ] - - for netuid, stake in zip(netuids, stakes): - assert stake > Balance(0), f"netuid={netuid} stake={stake}" - - alice_balance -= len(netuids) * Balance.from_tao(10_000) - - balances = subtensor.get_balances( - alice_wallet.coldkey.ss58_address, - bob_wallet.coldkey.ss58_address, - ) - - assert balances == { - alice_wallet.coldkey.ss58_address: ApproxBalance(alice_balance.rao), - bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), - } - - success = subtensor.unstake_multiple( - alice_wallet, - hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], - netuids=netuids, - amounts=[Balance.from_tao(100) for _ in netuids], - ) - - assert success is True - - for netuid, old_stake in zip(netuids, stakes): - stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - bob_wallet.hotkey.ss58_address, - netuid=netuid, - ) - - assert stake < old_stake, f"netuid={netuid} stake={stake}" - - balances = subtensor.get_balances( - alice_wallet.coldkey.ss58_address, - bob_wallet.coldkey.ss58_address, - ) - - assert balances == { - alice_wallet.coldkey.ss58_address: get_dynamic_balance( - balances[alice_wallet.coldkey.ss58_address].rao, 2 - ), - bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), - } - assert balances[alice_wallet.coldkey.ss58_address] > alice_balance +# def test_single_operation(subtensor, alice_wallet, bob_wallet): +# """ +# Tests: +# - Staking using `add_stake` +# - Unstaking using `unstake` +# - Checks StakeInfo +# """ +# alice_subnet_netuid = subtensor.get_total_subnets() # 2 +# +# # Register root as Alice - the subnet owner and validator +# assert subtensor.register_subnet(alice_wallet, True, True) +# +# # Verify subnet created successfully +# assert subtensor.subnet_exists(alice_subnet_netuid), ( +# "Subnet wasn't created successfully" +# ) +# +# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) +# +# subtensor.burned_register( +# alice_wallet, +# netuid=alice_subnet_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# subtensor.burned_register( +# bob_wallet, +# netuid=alice_subnet_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# ) +# +# assert stake == Balance(0).set_unit(alice_subnet_netuid) +# +# success = subtensor.add_stake( +# alice_wallet, +# bob_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# amount=Balance.from_tao(1), +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# assert success is True +# +# stake_alice = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# alice_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# ) +# +# stake_bob = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# ) +# +# assert stake_bob > Balance(0).set_unit(alice_subnet_netuid) +# +# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), +# locked=Balance(0).set_unit(alice_subnet_netuid), +# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), +# locked=Balance(0).set_unit(alice_subnet_netuid), +# emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# ] +# +# stakes = subtensor.get_stake_info_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), +# locked=Balance(0).set_unit(alice_subnet_netuid), +# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), +# locked=Balance(0).set_unit(alice_subnet_netuid), +# emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# ] +# +# stakes = subtensor.get_stake_for_coldkey_and_hotkey( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# ) +# +# assert stakes == { +# 0: StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=0, +# stake=Balance(0), +# locked=Balance(0), +# emission=Balance(0), +# drain=0, +# is_registered=False, +# ), +# 1: StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=1, +# stake=stake.set_unit(1), +# locked=Balance.from_tao(0, netuid=1), +# emission=Balance.from_tao(0, netuid=1), +# drain=0, +# is_registered=False, +# ), +# 2: StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[2].stake.rao, alice_subnet_netuid), +# locked=Balance.from_tao(0, netuid=alice_subnet_netuid), +# emission=get_dynamic_balance(stakes[2].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# } +# +# success = subtensor.unstake( +# alice_wallet, +# bob_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# amount=stake_bob, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# assert success is True +# +# stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# ) +# +# assert stake == Balance(0).set_unit(alice_subnet_netuid) +# +# +# def test_batch_operations(subtensor, alice_wallet, bob_wallet): +# """ +# Tests: +# - Staking using `add_stake_multiple` +# - Unstaking using `unstake_multiple` +# - Checks StakeInfo +# - Checks Accounts Balance +# """ +# +# netuids = [ +# 2, +# 3, +# ] +# +# for _ in netuids: +# subtensor.register_subnet( +# alice_wallet, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# # make sure we passed start_call limit for both subnets +# for netuid in netuids: +# assert wait_to_start_call(subtensor, alice_wallet, netuid) +# +# for netuid in netuids: +# subtensor.burned_register( +# bob_wallet, +# netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# for netuid in netuids: +# stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=netuid, +# ) +# +# assert stake == Balance(0), f"netuid={netuid} stake={stake}" +# +# balances = subtensor.get_balances( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.coldkey.ss58_address, +# ) +# +# assert balances == { +# alice_wallet.coldkey.ss58_address: get_dynamic_balance( +# balances[alice_wallet.coldkey.ss58_address].rao, 2 +# ), +# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998).set_unit(3), +# } +# +# alice_balance = balances[alice_wallet.coldkey.ss58_address] +# +# success = subtensor.add_stake_multiple( +# alice_wallet, +# hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], +# netuids=netuids, +# amounts=[Balance.from_tao(10_000) for _ in netuids], +# ) +# +# assert success is True +# +# stakes = [ +# subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=netuid, +# ) +# for netuid in netuids +# ] +# +# for netuid, stake in zip(netuids, stakes): +# assert stake > Balance(0), f"netuid={netuid} stake={stake}" +# +# alice_balance -= len(netuids) * Balance.from_tao(10_000) +# +# balances = subtensor.get_balances( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.coldkey.ss58_address, +# ) +# +# assert balances == { +# alice_wallet.coldkey.ss58_address: ApproxBalance(alice_balance.rao), +# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), +# } +# +# success = subtensor.unstake_multiple( +# alice_wallet, +# hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], +# netuids=netuids, +# amounts=[Balance.from_tao(100) for _ in netuids], +# ) +# +# assert success is True +# +# for netuid, old_stake in zip(netuids, stakes): +# stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.hotkey.ss58_address, +# netuid=netuid, +# ) +# +# assert stake < old_stake, f"netuid={netuid} stake={stake}" +# +# balances = subtensor.get_balances( +# alice_wallet.coldkey.ss58_address, +# bob_wallet.coldkey.ss58_address, +# ) +# +# assert balances == { +# alice_wallet.coldkey.ss58_address: get_dynamic_balance( +# balances[alice_wallet.coldkey.ss58_address].rao, 2 +# ), +# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), +# } +# assert balances[alice_wallet.coldkey.ss58_address] > alice_balance def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): @@ -476,313 +476,313 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): assert success is True, "Unstake should succeed" -def test_safe_swap_stake_scenarios(subtensor, alice_wallet, bob_wallet): - """ - Tests safe swap stake scenarios with different parameters. - - Tests: - 1. Fails with strict threshold (0.5%) - 2. Succeeds with lenient threshold (10%) - """ - # Create new subnet (netuid 2) and register Alice - origin_netuid = 2 - assert subtensor.register_subnet(bob_wallet, True, True) - assert subtensor.subnet_exists(origin_netuid), "Subnet wasn't created successfully" - dest_netuid = 3 - assert subtensor.register_subnet(bob_wallet, True, True) - assert subtensor.subnet_exists(dest_netuid), "Subnet wasn't created successfully" - - # make sure we passed start_call limit for both subnets - assert wait_to_start_call(subtensor, bob_wallet, origin_netuid) - assert wait_to_start_call(subtensor, bob_wallet, dest_netuid) - - # Register Alice on both subnets - subtensor.burned_register( - alice_wallet, - netuid=origin_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - subtensor.burned_register( - alice_wallet, - netuid=dest_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - # Add initial stake to swap from - initial_stake_amount = Balance.from_tao(10_000) - success = subtensor.add_stake( - alice_wallet, - alice_wallet.hotkey.ss58_address, - netuid=origin_netuid, - amount=initial_stake_amount, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - assert success is True - - origin_stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - alice_wallet.hotkey.ss58_address, - netuid=origin_netuid, - ) - assert origin_stake > Balance(0), "Origin stake should be non-zero" - - stake_swap_amount = Balance.from_tao(10_000) - # 1. Try swap with strict threshold and big amount- should fail - success = subtensor.swap_stake( - wallet=alice_wallet, - hotkey_ss58=alice_wallet.hotkey.ss58_address, - origin_netuid=origin_netuid, - destination_netuid=dest_netuid, - amount=stake_swap_amount, - wait_for_inclusion=True, - wait_for_finalization=True, - safe_staking=True, - rate_tolerance=0.005, # 0.5% - allow_partial_stake=False, - ) - assert success is False - - # Verify no stake was moved - dest_stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - alice_wallet.hotkey.ss58_address, - netuid=dest_netuid, - ) - assert dest_stake == Balance(0), ( - "Destination stake should remain 0 after failed swap" - ) - - # 2. Try swap with higher threshold and less amount - should succeed - stake_swap_amount = Balance.from_tao(100) - success = subtensor.swap_stake( - wallet=alice_wallet, - hotkey_ss58=alice_wallet.hotkey.ss58_address, - origin_netuid=origin_netuid, - destination_netuid=dest_netuid, - amount=stake_swap_amount, - wait_for_inclusion=True, - wait_for_finalization=True, - safe_staking=True, - rate_tolerance=0.3, # 30% - allow_partial_stake=True, - ) - assert success is True - - # Verify stake was moved - origin_stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - alice_wallet.hotkey.ss58_address, - netuid=origin_netuid, - ) - dest_stake = subtensor.get_stake( - alice_wallet.coldkey.ss58_address, - alice_wallet.hotkey.ss58_address, - netuid=dest_netuid, - ) - assert dest_stake > Balance(0), ( - "Destination stake should be non-zero after successful swap" - ) - - -def test_move_stake(subtensor, alice_wallet, bob_wallet): - """ - Tests: - - Adding stake - - Moving stake from one hotkey-subnet pair to another - """ - - alice_subnet_netuid = subtensor.get_total_subnets() # 2 - assert subtensor.register_subnet(alice_wallet, True, True) - assert subtensor.subnet_exists(alice_subnet_netuid), ( - "Subnet wasn't created successfully" - ) - - assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) - - subtensor.burned_register( - alice_wallet, - netuid=alice_subnet_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - assert subtensor.add_stake( - alice_wallet, - alice_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - amount=Balance.from_tao(1_000), - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), - locked=Balance(0), - emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), - drain=0, - is_registered=True, - ), - ] - - bob_subnet_netuid = subtensor.get_total_subnets() # 3 - subtensor.register_subnet(bob_wallet, True, True) - assert subtensor.subnet_exists(bob_subnet_netuid), ( - "Subnet wasn't created successfully" - ) - - assert wait_to_start_call(subtensor, bob_wallet, bob_subnet_netuid) - - assert subtensor.move_stake( - alice_wallet, - origin_hotkey=alice_wallet.hotkey.ss58_address, - origin_netuid=alice_subnet_netuid, - destination_hotkey=bob_wallet.hotkey.ss58_address, - destination_netuid=bob_subnet_netuid, - amount=stakes[0].stake, - wait_for_finalization=True, - wait_for_inclusion=True, - ) - - stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(stakes[0].stake.rao, bob_subnet_netuid), - locked=Balance(0).set_unit(bob_subnet_netuid), - emission=get_dynamic_balance(stakes[0].emission.rao, bob_subnet_netuid), - drain=0, - is_registered=True, - ), - StakeInfo( - hotkey_ss58=bob_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=bob_subnet_netuid, - stake=get_dynamic_balance(stakes[1].stake.rao, bob_subnet_netuid), - locked=Balance(0).set_unit(bob_subnet_netuid), - emission=get_dynamic_balance(stakes[1].emission.rao, bob_subnet_netuid), - drain=0, - is_registered=True, - ), - ] - - -def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet): - """ - Tests: - - Adding stake - - Transferring stake from one coldkey-subnet pair to another - """ - alice_subnet_netuid = subtensor.get_total_subnets() # 2 - - assert subtensor.register_subnet(alice_wallet, True, True) - assert subtensor.subnet_exists(alice_subnet_netuid), ( - "Subnet wasn't created successfully" - ) - - assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) - - subtensor.burned_register( - alice_wallet, - netuid=alice_subnet_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - assert subtensor.add_stake( - alice_wallet, - alice_wallet.hotkey.ss58_address, - netuid=alice_subnet_netuid, - amount=Balance.from_tao(1_000), - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert alice_stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), - locked=Balance(0), - emission=get_dynamic_balance( - alice_stakes[0].emission.rao, alice_subnet_netuid - ), - drain=0, - is_registered=True, - ), - ] - - bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) - - assert bob_stakes == [] - - dave_subnet_netuid = subtensor.get_total_subnets() # 3 - subtensor.register_subnet(dave_wallet, True, True) - - assert wait_to_start_call(subtensor, dave_wallet, dave_subnet_netuid) - - subtensor.burned_register( - bob_wallet, - netuid=dave_subnet_netuid, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - assert subtensor.transfer_stake( - alice_wallet, - destination_coldkey_ss58=bob_wallet.coldkey.ss58_address, - hotkey_ss58=alice_wallet.hotkey.ss58_address, - origin_netuid=alice_subnet_netuid, - destination_netuid=dave_subnet_netuid, - amount=alice_stakes[0].stake, - wait_for_inclusion=True, - wait_for_finalization=True, - ) - - alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) - - assert alice_stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=alice_wallet.coldkey.ss58_address, - netuid=alice_subnet_netuid, - stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), - locked=Balance(0).set_unit(alice_subnet_netuid), - emission=get_dynamic_balance( - alice_stakes[0].emission.rao, alice_subnet_netuid - ), - drain=0, - is_registered=True, - ), - ] - - bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) - - assert bob_stakes == [ - StakeInfo( - hotkey_ss58=alice_wallet.hotkey.ss58_address, - coldkey_ss58=bob_wallet.coldkey.ss58_address, - netuid=dave_subnet_netuid, - stake=get_dynamic_balance(bob_stakes[0].stake.rao, dave_subnet_netuid), - locked=Balance(0), - emission=get_dynamic_balance( - bob_stakes[0].emission.rao, dave_subnet_netuid - ), - drain=0, - is_registered=False, - ), - ] +# def test_safe_swap_stake_scenarios(subtensor, alice_wallet, bob_wallet): +# """ +# Tests safe swap stake scenarios with different parameters. +# +# Tests: +# 1. Fails with strict threshold (0.5%) +# 2. Succeeds with lenient threshold (10%) +# """ +# # Create new subnet (netuid 2) and register Alice +# origin_netuid = 2 +# assert subtensor.register_subnet(bob_wallet, True, True) +# assert subtensor.subnet_exists(origin_netuid), "Subnet wasn't created successfully" +# dest_netuid = 3 +# assert subtensor.register_subnet(bob_wallet, True, True) +# assert subtensor.subnet_exists(dest_netuid), "Subnet wasn't created successfully" +# +# # make sure we passed start_call limit for both subnets +# assert wait_to_start_call(subtensor, bob_wallet, origin_netuid) +# assert wait_to_start_call(subtensor, bob_wallet, dest_netuid) +# +# # Register Alice on both subnets +# subtensor.burned_register( +# alice_wallet, +# netuid=origin_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# subtensor.burned_register( +# alice_wallet, +# netuid=dest_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# # Add initial stake to swap from +# initial_stake_amount = Balance.from_tao(10_000) +# success = subtensor.add_stake( +# alice_wallet, +# alice_wallet.hotkey.ss58_address, +# netuid=origin_netuid, +# amount=initial_stake_amount, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# assert success is True +# +# origin_stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# alice_wallet.hotkey.ss58_address, +# netuid=origin_netuid, +# ) +# assert origin_stake > Balance(0), "Origin stake should be non-zero" +# +# stake_swap_amount = Balance.from_tao(10_000) +# # 1. Try swap with strict threshold and big amount- should fail +# success = subtensor.swap_stake( +# wallet=alice_wallet, +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# origin_netuid=origin_netuid, +# destination_netuid=dest_netuid, +# amount=stake_swap_amount, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# safe_staking=True, +# rate_tolerance=0.005, # 0.5% +# allow_partial_stake=False, +# ) +# assert success is False +# +# # Verify no stake was moved +# dest_stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# alice_wallet.hotkey.ss58_address, +# netuid=dest_netuid, +# ) +# assert dest_stake == Balance(0), ( +# "Destination stake should remain 0 after failed swap" +# ) +# +# # 2. Try swap with higher threshold and less amount - should succeed +# stake_swap_amount = Balance.from_tao(100) +# success = subtensor.swap_stake( +# wallet=alice_wallet, +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# origin_netuid=origin_netuid, +# destination_netuid=dest_netuid, +# amount=stake_swap_amount, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# safe_staking=True, +# rate_tolerance=0.3, # 30% +# allow_partial_stake=True, +# ) +# assert success is True +# +# # Verify stake was moved +# origin_stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# alice_wallet.hotkey.ss58_address, +# netuid=origin_netuid, +# ) +# dest_stake = subtensor.get_stake( +# alice_wallet.coldkey.ss58_address, +# alice_wallet.hotkey.ss58_address, +# netuid=dest_netuid, +# ) +# assert dest_stake > Balance(0), ( +# "Destination stake should be non-zero after successful swap" +# ) +# +# +# def test_move_stake(subtensor, alice_wallet, bob_wallet): +# """ +# Tests: +# - Adding stake +# - Moving stake from one hotkey-subnet pair to another +# """ +# +# alice_subnet_netuid = subtensor.get_total_subnets() # 2 +# assert subtensor.register_subnet(alice_wallet, True, True) +# assert subtensor.subnet_exists(alice_subnet_netuid), ( +# "Subnet wasn't created successfully" +# ) +# +# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) +# +# subtensor.burned_register( +# alice_wallet, +# netuid=alice_subnet_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# assert subtensor.add_stake( +# alice_wallet, +# alice_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# amount=Balance.from_tao(1_000), +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), +# locked=Balance(0), +# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# ] +# +# bob_subnet_netuid = subtensor.get_total_subnets() # 3 +# subtensor.register_subnet(bob_wallet, True, True) +# assert subtensor.subnet_exists(bob_subnet_netuid), ( +# "Subnet wasn't created successfully" +# ) +# +# assert wait_to_start_call(subtensor, bob_wallet, bob_subnet_netuid) +# +# assert subtensor.move_stake( +# alice_wallet, +# origin_hotkey=alice_wallet.hotkey.ss58_address, +# origin_netuid=alice_subnet_netuid, +# destination_hotkey=bob_wallet.hotkey.ss58_address, +# destination_netuid=bob_subnet_netuid, +# amount=stakes[0].stake, +# wait_for_finalization=True, +# wait_for_inclusion=True, +# ) +# +# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(stakes[0].stake.rao, bob_subnet_netuid), +# locked=Balance(0).set_unit(bob_subnet_netuid), +# emission=get_dynamic_balance(stakes[0].emission.rao, bob_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# StakeInfo( +# hotkey_ss58=bob_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=bob_subnet_netuid, +# stake=get_dynamic_balance(stakes[1].stake.rao, bob_subnet_netuid), +# locked=Balance(0).set_unit(bob_subnet_netuid), +# emission=get_dynamic_balance(stakes[1].emission.rao, bob_subnet_netuid), +# drain=0, +# is_registered=True, +# ), +# ] +# +# +# def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet): +# """ +# Tests: +# - Adding stake +# - Transferring stake from one coldkey-subnet pair to another +# """ +# alice_subnet_netuid = subtensor.get_total_subnets() # 2 +# +# assert subtensor.register_subnet(alice_wallet, True, True) +# assert subtensor.subnet_exists(alice_subnet_netuid), ( +# "Subnet wasn't created successfully" +# ) +# +# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) +# +# subtensor.burned_register( +# alice_wallet, +# netuid=alice_subnet_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# assert subtensor.add_stake( +# alice_wallet, +# alice_wallet.hotkey.ss58_address, +# netuid=alice_subnet_netuid, +# amount=Balance.from_tao(1_000), +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert alice_stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), +# locked=Balance(0), +# emission=get_dynamic_balance( +# alice_stakes[0].emission.rao, alice_subnet_netuid +# ), +# drain=0, +# is_registered=True, +# ), +# ] +# +# bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) +# +# assert bob_stakes == [] +# +# dave_subnet_netuid = subtensor.get_total_subnets() # 3 +# subtensor.register_subnet(dave_wallet, True, True) +# +# assert wait_to_start_call(subtensor, dave_wallet, dave_subnet_netuid) +# +# subtensor.burned_register( +# bob_wallet, +# netuid=dave_subnet_netuid, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# assert subtensor.transfer_stake( +# alice_wallet, +# destination_coldkey_ss58=bob_wallet.coldkey.ss58_address, +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# origin_netuid=alice_subnet_netuid, +# destination_netuid=dave_subnet_netuid, +# amount=alice_stakes[0].stake, +# wait_for_inclusion=True, +# wait_for_finalization=True, +# ) +# +# alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) +# +# assert alice_stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=alice_wallet.coldkey.ss58_address, +# netuid=alice_subnet_netuid, +# stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), +# locked=Balance(0).set_unit(alice_subnet_netuid), +# emission=get_dynamic_balance( +# alice_stakes[0].emission.rao, alice_subnet_netuid +# ), +# drain=0, +# is_registered=True, +# ), +# ] +# +# bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) +# +# assert bob_stakes == [ +# StakeInfo( +# hotkey_ss58=alice_wallet.hotkey.ss58_address, +# coldkey_ss58=bob_wallet.coldkey.ss58_address, +# netuid=dave_subnet_netuid, +# stake=get_dynamic_balance(bob_stakes[0].stake.rao, dave_subnet_netuid), +# locked=Balance(0), +# emission=get_dynamic_balance( +# bob_stakes[0].emission.rao, dave_subnet_netuid +# ), +# drain=0, +# is_registered=False, +# ), +# ] From 22378f36fb6d9f380bb438d898c6b509aceaa3c6 Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 24 Apr 2025 14:57:23 -0700 Subject: [PATCH 4/5] left the comments for the future debug --- .github/workflows/e2e-subtensor-tests.yaml | 3 +- tests/e2e_tests/test_staking.py | 1204 ++++++++++---------- 2 files changed, 603 insertions(+), 604 deletions(-) diff --git a/.github/workflows/e2e-subtensor-tests.yaml b/.github/workflows/e2e-subtensor-tests.yaml index 2f62fab24e..81576ffeef 100644 --- a/.github/workflows/e2e-subtensor-tests.yaml +++ b/.github/workflows/e2e-subtensor-tests.yaml @@ -38,10 +38,9 @@ jobs: - name: Find test files id: get-tests run: | - # test_files=$(find tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))') + test_files=$(find tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))') # keep it here for future debug # test_files=$(find tests/e2e_tests -type f -name "test*.py" | grep -E 'test_(incentive|commit_weights|set_weights)\.py$' | jq -R -s -c 'split("\n") | map(select(. != ""))') - test_files=$(find tests/e2e_tests -type f -name "test*.py" | grep -E 'test_staking.py$' | jq -R -s -c 'split("\n") | map(select(. != ""))') echo "test-files=$test_files" >> "$GITHUB_OUTPUT" shell: bash diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py index f0673c7532..ae687ccbc8 100644 --- a/tests/e2e_tests/test_staking.py +++ b/tests/e2e_tests/test_staking.py @@ -8,298 +8,298 @@ logging.enable_info() -# def test_single_operation(subtensor, alice_wallet, bob_wallet): -# """ -# Tests: -# - Staking using `add_stake` -# - Unstaking using `unstake` -# - Checks StakeInfo -# """ -# alice_subnet_netuid = subtensor.get_total_subnets() # 2 -# -# # Register root as Alice - the subnet owner and validator -# assert subtensor.register_subnet(alice_wallet, True, True) -# -# # Verify subnet created successfully -# assert subtensor.subnet_exists(alice_subnet_netuid), ( -# "Subnet wasn't created successfully" -# ) -# -# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) -# -# subtensor.burned_register( -# alice_wallet, -# netuid=alice_subnet_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# subtensor.burned_register( -# bob_wallet, -# netuid=alice_subnet_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# ) -# -# assert stake == Balance(0).set_unit(alice_subnet_netuid) -# -# success = subtensor.add_stake( -# alice_wallet, -# bob_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# amount=Balance.from_tao(1), -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# assert success is True -# -# stake_alice = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# alice_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# ) -# -# stake_bob = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# ) -# -# assert stake_bob > Balance(0).set_unit(alice_subnet_netuid) -# -# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), -# locked=Balance(0).set_unit(alice_subnet_netuid), -# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), -# locked=Balance(0).set_unit(alice_subnet_netuid), -# emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# ] -# -# stakes = subtensor.get_stake_info_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), -# locked=Balance(0).set_unit(alice_subnet_netuid), -# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), -# locked=Balance(0).set_unit(alice_subnet_netuid), -# emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# ] -# -# stakes = subtensor.get_stake_for_coldkey_and_hotkey( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# ) -# -# assert stakes == { -# 0: StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=0, -# stake=Balance(0), -# locked=Balance(0), -# emission=Balance(0), -# drain=0, -# is_registered=False, -# ), -# 1: StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=1, -# stake=stake.set_unit(1), -# locked=Balance.from_tao(0, netuid=1), -# emission=Balance.from_tao(0, netuid=1), -# drain=0, -# is_registered=False, -# ), -# 2: StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[2].stake.rao, alice_subnet_netuid), -# locked=Balance.from_tao(0, netuid=alice_subnet_netuid), -# emission=get_dynamic_balance(stakes[2].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# } -# -# success = subtensor.unstake( -# alice_wallet, -# bob_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# amount=stake_bob, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# assert success is True -# -# stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# ) -# -# assert stake == Balance(0).set_unit(alice_subnet_netuid) -# -# -# def test_batch_operations(subtensor, alice_wallet, bob_wallet): -# """ -# Tests: -# - Staking using `add_stake_multiple` -# - Unstaking using `unstake_multiple` -# - Checks StakeInfo -# - Checks Accounts Balance -# """ -# -# netuids = [ -# 2, -# 3, -# ] -# -# for _ in netuids: -# subtensor.register_subnet( -# alice_wallet, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# # make sure we passed start_call limit for both subnets -# for netuid in netuids: -# assert wait_to_start_call(subtensor, alice_wallet, netuid) -# -# for netuid in netuids: -# subtensor.burned_register( -# bob_wallet, -# netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# for netuid in netuids: -# stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=netuid, -# ) -# -# assert stake == Balance(0), f"netuid={netuid} stake={stake}" -# -# balances = subtensor.get_balances( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.coldkey.ss58_address, -# ) -# -# assert balances == { -# alice_wallet.coldkey.ss58_address: get_dynamic_balance( -# balances[alice_wallet.coldkey.ss58_address].rao, 2 -# ), -# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998).set_unit(3), -# } -# -# alice_balance = balances[alice_wallet.coldkey.ss58_address] -# -# success = subtensor.add_stake_multiple( -# alice_wallet, -# hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], -# netuids=netuids, -# amounts=[Balance.from_tao(10_000) for _ in netuids], -# ) -# -# assert success is True -# -# stakes = [ -# subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=netuid, -# ) -# for netuid in netuids -# ] -# -# for netuid, stake in zip(netuids, stakes): -# assert stake > Balance(0), f"netuid={netuid} stake={stake}" -# -# alice_balance -= len(netuids) * Balance.from_tao(10_000) -# -# balances = subtensor.get_balances( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.coldkey.ss58_address, -# ) -# -# assert balances == { -# alice_wallet.coldkey.ss58_address: ApproxBalance(alice_balance.rao), -# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), -# } -# -# success = subtensor.unstake_multiple( -# alice_wallet, -# hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], -# netuids=netuids, -# amounts=[Balance.from_tao(100) for _ in netuids], -# ) -# -# assert success is True -# -# for netuid, old_stake in zip(netuids, stakes): -# stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.hotkey.ss58_address, -# netuid=netuid, -# ) -# -# assert stake < old_stake, f"netuid={netuid} stake={stake}" -# -# balances = subtensor.get_balances( -# alice_wallet.coldkey.ss58_address, -# bob_wallet.coldkey.ss58_address, -# ) -# -# assert balances == { -# alice_wallet.coldkey.ss58_address: get_dynamic_balance( -# balances[alice_wallet.coldkey.ss58_address].rao, 2 -# ), -# bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), -# } -# assert balances[alice_wallet.coldkey.ss58_address] > alice_balance +def test_single_operation(subtensor, alice_wallet, bob_wallet): + """ + Tests: + - Staking using `add_stake` + - Unstaking using `unstake` + - Checks StakeInfo + """ + alice_subnet_netuid = subtensor.get_total_subnets() # 2 + + # Register root as Alice - the subnet owner and validator + assert subtensor.register_subnet(alice_wallet, True, True) + + # Verify subnet created successfully + assert subtensor.subnet_exists(alice_subnet_netuid), ( + "Subnet wasn't created successfully" + ) + + assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) + + subtensor.burned_register( + alice_wallet, + netuid=alice_subnet_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + subtensor.burned_register( + bob_wallet, + netuid=alice_subnet_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + ) + + assert stake == Balance(0).set_unit(alice_subnet_netuid) + + success = subtensor.add_stake( + alice_wallet, + bob_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + amount=Balance.from_tao(1), + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + assert success is True + + stake_alice = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + alice_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + ) + + stake_bob = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + ) + + assert stake_bob > Balance(0).set_unit(alice_subnet_netuid) + + stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), + locked=Balance(0).set_unit(alice_subnet_netuid), + emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), + locked=Balance(0).set_unit(alice_subnet_netuid), + emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + ] + + stakes = subtensor.get_stake_info_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), + locked=Balance(0).set_unit(alice_subnet_netuid), + emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[1].stake.rao, alice_subnet_netuid), + locked=Balance(0).set_unit(alice_subnet_netuid), + emission=get_dynamic_balance(stakes[1].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + ] + + stakes = subtensor.get_stake_for_coldkey_and_hotkey( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + ) + + assert stakes == { + 0: StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=0, + stake=Balance(0), + locked=Balance(0), + emission=Balance(0), + drain=0, + is_registered=False, + ), + 1: StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=1, + stake=stake.set_unit(1), + locked=Balance.from_tao(0, netuid=1), + emission=Balance.from_tao(0, netuid=1), + drain=0, + is_registered=False, + ), + 2: StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[2].stake.rao, alice_subnet_netuid), + locked=Balance.from_tao(0, netuid=alice_subnet_netuid), + emission=get_dynamic_balance(stakes[2].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + } + + success = subtensor.unstake( + alice_wallet, + bob_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + amount=stake_bob, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + assert success is True + + stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + ) + + assert stake == Balance(0).set_unit(alice_subnet_netuid) + + +def test_batch_operations(subtensor, alice_wallet, bob_wallet): + """ + Tests: + - Staking using `add_stake_multiple` + - Unstaking using `unstake_multiple` + - Checks StakeInfo + - Checks Accounts Balance + """ + + netuids = [ + 2, + 3, + ] + + for _ in netuids: + subtensor.register_subnet( + alice_wallet, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + # make sure we passed start_call limit for both subnets + for netuid in netuids: + assert wait_to_start_call(subtensor, alice_wallet, netuid) + + for netuid in netuids: + subtensor.burned_register( + bob_wallet, + netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + for netuid in netuids: + stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=netuid, + ) + + assert stake == Balance(0), f"netuid={netuid} stake={stake}" + + balances = subtensor.get_balances( + alice_wallet.coldkey.ss58_address, + bob_wallet.coldkey.ss58_address, + ) + + assert balances == { + alice_wallet.coldkey.ss58_address: get_dynamic_balance( + balances[alice_wallet.coldkey.ss58_address].rao, 2 + ), + bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998).set_unit(3), + } + + alice_balance = balances[alice_wallet.coldkey.ss58_address] + + success = subtensor.add_stake_multiple( + alice_wallet, + hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], + netuids=netuids, + amounts=[Balance.from_tao(10_000) for _ in netuids], + ) + + assert success is True + + stakes = [ + subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=netuid, + ) + for netuid in netuids + ] + + for netuid, stake in zip(netuids, stakes): + assert stake > Balance(0), f"netuid={netuid} stake={stake}" + + alice_balance -= len(netuids) * Balance.from_tao(10_000) + + balances = subtensor.get_balances( + alice_wallet.coldkey.ss58_address, + bob_wallet.coldkey.ss58_address, + ) + + assert balances == { + alice_wallet.coldkey.ss58_address: ApproxBalance(alice_balance.rao), + bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), + } + + success = subtensor.unstake_multiple( + alice_wallet, + hotkey_ss58s=[bob_wallet.hotkey.ss58_address for _ in netuids], + netuids=netuids, + amounts=[Balance.from_tao(100) for _ in netuids], + ) + + assert success is True + + for netuid, old_stake in zip(netuids, stakes): + stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + bob_wallet.hotkey.ss58_address, + netuid=netuid, + ) + + assert stake < old_stake, f"netuid={netuid} stake={stake}" + + balances = subtensor.get_balances( + alice_wallet.coldkey.ss58_address, + bob_wallet.coldkey.ss58_address, + ) + + assert balances == { + alice_wallet.coldkey.ss58_address: get_dynamic_balance( + balances[alice_wallet.coldkey.ss58_address].rao, 2 + ), + bob_wallet.coldkey.ss58_address: Balance.from_tao(999_998), + } + assert balances[alice_wallet.coldkey.ss58_address] > alice_balance def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): @@ -476,313 +476,313 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): assert success is True, "Unstake should succeed" -# def test_safe_swap_stake_scenarios(subtensor, alice_wallet, bob_wallet): -# """ -# Tests safe swap stake scenarios with different parameters. -# -# Tests: -# 1. Fails with strict threshold (0.5%) -# 2. Succeeds with lenient threshold (10%) -# """ -# # Create new subnet (netuid 2) and register Alice -# origin_netuid = 2 -# assert subtensor.register_subnet(bob_wallet, True, True) -# assert subtensor.subnet_exists(origin_netuid), "Subnet wasn't created successfully" -# dest_netuid = 3 -# assert subtensor.register_subnet(bob_wallet, True, True) -# assert subtensor.subnet_exists(dest_netuid), "Subnet wasn't created successfully" -# -# # make sure we passed start_call limit for both subnets -# assert wait_to_start_call(subtensor, bob_wallet, origin_netuid) -# assert wait_to_start_call(subtensor, bob_wallet, dest_netuid) -# -# # Register Alice on both subnets -# subtensor.burned_register( -# alice_wallet, -# netuid=origin_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# subtensor.burned_register( -# alice_wallet, -# netuid=dest_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# # Add initial stake to swap from -# initial_stake_amount = Balance.from_tao(10_000) -# success = subtensor.add_stake( -# alice_wallet, -# alice_wallet.hotkey.ss58_address, -# netuid=origin_netuid, -# amount=initial_stake_amount, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# assert success is True -# -# origin_stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# alice_wallet.hotkey.ss58_address, -# netuid=origin_netuid, -# ) -# assert origin_stake > Balance(0), "Origin stake should be non-zero" -# -# stake_swap_amount = Balance.from_tao(10_000) -# # 1. Try swap with strict threshold and big amount- should fail -# success = subtensor.swap_stake( -# wallet=alice_wallet, -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# origin_netuid=origin_netuid, -# destination_netuid=dest_netuid, -# amount=stake_swap_amount, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# safe_staking=True, -# rate_tolerance=0.005, # 0.5% -# allow_partial_stake=False, -# ) -# assert success is False -# -# # Verify no stake was moved -# dest_stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# alice_wallet.hotkey.ss58_address, -# netuid=dest_netuid, -# ) -# assert dest_stake == Balance(0), ( -# "Destination stake should remain 0 after failed swap" -# ) -# -# # 2. Try swap with higher threshold and less amount - should succeed -# stake_swap_amount = Balance.from_tao(100) -# success = subtensor.swap_stake( -# wallet=alice_wallet, -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# origin_netuid=origin_netuid, -# destination_netuid=dest_netuid, -# amount=stake_swap_amount, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# safe_staking=True, -# rate_tolerance=0.3, # 30% -# allow_partial_stake=True, -# ) -# assert success is True -# -# # Verify stake was moved -# origin_stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# alice_wallet.hotkey.ss58_address, -# netuid=origin_netuid, -# ) -# dest_stake = subtensor.get_stake( -# alice_wallet.coldkey.ss58_address, -# alice_wallet.hotkey.ss58_address, -# netuid=dest_netuid, -# ) -# assert dest_stake > Balance(0), ( -# "Destination stake should be non-zero after successful swap" -# ) -# -# -# def test_move_stake(subtensor, alice_wallet, bob_wallet): -# """ -# Tests: -# - Adding stake -# - Moving stake from one hotkey-subnet pair to another -# """ -# -# alice_subnet_netuid = subtensor.get_total_subnets() # 2 -# assert subtensor.register_subnet(alice_wallet, True, True) -# assert subtensor.subnet_exists(alice_subnet_netuid), ( -# "Subnet wasn't created successfully" -# ) -# -# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) -# -# subtensor.burned_register( -# alice_wallet, -# netuid=alice_subnet_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# assert subtensor.add_stake( -# alice_wallet, -# alice_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# amount=Balance.from_tao(1_000), -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), -# locked=Balance(0), -# emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# ] -# -# bob_subnet_netuid = subtensor.get_total_subnets() # 3 -# subtensor.register_subnet(bob_wallet, True, True) -# assert subtensor.subnet_exists(bob_subnet_netuid), ( -# "Subnet wasn't created successfully" -# ) -# -# assert wait_to_start_call(subtensor, bob_wallet, bob_subnet_netuid) -# -# assert subtensor.move_stake( -# alice_wallet, -# origin_hotkey=alice_wallet.hotkey.ss58_address, -# origin_netuid=alice_subnet_netuid, -# destination_hotkey=bob_wallet.hotkey.ss58_address, -# destination_netuid=bob_subnet_netuid, -# amount=stakes[0].stake, -# wait_for_finalization=True, -# wait_for_inclusion=True, -# ) -# -# stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(stakes[0].stake.rao, bob_subnet_netuid), -# locked=Balance(0).set_unit(bob_subnet_netuid), -# emission=get_dynamic_balance(stakes[0].emission.rao, bob_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# StakeInfo( -# hotkey_ss58=bob_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=bob_subnet_netuid, -# stake=get_dynamic_balance(stakes[1].stake.rao, bob_subnet_netuid), -# locked=Balance(0).set_unit(bob_subnet_netuid), -# emission=get_dynamic_balance(stakes[1].emission.rao, bob_subnet_netuid), -# drain=0, -# is_registered=True, -# ), -# ] -# -# -# def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet): -# """ -# Tests: -# - Adding stake -# - Transferring stake from one coldkey-subnet pair to another -# """ -# alice_subnet_netuid = subtensor.get_total_subnets() # 2 -# -# assert subtensor.register_subnet(alice_wallet, True, True) -# assert subtensor.subnet_exists(alice_subnet_netuid), ( -# "Subnet wasn't created successfully" -# ) -# -# assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) -# -# subtensor.burned_register( -# alice_wallet, -# netuid=alice_subnet_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# assert subtensor.add_stake( -# alice_wallet, -# alice_wallet.hotkey.ss58_address, -# netuid=alice_subnet_netuid, -# amount=Balance.from_tao(1_000), -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert alice_stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), -# locked=Balance(0), -# emission=get_dynamic_balance( -# alice_stakes[0].emission.rao, alice_subnet_netuid -# ), -# drain=0, -# is_registered=True, -# ), -# ] -# -# bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) -# -# assert bob_stakes == [] -# -# dave_subnet_netuid = subtensor.get_total_subnets() # 3 -# subtensor.register_subnet(dave_wallet, True, True) -# -# assert wait_to_start_call(subtensor, dave_wallet, dave_subnet_netuid) -# -# subtensor.burned_register( -# bob_wallet, -# netuid=dave_subnet_netuid, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# assert subtensor.transfer_stake( -# alice_wallet, -# destination_coldkey_ss58=bob_wallet.coldkey.ss58_address, -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# origin_netuid=alice_subnet_netuid, -# destination_netuid=dave_subnet_netuid, -# amount=alice_stakes[0].stake, -# wait_for_inclusion=True, -# wait_for_finalization=True, -# ) -# -# alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) -# -# assert alice_stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=alice_wallet.coldkey.ss58_address, -# netuid=alice_subnet_netuid, -# stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), -# locked=Balance(0).set_unit(alice_subnet_netuid), -# emission=get_dynamic_balance( -# alice_stakes[0].emission.rao, alice_subnet_netuid -# ), -# drain=0, -# is_registered=True, -# ), -# ] -# -# bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) -# -# assert bob_stakes == [ -# StakeInfo( -# hotkey_ss58=alice_wallet.hotkey.ss58_address, -# coldkey_ss58=bob_wallet.coldkey.ss58_address, -# netuid=dave_subnet_netuid, -# stake=get_dynamic_balance(bob_stakes[0].stake.rao, dave_subnet_netuid), -# locked=Balance(0), -# emission=get_dynamic_balance( -# bob_stakes[0].emission.rao, dave_subnet_netuid -# ), -# drain=0, -# is_registered=False, -# ), -# ] +def test_safe_swap_stake_scenarios(subtensor, alice_wallet, bob_wallet): + """ + Tests safe swap stake scenarios with different parameters. + + Tests: + 1. Fails with strict threshold (0.5%) + 2. Succeeds with lenient threshold (10%) + """ + # Create new subnet (netuid 2) and register Alice + origin_netuid = 2 + assert subtensor.register_subnet(bob_wallet, True, True) + assert subtensor.subnet_exists(origin_netuid), "Subnet wasn't created successfully" + dest_netuid = 3 + assert subtensor.register_subnet(bob_wallet, True, True) + assert subtensor.subnet_exists(dest_netuid), "Subnet wasn't created successfully" + + # make sure we passed start_call limit for both subnets + assert wait_to_start_call(subtensor, bob_wallet, origin_netuid) + assert wait_to_start_call(subtensor, bob_wallet, dest_netuid) + + # Register Alice on both subnets + subtensor.burned_register( + alice_wallet, + netuid=origin_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + subtensor.burned_register( + alice_wallet, + netuid=dest_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + # Add initial stake to swap from + initial_stake_amount = Balance.from_tao(10_000) + success = subtensor.add_stake( + alice_wallet, + alice_wallet.hotkey.ss58_address, + netuid=origin_netuid, + amount=initial_stake_amount, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + assert success is True + + origin_stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + alice_wallet.hotkey.ss58_address, + netuid=origin_netuid, + ) + assert origin_stake > Balance(0), "Origin stake should be non-zero" + + stake_swap_amount = Balance.from_tao(10_000) + # 1. Try swap with strict threshold and big amount- should fail + success = subtensor.swap_stake( + wallet=alice_wallet, + hotkey_ss58=alice_wallet.hotkey.ss58_address, + origin_netuid=origin_netuid, + destination_netuid=dest_netuid, + amount=stake_swap_amount, + wait_for_inclusion=True, + wait_for_finalization=True, + safe_staking=True, + rate_tolerance=0.005, # 0.5% + allow_partial_stake=False, + ) + assert success is False + + # Verify no stake was moved + dest_stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + alice_wallet.hotkey.ss58_address, + netuid=dest_netuid, + ) + assert dest_stake == Balance(0), ( + "Destination stake should remain 0 after failed swap" + ) + + # 2. Try swap with higher threshold and less amount - should succeed + stake_swap_amount = Balance.from_tao(100) + success = subtensor.swap_stake( + wallet=alice_wallet, + hotkey_ss58=alice_wallet.hotkey.ss58_address, + origin_netuid=origin_netuid, + destination_netuid=dest_netuid, + amount=stake_swap_amount, + wait_for_inclusion=True, + wait_for_finalization=True, + safe_staking=True, + rate_tolerance=0.3, # 30% + allow_partial_stake=True, + ) + assert success is True + + # Verify stake was moved + origin_stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + alice_wallet.hotkey.ss58_address, + netuid=origin_netuid, + ) + dest_stake = subtensor.get_stake( + alice_wallet.coldkey.ss58_address, + alice_wallet.hotkey.ss58_address, + netuid=dest_netuid, + ) + assert dest_stake > Balance(0), ( + "Destination stake should be non-zero after successful swap" + ) + + +def test_move_stake(subtensor, alice_wallet, bob_wallet): + """ + Tests: + - Adding stake + - Moving stake from one hotkey-subnet pair to another + """ + + alice_subnet_netuid = subtensor.get_total_subnets() # 2 + assert subtensor.register_subnet(alice_wallet, True, True) + assert subtensor.subnet_exists(alice_subnet_netuid), ( + "Subnet wasn't created successfully" + ) + + assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) + + subtensor.burned_register( + alice_wallet, + netuid=alice_subnet_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + assert subtensor.add_stake( + alice_wallet, + alice_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + amount=Balance.from_tao(1_000), + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[0].stake.rao, alice_subnet_netuid), + locked=Balance(0), + emission=get_dynamic_balance(stakes[0].emission.rao, alice_subnet_netuid), + drain=0, + is_registered=True, + ), + ] + + bob_subnet_netuid = subtensor.get_total_subnets() # 3 + subtensor.register_subnet(bob_wallet, True, True) + assert subtensor.subnet_exists(bob_subnet_netuid), ( + "Subnet wasn't created successfully" + ) + + assert wait_to_start_call(subtensor, bob_wallet, bob_subnet_netuid) + + assert subtensor.move_stake( + alice_wallet, + origin_hotkey=alice_wallet.hotkey.ss58_address, + origin_netuid=alice_subnet_netuid, + destination_hotkey=bob_wallet.hotkey.ss58_address, + destination_netuid=bob_subnet_netuid, + amount=stakes[0].stake, + wait_for_finalization=True, + wait_for_inclusion=True, + ) + + stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(stakes[0].stake.rao, bob_subnet_netuid), + locked=Balance(0).set_unit(bob_subnet_netuid), + emission=get_dynamic_balance(stakes[0].emission.rao, bob_subnet_netuid), + drain=0, + is_registered=True, + ), + StakeInfo( + hotkey_ss58=bob_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=bob_subnet_netuid, + stake=get_dynamic_balance(stakes[1].stake.rao, bob_subnet_netuid), + locked=Balance(0).set_unit(bob_subnet_netuid), + emission=get_dynamic_balance(stakes[1].emission.rao, bob_subnet_netuid), + drain=0, + is_registered=True, + ), + ] + + +def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet): + """ + Tests: + - Adding stake + - Transferring stake from one coldkey-subnet pair to another + """ + alice_subnet_netuid = subtensor.get_total_subnets() # 2 + + assert subtensor.register_subnet(alice_wallet, True, True) + assert subtensor.subnet_exists(alice_subnet_netuid), ( + "Subnet wasn't created successfully" + ) + + assert wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid) + + subtensor.burned_register( + alice_wallet, + netuid=alice_subnet_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + assert subtensor.add_stake( + alice_wallet, + alice_wallet.hotkey.ss58_address, + netuid=alice_subnet_netuid, + amount=Balance.from_tao(1_000), + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert alice_stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), + locked=Balance(0), + emission=get_dynamic_balance( + alice_stakes[0].emission.rao, alice_subnet_netuid + ), + drain=0, + is_registered=True, + ), + ] + + bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) + + assert bob_stakes == [] + + dave_subnet_netuid = subtensor.get_total_subnets() # 3 + subtensor.register_subnet(dave_wallet, True, True) + + assert wait_to_start_call(subtensor, dave_wallet, dave_subnet_netuid) + + subtensor.burned_register( + bob_wallet, + netuid=dave_subnet_netuid, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + assert subtensor.transfer_stake( + alice_wallet, + destination_coldkey_ss58=bob_wallet.coldkey.ss58_address, + hotkey_ss58=alice_wallet.hotkey.ss58_address, + origin_netuid=alice_subnet_netuid, + destination_netuid=dave_subnet_netuid, + amount=alice_stakes[0].stake, + wait_for_inclusion=True, + wait_for_finalization=True, + ) + + alice_stakes = subtensor.get_stake_for_coldkey(alice_wallet.coldkey.ss58_address) + + assert alice_stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=alice_wallet.coldkey.ss58_address, + netuid=alice_subnet_netuid, + stake=get_dynamic_balance(alice_stakes[0].stake.rao, alice_subnet_netuid), + locked=Balance(0).set_unit(alice_subnet_netuid), + emission=get_dynamic_balance( + alice_stakes[0].emission.rao, alice_subnet_netuid + ), + drain=0, + is_registered=True, + ), + ] + + bob_stakes = subtensor.get_stake_for_coldkey(bob_wallet.coldkey.ss58_address) + + assert bob_stakes == [ + StakeInfo( + hotkey_ss58=alice_wallet.hotkey.ss58_address, + coldkey_ss58=bob_wallet.coldkey.ss58_address, + netuid=dave_subnet_netuid, + stake=get_dynamic_balance(bob_stakes[0].stake.rao, dave_subnet_netuid), + locked=Balance(0), + emission=get_dynamic_balance( + bob_stakes[0].emission.rao, dave_subnet_netuid + ), + drain=0, + is_registered=False, + ), + ] From 51187feb8daace52b263615853fdf9646cb1f2e3 Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 24 Apr 2025 15:02:45 -0700 Subject: [PATCH 5/5] bring back previous rate_tolerance --- tests/e2e_tests/test_staking.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py index ae687ccbc8..dddd9d1af1 100644 --- a/tests/e2e_tests/test_staking.py +++ b/tests/e2e_tests/test_staking.py @@ -354,7 +354,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.001, # 0.5% + rate_tolerance=0.005, # 0.5% allow_partial_stake=False, ) assert success is False @@ -375,7 +375,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.001, # 0.5% + rate_tolerance=0.005, # 0.5% allow_partial_stake=True, ) assert success is True @@ -448,7 +448,7 @@ def test_safe_staking_scenarios(subtensor, alice_wallet, bob_wallet): wait_for_inclusion=True, wait_for_finalization=True, safe_staking=True, - rate_tolerance=0.001, # 0.5% + rate_tolerance=0.005, # 0.5% allow_partial_stake=True, ) assert success is True