Strategy Contracts

Strategy contracts manage the lifecycle and execution of trading strategies in the Noderr Protocol.

Strategy Lifecycle

┌──────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│  EVOLUTION   │───▶│    SHADOW    │───▶│     LIVE     │───▶│  DEPRECATED  │
│  (Testing)   │    │ (Paper Trade)│    │ (Real Money) │    │  (Retired)   │
└──────────────┘    └──────────────┘    └──────────────┘    └──────────────┘
│                    │                   │                    │
│ ML Generation      │ Guardian          │ Real              │ Performance
│ Backtesting        │ Validation        │ Execution         │ Decline
│                    │ Monte Carlo       │                   │

Contract Addresses (Base Sepolia)

Note: Verified addresses are published in the Base Sepolia deployment manifest (15 verified contracts as of the latest testnet release). The entries below are placeholders pending the published manifest reference.

StrategyRegistry

Central registry for all trading strategies.

Strategy Structure

struct Strategy {
bytes32 id;
string name;
address creator;
StrategyStatus status;
uint256 riskScore;
uint256 maxAllocation;
uint256 createdAt;
bytes32 dnaHash;  // Strategy parameters hash
}
enum StrategyStatus {
EVOLUTION,
SHADOW,
LIVE,
DEPRECATED
}

Key Functions

// Register new strategy
function registerStrategy(
string calldata name,
bytes32 dnaHash,
uint256 riskScore
) external onlyRole(ORACLE_ROLE) returns (bytes32 strategyId);
// Promote strategy to next stage
function promoteStrategy(
bytes32 strategyId,
bytes calldata validationProof
) external onlyRole(GUARDIAN_ROLE);
// Deprecate strategy
function deprecateStrategy(
bytes32 strategyId,
string calldata reason
) external onlyRole(ADMIN_ROLE);
// Get strategy info
function getStrategy(bytes32 strategyId) external view returns (Strategy memory);

Events

event StrategyRegistered(bytes32 indexed strategyId, string name, address creator);
event StrategyPromoted(bytes32 indexed strategyId, StrategyStatus newStatus);
event StrategyDeprecated(bytes32 indexed strategyId, string reason);

StrategyExecutor

Executes trading operations for live strategies.

Execution Flow

// Execute strategy trade
function executeTrade(
bytes32 strategyId,
TradeParams calldata params
) external onlyRole(ORACLE_ROLE) returns (bytes32 tradeId);
struct TradeParams {
address tokenIn;
address tokenOut;
uint256 amountIn;
uint256 minAmountOut;
bytes swapData;
uint256 deadline;
}

Risk Controls

// Check trade against risk limits
function validateTrade(
bytes32 strategyId,
TradeParams calldata params
) internal view {
Strategy memory strategy = registry.getStrategy(strategyId);
// Check position size
require(
params.amountIn <= strategy.maxAllocation * maxPositionPct / 100,
"Position too large"
);
// Check daily volume
require(
dailyVolume[strategyId] + params.amountIn <= maxDailyVolume,
"Daily volume exceeded"
);
// Check slippage
uint256 expectedOut = oracle.getExpectedOutput(params);
require(
params.minAmountOut >= expectedOut * (100 - maxSlippage) / 100,
"Slippage too high"
);
}

AllocationManager

Manages capital allocation across strategies.

Allocation Structure

struct Allocation {
bytes32 strategyId;
uint256 amount;
uint256 percentage;
uint256 lastRebalance;
}

Key Functions

// Set strategy allocation
function setAllocation(
bytes32 strategyId,
uint256 percentage
) external onlyRole(ADMIN_ROLE);
// Rebalance allocations
function rebalance() external onlyRole(ORACLE_ROLE);
// Get current allocations
function getAllocations() external view returns (Allocation[] memory);

Rebalancing Logic

function rebalance() external onlyRole(ORACLE_ROLE) {
Allocation[] memory allocations = getAllocations();
uint256 totalValue = getTotalValue();
for (uint256 i = 0; i < allocations.length; i++) {
uint256 targetValue = totalValue * allocations[i].percentage / 100;
uint256 currentValue = getStrategyValue(allocations[i].strategyId);
if (currentValue > targetValue * (100 + rebalanceThreshold) / 100) {
// Reduce allocation
_reduceAllocation(allocations[i].strategyId, currentValue - targetValue);
} else if (currentValue < targetValue * (100 - rebalanceThreshold) / 100) {
// Increase allocation
_increaseAllocation(allocations[i].strategyId, targetValue - currentValue);
}
}
}

PerformanceTracker

Tracks and records strategy performance metrics.

Metrics Structure

struct PerformanceMetrics {
uint256 totalReturn;
uint256 sharpeRatio;
uint256 maxDrawdown;
uint256 winRate;
uint256 avgTradeSize;
uint256 totalTrades;
uint256 lastUpdate;
}

Key Functions

// Record trade result
function recordTrade(
bytes32 strategyId,
int256 pnl,
uint256 tradeSize
) external onlyRole(EXECUTOR_ROLE);
// Get performance metrics
function getMetrics(bytes32 strategyId) external view returns (PerformanceMetrics memory);
// Calculate Sharpe ratio
function calculateSharpe(bytes32 strategyId) external view returns (uint256);

Integration with Vaults

Strategies are the active-trading layer (the ATE sleeve) and connect to vaults through the on-chain execution path (ExecutionRouter + StrategyRegistry + BaseRateGovernor):

// Vault allocates to strategy
function allocateToStrategy(
bytes32 strategyId,
uint256 amount
) external onlyVault {
require(registry.getStrategy(strategyId).status == StrategyStatus.LIVE, "Not live");
allocationManager.allocate(strategyId, amount);
}
// Strategy returns profits to vault
function returnProfits(
address vault,
uint256 amount
) external onlyRole(EXECUTOR_ROLE) {
IERC20(asset).transfer(vault, amount);
emit ProfitsReturned(vault, amount);
}

Security Features

Circuit Breaker

// Emergency stop for strategy
function emergencyStop(bytes32 strategyId) external onlyRole(GUARDIAN_ROLE) {
strategies[strategyId].status = StrategyStatus.DEPRECATED;
_closeAllPositions(strategyId);
emit EmergencyStop(strategyId, msg.sender);
}

Position Limits

Last Updated: June 2026