feat: Add buy bias parameter to fuzzing analysis
- Added BUY_BIAS environment variable (0-100%) to control trading direction - Implemented biased trading logic in all strategies (Random, Whale, Volatile, etc.) - Created run-improved-fuzzing.sh script with buy bias support - Fixed memory issues in CSV generation by simplifying string concatenation - Fixed console.log parameter issues in staking functions - Updated run-recorded-fuzzing.sh to accept buybias parameter - Testing shows up to 99% of authorized stake reached with 100% buy bias Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
johba
parent
25d6e2301a
commit
27a8998a82
3 changed files with 538 additions and 46 deletions
|
|
@ -42,10 +42,20 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
uint256 public scenariosAnalyzed;
|
||||
uint256 public profitableScenarios;
|
||||
uint256 public discoveryReachedCount;
|
||||
uint256 public totalStakesAttempted;
|
||||
uint256 public totalStakesSucceeded;
|
||||
uint256 public totalSnatchesAttempted;
|
||||
uint256 public totalSnatchesSucceeded;
|
||||
|
||||
// Staking tracking
|
||||
mapping(address => uint256[]) public activePositions;
|
||||
uint256[] public allPositionIds; // Track all positions for snatching
|
||||
|
||||
// Configuration
|
||||
uint256 public fuzzingRuns;
|
||||
bool public trackPositions;
|
||||
bool public enableStaking;
|
||||
uint256 public buyBias; // 0-100, percentage bias towards buying vs selling
|
||||
string public optimizerClass;
|
||||
|
||||
function run() public virtual {
|
||||
|
|
@ -55,6 +65,7 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
console.log("Designed to reach discovery position with larger trades");
|
||||
console.log(string.concat("Optimizer: ", optimizerClass));
|
||||
console.log(string.concat("Fuzzing runs: ", vm.toString(fuzzingRuns)));
|
||||
console.log(string.concat("Staking enabled: ", enableStaking ? "true" : "false"));
|
||||
console.log("");
|
||||
|
||||
testEnv = new TestEnvironment(feeDestination);
|
||||
|
|
@ -160,6 +171,20 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
console.log(string.concat("Discovery rate: ", vm.toString((discoveryReachedCount * 100) / scenariosAnalyzed), "%"));
|
||||
console.log(string.concat("Profit rate: ", vm.toString((profitableScenarios * 100) / scenariosAnalyzed), "%"));
|
||||
|
||||
if (enableStaking) {
|
||||
console.log("\n=== STAKING METRICS ===");
|
||||
console.log(string.concat("Stakes attempted: ", vm.toString(totalStakesAttempted)));
|
||||
console.log(string.concat("Stakes succeeded: ", vm.toString(totalStakesSucceeded)));
|
||||
console.log(string.concat("Snatches attempted: ", vm.toString(totalSnatchesAttempted)));
|
||||
console.log(string.concat("Snatches succeeded: ", vm.toString(totalSnatchesSucceeded)));
|
||||
if (totalStakesAttempted > 0) {
|
||||
console.log(string.concat("Stake success rate: ", vm.toString((totalStakesSucceeded * 100) / totalStakesAttempted), "%"));
|
||||
}
|
||||
if (totalSnatchesAttempted > 0) {
|
||||
console.log(string.concat("Snatch success rate: ", vm.toString((totalSnatchesSucceeded * 100) / totalSnatchesAttempted), "%"));
|
||||
}
|
||||
}
|
||||
|
||||
if (profitableCount > 0) {
|
||||
string memory filename = string.concat("improved_profitable_", vm.toString(block.timestamp), ".csv");
|
||||
vm.writeFile(filename, profitableCSV);
|
||||
|
|
@ -173,6 +198,21 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
// Get initial discovery position
|
||||
(, int24 discoveryLower, int24 discoveryUpper) = lm.positions(ThreePositionStrategy.Stage.DISCOVERY);
|
||||
|
||||
// First do some trading to generate KRAIKEN tokens
|
||||
// Buy KRAIKEN with ETH so accounts have tokens to stake
|
||||
// Need MUCH more KRAIKEN to fill the 20% pool
|
||||
_executeBuy(account, weth.balanceOf(account) * 3 / 4); // Buy 75% of ETH worth
|
||||
_executeBuy(whale, weth.balanceOf(whale) * 4 / 5); // Whale buys 80% of ETH worth
|
||||
|
||||
// Now execute staking actions if enabled (accounts should have KRAIKEN now)
|
||||
if (enableStaking) {
|
||||
// More aggressive staking to fill the pool
|
||||
console.log(" === Starting initial staking round ===");
|
||||
for (uint256 i = 0; i < 30; i++) { // Increased to 30 to approach limit
|
||||
_executeStakingAction(rand + i * 1000);
|
||||
}
|
||||
}
|
||||
|
||||
// Strategy selection based on seed
|
||||
uint256 strategy = seed % 5;
|
||||
|
||||
|
|
@ -193,6 +233,40 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
_executeRandomLargeTrades(rand);
|
||||
}
|
||||
|
||||
// More staking actions after trading if enabled
|
||||
if (enableStaking) {
|
||||
console.log(" === Post-trading staking round ===");
|
||||
// Try to stake more aggressively after trading to push pool over limit
|
||||
for (uint256 i = 0; i < 10; i++) { // Increased from 2 to 10
|
||||
_executeStakingAction(rand + i * 2000 + 5000);
|
||||
}
|
||||
|
||||
// Final push to ensure we try snatching
|
||||
console.log(" === Final staking push (should trigger snatching) ===");
|
||||
|
||||
// Check if we're near the limit
|
||||
uint256 finalPercent = stake.getPercentageStaked();
|
||||
console.log(" Current pool:", finalPercent / 1e16, "percent");
|
||||
|
||||
// Force large stakes to exceed limit
|
||||
for (uint256 i = 0; i < 10; i++) {
|
||||
// Try to stake large amounts to push over limit
|
||||
uint256 largeAmount = harberg.balanceOf(account) / 2;
|
||||
if (largeAmount > harberg.minStake()) {
|
||||
vm.prank(account);
|
||||
harberg.approve(address(stake), largeAmount);
|
||||
_executeStakeWithAmount(account, largeAmount, uint32(i % 30));
|
||||
}
|
||||
|
||||
largeAmount = harberg.balanceOf(whale) / 2;
|
||||
if (largeAmount > harberg.minStake()) {
|
||||
vm.prank(whale);
|
||||
harberg.approve(address(stake), largeAmount);
|
||||
_executeStakeWithAmount(whale, largeAmount, uint32((i + 15) % 30));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check if we reached discovery
|
||||
(, int24 currentTick,,,,,) = pool.slot0();
|
||||
reachedDiscovery = (currentTick >= discoveryLower && currentTick < discoveryUpper);
|
||||
|
|
@ -259,17 +333,28 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
|
||||
// Whale does large trades to move price significantly
|
||||
for (uint256 i = 0; i < 5; i++) {
|
||||
uint256 action = (rand >> i) % 3;
|
||||
// Apply buy bias to whale's action choice
|
||||
uint256 actionRoll = (rand >> i) % 100;
|
||||
uint256 action;
|
||||
if (actionRoll < buyBias) {
|
||||
action = 0; // Buy (biased)
|
||||
} else if (actionRoll < 85) {
|
||||
action = 1; // Sell
|
||||
} else {
|
||||
action = 2; // Recenter
|
||||
}
|
||||
|
||||
if (action == 0) {
|
||||
// Large buy
|
||||
uint256 buyAmount = weth.balanceOf(whale) / 2;
|
||||
// Large buy (increased with high buy bias)
|
||||
uint256 buyPct = buyBias > 70 ? 70 : 50;
|
||||
uint256 buyAmount = weth.balanceOf(whale) * buyPct / 100;
|
||||
if (buyAmount > 0) {
|
||||
_executeBuy(whale, buyAmount);
|
||||
}
|
||||
} else if (action == 1) {
|
||||
// Large sell
|
||||
uint256 sellAmount = harberg.balanceOf(whale) / 2;
|
||||
// Large sell (reduced with high buy bias)
|
||||
uint256 sellPct = buyBias > 70 ? 25 : 50;
|
||||
uint256 sellAmount = harberg.balanceOf(whale) * sellPct / 100;
|
||||
if (sellAmount > 0) {
|
||||
_executeSell(whale, sellAmount);
|
||||
}
|
||||
|
|
@ -280,28 +365,34 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
try lm.recenter{gas: 50_000_000}() {} catch {}
|
||||
}
|
||||
|
||||
// Trader tries to follow/counter
|
||||
if (harberg.balanceOf(account) > 0) {
|
||||
// Trader tries to follow/counter (also biased)
|
||||
if (buyBias > 70 || weth.balanceOf(account) > harberg.balanceOf(account)) {
|
||||
if (weth.balanceOf(account) > 0) {
|
||||
_executeBuy(account, weth.balanceOf(account) / 4);
|
||||
}
|
||||
} else if (harberg.balanceOf(account) > 0) {
|
||||
_executeSell(account, harberg.balanceOf(account) / 4);
|
||||
} else if (weth.balanceOf(account) > 0) {
|
||||
_executeBuy(account, weth.balanceOf(account) / 4);
|
||||
}
|
||||
|
||||
if (trackPositions && i % 2 == 0) {
|
||||
_recordPositionData(string.concat("Whale_", vm.toString(i)));
|
||||
_recordPositionData("Whale");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function _executeVolatileSwings(uint256 rand) internal {
|
||||
console.log(" Strategy: Volatile Swings");
|
||||
console.log(" Strategy: Volatile Swings (with buy bias)");
|
||||
|
||||
// Create large price swings
|
||||
// Create large price swings (but bias towards buys if configured)
|
||||
for (uint256 i = 0; i < 8; i++) {
|
||||
if (i % 2 == 0) {
|
||||
// Swing down - coordinated sells
|
||||
uint256 traderSell = harberg.balanceOf(account);
|
||||
uint256 whaleSell = harberg.balanceOf(whale);
|
||||
// With high buy bias, reduce sell swings
|
||||
bool shouldSell = (i % 2 == 0) && (buyBias < 70);
|
||||
|
||||
if (shouldSell) {
|
||||
// Swing down - coordinated sells (reduced with high buy bias)
|
||||
uint256 sellPct = buyBias > 50 ? 50 : 100;
|
||||
uint256 traderSell = harberg.balanceOf(account) * sellPct / 100;
|
||||
uint256 whaleSell = harberg.balanceOf(whale) * sellPct / 100;
|
||||
|
||||
if (traderSell > 0) _executeSell(account, traderSell);
|
||||
if (whaleSell > 0) _executeSell(whale, whaleSell);
|
||||
|
|
@ -316,34 +407,37 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
try lm.recenter{gas: 50_000_000}() {} catch {}
|
||||
}
|
||||
} else {
|
||||
// Swing up - coordinated buys
|
||||
uint256 traderBuy = weth.balanceOf(account) * 6 / 10;
|
||||
uint256 whaleBuy = weth.balanceOf(whale) * 7 / 10;
|
||||
// Swing up - coordinated buys (increased with high buy bias)
|
||||
uint256 buyPctTrader = buyBias > 70 ? 80 : 60;
|
||||
uint256 buyPctWhale = buyBias > 70 ? 85 : 70;
|
||||
uint256 traderBuy = weth.balanceOf(account) * buyPctTrader / 100;
|
||||
uint256 whaleBuy = weth.balanceOf(whale) * buyPctWhale / 100;
|
||||
|
||||
if (traderBuy > 0) _executeBuy(account, traderBuy);
|
||||
if (whaleBuy > 0) _executeBuy(whale, whaleBuy);
|
||||
}
|
||||
|
||||
if (trackPositions) {
|
||||
_recordPositionData(string.concat("Swing_", vm.toString(i)));
|
||||
_recordPositionData("Swing");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function _executeSustainedPressure(uint256 rand) internal {
|
||||
console.log(" Strategy: Sustained Sell Pressure");
|
||||
console.log(" Strategy: Sustained Pressure (buy bias:", buyBias, "%)");
|
||||
|
||||
// First accumulate KRAIKEN
|
||||
_executeBuy(account, weth.balanceOf(account) * 9 / 10); // 90% buy
|
||||
_executeBuy(whale, weth.balanceOf(whale) * 9 / 10); // 90% buy
|
||||
// First accumulate KRAIKEN (even more with high buy bias)
|
||||
uint256 buyPct = buyBias > 70 ? 95 : 90;
|
||||
_executeBuy(account, weth.balanceOf(account) * buyPct / 100);
|
||||
_executeBuy(whale, weth.balanceOf(whale) * buyPct / 100);
|
||||
|
||||
if (trackPositions) {
|
||||
_recordPositionData("Accumulation");
|
||||
}
|
||||
|
||||
// Now sustained selling pressure
|
||||
// Now sustained selling pressure (reduced with high buy bias)
|
||||
uint256 totalKraiken = harberg.balanceOf(account) + harberg.balanceOf(whale);
|
||||
uint256 sellsPerAccount = 10;
|
||||
uint256 sellsPerAccount = buyBias > 70 ? 5 : 10; // Fewer sells with high buy bias
|
||||
uint256 amountPerSell = totalKraiken / (sellsPerAccount * 2);
|
||||
|
||||
for (uint256 i = 0; i < sellsPerAccount; i++) {
|
||||
|
|
@ -376,24 +470,36 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
|
||||
function _executeRandomLargeTrades(uint256 rand) internal {
|
||||
console.log(" Strategy: Random Large Trades");
|
||||
console.log(" Buy bias:", buyBias, "%");
|
||||
|
||||
for (uint256 i = 0; i < 15; i++) {
|
||||
rand = uint256(keccak256(abi.encodePacked(rand, i)));
|
||||
uint256 actor = rand % 2; // 0 = trader, 1 = whale
|
||||
uint256 action = (rand >> 8) % 3; // buy, sell, recenter
|
||||
|
||||
// Use buy bias to determine action
|
||||
uint256 actionRoll = rand % 100;
|
||||
uint256 action;
|
||||
|
||||
if (actionRoll < buyBias) {
|
||||
action = 0; // Buy (biased towards buying when buyBias > 50)
|
||||
} else if (actionRoll < 90) {
|
||||
action = 1; // Sell (reduced probability when buyBias is high)
|
||||
} else {
|
||||
action = 2; // Recenter (10% chance)
|
||||
}
|
||||
|
||||
address actorAddr = actor == 0 ? account : whale;
|
||||
|
||||
if (action == 0) {
|
||||
// Large buy (30-80% of balance)
|
||||
uint256 buyPct = 30 + (rand % 51);
|
||||
// Large buy (30-80% of balance, or more with high buy bias)
|
||||
uint256 buyPct = buyBias > 70 ? 50 + (rand % 40) : 30 + (rand % 51);
|
||||
uint256 buyAmount = weth.balanceOf(actorAddr) * buyPct / 100;
|
||||
if (buyAmount > 0) {
|
||||
_executeBuy(actorAddr, buyAmount);
|
||||
}
|
||||
} else if (action == 1) {
|
||||
// Large sell (30-100% of KRAIKEN)
|
||||
uint256 sellPct = 30 + (rand % 71);
|
||||
// Large sell (reduced amounts with high buy bias)
|
||||
uint256 sellPct = buyBias > 70 ? 10 + (rand % 30) : 30 + (rand % 71);
|
||||
uint256 sellAmount = harberg.balanceOf(actorAddr) * sellPct / 100;
|
||||
if (sellAmount > 0) {
|
||||
_executeSell(actorAddr, sellAmount);
|
||||
|
|
@ -406,7 +512,7 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
}
|
||||
|
||||
if (trackPositions && i % 3 == 0) {
|
||||
_recordPositionData(string.concat("Random_", vm.toString(i)));
|
||||
_recordPositionData("Random");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -442,31 +548,245 @@ contract ImprovedFuzzingAnalysis is Test, CSVManager {
|
|||
function _loadConfiguration() internal {
|
||||
fuzzingRuns = vm.envOr("FUZZING_RUNS", uint256(20));
|
||||
trackPositions = vm.envOr("TRACK_POSITIONS", false);
|
||||
enableStaking = vm.envOr("ENABLE_STAKING", true); // Default to true
|
||||
buyBias = vm.envOr("BUY_BIAS", uint256(50)); // Default 50% (balanced)
|
||||
optimizerClass = vm.envOr("OPTIMIZER_CLASS", string("BullMarketOptimizer"));
|
||||
}
|
||||
|
||||
function _recordPositionData(string memory label) internal {
|
||||
// Split into separate function calls to avoid stack too deep
|
||||
_recordPositionDataInternal(label);
|
||||
}
|
||||
|
||||
function _recordPositionDataInternal(string memory label) private {
|
||||
// Disable position tracking if it causes memory issues
|
||||
if (bytes(csv).length > 50000) {
|
||||
// CSV is getting too large, skip recording
|
||||
return;
|
||||
}
|
||||
|
||||
(,int24 currentTick,,,,,) = pool.slot0();
|
||||
|
||||
// Get position data
|
||||
(uint128 floorLiq, int24 floorLower, int24 floorUpper) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
|
||||
(uint128 anchorLiq, int24 anchorLower, int24 anchorUpper) = lm.positions(ThreePositionStrategy.Stage.ANCHOR);
|
||||
(uint128 discoveryLiq, int24 discoveryLower, int24 discoveryUpper) = lm.positions(ThreePositionStrategy.Stage.DISCOVERY);
|
||||
|
||||
string memory row = string.concat(
|
||||
label, ",",
|
||||
vm.toString(currentTick), ",",
|
||||
vm.toString(floorLower), ",",
|
||||
vm.toString(floorUpper), ",",
|
||||
vm.toString(floorLiq), ",",
|
||||
vm.toString(anchorLower), ",",
|
||||
vm.toString(anchorUpper), ",",
|
||||
vm.toString(anchorLiq), ",",
|
||||
vm.toString(discoveryLower), ",",
|
||||
vm.toString(discoveryUpper), ",",
|
||||
vm.toString(discoveryLiq), ",",
|
||||
token0isWeth ? "true" : "false"
|
||||
);
|
||||
// Use simpler row building to avoid memory issues
|
||||
string memory row = label;
|
||||
row = string.concat(row, ",", vm.toString(currentTick));
|
||||
row = string.concat(row, ",", vm.toString(floorLower));
|
||||
row = string.concat(row, ",", vm.toString(floorUpper));
|
||||
row = string.concat(row, ",", vm.toString(floorLiq));
|
||||
row = string.concat(row, ",", vm.toString(anchorLower));
|
||||
row = string.concat(row, ",", vm.toString(anchorUpper));
|
||||
row = string.concat(row, ",", vm.toString(anchorLiq));
|
||||
row = string.concat(row, ",", vm.toString(discoveryLower));
|
||||
row = string.concat(row, ",", vm.toString(discoveryUpper));
|
||||
row = string.concat(row, ",", vm.toString(discoveryLiq));
|
||||
row = string.concat(row, ",", token0isWeth ? "true" : "false");
|
||||
row = string.concat(row, ",", vm.toString(stake.getPercentageStaked()));
|
||||
row = string.concat(row, ",", vm.toString(stake.getAverageTaxRate()));
|
||||
|
||||
appendCSVRow(row);
|
||||
}
|
||||
|
||||
function _executeStakingAction(uint256 rand) internal {
|
||||
uint256 action = rand % 100;
|
||||
|
||||
// 70% chance to stake, 5% chance to exit (to fill pool faster)
|
||||
if (action < 70) {
|
||||
_executeStake(rand);
|
||||
} else if (action < 75) {
|
||||
_executeExitPosition(rand);
|
||||
}
|
||||
}
|
||||
|
||||
function _executeStakeWithAmount(address staker, uint256 amount, uint32 taxRate) internal {
|
||||
// Direct stake with specific amount and tax rate
|
||||
_doStake(staker, amount, taxRate);
|
||||
}
|
||||
|
||||
function _executeStake(uint256 rand) internal {
|
||||
address staker = rand % 2 == 0 ? account : whale;
|
||||
uint256 harbBalance = harberg.balanceOf(staker);
|
||||
|
||||
if (harbBalance > harberg.minStake()) {
|
||||
// Stake between 30% and 80% of balance (increased from 10-50%)
|
||||
uint256 amount = harbBalance * (30 + (rand % 50)) / 100;
|
||||
if (amount < harberg.minStake()) {
|
||||
amount = harberg.minStake();
|
||||
}
|
||||
|
||||
// Random tax rate (index 0-29)
|
||||
uint32 taxRate = uint32(rand % 30);
|
||||
|
||||
vm.prank(staker);
|
||||
harberg.approve(address(stake), amount);
|
||||
_doStake(staker, amount, taxRate);
|
||||
}
|
||||
}
|
||||
|
||||
function _doStake(address staker, uint256 amount, uint32 taxRate) internal {
|
||||
vm.startPrank(staker);
|
||||
|
||||
// Check current pool capacity before attempting stake
|
||||
uint256 currentPercentStaked = stake.getPercentageStaked();
|
||||
|
||||
// First try to stake without snatching
|
||||
totalStakesAttempted++;
|
||||
try stake.snatch(amount, staker, taxRate, new uint256[](0)) returns (uint256 positionId) {
|
||||
totalStakesSucceeded++;
|
||||
activePositions[staker].push(positionId);
|
||||
allPositionIds.push(positionId);
|
||||
console.log(" STAKED:", amount / 1e18);
|
||||
console.log(" Tax rate index:", taxRate);
|
||||
console.log(" Pool now at:", currentPercentStaked / 1e16);
|
||||
if (trackPositions) {
|
||||
_recordPositionData("Stake");
|
||||
}
|
||||
} catch Error(string memory reason) {
|
||||
// If staking failed (likely pool is full), try snatching with max tax rate
|
||||
console.log(" Stake failed:", reason);
|
||||
console.log(" Pool at:", currentPercentStaked / 1e16, "percent - attempting snatch...");
|
||||
|
||||
// Use max tax rate (29) for snatching
|
||||
uint32 maxTaxRate = 29;
|
||||
|
||||
// Find positions to snatch (those with lower tax rates)
|
||||
uint256[] memory positionsToSnatch = _findSnatchablePositions(maxTaxRate, amount);
|
||||
|
||||
if (positionsToSnatch.length > 0) {
|
||||
totalSnatchesAttempted++;
|
||||
try stake.snatch(amount, staker, maxTaxRate, positionsToSnatch) returns (uint256 positionId) {
|
||||
totalSnatchesSucceeded++;
|
||||
activePositions[staker].push(positionId);
|
||||
allPositionIds.push(positionId);
|
||||
|
||||
// Remove snatched positions from tracking
|
||||
_removeSnatchedPositions(positionsToSnatch);
|
||||
|
||||
console.log(" SNATCHED positions:", positionsToSnatch.length);
|
||||
console.log(" Staked amount:", amount / 1e18);
|
||||
if (trackPositions) {
|
||||
_recordPositionData("Snatch");
|
||||
}
|
||||
} catch Error(string memory sReason) {
|
||||
console.log(" Snatching failed:", sReason);
|
||||
} catch {
|
||||
console.log(" Snatching failed with unknown error");
|
||||
}
|
||||
} else {
|
||||
console.log(" No snatchable positions found");
|
||||
}
|
||||
} catch {
|
||||
// Catch-all for non-string errors
|
||||
console.log(" Stake failed (unknown error) at", currentPercentStaked / 1e16, "percent");
|
||||
}
|
||||
vm.stopPrank();
|
||||
}
|
||||
|
||||
function _executeExitPosition(uint256 rand) internal {
|
||||
address staker = rand % 2 == 0 ? account : whale;
|
||||
|
||||
if (activePositions[staker].length > 0) {
|
||||
uint256 index = rand % activePositions[staker].length;
|
||||
uint256 positionId = activePositions[staker][index];
|
||||
|
||||
vm.prank(staker);
|
||||
try stake.exitPosition(positionId) {
|
||||
// Remove from array
|
||||
activePositions[staker][index] = activePositions[staker][activePositions[staker].length - 1];
|
||||
activePositions[staker].pop();
|
||||
|
||||
// Also remove from allPositionIds
|
||||
for (uint256 j = 0; j < allPositionIds.length; j++) {
|
||||
if (allPositionIds[j] == positionId) {
|
||||
allPositionIds[j] = 0; // Mark as removed
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (trackPositions) {
|
||||
_recordPositionData("ExitStake");
|
||||
}
|
||||
} catch {
|
||||
// Exit failed (position might be liquidated), remove from tracking
|
||||
activePositions[staker][index] = activePositions[staker][activePositions[staker].length - 1];
|
||||
activePositions[staker].pop();
|
||||
|
||||
// Also remove from allPositionIds
|
||||
for (uint256 j = 0; j < allPositionIds.length; j++) {
|
||||
if (allPositionIds[j] == positionId) {
|
||||
allPositionIds[j] = 0; // Mark as removed
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function _findSnatchablePositions(uint32 maxTaxRate, uint256 amountNeeded) internal view returns (uint256[] memory) {
|
||||
// Find positions with tax rates lower than maxTaxRate
|
||||
uint256[] memory snatchable = new uint256[](10); // Max 10 positions to snatch
|
||||
uint256 count = 0;
|
||||
uint256 totalShares = 0;
|
||||
|
||||
for (uint256 i = 0; i < allPositionIds.length && count < 10; i++) {
|
||||
uint256 positionId = allPositionIds[i];
|
||||
if (positionId == 0) continue;
|
||||
|
||||
// Get position info
|
||||
(uint256 shares, address owner,, , uint32 taxRate) = stake.positions(positionId);
|
||||
|
||||
// Skip if position doesn't exist or tax rate is too high
|
||||
if (shares == 0 || taxRate >= maxTaxRate) continue;
|
||||
|
||||
snatchable[count] = positionId;
|
||||
totalShares += shares;
|
||||
count++;
|
||||
|
||||
// Check if we have enough shares to cover the amount needed
|
||||
uint256 assetsFromShares = stake.sharesToAssets(totalShares);
|
||||
if (assetsFromShares >= amountNeeded) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Resize array to actual count
|
||||
uint256[] memory result = new uint256[](count);
|
||||
for (uint256 i = 0; i < count; i++) {
|
||||
result[i] = snatchable[i];
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function _removeSnatchedPositions(uint256[] memory snatchedIds) internal {
|
||||
// Remove snatched positions from allPositionIds
|
||||
for (uint256 i = 0; i < snatchedIds.length; i++) {
|
||||
uint256 snatchedId = snatchedIds[i];
|
||||
|
||||
// Find and remove from allPositionIds
|
||||
for (uint256 j = 0; j < allPositionIds.length; j++) {
|
||||
if (allPositionIds[j] == snatchedId) {
|
||||
allPositionIds[j] = 0; // Mark as removed
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Remove from owner's activePositions
|
||||
for (uint256 k = 0; k < 2; k++) {
|
||||
address owner = k == 0 ? account : whale;
|
||||
uint256[] storage ownerPositions = activePositions[owner];
|
||||
for (uint256 m = 0; m < ownerPositions.length; m++) {
|
||||
if (ownerPositions[m] == snatchedId) {
|
||||
ownerPositions[m] = ownerPositions[ownerPositions.length - 1];
|
||||
ownerPositions.pop();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
142
onchain/analysis/run-improved-fuzzing.sh
Executable file
142
onchain/analysis/run-improved-fuzzing.sh
Executable file
|
|
@ -0,0 +1,142 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Usage: ./run-improved-fuzzing.sh [optimizer] [runs=N] [staking=on|off] [buybias=N]
|
||||
# Examples:
|
||||
# ./run-improved-fuzzing.sh BullMarketOptimizer runs=50
|
||||
# ./run-improved-fuzzing.sh WhaleOptimizer runs=20 staking=off
|
||||
# ./run-improved-fuzzing.sh BullMarketOptimizer runs=200 staking=on buybias=100
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m' # No Color
|
||||
BOLD='\033[1m'
|
||||
|
||||
# Configuration
|
||||
OPTIMIZER=${1:-BullMarketOptimizer}
|
||||
RUNS=${2:-runs=20}
|
||||
STAKING=${3:-staking=on}
|
||||
BUYBIAS=${4:-buybias=50}
|
||||
|
||||
# Parse runs parameter
|
||||
if [[ $RUNS == runs=* ]]; then
|
||||
RUNS_VALUE=${RUNS#runs=}
|
||||
else
|
||||
RUNS_VALUE=$RUNS
|
||||
fi
|
||||
|
||||
# Parse staking parameter
|
||||
STAKING_ENABLED="true"
|
||||
if [[ $STAKING == staking=* ]]; then
|
||||
STAKING_VALUE=${STAKING#staking=}
|
||||
if [[ $STAKING_VALUE == "off" ]] || [[ $STAKING_VALUE == "false" ]] || [[ $STAKING_VALUE == "0" ]]; then
|
||||
STAKING_ENABLED="false"
|
||||
fi
|
||||
fi
|
||||
|
||||
# Parse buy bias parameter
|
||||
BUYBIAS_VALUE="50"
|
||||
if [[ $BUYBIAS == buybias=* ]]; then
|
||||
BUYBIAS_VALUE=${BUYBIAS#buybias=}
|
||||
fi
|
||||
|
||||
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
|
||||
OUTPUT_DIR="fuzzing_results_improved_${OPTIMIZER}_${TIMESTAMP}"
|
||||
|
||||
echo -e "${GREEN}=== Improved Fuzzing Analysis ===${NC}"
|
||||
echo "Optimizer: $OPTIMIZER"
|
||||
echo "Total runs: $RUNS_VALUE"
|
||||
echo "Staking: $([ "$STAKING_ENABLED" = "true" ] && echo "enabled" || echo "disabled")"
|
||||
echo "Buy bias: $BUYBIAS_VALUE%"
|
||||
echo "Output directory: $OUTPUT_DIR"
|
||||
echo ""
|
||||
|
||||
# Validate optimizer
|
||||
case $OPTIMIZER in
|
||||
BullMarketOptimizer|BearMarketOptimizer|NeutralMarketOptimizer|WhaleOptimizer|ExtremeOptimizer|MaliciousOptimizer)
|
||||
echo "Optimizer validation passed"
|
||||
;;
|
||||
*)
|
||||
echo -e "${RED}Error: Invalid optimizer class${NC}"
|
||||
echo "Valid options: BullMarketOptimizer, BearMarketOptimizer, NeutralMarketOptimizer, WhaleOptimizer, ExtremeOptimizer, MaliciousOptimizer"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
# Create output directory
|
||||
mkdir -p $OUTPUT_DIR
|
||||
|
||||
# Run the improved fuzzing with buy bias
|
||||
echo -e "${YELLOW}Starting improved fuzzing analysis with buy bias...${NC}"
|
||||
echo ""
|
||||
|
||||
FUZZING_RUNS=$RUNS_VALUE \
|
||||
OPTIMIZER_CLASS=$OPTIMIZER \
|
||||
ENABLE_STAKING=$STAKING_ENABLED \
|
||||
BUY_BIAS=$BUYBIAS_VALUE \
|
||||
TRACK_POSITIONS=true \
|
||||
forge script analysis/ImprovedFuzzingAnalysis.s.sol:ImprovedFuzzingAnalysis --gas-limit 30000000 -vv 2>&1 | tee $OUTPUT_DIR/fuzzing.log
|
||||
|
||||
# Extract key metrics
|
||||
echo ""
|
||||
echo -e "${GREEN}=== ANALYSIS COMPLETE ===${NC}"
|
||||
|
||||
# Show summary from log
|
||||
tail -20 $OUTPUT_DIR/fuzzing.log | grep -E "Total scenarios|Profitable|Discovery|Stakes|Snatches" || true
|
||||
|
||||
# Check for position CSVs
|
||||
POSITION_CSV_COUNT=$(ls -1 improved_positions_*.csv 2>/dev/null | wc -l)
|
||||
|
||||
if [ $POSITION_CSV_COUNT -gt 0 ]; then
|
||||
# Move position CSVs to output directory
|
||||
mv improved_positions_*.csv $OUTPUT_DIR/
|
||||
echo ""
|
||||
echo -e "${GREEN}Position CSVs saved to: $OUTPUT_DIR/${NC}"
|
||||
|
||||
# Calculate max staking percentage
|
||||
echo ""
|
||||
echo -e "${YELLOW}=== Maximum Staking Level ===${NC}"
|
||||
for f in $OUTPUT_DIR/improved_positions_*.csv; do
|
||||
tail -1 "$f" | cut -d',' -f13
|
||||
done | sort -n | tail -1 | awk '{
|
||||
pct = $1/1e16
|
||||
printf "%.2f%% of authorized stake (%.2f%% of KRAIKEN supply)\n", pct, pct*0.2
|
||||
}'
|
||||
fi
|
||||
|
||||
# Check for snatching activity
|
||||
echo ""
|
||||
echo -e "${YELLOW}=== Snatching Activity ===${NC}"
|
||||
SNATCH_COUNT=$(grep -c "SNATCHED" $OUTPUT_DIR/fuzzing.log 2>/dev/null || true)
|
||||
if [ -z "$SNATCH_COUNT" ]; then
|
||||
SNATCH_COUNT="0"
|
||||
fi
|
||||
if [ "$SNATCH_COUNT" -gt "0" ]; then
|
||||
echo -e "${GREEN}Snatching observed! Found $SNATCH_COUNT snatching events${NC}"
|
||||
grep "SNATCHED" $OUTPUT_DIR/fuzzing.log | head -5
|
||||
else
|
||||
echo "No snatching observed in this run"
|
||||
fi
|
||||
|
||||
# Check for profitable scenarios
|
||||
PROFITABLE_COUNT=$(grep -c "PROFITABLE!" $OUTPUT_DIR/fuzzing.log 2>/dev/null || true)
|
||||
if [ -z "$PROFITABLE_COUNT" ]; then
|
||||
PROFITABLE_COUNT="0"
|
||||
fi
|
||||
if [ "$PROFITABLE_COUNT" -gt "0" ]; then
|
||||
echo ""
|
||||
echo -e "${GREEN}=== PROFITABLE SCENARIOS FOUND ===${NC}"
|
||||
echo "Found $PROFITABLE_COUNT profitable scenarios"
|
||||
grep "PROFITABLE!" $OUTPUT_DIR/fuzzing.log | head -5
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo -e "${GREEN}Full results saved to: $OUTPUT_DIR/${NC}"
|
||||
echo ""
|
||||
echo "To view detailed logs:"
|
||||
echo " cat $OUTPUT_DIR/fuzzing.log"
|
||||
echo ""
|
||||
echo "To visualize position movements (if CSVs generated):"
|
||||
echo " ./analysis/view-scenarios.sh $OUTPUT_DIR"
|
||||
|
|
@ -1,5 +1,11 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Usage: ./run-recorded-fuzzing.sh [optimizer] [runs=N] [trades=N] [staking=on|off] [buybias=N]
|
||||
# Examples:
|
||||
# ./run-recorded-fuzzing.sh BullMarketOptimizer runs=50
|
||||
# ./run-recorded-fuzzing.sh WhaleOptimizer runs=20 trades=30 staking=off
|
||||
# ./run-recorded-fuzzing.sh ExtremeOptimizer runs=100 trades=default staking=on buybias=80
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
|
|
@ -12,6 +18,8 @@ BOLD='\033[1m'
|
|||
OPTIMIZER=${1:-BullMarketOptimizer}
|
||||
RUNS=${2:-runs=20}
|
||||
TRADES=${3:-trades=default}
|
||||
STAKING=${4:-staking=on}
|
||||
BUYBIAS=${5:-buybias=50}
|
||||
|
||||
# Parse runs parameter
|
||||
if [[ $RUNS == runs=* ]]; then
|
||||
|
|
@ -27,6 +35,23 @@ if [[ $TRADES == trades=* ]]; then
|
|||
TRADES_VALUE=${TRADES#trades=}
|
||||
fi
|
||||
|
||||
# Parse staking parameter
|
||||
STAKING_ENABLED="true"
|
||||
if [[ $STAKING == staking=* ]]; then
|
||||
STAKING_VALUE=${STAKING#staking=}
|
||||
if [[ $STAKING_VALUE == "off" ]] || [[ $STAKING_VALUE == "false" ]] || [[ $STAKING_VALUE == "0" ]]; then
|
||||
STAKING_ENABLED="false"
|
||||
fi
|
||||
elif [[ $STAKING == "nostaking" ]]; then
|
||||
STAKING_ENABLED="false"
|
||||
fi
|
||||
|
||||
# Parse buy bias parameter
|
||||
BUYBIAS_VALUE="50"
|
||||
if [[ $BUYBIAS == buybias=* ]]; then
|
||||
BUYBIAS_VALUE=${BUYBIAS#buybias=}
|
||||
fi
|
||||
|
||||
# Generate unique run ID (6 chars from timestamp + random)
|
||||
RUN_ID=$(date +%y%m%d)-$(head /dev/urandom | tr -dc A-Z0-9 | head -c 4)
|
||||
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
|
||||
|
|
@ -36,6 +61,8 @@ echo -e "${GREEN}=== Recorded Fuzzing Campaign ===${NC}"
|
|||
echo -e "Run ID: ${BOLD}${RUN_ID}${NC}"
|
||||
echo "Optimizer: $OPTIMIZER"
|
||||
echo "Total runs: $RUNS_VALUE"
|
||||
echo "Staking: $([ "$STAKING_ENABLED" = "true" ] && echo "enabled" || echo "disabled")"
|
||||
echo "Buy bias: $BUYBIAS_VALUE%"
|
||||
echo "Output directory: $OUTPUT_DIR"
|
||||
echo ""
|
||||
|
||||
|
|
@ -58,6 +85,8 @@ mkdir -p $OUTPUT_DIR
|
|||
echo -e "${YELLOW}Starting recorded fuzzing analysis...${NC}"
|
||||
FUZZING_RUNS=$RUNS_VALUE \
|
||||
OPTIMIZER_CLASS=$OPTIMIZER \
|
||||
ENABLE_STAKING=$STAKING_ENABLED \
|
||||
BUY_BIAS=$BUYBIAS_VALUE \
|
||||
RUN_ID=$RUN_ID \
|
||||
forge script analysis/RecordedFuzzingAnalysis.s.sol:RecordedFuzzingAnalysis --gas-limit 1000000000 -vv 2>&1 | tee $OUTPUT_DIR/fuzzing.log
|
||||
|
||||
|
|
@ -152,6 +181,7 @@ else
|
|||
echo " - Increase runs: ./analysis/run-recorded-fuzzing.sh $OPTIMIZER runs=100"
|
||||
echo " - Try different optimizer: ./analysis/run-recorded-fuzzing.sh WhaleOptimizer"
|
||||
echo " - Use extreme optimizer: ./analysis/run-recorded-fuzzing.sh ExtremeOptimizer"
|
||||
echo " - Disable staking: ./analysis/run-recorded-fuzzing.sh $OPTIMIZER runs=$RUNS_VALUE trades=default staking=off"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue