Merge branch 'staging' into feat/zyzniewski/set_children_and_pending_children

Author: zyzniewski-reef

.github/workflows/e2e-subtensor-tests.yaml

@@ -25,7 +25,7 @@ env:
 
 # job to run tests in parallel
 jobs:
-  # Job to find all test files
+
   find-tests:
     runs-on: ubuntu-latest
     if: ${{ github.event_name != 'pull_request' || github.event.pull_request.draft == false }}
@@ -42,68 +42,55 @@ jobs:
           echo "::set-output name=test-files::$test_files"
         shell: bash
 
+  pull-docker-image:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Log in to GitHub Container Registry
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u $GITHUB_ACTOR --password-stdin
+
+      - name: Pull Docker Image
+        run: docker pull ghcr.io/opentensor/subtensor-localnet:latest
+
+      - name: Save Docker Image to Cache
+        run: docker save -o subtensor-localnet.tar ghcr.io/opentensor/subtensor-localnet:latest
+
+      - name: Upload Docker Image as Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: subtensor-localnet
+          path: subtensor-localnet.tar
+
   # Job to run tests in parallel
   run:
-    needs: find-tests
-    runs-on: SubtensorCI
+    needs:
+      - find-tests
+      - pull-docker-image
+    runs-on: ubuntu-latest
     timeout-minutes: 45
     strategy:
       fail-fast: false  # Allow other matrix jobs to run even if this job fails
-      max-parallel: 8  # Set the maximum number of parallel jobs
+      max-parallel: 32  # Set the maximum number of parallel jobs (same as we have cores in SubtensorCI runner)
       matrix:
-        rust-branch:
-          - stable
-        rust-target:
-          - x86_64-unknown-linux-gnu
         os:
           - ubuntu-latest
         test-file: ${{ fromJson(needs.find-tests.outputs.test-files) }}
-    env:
-      RELEASE_NAME: development
-      RUSTV: ${{ matrix.rust-branch }}
-      RUST_BACKTRACE: full
-      RUST_BIN_DIR: target/${{ matrix.rust-target }}
-      TARGET: ${{ matrix.rust-target }}
     steps:
-      - name: Check-out repository under $GITHUB_WORKSPACE
+      - name: Check-out repository
         uses: actions/checkout@v4
 
-      - name: Install dependencies
-        run: |
-          sudo apt-get update &&
-          sudo apt-get install -y clang curl libssl-dev llvm libudev-dev protobuf-compiler
-
-      - name: Install Rust ${{ matrix.rust-branch }}
-        uses: actions-rs/[email protected]
-        with:
-          toolchain: ${{ matrix.rust-branch }}
-          components: rustfmt
-          profile: minimal
-
-      - name: Add wasm32-unknown-unknown target
-        run: |
-          rustup target add wasm32-unknown-unknown --toolchain stable-x86_64-unknown-linux-gnu
-          rustup component add rust-src --toolchain stable-x86_64-unknown-linux-gnu
-
-      - name: Clone subtensor repo
-        run: git clone https://github.com/opentensor/subtensor.git
-
-      - name: Setup subtensor repo
-        working-directory: ${{ github.workspace }}/subtensor
-        run: git checkout devnet-ready
-
       - name: Install uv
         uses: astral-sh/setup-uv@v4
 
       - name: install dependencies
         run: uv sync --all-extras --dev
 
-      - name: Run tests
-        run: |
-          LOCALNET_SH_PATH="${{ github.workspace }}/subtensor/scripts/localnet.sh" uv run pytest ${{ matrix.test-file }} -s
+      - name: Download Cached Docker Image
+        uses: actions/download-artifact@v4
+        with:
+          name: subtensor-localnet
 
-      - name: Retry failed tests
-        if: failure()
-        run: |
-          sleep 10
-          LOCALNET_SH_PATH="${{ github.workspace }}/subtensor/scripts/localnet.sh" uv run pytest ${{ matrix.test-file }} -s
+      - name: Load Docker Image
+        run: docker load -i subtensor-localnet.tar
+
+      - name: Run tests
+        run: uv run pytest ${{ matrix.test-file }} -s

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 9.2.0 /2025-03-18
+
+## What's Changed
+* Fix E2E test_incentive by waiting till start of the very next epoch by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2746
+* New era of e2e Tests Bittensor by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2743
+* Allow installation on Py 3.13 by @thewhaleking in https://github.com/opentensor/bittensor/pull/2756
+* Feat/dynamic stake prices by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2755
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.1.0...v9.2.0
+
 ## 9.1.0 /2025-03-12
 
 ## What's Changed

README.md

@@ -221,6 +221,49 @@ The Python interpreter output will look like below.
 >>>
 ```
 
+### Testing
+You can run integration and unit tests in interactive mode of IDE or in terminal mode using the command:
+```bash
+pytest tests/integration_tests
+pytest tests/unit_tests
+```
+
+#### E2E tests have 2 options for launching (legacy runner):
+- using a compiler based on the substrait code
+- using an already built docker image (docker runner)
+
+#### Using `docker runner` (default for now):
+- E2E tests with docker image do not require preliminary compilation
+- are executed very quickly
+- require docker installed in OS
+
+Ho to use:
+```bash
+pytest tests/e2e_tests
+```
+
+#### TUsing `legacy runner`:
+- Will start compilation of the collected code in your subtensor repository
+- you must provide the `LOCALNET_SH_PATH` variable in the local environment with the path to the file `/scripts/localnet.sh` in the cloned repository within your OS
+- you can use the `BUILD_BINARY=0` variable, this will skip the copy step for each test.
+- you can use the `USE_DOCKER=0` variable, this will run tests using the "legacy runner", even if docker is installed in your OS
+
+#### Ho to use:
+Regular e2e tests run
+```bash
+LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
+```
+
+If you want to skip re-build process for each e2e test
+```bash
+BUILD_BINARY=0 LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
+```
+
+If you want to use legacy runner even with installed Docker in your OS
+```bash
+USE_DOCKER=0 BUILD_BINARY=0 LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests
+```
+
 ---
 
 ## Release Guidelines

VERSION

@@ -1 +1 @@
-9.1.0
+9.2.0

bittensor/core/async_subtensor.py

@@ -1628,6 +1628,117 @@ async def get_stake(
 
         return Balance.from_rao(int(stake)).set_unit(netuid=netuid)
 
+    async def get_stake_add_fee(
+        self,
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for adding new stake to a hotkey.
+
+        Args:
+            amount: Amount of stake to add in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of source coldkey
+            hotkey_ss58: SS58 address of destination hotkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                None,
+                coldkey_ss58,
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
+
+    async def get_unstake_fee(
+        self,
+        amount: Balance,
+        netuid: int,
+        coldkey_ss58: str,
+        hotkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for unstaking from a hotkey.
+
+        Args:
+            amount: Amount of stake to unstake in TAO
+            netuid: Netuid of subnet
+            coldkey_ss58: SS58 address of source coldkey
+            hotkey_ss58: SS58 address of destination hotkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                None,
+                coldkey_ss58,
+                (hotkey_ss58, netuid),
+                coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
+
+    async def get_stake_movement_fee(
+        self,
+        amount: Balance,
+        origin_netuid: int,
+        origin_hotkey_ss58: str,
+        origin_coldkey_ss58: str,
+        destination_netuid: int,
+        destination_hotkey_ss58: str,
+        destination_coldkey_ss58: str,
+        block: Optional[int] = None,
+    ) -> Balance:
+        """
+        Calculates the fee for moving stake between hotkeys/subnets/coldkeys.
+
+        Args:
+            amount: Amount of stake to move in TAO
+            origin_netuid: Netuid of source subnet
+            origin_hotkey_ss58: SS58 address of source hotkey
+            origin_coldkey_ss58: SS58 address of source coldkey
+            destination_netuid: Netuid of destination subnet
+            destination_hotkey_ss58: SS58 address of destination hotkey
+            destination_coldkey_ss58: SS58 address of destination coldkey
+            block: Block number at which to perform the calculation
+
+        Returns:
+            The calculated stake fee as a Balance object
+        """
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_fee",
+            params=[
+                (origin_hotkey_ss58, origin_netuid),
+                origin_coldkey_ss58,
+                (destination_hotkey_ss58, destination_netuid),
+                destination_coldkey_ss58,
+                amount.rao,
+            ],
+            block=block,
+        )
+        return Balance.from_rao(result)
+
     async def get_stake_for_coldkey_and_hotkey(
         self,
         coldkey_ss58: str,
@@ -1962,10 +2073,11 @@ async def get_vote_data(
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
         )
+
         if vote_data is None:
             return None
-        else:
-            return ProposalVoteData(vote_data)
+
+        return ProposalVoteData.from_dict(vote_data)
 
     async def get_uid_for_hotkey_on_subnet(
         self,

bittensor/core/chain_data/proposal_vote_data.py

@@ -1,22 +1,27 @@
+from dataclasses import dataclass
+
+from bittensor.core.chain_data.info_base import InfoBase
 from bittensor.core.chain_data.utils import decode_account_id
 
 
-# Senate / Proposal data
-class ProposalVoteData:
+@dataclass
+class ProposalVoteData(InfoBase):
+    """
+    Senate / Proposal data
+    """
+
     index: int
     threshold: int
     ayes: list[str]
     nays: list[str]
     end: int
 
-    def __init__(self, proposal_dict: dict) -> None:
-        self.index = proposal_dict["index"]
-        self.threshold = proposal_dict["threshold"]
-        self.ayes = self.decode_ss58_tuples(proposal_dict["ayes"])
-        self.nays = self.decode_ss58_tuples(proposal_dict["nays"])
-        self.end = proposal_dict["end"]
-
-    @staticmethod
-    def decode_ss58_tuples(line: tuple):
-        """Decodes a tuple of ss58 addresses formatted as bytes tuples."""
-        return [decode_account_id(line[x][0]) for x in range(len(line))]
+    @classmethod
+    def from_dict(cls, proposal_dict: dict) -> "ProposalVoteData":
+        return cls(
+            ayes=[decode_account_id(key) for key in proposal_dict["ayes"]],
+            end=proposal_dict["end"],
+            index=proposal_dict["index"],
+            nays=[decode_account_id(key) for key in proposal_dict["nays"]],
+            threshold=proposal_dict["threshold"],
+        )

bittensor/core/settings.py

@@ -1,4 +1,4 @@
-__version__ = "9.1.0"
+__version__ = "9.2.0"
 
 import os
 import re