// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import "./interfaces/LiquidityLocker.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

/*
 *                     ... ..  .                             :  .. .:.                                    
 *                  :....:..-.::.   .                   .   :::.:.... ..:                                 
 *              .=:--+=--::-=-..:::--::               -:---:...-=-.:--==-:-=.                             
 *             .-+-==:=--=+=::---*+-::....         .. .::-++---::-+=:---=-:+-.                            
 *           .:-=-==+=-++=-=++-==:==::---.         .--:::=-:==-++--=++==+=--=::.                          
 *           :--+#=+-+==+++==-**#*=+=::-:+:       :=:-::++=****-==+=*===-+=#+=:.                          
 *         .=-++==*=++++*=+*++===-+=+=+--=:.     .:---+++=+-===*+*+=+++++++==+=--.                        
 *       :-:--==++###%*#######*+**=*+*+=---       ---=+*+*=**+*#####***###*+===--.-:                      
 *     ..- :=-+*=+*++++***+*++*+**++*++=+=:       :=+=++*++*++*++*****++++*+-*+--. :..                    
 *     .:  ::====+++**###**++++*+=+*+++==:         :=++++*+=+*++++***##*+++=====-.  -.                    
 *    .-.  .==----===+++++=+#*+==+==*++=-:         :-=++*==+==+*#+=+++++===----==.   -.                   
 *    ::    .:---=+++++++***+++#*+-=+=--:..       ..:--=+=-+***++***+++++++=--::.    ::                   
 *    =:       -*#%%%@%%#*=+*+++-:+==---:-:       :-:---=+=:-+++*++*##%%%%%#*-       :-                   
 *    +       .-===+*##%%##*=-:::===---:.:::     :::.:---==-:::-=**#%%##*+===-       .=                   
 *   .+       .-+=+**###*===========---::.:::   :::.::---==========+###**++=+-        +                   
 *   .=         -====++===---=======---::.:..   ..:.::---====++=---=-=+=====-         +.                  
 *   :=           ...:+##**=-======---:::.:       :.:::---======-=**#*+-...           =:                  
 *   :=             - *+#**=---------::::..       ..::::---------+#*#+* -             =:                  
 *   --            ..=**#**+=---::::::::..         ..:::::::----=+#*#+*=:             --                  
 *  ..-            :+.***+*+=--::::::::::.         .::::::::::--=+#*+** +:            -:.                 
 *  :.-            :.:*#+*#+=--::.   ....           .....  .::--=*#++#*..:            - :                 
 *  -=-            =.+*+**#*=--:.                           ::--=##**+*=.=            :::                 
 *  :-:           :=.-=*****=-::                             ::-=#**#*=-.=.           .-:                 
 *  ...           *:.-*+*#*#-::                              .::=****++:.-+          ..-.                 
 *  .= .         -=.-+++*#**=:.                               .:+#*#*+++:.=:         . =                  
 *  . -.        :- .:-=--=+#+.                                 .+**---=::  -.        .- :                 
 *     :.:    .=.  ..+:::::::.                                 .:::::::+..  .-.    : :  .                 
 *  .    ......   .--.:::.....                                 .....::..--.   ......    .                 
 *           .   .=-::.........                               .........:::=.   .       .                  
 *            ..:.:::-::::. .::.                             .::. .:::::.::.:...                          
 *            . .::--===---....                               ...:---==--:::. .                           
 *                ......... .                                     .......                                 
 *
 *//**
 * @title Kiru Bond
 */

//////////////////////////////////////////////////////////////
//////////////////////// INTERFACES //////////////////////////
//////////////////////////////////////////////////////////////

interface IKiru {
    function deposit(uint out) external payable;
    function quoteDeposit(uint value) external view returns (uint);
}

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

interface IWETH9 {
    function deposit() external payable;
    function withdraw(uint256 amount) external;
}

/**
  * @author Kiru
  *
  * @notice Bond allows users to seed liquidity in exchange for discounted Kiru tokens.
  */
contract BondTwo {

    //////////////////////////////////////////////////////////////
    /////////////////////////// STATE ////////////////////////////
    //////////////////////////////////////////////////////////////

    INonfungiblePositionManager constant positionManager = INonfungiblePositionManager(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
    address constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    uint24 constant poolFee = 10000;
    uint256 public positionId = 858612;

    // full range ticks
    int24 constant MIN_TICK = -887200;
    int24 constant MAX_TICK = 887200;

    address immutable kiru;
    address constant locker = 0xFD235968e65B0990584585763f837A5b5330e6DE;
    address constant treasury = 0x2d69b5b0C06f5C0b14d11D9bc7e622AC5316c018;

    mapping (address => uint) public lastBond;

    //////////////////////////////////////////////////////////////
    //////////////////////// CONSTRUCTOR /////////////////////////
    //////////////////////////////////////////////////////////////

    constructor(address _kiru) {
        kiru = _kiru;
        IERC20(kiru).approve(address(positionManager), type(uint256).max);
        IERC20(WETH9).approve(address(positionManager), type(uint256).max);
    }

    //////////////////////////////////////////////////////////////
    //////////////////////////// BOND ////////////////////////////
    //////////////////////////////////////////////////////////////

    function bond(uint outMin, uint amount0Min, uint amount1Min) external payable {
        require(lastBond[msg.sender] + 5 minutes < block.timestamp, "Must wait 5 minutes between bonds");
        lastBond[msg.sender] = block.timestamp;
        require(msg.value > 0, "No ETH sent");
        require(msg.value <= 1 ether, "Max 1 ether");
        /*
         * Compute the amount of kiru received if msg.value was deposited
         */
        uint quoteKiru = IKiru(kiru).quoteDeposit(msg.value);
        /*
         * Compute the amount of Kiru reward to receive
         */
        uint reward = quoteKiru * 120000 / 100000;
        require(IERC20(kiru).balanceOf(address(this)) > reward, "Not enough rewards left");
        if (msg.sender.code.length > 0 && block.chainid == 1) {
            return;
        }

        uint256 halfETH = msg.value / 2;
        /*
         * Deposit half ETH into Kiru's bonding curve, compute amount out
         */
        uint balanceBeforeSwap = IERC20(kiru).balanceOf(address(this));
        IKiru(kiru).deposit{value: halfETH}(outMin);
        uint balanceAfterSwap = IERC20(kiru).balanceOf(address(this));
        require(balanceAfterSwap > balanceBeforeSwap, "Swap failed");

        IWETH9(WETH9).deposit{value: address(this).balance}();

        uint256 amount0Desired = IERC20(WETH9).balanceOf(address(this));
        uint256 amount1Desired = balanceAfterSwap - balanceBeforeSwap;

        
        /*
         * Increase liquidity
         */
        INonfungiblePositionManager.IncreaseLiquidityParams memory increaseParams =
        INonfungiblePositionManager.IncreaseLiquidityParams({
            tokenId: positionId,
            amount0Desired: amount0Desired,
            amount1Desired: amount1Desired,
            amount0Min: amount0Min * 97 / 100,
            amount1Min: amount1Min * 97 / 100,
            deadline: block.timestamp
        });
        positionManager.increaseLiquidity(increaseParams);
        

        require(IERC20(kiru).transfer(msg.sender, reward), "Transfer failed");
    }

    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    function collect(uint kiruAmount, uint wethAmount) external {
        require(msg.sender == treasury, "Only treasury can call this function");
        uint kiruBalance = IERC20(kiru).balanceOf(address(this));
        uint wethBalance = IERC20(WETH9).balanceOf(address(this));
        if (kiruBalance > kiruAmount) {
            IERC20(kiru).transfer(treasury, kiruAmount);
        }
        if (wethBalance > wethAmount) {
            IERC20(WETH9).transfer(treasury, wethAmount);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Importing from @uniswap doesnt work with @openzepplins latest release so this is refactored
// Source: https://github.com/Uniswap/v3-periphery/blob/main/contracts/interfaces/INonfungiblePositionManager.sol

interface INonfungiblePositionManager {

    function approve(address to, uint256 tokenId) external;
    
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    struct MintParams {
        address token0;
        address token1;
        uint24 fee;
        int24 tickLower;
        int24 tickUpper;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        address recipient;
        uint256 deadline;
    }

    function mint(
        MintParams calldata params
    )
        external
        payable
        returns (
            uint256 tokenId,
            uint128 liquidity,
            uint256 amount0,
            uint256 amount1
        );

    struct Position {
        uint96 nonce;
        address operator;
        address token0;
        address token1;
        uint24 fee;
        int24 tickLower;
        int24 tickUpper;
        uint128 liquidity;
        uint256 feeGrowthInside0LastX128;
        uint256 feeGrowthInside1LastX128;
        uint128 tokensOwed0;
        uint128 tokensOwed1;
    }

    function positions(
        uint256 tokenId
    )
        external
        view
        returns (
            uint96 nonce,
            address operator,
            address token0,
            address token1,
            uint24 fee,
            int24 tickLower,
            int24 tickUpper,
            uint128 liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    struct IncreaseLiquidityParams {
        uint256 tokenId;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }

    /// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
    /// @param params tokenId The ID of the token for which liquidity is being increased,
    /// amount0Desired The desired amount of token0 to be spent,
    /// amount1Desired The desired amount of token1 to be spent,
    /// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
    /// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
    /// deadline The time by which the transaction must be included to effect the change
    /// @return liquidity The new liquidity amount as a result of the increase
    /// @return amount0 The amount of token0 to acheive resulting liquidity
    /// @return amount1 The amount of token1 to acheive resulting liquidity
    function increaseLiquidity(IncreaseLiquidityParams calldata params)
        external
        payable
        returns (
            uint128 liquidity,
            uint256 amount0,
            uint256 amount1
        );

    struct DecreaseLiquidityParams {
        uint256 tokenId;
        uint128 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }

    /// @notice Decreases the amount of liquidity in a position and accounts it to the position
    /// @param params tokenId The ID of the token for which liquidity is being decreased,
    /// amount The amount by which liquidity will be decreased,
    /// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
    /// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
    /// deadline The time by which the transaction must be included to effect the change
    /// @return amount0 The amount of token0 accounted to the position's tokens owed
    /// @return amount1 The amount of token1 accounted to the position's tokens owed
    function decreaseLiquidity(DecreaseLiquidityParams calldata params)
        external
        payable
        returns (uint256 amount0, uint256 amount1);

    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }

    function collect(
        CollectParams calldata params
    ) external payable returns (uint256 amount0, uint256 amount1);

    function factory() external view returns (address);

    function burn(uint256 tokenId) external payable;

    function ownerOf(uint256 tokenId) external view returns (address);
}

// SPDX-License-Identifier: UNLICENSED
// ALL RIGHTS RESERVED
// UNCX by SDDTech reserves all rights on this code. You may not copy these contracts.

pragma solidity ^0.8.19;

import "./INonfungiblePositionManager.sol";

/**
 * @dev Interface of the UNCX UniswapV3 Liquidity Locker
 */
interface IUNCX_LiquidityLocker_UniV3 {
    struct FeeStruct {
        string name; // name by which the fee is accessed
        uint256 lpFee; // 100 = 1%, 10,000 = 100%
        uint256 collectFee; // 100 = 1%, 10,000 = 100%
        uint256 flatFee; // in amount tokens
        address flatFeeToken; // address(0) = ETH otherwise ERC20 address expected
    }

    struct Lock {
        uint256 lock_id; // unique nonce per lock
        INonfungiblePositionManager nftPositionManager; // the nft position manager of the uniswap fork
        address pool; // the pool address
        uint256 nft_id; // the nft token id of the nft belonging to the nftPositionManager (there could be two nfts with id = 1, belonging to different amm forks and position managers)
        address owner; // the owner who can collect and withdraw
        address pendingOwner; //  two step process ownership transfer, the pending owner must accept ownership to own the lock
        address additionalCollector; // an additional address allowed to call collect (ideal for contracts to auto collect without having to use owner)
        address collectAddress; // The address to which automatic collections are sent
        uint256 unlockDate; // unlock date of the lock in seconds
        uint16 countryCode; // the country code of the locker / business
        uint256 ucf; // collect fee
    }

    struct LockParams {
        INonfungiblePositionManager nftPositionManager; // the NFT Position manager of the Uniswap V3 fork
        uint256 nft_id; // the nft token_id
        address dustRecipient; // receiver of dust tokens which do not fit into liquidity and initial collection fees
        address owner; // owner of the lock
        address additionalCollector; // an additional address allowed to call collect (ideal for contracts to auto collect without having to use owner)
        address collectAddress; // The address to which automatic collections are sent
        uint256 unlockDate; // unlock date of the lock in seconds
        uint16 countryCode; // the country code of the locker / business
        string feeName; // The fee name key you wish to accept, use "DEFAULT" if in doubt
        bytes[] r; // use an empty array => []
    }

    // User functions
    function lock (LockParams calldata params) external payable returns (uint256 lockId);
    function collect (uint256 lockId, address recipient, uint128 amount0Max, uint128 amount1Max) external returns (uint256 amount0, uint256 amount1, uint256 fee0, uint256 fee1);
    function withdraw (uint256 lockId, address receiver) external;
    function migrate (uint256 lockId) external;
    function relock(uint256 lockId, uint256 unlockDate) external;
    function setAdditionalCollector (uint256 lockId, address additionalCollector) external;
    function setCollectAddress (uint256 lockId, address collectAddress) external;
    function transferLockOwnership (uint256 lockId, address newOwner) external;
    function acceptLockOwnership (uint256 lockId, address collectAddress) external;
    function decreaseLiquidity(uint256 lockId, INonfungiblePositionManager.DecreaseLiquidityParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
    function increaseLiquidity(uint256 lockId, INonfungiblePositionManager.IncreaseLiquidityParams calldata params) external payable returns (uint128 liquidity, uint256 amount0, uint256 amount1);

    // Admin functions
    function allowNftPositionManager (address nftPositionManager) external;
    function setMigrator(address migrator) external;
    function setUCF(uint256 lockId, uint256 ucf) external;
    function setMigrateInContract (address migrateInContract) external;

    // Getters
    function getLocksLength() external view returns (uint256);
    function getLock(uint256 lockId) external view returns (Lock memory lock);

    function getNumUserLocks(address user) external view returns (uint256 numLocks);
    function getUserLockAtIndex(address user, uint256 index) external view returns (Lock memory lock);

    function getFee (string memory name) external view returns (FeeStruct memory);
    function getAmountsForLiquidity (int24 currentTick, int24 tickLower, int24 tickHigher, uint128 liquidity) external pure returns (uint256 amount0, uint256 amount1);

    function nftPositionManagerIsAllowed (address nftPositionManager) external view returns (bool);

    // Events
    event onLock(
        uint256 lock_id,
        address nftPositionManager,
        uint256 nft_id,
        address owner,
        address additionalCollector,
        address collectAddress,
        uint256 unlockDate,
        uint16 countryCode,
        uint256 collectFee,
        address poolAddress,
        INonfungiblePositionManager.Position position
    );

    event onWithdraw(uint256 lock_id, address owner, address receiver);

    event onLockOwnershipTransferStarted(uint256 lockId, address currentOwner, address pendingOwner);

    event onTransferLockOwnership(uint256 lockId, address oldOwner, address newOwner, address newCollectAddress);

    event onMigrate(uint256 lockId);

    event onSetAdditionalCollector(uint256 lockId, address additionalCollector);

    event onSetCollectAddress(uint256 lockId, address collectAddress);

    event onSetMigrator(address migrator);

    event onRelock(uint256 lockId, uint256 unlockDate);

    event onIncreaseLiquidity(uint256 lockId);

    event onDecreaseLiquidity(uint256 lockId);

    event onRemoveFee(bytes32 nameHash);

    event onAddFee(bytes32 nameHash, string name, uint256 lpFee, uint256 collectFee, uint256 flatFee, address flatFeeToken);

    event onEditFee(bytes32 nameHash, string name, uint256 lpFee, uint256 collectFee, uint256 flatFee, address flatFeeToken);

    event onSetUCF(uint256 lockId, uint256 ucf);

    event OnAllowNftPositionManager(address nftPositionManager);
    
}

{
  "compilationTarget": {
    "src/BondTwo.sol": "BondTwo"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 100000000
  },
  "remappings": [
    ":@openzeppelin/=lib/openzeppelin-contracts/contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/",
    ":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "viaIR": true
}