Technical Reference
System Architecture
Core Components
graph TD
A[Pool Factory] --> B[Structured Pool]
A --> C[Cross Pool]
A --> D[Passive Pool]
B --> E[Risk Propagation]
C --> E
D --> E
E --> F[ML Optimizer]
E --> G[Pool Metrics]
F --> H[Risk Oracle]
G --> H
Smart Contract Interfaces
1. IPoolBase
Base interface for all pool types.
interface IPoolBase {
enum PoolType { STRUCTURED, CROSS, PASSIVE_STRUCTURED, PASSIVE_CROSS }
struct PoolConfig {
string name;
string symbol;
uint256 maxCapacity;
uint256 minStakeTime;
uint256 targetAPY;
bytes riskParameters;
}
function initialize(
uint256 poolId,
PoolConfig memory config
) external;
function stake(
address account,
uint256 amount
) external returns (uint256);
function unstake(
address account,
uint256 amount
) external returns (uint256);
function getPoolMetrics() external view returns (
uint256 totalStaked,
uint256 utilizationRate,
uint256 riskScore
);
}
2. IStructuredPool
Interface for structured pools with tranche support.
interface IStructuredPool is IPoolBase {
struct TrancheConfig {
string name;
uint256 targetAPY;
uint256 maxCapacity;
uint256 minStakeTime;
}
struct TrancheMetrics {
uint256 totalStaked;
uint256 utilizationRate;
uint256 currentAPY;
uint256 riskScore;
}
function initializeTranches(
TrancheConfig[] memory configs
) external;
function stakeInTranche(
uint256 trancheId,
uint256 amount
) external returns (uint256);
function getTrancheMetrics(
uint256 trancheId
) external view returns (TrancheMetrics memory);
}
3. ICrossPool
Interface for cross-pool risk management.
interface ICrossPool is IPoolBase {
struct CrossPoolConfig {
uint256 maxConcentration;
uint256 targetCorrelation;
uint256 rebalanceThreshold;
}
struct ConnectionMetrics {
uint256 riskExposure;
uint256 correlation;
uint256 utilizationRate;
}
function connect(
uint256 targetPoolId,
uint256 maxExposure
) external returns (bool);
function getConnectionMetrics(
uint256 poolId
) external view returns (ConnectionMetrics memory);
}
4. IPassivePool
Interface for passive pools.
interface IPassivePool is IPoolBase {
struct PassiveConfig {
uint256 maxDrawdown;
uint256 rewardRate;
uint256 utilizationTarget;
}
struct PassiveMetrics {
uint256 totalStaked;
uint256 currentAPY;
uint256 utilizationRate;
uint256 rewardAccrued;
}
function initializePassive(
PassiveConfig memory config
) external;
function getPassiveMetrics() external view returns (
PassiveMetrics memory metrics
);
}
Core Functions
1. Risk Propagation
library RiskPropagation {
struct PropagationParams {
uint256 sourcePoolId;
uint256 targetPoolId;
uint256 amount;
bytes data;
}
function propagateRisk(
PropagationParams memory params
) internal returns (bool) {
// Validate propagation
require(_validatePropagation(params), "Invalid propagation");
// Calculate risk metrics
(uint256 sourceRisk, uint256 targetRisk) = _calculateRiskMetrics(params);
// Execute propagation
return _executePropagation(params, sourceRisk, targetRisk);
}
function _validatePropagation(
PropagationParams memory params
) private view returns (bool) {
// Implementation details
}
function _calculateRiskMetrics(
PropagationParams memory params
) private view returns (uint256, uint256) {
// Implementation details
}
function _executePropagation(
PropagationParams memory params,
uint256 sourceRisk,
uint256 targetRisk
) private returns (bool) {
// Implementation details
}
}
2. Pool Metrics
library PoolMetrics {
struct MetricsParams {
uint256 poolId;
uint256 totalStaked;
uint256 utilizationRate;
uint256 riskScore;
uint256 timestamp;
}
function updateMetrics(
MetricsParams memory params
) internal returns (bool) {
// Validate metrics
require(_validateMetrics(params), "Invalid metrics");
// Calculate aggregated metrics
uint256 aggregatedScore = _calculateAggregatedScore(params);
// Update metrics
return _updateMetricsStorage(params, aggregatedScore);
}
function _validateMetrics(
MetricsParams memory params
) private pure returns (bool) {
// Implementation details
}
function _calculateAggregatedScore(
MetricsParams memory params
) private view returns (uint256) {
// Implementation details
}
function _updateMetricsStorage(
MetricsParams memory params,
uint256 aggregatedScore
) private returns (bool) {
// Implementation details
}
}
Events
1. Pool Events
interface IPoolEvents {
event PoolCreated(
uint256 indexed poolId,
address indexed pool,
IPoolBase.PoolType poolType,
string name,
string symbol
);
event Staked(
uint256 indexed poolId,
address indexed account,
uint256 amount,
uint256 timestamp
);
event Unstaked(
uint256 indexed poolId,
address indexed account,
uint256 amount,
uint256 timestamp
);
event MetricsUpdated(
uint256 indexed poolId,
uint256 totalStaked,
uint256 utilizationRate,
uint256 riskScore,
uint256 timestamp
);
}
2. Risk Events
interface IRiskEvents {
event RiskPropagated(
uint256 indexed sourcePoolId,
uint256 indexed targetPoolId,
uint256 amount,
uint256 riskScore,
uint256 timestamp
);
event RiskLevelBreached(
uint256 indexed poolId,
uint256 currentRisk,
uint256 threshold,
uint256 timestamp
);
event RiskParametersUpdated(
uint256 indexed poolId,
bytes newParameters,
uint256 timestamp
);
}
Error Codes
library Errors {
// Pool Errors
error InsufficientCapacity(uint256 required, uint256 available);
error InvalidPoolType(uint256 poolId, IPoolBase.PoolType poolType);
error UnauthorizedAccess(address caller, address required);
// Risk Errors
error ExceededRiskLimit(uint256 current, uint256 limit);
error InvalidRiskParameters(string reason);
error PropagationFailed(uint256 sourceId, uint256 targetId);
// Validation Errors
error InvalidAmount(uint256 amount);
error InvalidDuration(uint256 duration);
error InvalidConfiguration(string reason);
}
Constants
library Constants {
// Risk Constants
uint256 public constant MAX_RISK_SCORE = 10000; // 100%
uint256 public constant BASE_RISK_FACTOR = 100; // 1%
uint256 public constant CORRELATION_PRECISION = 10000;
// Time Constants
uint256 public constant MIN_STAKE_TIME = 1 days;
uint256 public constant MAX_STAKE_TIME = 365 days;
uint256 public constant REWARD_INTERVAL = 1 hours;
// Pool Constants
uint256 public constant MIN_POOL_CAPACITY = 1000e18;
uint256 public constant MAX_POOL_CAPACITY = 1000000e18;
uint256 public constant MAX_POOLS_PER_TYPE = 100;
}
Security Considerations
Access Control
modifier onlyPool(uint256 poolId) { require(msg.sender == getPoolAddress(poolId), "Unauthorized"); _; } modifier onlyAdmin() { require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "Unauthorized"); _; }Reentrancy Protection
modifier nonReentrant() { require(_notEntered, "ReentrancyGuard: reentrant call"); _notEntered = false; _; _notEntered = true; }Validation
modifier validPool(uint256 poolId) { require(_pools[poolId].exists, "Pool does not exist"); _; } modifier validAmount(uint256 amount) { require(amount > 0, "Invalid amount"); _; }
Performance Optimizations
Gas Optimization
// Use unchecked for counter increments unchecked { i++; } // Pack structs efficiently struct PackedMetrics { uint128 totalStaked; uint64 utilizationRate; uint64 riskScore; }Storage Optimization
// Use bytes32 for fixed-size data mapping(bytes32 => uint256) private _metricsByKey; // Use compact storage for arrays uint256[] private _compactArray;
Testing
contract RiskifyTest {
function testPoolCreation() public {
// Test pool creation
}
function testRiskPropagation() public {
// Test risk propagation
}
function testMetricsUpdate() public {
// Test metrics update
}
}
Navigation
| ← Back to Technical Page | ML Integration → |