wip

Author: l0r1s

evm-tests/run-mechanism-tests.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+echo "Starting Submechanism E2E Tests"
+echo "================================="
+
+# Check if localnet is running
+if ! nc -z localhost 9944; then
+    echo "Starting localnet..."
+    ../scripts/localnet.sh &>/dev/null &
+    LOCALNET_PID=$!
+    
+    # Wait for localnet to start
+    i=1
+    while [ $i -le 1000 ]; do
+        if nc -z localhost 9944; then
+            echo "Localnet is running after $i seconds"
+            break
+        fi
+        sleep 1
+        i=$((i + 1))
+    done
+    
+    # Check if localnet started successfully
+    if [ "$i" -eq 1000 ]; then
+        echo "Failed to start localnet"
+        exit 1
+    fi
+else
+    echo "Localnet is already running"
+fi
+
+# Wait a bit more for the node to be fully ready
+sleep 5
+
+# Check if localnet is still running
+if ! nc -z localhost 9944; then
+    echo "Localnet stopped unexpectedly"
+    exit 1
+fi
+
+echo "Setting up test environment..."
+
+# Install dependencies if needed
+if [ ! -d "node_modules" ]; then
+    echo "Installing dependencies..."
+    yarn install
+fi
+
+# Get metadata if needed
+if [ ! -d ".papi" ]; then
+    echo "Getting metadata..."
+    bash get-metadata.sh
+    sleep 5
+fi
+
+echo "Running mechanism e2e tests..."
+
+# Run the mechanism tests
+yarn run test -- --grep "Submechanism E2E Tests"
+
+TEST_EXIT_CODE=$?
+
+if [ $TEST_EXIT_CODE -ne 0 ]; then
+    echo "Mechanism tests failed with exit code $TEST_EXIT_CODE"
+    if [ ! -z "$LOCALNET_PID" ]; then
+        kill $LOCALNET_PID 2>/dev/null || true
+    fi
+    pkill node-subtensor 2>/dev/null || true
+    exit $TEST_EXIT_CODE
+fi
+
+echo "All mechanism tests passed!"
+
+# Cleanup
+if [ ! -z "$LOCALNET_PID" ]; then
+    kill $LOCALNET_PID 2>/dev/null || true
+fi
+pkill node-subtensor 2>/dev/null || true
+
+exit 0

evm-tests/src/mechanism.ts

@@ -0,0 +1,315 @@
+import { ApiPromise } from '@polkadot/api';
+import { Substrate } from './substrate';
+import { Subtensor } from './subtensor';
+
+export class MechanismManager {
+  constructor(
+    private api: ApiPromise,
+    private substrate: Substrate,
+    private subtensor: Subtensor
+  ) {}
+
+  /**
+   * Creates a subnet with the specified number of mechanisms
+   */
+  async createSubnet(netuid: number, mechanismCount: number): Promise<void> {
+    // Create the base subnet
+    await this.substrate.createSubnet(netuid, 0);
+    
+    // Set the mechanism count
+    await this.substrate.setMechanismCount(netuid, mechanismCount);
+  }
+
+  /**
+   * Sets the mechanism count for a subnet
+   */
+  async setMechanismCount(netuid: number, mechanismCount: number): Promise<void> {
+    const tx = this.api.tx.subtensor.setMechanismCount(netuid, mechanismCount);
+    await this.substrate.signAndSend(tx);
+  }
+
+  /**
+   * Sets custom emission split for mechanisms
+   */
+  async setEmissionSplit(netuid: number, split: number[]): Promise<void> {
+    const tx = this.api.tx.subtensor.setEmissionSplit(netuid, split);
+    await this.substrate.signAndSend(tx);
+  }
+
+  /**
+   * Sets weights for a specific mechanism
+   */
+  async setMechanismWeights(
+    netuid: number,
+    mechanismId: number,
+    validatorUid: number,
+    dests: number[],
+    weights: number[]
+  ): Promise<void> {
+    const tx = this.api.tx.subtensor.setMechanismWeights(
+      netuid,
+      mechanismId,
+      dests,
+      weights,
+      0 // version_key
+    );
+    await this.substrate.signAndSend(tx);
+  }
+
+  /**
+   * Commits weights for a specific mechanism
+   */
+  async commitMechanismWeights(
+    netuid: number,
+    mechanismId: number,
+    hotkey: string,
+    dests: number[],
+    weights: number[],
+    salt: number[],
+    versionKey: number
+  ): Promise<string> {
+    // Calculate commit hash
+    const commitData = {
+      hotkey,
+      mechanismId,
+      dests,
+      weights,
+      salt,
+      versionKey
+    };
+    
+    const commitHash = this.api.createType('Hash', commitData).toString();
+    
+    const tx = this.api.tx.subtensor.commitMechanismWeights(
+      netuid,
+      mechanismId,
+      commitHash
+    );
+    
+    await this.substrate.signAndSend(tx);
+    return commitHash;
+  }
+
+  /**
+   * Reveals weights for a specific mechanism
+   */
+  async revealMechanismWeights(
+    netuid: number,
+    mechanismId: number,
+    hotkey: string,
+    dests: number[],
+    weights: number[],
+    salt: number[],
+    versionKey: number
+  ): Promise<void> {
+    const tx = this.api.tx.subtensor.revealMechanismWeights(
+      netuid,
+      mechanismId,
+      dests,
+      weights,
+      salt,
+      versionKey
+    );
+    
+    await this.substrate.signAndSend(tx);
+  }
+
+  /**
+   * Commits timelocked weights for a specific mechanism
+   */
+  async commitTimelockedMechanismWeights(
+    netuid: number,
+    mechanismId: number,
+    commitData: Uint8Array,
+    revealRound: number,
+    version: number
+  ): Promise<void> {
+    const tx = this.api.tx.subtensor.commitTimelockedMechanismWeights(
+      netuid,
+      mechanismId,
+      commitData,
+      revealRound,
+      version
+    );
+    
+    await this.substrate.signAndSend(tx);
+  }
+
+  /**
+   * Gets the mechanism count for a subnet
+   */
+  async getMechanismCount(netuid: number): Promise<number> {
+    const result = await this.api.query.subtensor.mechanismCountCurrent(netuid);
+    return result.toNumber();
+  }
+
+  /**
+   * Checks if a mechanism exists
+   */
+  async ensureMechanismExists(netuid: number, mechanismId: number): Promise<boolean> {
+    try {
+      const mechanismCount = await this.getMechanismCount(netuid);
+      return mechanismId < mechanismCount;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Gets weights for a specific mechanism and validator
+   */
+  async getMechanismWeights(
+    netuid: number,
+    mechanismId: number,
+    validatorUid: number
+  ): Promise<Array<[number, number]>> {
+    const storageIndex = this.calculateStorageIndex(netuid, mechanismId);
+    const result = await this.api.query.subtensor.weights(storageIndex, validatorUid);
+    
+    if (result.isNone) {
+      return [];
+    }
+    
+    return result.unwrap().toJSON() as Array<[number, number]>;
+  }
+
+  /**
+   * Gets incentive values for a specific mechanism
+   */
+  async getMechanismIncentive(netuid: number, mechanismId: number): Promise<number[]> {
+    const storageIndex = this.calculateStorageIndex(netuid, mechanismId);
+    const result = await this.api.query.subtensor.incentive(storageIndex);
+    
+    if (result.isNone) {
+      return [];
+    }
+    
+    return result.unwrap().toJSON() as number[];
+  }
+
+  /**
+   * Gets bonds for a specific mechanism and validator
+   */
+  async getMechanismBonds(
+    netuid: number,
+    mechanismId: number,
+    validatorUid: number
+  ): Promise<Array<[number, number]>> {
+    const storageIndex = this.calculateStorageIndex(netuid, mechanismId);
+    const result = await this.api.query.subtensor.bonds(storageIndex, validatorUid);
+    
+    if (result.isNone) {
+      return [];
+    }
+    
+    return result.unwrap().toJSON() as Array<[number, number]>;
+  }
+
+  /**
+   * Splits emissions across mechanisms
+   */
+  async splitEmissions(netuid: number, totalEmission: number): Promise<number[]> {
+    // This would typically be called through the runtime, but for testing
+    // we'll simulate the logic based on the mechanism count and split
+    const mechanismCount = await this.getMechanismCount(netuid);
+    const emissionSplit = await this.getEmissionSplit(netuid);
+    
+    if (emissionSplit && emissionSplit.length > 0) {
+      // Custom split
+      return emissionSplit.map(split => 
+        Math.floor((totalEmission * split) / 65535)
+      );
+    } else {
+      // Even split
+      const perMechanism = Math.floor(totalEmission / mechanismCount);
+      const remainder = totalEmission % mechanismCount;
+      
+      const result = new Array(mechanismCount).fill(perMechanism);
+      if (remainder > 0) {
+        result[0] += remainder; // Add remainder to first mechanism
+      }
+      
+      return result;
+    }
+  }
+
+  /**
+   * Gets the emission split configuration for a subnet
+   */
+  async getEmissionSplit(netuid: number): Promise<number[] | null> {
+    const result = await this.api.query.subtensor.mechanismEmissionSplit(netuid);
+    
+    if (result.isNone) {
+      return null;
+    }
+    
+    return result.unwrap().toJSON() as number[];
+  }
+
+  /**
+   * Runs epoch processing with mechanisms
+   */
+  async epochWithMechanisms(netuid: number, emission: number): Promise<Array<[string, number, number]>> {
+    // This would typically be called through the runtime
+    // For testing, we'll simulate the epoch processing
+    const mechanismCount = await this.getMechanismCount(netuid);
+    const mechanismEmissions = await this.splitEmissions(netuid, emission);
+    
+    const results: Array<[string, number, number]> = [];
+    
+    for (let i = 0; i < mechanismCount; i++) {
+      const mechanismEmission = mechanismEmissions[i];
+      const epochOutput = await this.epochMechanism(netuid, i, mechanismEmission);
+      
+      // Aggregate results
+      for (const [hotkey, terms] of epochOutput) {
+        const existing = results.find(([h]) => h === hotkey);
+        if (existing) {
+          existing[1] += terms.serverEmission;
+          existing[2] += terms.validatorEmission;
+        } else {
+          results.push([hotkey, terms.serverEmission, terms.validatorEmission]);
+        }
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Runs epoch processing for a specific mechanism
+   */
+  async epochMechanism(
+    netuid: number,
+    mechanismId: number,
+    emission: number
+  ): Promise<Map<string, { serverEmission: number; validatorEmission: number }>> {
+    // This would typically be called through the runtime
+    // For testing, we'll simulate the epoch processing
+    const results = new Map<string, { serverEmission: number; validatorEmission: number }>();
+    
+    // Get all neurons in the subnet
+    const neuronCount = await this.subtensor.getSubnetworkN(netuid);
+    
+    for (let uid = 0; uid < neuronCount; uid++) {
+      const hotkey = await this.subtensor.getHotkeyForNetAndUid(netuid, uid);
+      if (hotkey) {
+        // Simulate emission distribution
+        const serverEmission = Math.floor(emission * 0.5 / neuronCount);
+        const validatorEmission = Math.floor(emission * 0.5 / neuronCount);
+        
+        results.set(hotkey, { serverEmission, validatorEmission });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Calculates the storage index for a mechanism
+   */
+  private calculateStorageIndex(netuid: number, mechanismId: number): number {
+    const GLOBAL_MAX_SUBNET_COUNT = 4096;
+    return mechanismId * GLOBAL_MAX_SUBNET_COUNT + netuid;
+  }
+}