2c849ec456
Move the orphaned NatSpec block (originally for calculateParams) from above getLiquidityParams to directly precede calculateParams, and give getLiquidityParams only its own @inheritdoc block. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
291 lines
20 KiB
Solidity
291 lines
20 KiB
Solidity
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
pragma solidity ^0.8.19;
|
|
|
|
import {IOptimizer, OptimizerInput} from "./IOptimizer.sol";
|
|
|
|
/**
|
|
* @title OptimizerV3Push3
|
|
* @notice Auto-generated from optimizer_v3.push3 via Push3→Solidity transpiler.
|
|
* Implements calculateParams with 8 dyadic rational inputs and 4 outputs.
|
|
*/
|
|
contract OptimizerV3Push3 is IOptimizer {
|
|
/**
|
|
* @inheritdoc IOptimizer
|
|
* @dev Calls calculateParams with zeroed inputs (percentageStaked=0, averageTaxRate=0),
|
|
* producing bear-mode defaults: (ci=0, anchorShare=0.3e18, anchorWidth=100, discoveryDepth=0.3e18).
|
|
* This contract is a standalone transpiler output without access to on-chain stake data;
|
|
* use OptimizerV3 (which inherits Optimizer) for a live deployment with real inputs.
|
|
*/
|
|
function getLiquidityParams()
|
|
external
|
|
view
|
|
returns (uint256 capitalInefficiency, uint256 anchorShare, uint24 anchorWidth, uint256 discoveryDepth)
|
|
{
|
|
OptimizerInput[8] memory inputs;
|
|
return calculateParams(inputs);
|
|
}
|
|
|
|
/**
|
|
* @notice Compute liquidity parameters from 8 dyadic rational inputs.
|
|
* @dev capitalInefficiency (ci) is intentionally hardcoded to 0 in both the bear
|
|
* and bull branches of this implementation. CI is a pure risk lever that
|
|
* controls the VWAP bias applied when placing the floor position: CI=0 means
|
|
* the floor tracks the raw VWAP with no upward adjustment, which is the
|
|
* safest setting and carries zero effect on fee revenue. Any integrating
|
|
* proxy (e.g. ThreePositionStrategy) must therefore treat the floor scarcity
|
|
* and VWAP adjustment as if no capital-inefficiency premium is active.
|
|
* Future optimizer versions that expose non-zero CI values should document
|
|
* the resulting floor-placement and eth-scarcity effects explicitly.
|
|
* @param inputs 8-slot dyadic rational array (all values 0..1e18):
|
|
* slot 0 = percentageStaked, slot 1 = averageTaxRate,
|
|
* slot 2 = pricePosition, slot 3 = volatility, slot 4 = momentum,
|
|
* slot 5 = timeSinceRecenter, slot 6 = utilizationRate, slot 7 = reserved.
|
|
* This implementation uses only slots 0 and 1; slots 2-7 are available
|
|
* to future evolved programs that use the normalized indicators.
|
|
* @return ci Capital inefficiency (0..1e18). Always 0 in this implementation.
|
|
* @return anchorShare Fraction of non-floor ETH in anchor (0..1e18).
|
|
* @return anchorWidth Anchor position width in tick units.
|
|
* @return discoveryDepth Discovery liquidity density (0..1e18).
|
|
*/
|
|
function calculateParams(OptimizerInput[8] memory inputs)
|
|
public
|
|
pure
|
|
returns (uint256 ci, uint256 anchorShare, uint24 anchorWidth, uint256 discoveryDepth)
|
|
{
|
|
// Validate mantissa for percentageStaked
|
|
require(inputs[0].mantissa <= 1e18, "mantissa overflow");
|
|
|
|
// Validate that shift is 0 (future-only field, not yet supported)
|
|
for (uint256 k = 0; k < 8; k++) {
|
|
require(inputs[k].shift == 0, "shift not yet supported");
|
|
}
|
|
|
|
uint256 percentagestaked = uint256(uint256(inputs[0].mantissa));
|
|
uint256 taxrate = uint256(uint256(inputs[1].mantissa));
|
|
uint256 staked = uint256(((percentagestaked * 100) / 1000000000000000000));
|
|
uint256 r37;
|
|
uint256 r38;
|
|
uint256 r39;
|
|
uint256 r40;
|
|
if ((staked > 91)) {
|
|
uint256 deltas = uint256((100 - staked));
|
|
uint256 r28;
|
|
if ((taxrate <= 206185567010309)) {
|
|
r28 = uint256(0);
|
|
} else {
|
|
uint256 r27;
|
|
if ((taxrate <= 412371134020618)) {
|
|
r27 = uint256(1);
|
|
} else {
|
|
uint256 r26;
|
|
if ((taxrate <= 618556701030927)) {
|
|
r26 = uint256(2);
|
|
} else {
|
|
uint256 r25;
|
|
if ((taxrate <= 1030927835051546)) {
|
|
r25 = uint256(3);
|
|
} else {
|
|
uint256 r24;
|
|
if ((taxrate <= 1546391752577319)) {
|
|
r24 = uint256(4);
|
|
} else {
|
|
uint256 r23;
|
|
if ((taxrate <= 2164948453608247)) {
|
|
r23 = uint256(5);
|
|
} else {
|
|
uint256 r22;
|
|
if ((taxrate <= 2783505154639175)) {
|
|
r22 = uint256(6);
|
|
} else {
|
|
uint256 r21;
|
|
if ((taxrate <= 3608247422680412)) {
|
|
r21 = uint256(7);
|
|
} else {
|
|
uint256 r20;
|
|
if ((taxrate <= 4639175257731958)) {
|
|
r20 = uint256(8);
|
|
} else {
|
|
uint256 r19;
|
|
if ((taxrate <= 5670103092783505)) {
|
|
r19 = uint256(9);
|
|
} else {
|
|
uint256 r18;
|
|
if ((taxrate <= 7216494845360824)) {
|
|
r18 = uint256(10);
|
|
} else {
|
|
uint256 r17;
|
|
if ((taxrate <= 9278350515463917)) {
|
|
r17 = uint256(11);
|
|
} else {
|
|
uint256 r16;
|
|
if ((taxrate <= 11855670103092783)) {
|
|
r16 = uint256(12);
|
|
} else {
|
|
uint256 r15;
|
|
if ((taxrate <= 15979381443298969)) {
|
|
r15 = uint256(13);
|
|
} else {
|
|
uint256 r14;
|
|
if ((taxrate <= 22164948453608247)) {
|
|
r14 = uint256(14);
|
|
} else {
|
|
uint256 r13;
|
|
if ((taxrate <= 29381443298969072)) {
|
|
r13 = uint256(15);
|
|
} else {
|
|
uint256 r12;
|
|
if ((taxrate <= 38144329896907216)) {
|
|
r12 = uint256(16);
|
|
} else {
|
|
uint256 r11;
|
|
if ((taxrate <= 49484536082474226)) {
|
|
r11 = uint256(17);
|
|
} else {
|
|
uint256 r10;
|
|
if ((taxrate <= 63917525773195876)) {
|
|
r10 = uint256(18);
|
|
} else {
|
|
uint256 r9;
|
|
if ((taxrate <= 83505154639175257)) {
|
|
r9 = uint256(19);
|
|
} else {
|
|
uint256 r8;
|
|
if ((taxrate <= 109278350515463917)) {
|
|
r8 = uint256(20);
|
|
} else {
|
|
uint256 r7;
|
|
if ((taxrate <= 144329896907216494)) {
|
|
r7 = uint256(21);
|
|
} else {
|
|
uint256 r6;
|
|
if ((taxrate <= 185567010309278350)) {
|
|
r6 = uint256(22);
|
|
} else {
|
|
uint256 r5;
|
|
if ((taxrate <= 237113402061855670)) {
|
|
r5 = uint256(23);
|
|
} else {
|
|
uint256 r4;
|
|
if ((taxrate <= 309278350515463917)) {
|
|
r4 = uint256(24);
|
|
} else {
|
|
uint256 r3;
|
|
if ((taxrate <= 402061855670103092)) {
|
|
r3 = uint256(25);
|
|
} else {
|
|
uint256 r2;
|
|
if ((taxrate <= 520618556701030927)) {
|
|
r2 = uint256(26);
|
|
} else {
|
|
uint256 r1;
|
|
if ((taxrate <= 680412371134020618)) {
|
|
r1 = uint256(27);
|
|
} else {
|
|
uint256 r0;
|
|
if ((taxrate <= 886597938144329896)) {
|
|
r0 = uint256(28);
|
|
} else {
|
|
r0 = uint256(29);
|
|
}
|
|
r1 = uint256(r0);
|
|
}
|
|
r2 = uint256(r1);
|
|
}
|
|
r3 = uint256(r2);
|
|
}
|
|
r4 = uint256(r3);
|
|
}
|
|
r5 = uint256(r4);
|
|
}
|
|
r6 = uint256(r5);
|
|
}
|
|
r7 = uint256(r6);
|
|
}
|
|
r8 = uint256(r7);
|
|
}
|
|
r9 = uint256(r8);
|
|
}
|
|
r10 = uint256(r9);
|
|
}
|
|
r11 = uint256(r10);
|
|
}
|
|
r12 = uint256(r11);
|
|
}
|
|
r13 = uint256(r12);
|
|
}
|
|
r14 = uint256(r13);
|
|
}
|
|
r15 = uint256(r14);
|
|
}
|
|
r16 = uint256(r15);
|
|
}
|
|
r17 = uint256(r16);
|
|
}
|
|
r18 = uint256(r17);
|
|
}
|
|
r19 = uint256(r18);
|
|
}
|
|
r20 = uint256(r19);
|
|
}
|
|
r21 = uint256(r20);
|
|
}
|
|
r22 = uint256(r21);
|
|
}
|
|
r23 = uint256(r22);
|
|
}
|
|
r24 = uint256(r23);
|
|
}
|
|
r25 = uint256(r24);
|
|
}
|
|
r26 = uint256(r25);
|
|
}
|
|
r27 = uint256(r26);
|
|
}
|
|
r28 = uint256(r27);
|
|
}
|
|
uint256 dup29 = uint256(r28);
|
|
uint256 r32;
|
|
if ((dup29 >= 14)) {
|
|
uint256 dup30 = uint256((dup29 + 1));
|
|
uint256 r31;
|
|
if ((dup30 > 29)) {
|
|
r31 = uint256(29);
|
|
} else {
|
|
r31 = uint256(dup30);
|
|
}
|
|
r32 = uint256(r31);
|
|
} else {
|
|
r32 = uint256(dup29);
|
|
}
|
|
uint256 effidx = uint256(r32);
|
|
uint256 r33;
|
|
uint256 r34;
|
|
uint256 r35;
|
|
uint256 r36;
|
|
if ((((((deltas * deltas) * deltas) * effidx) / 20) < 50)) {
|
|
r33 = uint256(1000000000000000000);
|
|
r34 = uint256(20);
|
|
r35 = uint256(1000000000000000000);
|
|
r36 = uint256(0);
|
|
} else {
|
|
r33 = uint256(300000000000000000);
|
|
r34 = uint256(100);
|
|
r35 = uint256(300000000000000000);
|
|
r36 = uint256(0);
|
|
}
|
|
r37 = uint256(r33);
|
|
r38 = uint256(r34);
|
|
r39 = uint256(r35);
|
|
r40 = uint256(r36);
|
|
} else {
|
|
r37 = uint256(300000000000000000);
|
|
r38 = uint256(100);
|
|
r39 = uint256(300000000000000000);
|
|
r40 = uint256(0);
|
|
}
|
|
ci = uint256(r40);
|
|
anchorShare = uint256(r39);
|
|
anchorWidth = uint24(r38);
|
|
discoveryDepth = uint256(r37);
|
|
}
|
|
}
|