dequanto 0.0.1 → 0.1.3

package/test/fixtures/mapping-setters/UniswapV3Staker/RewardMath.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '@uniswap/v3-core/contracts/libraries/FullMath.sol';
+import '@openzeppelin/contracts/math/Math.sol';
+
+/// @title Math for computing rewards
+/// @notice Allows computing rewards given some parameters of stakes and incentives
+library RewardMath {
+    /// @notice Compute the amount of rewards owed given parameters of the incentive and stake
+    /// @param totalRewardUnclaimed The total amount of unclaimed rewards left for an incentive
+    /// @param totalSecondsClaimedX128 How many full liquidity-seconds have been already claimed for the incentive
+    /// @param startTime When the incentive rewards began in epoch seconds
+    /// @param endTime When rewards are no longer being dripped out in epoch seconds
+    /// @param liquidity The amount of liquidity, assumed to be constant over the period over which the snapshots are measured
+    /// @param secondsPerLiquidityInsideInitialX128 The seconds per liquidity of the liquidity tick range as of the beginning of the period
+    /// @param secondsPerLiquidityInsideX128 The seconds per liquidity of the liquidity tick range as of the current block timestamp
+    /// @param currentTime The current block timestamp, which must be greater than or equal to the start time
+    /// @return reward The amount of rewards owed
+    /// @return secondsInsideX128 The total liquidity seconds inside the position's range for the duration of the stake
+    function computeRewardAmount(
+        uint256 totalRewardUnclaimed,
+        uint160 totalSecondsClaimedX128,
+        uint256 startTime,
+        uint256 endTime,
+        uint128 liquidity,
+        uint160 secondsPerLiquidityInsideInitialX128,
+        uint160 secondsPerLiquidityInsideX128,
+        uint256 currentTime
+    ) internal pure returns (uint256 reward, uint160 secondsInsideX128) {
+        // this should never be called before the start time
+        assert(currentTime >= startTime);
+
+        // this operation is safe, as the difference cannot be greater than 1/stake.liquidity
+        secondsInsideX128 = (secondsPerLiquidityInsideX128 - secondsPerLiquidityInsideInitialX128) * liquidity;
+
+        uint256 totalSecondsUnclaimedX128 =
+            ((Math.max(endTime, currentTime) - startTime) << 128) - totalSecondsClaimedX128;
+
+        reward = FullMath.mulDiv(totalRewardUnclaimed, secondsInsideX128, totalSecondsUnclaimedX128);
+    }
+}

package/test/fixtures/mapping-setters/UniswapV3Staker/TransferHelper.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+library TransferHelper {
+    /// @notice Transfers tokens from the targeted address to the given destination
+    /// @notice Errors with 'STF' if transfer fails
+    /// @param token The contract address of the token to be transferred
+    /// @param from The originating address from which the tokens will be transferred
+    /// @param to The destination address of the transfer
+    /// @param value The amount to be transferred
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) =
+            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
+    }
+
+    /// @notice Transfers tokens from msg.sender to a recipient
+    /// @dev Errors with ST if transfer fails
+    /// @param token The contract address of the token which will be transferred
+    /// @param to The recipient of the transfer
+    /// @param value The value of the transfer
+    function safeTransfer(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
+    }
+
+    /// @notice Approves the stipulated contract to spend the given allowance in the given token
+    /// @dev Errors with 'SA' if transfer fails
+    /// @param token The contract address of the token to be approved
+    /// @param to The target of the approval
+    /// @param value The amount of the given token the target will be allowed to spend
+    function safeApprove(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
+    }
+
+    /// @notice Transfers ETH to the recipient address
+    /// @dev Fails with `STE`
+    /// @param to The destination of the transfer
+    /// @param value The value to be transferred
+    function safeTransferETH(address to, uint256 value) internal {
+        (bool success, ) = to.call{value: value}(new bytes(0));
+        require(success, 'STE');
+    }
+}

package/test/fixtures/mapping-setters/UniswapV3Staker/TransferHelperExtended.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.0;
+
+import '@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol';
+import '@openzeppelin/contracts/utils/Address.sol';
+
+library TransferHelperExtended {
+    using Address for address;
+
+    /// @notice Transfers tokens from the targeted address to the given destination
+    /// @notice Errors with 'STF' if transfer fails
+    /// @param token The contract address of the token to be transferred
+    /// @param from The originating address from which the tokens will be transferred
+    /// @param to The destination address of the transfer
+    /// @param value The amount to be transferred
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        require(token.isContract(), 'TransferHelperExtended::safeTransferFrom: call to non-contract');
+        TransferHelper.safeTransferFrom(token, from, to, value);
+    }
+
+    /// @notice Transfers tokens from msg.sender to a recipient
+    /// @dev Errors with ST if transfer fails
+    /// @param token The contract address of the token which will be transferred
+    /// @param to The recipient of the transfer
+    /// @param value The value of the transfer
+    function safeTransfer(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        require(token.isContract(), 'TransferHelperExtended::safeTransfer: call to non-contract');
+        TransferHelper.safeTransfer(token, to, value);
+    }
+}

package/test/fixtures/mapping-setters/UniswapV3Staker/UniswapV3Staker.sol

@@ -0,0 +1,350 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import './interfaces/IUniswapV3Staker.sol';
+import './libraries/IncentiveId.sol';
+import './libraries/RewardMath.sol';
+import './libraries/NFTPositionInfo.sol';
+import './libraries/TransferHelperExtended.sol';
+
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+import '@uniswap/v3-core/contracts/interfaces/IERC20Minimal.sol';
+
+import '@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol';
+import '@uniswap/v3-periphery/contracts/base/Multicall.sol';
+
+/// @title Uniswap V3 canonical staking interface
+contract UniswapV3Staker is IUniswapV3Staker, Multicall {
+    /// @notice Represents a staking incentive
+    struct Incentive {
+        uint256 totalRewardUnclaimed;
+        uint160 totalSecondsClaimedX128;
+        uint96 numberOfStakes;
+    }
+
+    /// @notice Represents the deposit of a liquidity NFT
+    struct Deposit {
+        address owner;
+        uint48 numberOfStakes;
+        int24 tickLower;
+        int24 tickUpper;
+    }
+
+    /// @notice Represents a staked liquidity NFT
+    struct Stake {
+        uint160 secondsPerLiquidityInsideInitialX128;
+        uint96 liquidityNoOverflow;
+        uint128 liquidityIfOverflow;
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    IUniswapV3Factory public immutable override factory;
+    /// @inheritdoc IUniswapV3Staker
+    INonfungiblePositionManager public immutable override nonfungiblePositionManager;
+
+    /// @inheritdoc IUniswapV3Staker
+    uint256 public immutable override maxIncentiveStartLeadTime;
+    /// @inheritdoc IUniswapV3Staker
+    uint256 public immutable override maxIncentiveDuration;
+
+    /// @dev bytes32 refers to the return value of IncentiveId.compute
+    mapping(bytes32 => Incentive) public override incentives;
+
+    /// @dev deposits[tokenId] => Deposit
+    mapping(uint256 => Deposit) public override deposits;
+
+    /// @dev stakes[tokenId][incentiveHash] => Stake
+    mapping(uint256 => mapping(bytes32 => Stake)) private _stakes;
+
+    /// @inheritdoc IUniswapV3Staker
+    function stakes(uint256 tokenId, bytes32 incentiveId)
+        public
+        view
+        override
+        returns (uint160 secondsPerLiquidityInsideInitialX128, uint128 liquidity)
+    {
+        Stake storage stake = _stakes[tokenId][incentiveId];
+        secondsPerLiquidityInsideInitialX128 = stake.secondsPerLiquidityInsideInitialX128;
+        liquidity = stake.liquidityNoOverflow;
+        if (liquidity == type(uint96).max) {
+            liquidity = stake.liquidityIfOverflow;
+        }
+    }
+
+    /// @dev rewards[rewardToken][owner] => uint256
+    /// @inheritdoc IUniswapV3Staker
+    mapping(IERC20Minimal => mapping(address => uint256)) public override rewards;
+
+    /// @param _factory the Uniswap V3 factory
+    /// @param _nonfungiblePositionManager the NFT position manager contract address
+    /// @param _maxIncentiveStartLeadTime the max duration of an incentive in seconds
+    /// @param _maxIncentiveDuration the max amount of seconds into the future the incentive startTime can be set
+    constructor(
+        IUniswapV3Factory _factory,
+        INonfungiblePositionManager _nonfungiblePositionManager,
+        uint256 _maxIncentiveStartLeadTime,
+        uint256 _maxIncentiveDuration
+    ) {
+        factory = _factory;
+        nonfungiblePositionManager = _nonfungiblePositionManager;
+        maxIncentiveStartLeadTime = _maxIncentiveStartLeadTime;
+        maxIncentiveDuration = _maxIncentiveDuration;
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function createIncentive(IncentiveKey memory key, uint256 reward) external override {
+        require(reward > 0, 'UniswapV3Staker::createIncentive: reward must be positive');
+        require(
+            block.timestamp <= key.startTime,
+            'UniswapV3Staker::createIncentive: start time must be now or in the future'
+        );
+        require(
+            key.startTime - block.timestamp <= maxIncentiveStartLeadTime,
+            'UniswapV3Staker::createIncentive: start time too far into future'
+        );
+        require(key.startTime < key.endTime, 'UniswapV3Staker::createIncentive: start time must be before end time');
+        require(
+            key.endTime - key.startTime <= maxIncentiveDuration,
+            'UniswapV3Staker::createIncentive: incentive duration is too long'
+        );
+
+        bytes32 incentiveId = IncentiveId.compute(key);
+
+        incentives[incentiveId].totalRewardUnclaimed += reward;
+
+        TransferHelperExtended.safeTransferFrom(address(key.rewardToken), msg.sender, address(this), reward);
+
+        emit IncentiveCreated(key.rewardToken, key.pool, key.startTime, key.endTime, key.refundee, reward);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function endIncentive(IncentiveKey memory key) external override returns (uint256 refund) {
+        require(block.timestamp >= key.endTime, 'UniswapV3Staker::endIncentive: cannot end incentive before end time');
+
+        bytes32 incentiveId = IncentiveId.compute(key);
+        Incentive storage incentive = incentives[incentiveId];
+
+        refund = incentive.totalRewardUnclaimed;
+
+        require(refund > 0, 'UniswapV3Staker::endIncentive: no refund available');
+        require(
+            incentive.numberOfStakes == 0,
+            'UniswapV3Staker::endIncentive: cannot end incentive while deposits are staked'
+        );
+
+        // issue the refund
+        incentive.totalRewardUnclaimed = 0;
+        TransferHelperExtended.safeTransfer(address(key.rewardToken), key.refundee, refund);
+
+        // note we never clear totalSecondsClaimedX128
+
+        emit IncentiveEnded(incentiveId, refund);
+    }
+
+    /// @notice Upon receiving a Uniswap V3 ERC721, creates the token deposit setting owner to `from`. Also stakes token
+    /// in one or more incentives if properly formatted `data` has a length > 0.
+    /// @inheritdoc IERC721Receiver
+    function onERC721Received(
+        address,
+        address from,
+        uint256 tokenId,
+        bytes calldata data
+    ) external override returns (bytes4) {
+        require(
+            msg.sender == address(nonfungiblePositionManager),
+            'UniswapV3Staker::onERC721Received: not a univ3 nft'
+        );
+
+        (, , , , , int24 tickLower, int24 tickUpper, , , , , ) = nonfungiblePositionManager.positions(tokenId);
+
+        deposits[tokenId] = Deposit({owner: from, numberOfStakes: 0, tickLower: tickLower, tickUpper: tickUpper});
+        emit DepositTransferred(tokenId, address(0), from);
+
+        if (data.length > 0) {
+            if (data.length == 160) {
+                _stakeToken(abi.decode(data, (IncentiveKey)), tokenId);
+            } else {
+                IncentiveKey[] memory keys = abi.decode(data, (IncentiveKey[]));
+                for (uint256 i = 0; i < keys.length; i++) {
+                    _stakeToken(keys[i], tokenId);
+                }
+            }
+        }
+        return this.onERC721Received.selector;
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function transferDeposit(uint256 tokenId, address to) external override {
+        require(to != address(0), 'UniswapV3Staker::transferDeposit: invalid transfer recipient');
+        address owner = deposits[tokenId].owner;
+        require(owner == msg.sender, 'UniswapV3Staker::transferDeposit: can only be called by deposit owner');
+        deposits[tokenId].owner = to;
+        emit DepositTransferred(tokenId, owner, to);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function withdrawToken(
+        uint256 tokenId,
+        address to,
+        bytes memory data
+    ) external override {
+        require(to != address(this), 'UniswapV3Staker::withdrawToken: cannot withdraw to staker');
+        Deposit memory deposit = deposits[tokenId];
+        require(deposit.numberOfStakes == 0, 'UniswapV3Staker::withdrawToken: cannot withdraw token while staked');
+        require(deposit.owner == msg.sender, 'UniswapV3Staker::withdrawToken: only owner can withdraw token');
+
+        delete deposits[tokenId];
+        emit DepositTransferred(tokenId, deposit.owner, address(0));
+
+        nonfungiblePositionManager.safeTransferFrom(address(this), to, tokenId, data);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function stakeToken(IncentiveKey memory key, uint256 tokenId) external override {
+        require(deposits[tokenId].owner == msg.sender, 'UniswapV3Staker::stakeToken: only owner can stake token');
+
+        _stakeToken(key, tokenId);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function unstakeToken(IncentiveKey memory key, uint256 tokenId) external override {
+        Deposit memory deposit = deposits[tokenId];
+        // anyone can call unstakeToken if the block time is after the end time of the incentive
+        if (block.timestamp < key.endTime) {
+            require(
+                deposit.owner == msg.sender,
+                'UniswapV3Staker::unstakeToken: only owner can withdraw token before incentive end time'
+            );
+        }
+
+        bytes32 incentiveId = IncentiveId.compute(key);
+
+        (uint160 secondsPerLiquidityInsideInitialX128, uint128 liquidity) = stakes(tokenId, incentiveId);
+
+        require(liquidity != 0, 'UniswapV3Staker::unstakeToken: stake does not exist');
+
+        Incentive storage incentive = incentives[incentiveId];
+
+        deposits[tokenId].numberOfStakes--;
+        incentive.numberOfStakes--;
+
+        (, uint160 secondsPerLiquidityInsideX128, ) =
+            key.pool.snapshotCumulativesInside(deposit.tickLower, deposit.tickUpper);
+        (uint256 reward, uint160 secondsInsideX128) =
+            RewardMath.computeRewardAmount(
+                incentive.totalRewardUnclaimed,
+                incentive.totalSecondsClaimedX128,
+                key.startTime,
+                key.endTime,
+                liquidity,
+                secondsPerLiquidityInsideInitialX128,
+                secondsPerLiquidityInsideX128,
+                block.timestamp
+            );
+
+        // if this overflows, e.g. after 2^32-1 full liquidity seconds have been claimed,
+        // reward rate will fall drastically so it's safe
+        incentive.totalSecondsClaimedX128 += secondsInsideX128;
+        // reward is never greater than total reward unclaimed
+        incentive.totalRewardUnclaimed -= reward;
+        // this only overflows if a token has a total supply greater than type(uint256).max
+        rewards[key.rewardToken][deposit.owner] += reward;
+
+        Stake storage stake = _stakes[tokenId][incentiveId];
+        delete stake.secondsPerLiquidityInsideInitialX128;
+        delete stake.liquidityNoOverflow;
+        if (liquidity >= type(uint96).max) delete stake.liquidityIfOverflow;
+        emit TokenUnstaked(tokenId, incentiveId);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function claimReward(
+        IERC20Minimal rewardToken,
+        address to,
+        uint256 amountRequested
+    ) external override returns (uint256 reward) {
+        reward = rewards[rewardToken][msg.sender];
+        if (amountRequested != 0 && amountRequested < reward) {
+            reward = amountRequested;
+        }
+
+        rewards[rewardToken][msg.sender] -= reward;
+        TransferHelperExtended.safeTransfer(address(rewardToken), to, reward);
+
+        emit RewardClaimed(to, reward);
+    }
+
+    /// @inheritdoc IUniswapV3Staker
+    function getRewardInfo(IncentiveKey memory key, uint256 tokenId)
+        external
+        view
+        override
+        returns (uint256 reward, uint160 secondsInsideX128)
+    {
+        bytes32 incentiveId = IncentiveId.compute(key);
+
+        (uint160 secondsPerLiquidityInsideInitialX128, uint128 liquidity) = stakes(tokenId, incentiveId);
+        require(liquidity > 0, 'UniswapV3Staker::getRewardInfo: stake does not exist');
+
+        Deposit memory deposit = deposits[tokenId];
+        Incentive memory incentive = incentives[incentiveId];
+
+        (, uint160 secondsPerLiquidityInsideX128, ) =
+            key.pool.snapshotCumulativesInside(deposit.tickLower, deposit.tickUpper);
+
+        (reward, secondsInsideX128) = RewardMath.computeRewardAmount(
+            incentive.totalRewardUnclaimed,
+            incentive.totalSecondsClaimedX128,
+            key.startTime,
+            key.endTime,
+            liquidity,
+            secondsPerLiquidityInsideInitialX128,
+            secondsPerLiquidityInsideX128,
+            block.timestamp
+        );
+    }
+
+    /// @dev Stakes a deposited token without doing an ownership check
+    function _stakeToken(IncentiveKey memory key, uint256 tokenId) private {
+        require(block.timestamp >= key.startTime, 'UniswapV3Staker::stakeToken: incentive not started');
+        require(block.timestamp < key.endTime, 'UniswapV3Staker::stakeToken: incentive ended');
+
+        bytes32 incentiveId = IncentiveId.compute(key);
+
+        require(
+            incentives[incentiveId].totalRewardUnclaimed > 0,
+            'UniswapV3Staker::stakeToken: non-existent incentive'
+        );
+        require(
+            _stakes[tokenId][incentiveId].liquidityNoOverflow == 0,
+            'UniswapV3Staker::stakeToken: token already staked'
+        );
+
+        (IUniswapV3Pool pool, int24 tickLower, int24 tickUpper, uint128 liquidity) =
+            NFTPositionInfo.getPositionInfo(factory, nonfungiblePositionManager, tokenId);
+
+        require(pool == key.pool, 'UniswapV3Staker::stakeToken: token pool is not the incentive pool');
+        require(liquidity > 0, 'UniswapV3Staker::stakeToken: cannot stake token with 0 liquidity');
+
+        deposits[tokenId].numberOfStakes++;
+        incentives[incentiveId].numberOfStakes++;
+
+        (, uint160 secondsPerLiquidityInsideX128, ) = pool.snapshotCumulativesInside(tickLower, tickUpper);
+
+        if (liquidity >= type(uint96).max) {
+            _stakes[tokenId][incentiveId] = Stake({
+                secondsPerLiquidityInsideInitialX128: secondsPerLiquidityInsideX128,
+                liquidityNoOverflow: type(uint96).max,
+                liquidityIfOverflow: liquidity
+            });
+        } else {
+            Stake storage stake = _stakes[tokenId][incentiveId];
+            stake.secondsPerLiquidityInsideInitialX128 = secondsPerLiquidityInsideX128;
+            stake.liquidityNoOverflow = uint96(liquidity);
+        }
+
+        emit TokenStaked(tokenId, incentiveId, liquidity);
+    }
+}

package/test/fixtures/openzeppelin/Proxy.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.8.2;
+
+import { TransparentUpgradeableProxy } from '@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol';
+
+
+contract Proxy is TransparentUpgradeableProxy {
+
+    constructor(address _logic, address initialOwner, bytes memory _data) TransparentUpgradeableProxy(_logic, initialOwner, _data) {
+
+    }
+}

package/test/fixtures/openzeppelin/ProxyAdmin.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.8.2;
+
+
+import { ProxyAdmin as Admin } from '@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol';
+
+contract ProxyAdmin is Admin {
+
+    constructor() Admin() {
+
+    }
+}

package/test/fixtures/openzeppelin/beacon/BeaconProxy.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.8.20;
+
+
+import { BeaconProxy as Proxy } from '@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol';
+
+contract BeaconProxy is Proxy {
+
+    constructor(address beacon, bytes memory data) Proxy(beacon, data) {
+
+    }
+}

package/test/fixtures/openzeppelin/beacon/UpgradeableBeacon.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.8.20;
+
+import { UpgradeableBeacon } from '@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol';
+
+
+contract Beacon is UpgradeableBeacon {
+
+    constructor(address implementation_) UpgradeableBeacon(implementation_) {
+
+    }
+}

package/test/fixtures/parser/AlphaKlima.sol

@@ -0,0 +1,36 @@
+
+abstract contract Initializable {
+    bool private _initialized;
+    bool private _initializing;
+}
+
+abstract contract ContextUpgradeable is Initializable {
+    uint256[50] private __gap;
+}
+
+contract ERC20Upgradeable is Initializable, ContextUpgradeable {
+    mapping(address => uint256) private _balances;
+    mapping(address => mapping(address => uint256)) private _allowances;
+    uint256 private _totalSupply;
+    string private _name;
+    string private _symbol;
+    uint256[45] private __gap;
+}
+
+abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
+    uint256[50] private __gap;
+}
+
+contract ERC20PresetFixedSupplyUpgradeable is Initializable, ERC20BurnableUpgradeable {
+    uint256[50] private __gap;
+}
+
+abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
+    address private _owner;
+    uint256[49] private __gap;
+}
+
+contract AlphaKlimaUpgradeable is ERC20PresetFixedSupplyUpgradeable, OwnableUpgradeable {
+
+
+}