naps62 · January 15, 2025 11:30 · pvgo80 · Jan 15, 2025
diff --git a/liquidity.sol b/liquidity.sol
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.24;

 import "openzeppelin-contracts/contracts/utils/math/Math.sol";

 import "src/Interfaces/IBorrowerOperations.sol";
 import {DECIMAL_PRECISION} from "src/Dependencies/Constants.sol";

 import "src/Zappers/Modules/Exchanges/UniswapV3/IUniswapV3Pool.sol";
 import "src/Zappers/Modules/Exchanges/UniswapV3/INonfungiblePositionManager.sol";
 import {ICrocSwapDex, CrocSwapDexHelper} from "src/Exchanges/CrocSwap/ICrocSwapDex.sol";

 INonfungiblePositionManager constant scrollUniV3PositionManager =
        INonfungiblePositionManager(0xB39002E4033b162fAc607fc3471E205FA2aE5967);
    ICrocSwapDex crocSwapDex = ICrocSwapDex(0xaaaaAAAACB71BF2C8CaE522EA5fa455571A74106);

    // Initial liquidity values (these values need to be changed)
    uint256 constant initialLiquidityTroveUsdqAmount = 500e18;
    uint256 constant initialLiquidityTroveWethAmount = 500e18;
    uint256 constant initialLiquidityTroveInterestRate = _1pct / 2;

    uint256 constant initialLiquiditySpAmount = 100e18;
    uint256 constant initialLiquidityUniV3Amount = 200e18;
    uint256 constant initialLiquidityCrocSwapAmount = 200e18;
    uint256 constant initialLiquidityExchangePrice = DECIMAL_PRECISION; // 10e18; // 1:1 ratio, same amount for both tokens (?)
    uint24 constant UNIV3_FEE = 0.3e4;

 function openInitialLiquidityTrove(
    address deployer,
    IBorrowerOperations borrowerOperations,
    uint256 boldAmount,
    uint256 collAmount,
    uint256 annualInterestRate,
    uint256 maxUpfrontFee
 ) {
    borrowerOperations.openTrove(
        deployer, // _owner
        0, // _ownerIndex
        collAmount, // _collAmount
        boldAmount, // _boldAmount
        0, // _upperHint
        0, // _lowerHint
        annualInterestRate, // _annualInterestRate
        // type(uint256).max, // _maxUpfrontFee
        maxUpfrontFee, // _maxUpfrontFee
        address(0), // _addManager
        address(0), // _removeManager
        address(0) // _receiver
    );
 }

 function depositInStabilityPool(IStabilityPool stabilityPool, uint256 boldAmount) {
    stabilityPool.provideToSP(
        boldAmount, // _topUp
        false // _doClaim
    );
 }

 struct ProvideUniV3LiquidityVars {
    uint256 token2Amount;
    uint256 price;
    int24 TICK_SPACING;
    int24 tick;
    int24 tickLower;
    int24 tickUpper;
    address[2] tokens;
    uint256[2] amounts;
 }

 // _price should be _token1 / _token2
 function provideUniV3Liquidity(
    address deployer,
    INonfungiblePositionManager uniV3PositionManager,
    IERC20 _token1,
    IERC20 _token2,
    uint256 _token1Amount,
    uint256 _price,
    uint24 _fee
 ) returns (address uniV3PoolAddress, uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1) {
    ProvideUniV3LiquidityVars memory vars;

    // tokens and amounts
    vars.token2Amount = _token1Amount * DECIMAL_PRECISION / _price;

    if (address(_token1) < address(_token2)) {
        vars.tokens[0] = address(_token1);
        vars.tokens[1] = address(_token2);
        vars.amounts[0] = _token1Amount;
        vars.amounts[1] = vars.token2Amount;
        // inverse price if token1 goes first
        vars.price = DECIMAL_PRECISION * DECIMAL_PRECISION / _price;
    } else {
        vars.tokens[0] = address(_token2);
        vars.tokens[1] = address(_token1);
        vars.amounts[0] = vars.token2Amount;
        vars.amounts[1] = _token1Amount;
        vars.price = _price;
    }

    uniV3PoolAddress = uniV3PositionManager.createAndInitializePoolIfNecessary(
        vars.tokens[0],
        vars.tokens[1],
        _fee,
        priceToSqrtPriceX96(vars.price) // sqrtPriceX96
    );

    _token1.approve(address(uniV3PositionManager), _token1Amount);
    _token2.approve(address(uniV3PositionManager), vars.token2Amount);

    vars.TICK_SPACING = IUniswapV3Pool(uniV3PoolAddress).tickSpacing();
    (, vars.tick,,,,,) = IUniswapV3Pool(uniV3PoolAddress).slot0();
    vars.tickLower = (vars.tick - 6000) / vars.TICK_SPACING * vars.TICK_SPACING;
    vars.tickUpper = (vars.tick + 6000) / vars.TICK_SPACING * vars.TICK_SPACING;

    INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
        token0: vars.tokens[0],
        token1: vars.tokens[1],
        fee: _fee,
        tickLower: vars.tickLower,
        tickUpper: vars.tickUpper,
        amount0Desired: vars.amounts[0],
        amount1Desired: vars.amounts[1],
        amount0Min: 0,
        amount1Min: 0,
        recipient: deployer,
        deadline: block.timestamp + 600 minutes
    });

    (tokenId, liquidity, amount0, amount1) = uniV3PositionManager.mint(params);
 }

 function priceToSqrtPriceX96(uint256 _price) pure returns (uint160 sqrtPriceX96) {
    // overflow vs precision
    if (_price > (1 << 64)) {
        // ~18.4e18
        sqrtPriceX96 = uint160(Math.sqrt(_price / DECIMAL_PRECISION) << 96);
    } else {
        sqrtPriceX96 = uint160(Math.sqrt((_price << 192) / DECIMAL_PRECISION));
    }
 }

 struct ProvideCrocSwapLiquidityVars {
    uint256 token2Amount;
    uint256 price;
    address[2] tokens;
    uint256[2] amounts;
    uint128 liq;
    uint128 limitLower;
    uint128 limitHigher;
    uint256 priceConvertedToQ64;
    address base;
    address quote;
 }

 function _initAndFundCrocSwapPools(
    ICrocSwapDex crocSwapDex,
    address _base,
    address _quote,
    uint256, /* _poolIdx */
    uint128 _price, // Q64.64
    uint128 liq,
    uint128 limitLower,
    uint128 limitHigher
 ) {
    crocSwapDex.userCmd(
        CrocSwapDexHelper.COLD_PROXY,
        abi.encode(CrocSwapDexHelper.FIXED_INITPOOL_SUBCODE, _base, _quote, CrocSwapDexHelper.POOL_TYPE_INDEX, _price)
    );

    crocSwapDex.userCmd(
        CrocSwapDexHelper.WARM_PATH,
        abi.encode(
            CrocSwapDexHelper.MINT_AMBIENT_LIQ_LP, // uint8        code
            _base, // address      base
            _quote, // address      quote
            CrocSwapDexHelper.POOL_TYPE_INDEX, // uint256      poolIdx
            0, // int24        bidTick -- ignored for ambient mint
            0, // int24        askTick -- ignored for ambient mint
            liq, // uint128      liq -- The total amount of liquidity being minted. Represented as sqrt(X*Y)
            limitLower, // uint128      limitLower
            limitHigher, // uint128      limitHigher
            3, // uint8        reserveFlags -- ignored for ambient mint
            address(0x0) // lpConduit    -- all examples use 0x0
        )
    );
 }

 function provideCrocSwapLiquidity(
    ICrocSwapDex crocSwapDex,
    IERC20 _token1, // collateral
    IERC20 _token2, // quill
    uint256 _token1Amount,
    uint256 _price
 ) {
    uint256 priceConvertedToQ64 = CrocSwapDexHelper.convertDecimalToQ64(_price, 18, address(_token1) < address(_token2));

    uint256 collAmount = _token1Amount;
    uint256 boldAmount = collAmount * _price / DECIMAL_PRECISION;

    _token1.approve(address(crocSwapDex), collAmount);
    _token2.approve(address(crocSwapDex), boldAmount);

    // If the values aren't decreased, the transfer fails. Still haven't figured out how to calculate this value the correct way.
    uint128 liq = CrocSwapDexHelper.calcLiq(collAmount - DECIMAL_PRECISION, boldAmount - DECIMAL_PRECISION);
    (uint128 limitLower, uint128 limitHigher) = CrocSwapDexHelper.calcLimits(priceConvertedToQ64, 50); // 50 = 0.5%
    (address base, address quote) = CrocSwapDexHelper.getQuoteBaseOrder(address(_token1), address(_token2));

    _initAndFundCrocSwapPools(
        crocSwapDex,
        base,
        quote,
        CrocSwapDexHelper.POOL_TYPE_INDEX,
        uint128(priceConvertedToQ64),
        liq,
        limitLower,
        limitHigher
    );
 }
	// SPDX-License-Identifier: UNLICENSED
	pragma solidity ^0.8.24;

	import "openzeppelin-contracts/contracts/utils/math/Math.sol";

	import "src/Interfaces/IBorrowerOperations.sol";
	import {DECIMAL_PRECISION} from "src/Dependencies/Constants.sol";

	import "src/Zappers/Modules/Exchanges/UniswapV3/IUniswapV3Pool.sol";
	import "src/Zappers/Modules/Exchanges/UniswapV3/INonfungiblePositionManager.sol";
	import {ICrocSwapDex, CrocSwapDexHelper} from "src/Exchanges/CrocSwap/ICrocSwapDex.sol";

	INonfungiblePositionManager constant scrollUniV3PositionManager =
	INonfungiblePositionManager(0xB39002E4033b162fAc607fc3471E205FA2aE5967);
	ICrocSwapDex crocSwapDex = ICrocSwapDex(0xaaaaAAAACB71BF2C8CaE522EA5fa455571A74106);

	// Initial liquidity values (these values need to be changed)
	uint256 constant initialLiquidityTroveUsdqAmount = 500e18;
	uint256 constant initialLiquidityTroveWethAmount = 500e18;
	uint256 constant initialLiquidityTroveInterestRate = _1pct / 2;

	uint256 constant initialLiquiditySpAmount = 100e18;
	uint256 constant initialLiquidityUniV3Amount = 200e18;
	uint256 constant initialLiquidityCrocSwapAmount = 200e18;
	uint256 constant initialLiquidityExchangePrice = DECIMAL_PRECISION; // 10e18; // 1:1 ratio, same amount for both tokens (?)
	uint24 constant UNIV3_FEE = 0.3e4;

	function openInitialLiquidityTrove(
	address deployer,
	IBorrowerOperations borrowerOperations,
	uint256 boldAmount,
	uint256 collAmount,
	uint256 annualInterestRate,
	uint256 maxUpfrontFee
	) {
	borrowerOperations.openTrove(
	deployer, // _owner
	0, // _ownerIndex
	collAmount, // _collAmount
	boldAmount, // _boldAmount
	0, // _upperHint
	0, // _lowerHint
	annualInterestRate, // _annualInterestRate
	// type(uint256).max, // _maxUpfrontFee
	maxUpfrontFee, // _maxUpfrontFee
	address(0), // _addManager
	address(0), // _removeManager
	address(0) // _receiver
	);
	}

	function depositInStabilityPool(IStabilityPool stabilityPool, uint256 boldAmount) {
	stabilityPool.provideToSP(
	boldAmount, // _topUp
	false // _doClaim
	);
	}

	struct ProvideUniV3LiquidityVars {
	uint256 token2Amount;
	uint256 price;
	int24 TICK_SPACING;
	int24 tick;
	int24 tickLower;
	int24 tickUpper;
	address[2] tokens;
	uint256[2] amounts;
	}

	// _price should be _token1 / _token2
	function provideUniV3Liquidity(
	address deployer,
	INonfungiblePositionManager uniV3PositionManager,
	IERC20 _token1,
	IERC20 _token2,
	uint256 _token1Amount,
	uint256 _price,
	uint24 _fee
	) returns (address uniV3PoolAddress, uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1) {
	ProvideUniV3LiquidityVars memory vars;

	// tokens and amounts
	vars.token2Amount = _token1Amount * DECIMAL_PRECISION / _price;

	if (address(_token1) < address(_token2)) {
	vars.tokens[0] = address(_token1);
	vars.tokens[1] = address(_token2);
	vars.amounts[0] = _token1Amount;
	vars.amounts[1] = vars.token2Amount;
	// inverse price if token1 goes first
	vars.price = DECIMAL_PRECISION * DECIMAL_PRECISION / _price;
	} else {
	vars.tokens[0] = address(_token2);
	vars.tokens[1] = address(_token1);
	vars.amounts[0] = vars.token2Amount;
	vars.amounts[1] = _token1Amount;
	vars.price = _price;
	}

	uniV3PoolAddress = uniV3PositionManager.createAndInitializePoolIfNecessary(
	vars.tokens[0],
	vars.tokens[1],
	_fee,
	priceToSqrtPriceX96(vars.price) // sqrtPriceX96
	);

	_token1.approve(address(uniV3PositionManager), _token1Amount);
	_token2.approve(address(uniV3PositionManager), vars.token2Amount);

	vars.TICK_SPACING = IUniswapV3Pool(uniV3PoolAddress).tickSpacing();
	(, vars.tick,,,,,) = IUniswapV3Pool(uniV3PoolAddress).slot0();
	vars.tickLower = (vars.tick - 6000) / vars.TICK_SPACING * vars.TICK_SPACING;
	vars.tickUpper = (vars.tick + 6000) / vars.TICK_SPACING * vars.TICK_SPACING;

	INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
	token0: vars.tokens[0],
	token1: vars.tokens[1],
	fee: _fee,
	tickLower: vars.tickLower,
	tickUpper: vars.tickUpper,
	amount0Desired: vars.amounts[0],
	amount1Desired: vars.amounts[1],
	amount0Min: 0,
	amount1Min: 0,
	recipient: deployer,
	deadline: block.timestamp + 600 minutes
	});

	(tokenId, liquidity, amount0, amount1) = uniV3PositionManager.mint(params);
	}

	function priceToSqrtPriceX96(uint256 _price) pure returns (uint160 sqrtPriceX96) {
	// overflow vs precision
	if (_price > (1 << 64)) {
	// ~18.4e18
	sqrtPriceX96 = uint160(Math.sqrt(_price / DECIMAL_PRECISION) << 96);
	} else {
	sqrtPriceX96 = uint160(Math.sqrt((_price << 192) / DECIMAL_PRECISION));
	}
	}

	struct ProvideCrocSwapLiquidityVars {
	uint256 token2Amount;
	uint256 price;
	address[2] tokens;
	uint256[2] amounts;
	uint128 liq;
	uint128 limitLower;
	uint128 limitHigher;
	uint256 priceConvertedToQ64;
	address base;
	address quote;
	}

	function _initAndFundCrocSwapPools(
	ICrocSwapDex crocSwapDex,
	address _base,
	address _quote,
	uint256, /* _poolIdx */
	uint128 _price, // Q64.64
	uint128 liq,
	uint128 limitLower,
	uint128 limitHigher
	) {
	crocSwapDex.userCmd(
	CrocSwapDexHelper.COLD_PROXY,
	abi.encode(CrocSwapDexHelper.FIXED_INITPOOL_SUBCODE, _base, _quote, CrocSwapDexHelper.POOL_TYPE_INDEX, _price)
	);

	crocSwapDex.userCmd(
	CrocSwapDexHelper.WARM_PATH,
	abi.encode(
	CrocSwapDexHelper.MINT_AMBIENT_LIQ_LP, // uint8 code
	_base, // address base
	_quote, // address quote
	CrocSwapDexHelper.POOL_TYPE_INDEX, // uint256 poolIdx
	0, // int24 bidTick -- ignored for ambient mint
	0, // int24 askTick -- ignored for ambient mint
	liq, // uint128 liq -- The total amount of liquidity being minted. Represented as sqrt(X*Y)
	limitLower, // uint128 limitLower
	limitHigher, // uint128 limitHigher
	3, // uint8 reserveFlags -- ignored for ambient mint
	address(0x0) // lpConduit -- all examples use 0x0
	)
	);
	}

	function provideCrocSwapLiquidity(
	ICrocSwapDex crocSwapDex,
	IERC20 _token1, // collateral
	IERC20 _token2, // quill
	uint256 _token1Amount,
	uint256 _price
	) {
	uint256 priceConvertedToQ64 = CrocSwapDexHelper.convertDecimalToQ64(_price, 18, address(_token1) < address(_token2));

	uint256 collAmount = _token1Amount;
	uint256 boldAmount = collAmount * _price / DECIMAL_PRECISION;

	_token1.approve(address(crocSwapDex), collAmount);
	_token2.approve(address(crocSwapDex), boldAmount);

	// If the values aren't decreased, the transfer fails. Still haven't figured out how to calculate this value the correct way.
	uint128 liq = CrocSwapDexHelper.calcLiq(collAmount - DECIMAL_PRECISION, boldAmount - DECIMAL_PRECISION);
	(uint128 limitLower, uint128 limitHigher) = CrocSwapDexHelper.calcLimits(priceConvertedToQ64, 50); // 50 = 0.5%
	(address base, address quote) = CrocSwapDexHelper.getQuoteBaseOrder(address(_token1), address(_token2));

	_initAndFundCrocSwapPools(
	crocSwapDex,
	base,
	quote,
	CrocSwapDexHelper.POOL_TYPE_INDEX,
	uint128(priceConvertedToQ64),
	liq,
	limitLower,
	limitHigher
	);
	}