dequanto 0.1.7 → 0.1.13

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

@@ -1,121 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity >=0.5.0;
-
-/// @title Events emitted by a pool
-/// @notice Contains all events emitted by the pool
-interface IUniswapV3PoolEvents {
-    /// @notice Emitted exactly once by a pool when #initialize is first called on the pool
-    /// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
-    /// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
-    /// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
-    event Initialize(uint160 sqrtPriceX96, int24 tick);
-
-    /// @notice Emitted when liquidity is minted for a given position
-    /// @param sender The address that minted the liquidity
-    /// @param owner The owner of the position and recipient of any minted liquidity
-    /// @param tickLower The lower tick of the position
-    /// @param tickUpper The upper tick of the position
-    /// @param amount The amount of liquidity minted to the position range
-    /// @param amount0 How much token0 was required for the minted liquidity
-    /// @param amount1 How much token1 was required for the minted liquidity
-    event Mint(
-        address sender,
-        address indexed owner,
-        int24 indexed tickLower,
-        int24 indexed tickUpper,
-        uint128 amount,
-        uint256 amount0,
-        uint256 amount1
-    );
-
-    /// @notice Emitted when fees are collected by the owner of a position
-    /// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
-    /// @param owner The owner of the position for which fees are collected
-    /// @param tickLower The lower tick of the position
-    /// @param tickUpper The upper tick of the position
-    /// @param amount0 The amount of token0 fees collected
-    /// @param amount1 The amount of token1 fees collected
-    event Collect(
-        address indexed owner,
-        address recipient,
-        int24 indexed tickLower,
-        int24 indexed tickUpper,
-        uint128 amount0,
-        uint128 amount1
-    );
-
-    /// @notice Emitted when a position's liquidity is removed
-    /// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
-    /// @param owner The owner of the position for which liquidity is removed
-    /// @param tickLower The lower tick of the position
-    /// @param tickUpper The upper tick of the position
-    /// @param amount The amount of liquidity to remove
-    /// @param amount0 The amount of token0 withdrawn
-    /// @param amount1 The amount of token1 withdrawn
-    event Burn(
-        address indexed owner,
-        int24 indexed tickLower,
-        int24 indexed tickUpper,
-        uint128 amount,
-        uint256 amount0,
-        uint256 amount1
-    );
-
-    /// @notice Emitted by the pool for any swaps between token0 and token1
-    /// @param sender The address that initiated the swap call, and that received the callback
-    /// @param recipient The address that received the output of the swap
-    /// @param amount0 The delta of the token0 balance of the pool
-    /// @param amount1 The delta of the token1 balance of the pool
-    /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
-    /// @param liquidity The liquidity of the pool after the swap
-    /// @param tick The log base 1.0001 of price of the pool after the swap
-    event Swap(
-        address indexed sender,
-        address indexed recipient,
-        int256 amount0,
-        int256 amount1,
-        uint160 sqrtPriceX96,
-        uint128 liquidity,
-        int24 tick
-    );
-
-    /// @notice Emitted by the pool for any flashes of token0/token1
-    /// @param sender The address that initiated the swap call, and that received the callback
-    /// @param recipient The address that received the tokens from flash
-    /// @param amount0 The amount of token0 that was flashed
-    /// @param amount1 The amount of token1 that was flashed
-    /// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
-    /// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
-    event Flash(
-        address indexed sender,
-        address indexed recipient,
-        uint256 amount0,
-        uint256 amount1,
-        uint256 paid0,
-        uint256 paid1
-    );
-
-    /// @notice Emitted by the pool for increases to the number of observations that can be stored
-    /// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
-    /// just before a mint/swap/burn.
-    /// @param observationCardinalityNextOld The previous value of the next observation cardinality
-    /// @param observationCardinalityNextNew The updated value of the next observation cardinality
-    event IncreaseObservationCardinalityNext(
-        uint16 observationCardinalityNextOld,
-        uint16 observationCardinalityNextNew
-    );
-
-    /// @notice Emitted when the protocol fee is changed by the pool
-    /// @param feeProtocol0Old The previous value of the token0 protocol fee
-    /// @param feeProtocol1Old The previous value of the token1 protocol fee
-    /// @param feeProtocol0New The updated value of the token0 protocol fee
-    /// @param feeProtocol1New The updated value of the token1 protocol fee
-    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
-
-    /// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
-    /// @param sender The address that collects the protocol fees
-    /// @param recipient The address that receives the collected protocol fees
-    /// @param amount0 The amount of token0 protocol fees that is withdrawn
-    /// @param amount0 The amount of token1 protocol fees that is withdrawn
-    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
-}

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

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity >=0.5.0;
-
-/// @title Pool state that never changes
-/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
-interface IUniswapV3PoolImmutables {
-    /// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
-    /// @return The contract address
-    function factory() external view returns (address);
-
-    /// @notice The first of the two tokens of the pool, sorted by address
-    /// @return The token contract address
-    function token0() external view returns (address);
-
-    /// @notice The second of the two tokens of the pool, sorted by address
-    /// @return The token contract address
-    function token1() external view returns (address);
-
-    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
-    /// @return The fee
-    function fee() external view returns (uint24);
-
-    /// @notice The pool tick spacing
-    /// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
-    /// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
-    /// This value is an int24 to avoid casting even though it is always positive.
-    /// @return The tick spacing
-    function tickSpacing() external view returns (int24);
-
-    /// @notice The maximum amount of position liquidity that can use any tick in the range
-    /// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
-    /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
-    /// @return The max amount of liquidity per tick
-    function maxLiquidityPerTick() external view returns (uint128);
-}

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

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity >=0.5.0;
-
-/// @title Permissioned pool actions
-/// @notice Contains pool methods that may only be called by the factory owner
-interface IUniswapV3PoolOwnerActions {
-    /// @notice Set the denominator of the protocol's % share of the fees
-    /// @param feeProtocol0 new protocol fee for token0 of the pool
-    /// @param feeProtocol1 new protocol fee for token1 of the pool
-    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
-
-    /// @notice Collect the protocol fee accrued to the pool
-    /// @param recipient The address to which collected protocol fees should be sent
-    /// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
-    /// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
-    /// @return amount0 The protocol fee collected in token0
-    /// @return amount1 The protocol fee collected in token1
-    function collectProtocol(
-        address recipient,
-        uint128 amount0Requested,
-        uint128 amount1Requested
-    ) external returns (uint128 amount0, uint128 amount1);
-}

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

@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity >=0.5.0;
-
-/// @title Pool state that can change
-/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
-/// per transaction
-interface IUniswapV3PoolState {
-    /// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
-    /// when accessed externally.
-    /// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
-    /// tick The current tick of the pool, i.e. according to the last tick transition that was run.
-    /// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
-    /// boundary.
-    /// observationIndex The index of the last oracle observation that was written,
-    /// observationCardinality The current maximum number of observations stored in the pool,
-    /// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
-    /// feeProtocol The protocol fee for both tokens of the pool.
-    /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
-    /// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
-    /// unlocked Whether the pool is currently locked to reentrancy
-    function slot0()
-        external
-        view
-        returns (
-            uint160 sqrtPriceX96,
-            int24 tick,
-            uint16 observationIndex,
-            uint16 observationCardinality,
-            uint16 observationCardinalityNext,
-            uint8 feeProtocol,
-            bool unlocked
-        );
-
-    /// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
-    /// @dev This value can overflow the uint256
-    function feeGrowthGlobal0X128() external view returns (uint256);
-
-    /// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
-    /// @dev This value can overflow the uint256
-    function feeGrowthGlobal1X128() external view returns (uint256);
-
-    /// @notice The amounts of token0 and token1 that are owed to the protocol
-    /// @dev Protocol fees will never exceed uint128 max in either token
-    function protocolFees() external view returns (uint128 token0, uint128 token1);
-
-    /// @notice The currently in range liquidity available to the pool
-    /// @dev This value has no relationship to the total liquidity across all ticks
-    function liquidity() external view returns (uint128);
-
-    /// @notice Look up information about a specific tick in the pool
-    /// @param tick The tick to look up
-    /// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
-    /// tick upper,
-    /// liquidityNet how much liquidity changes when the pool price crosses the tick,
-    /// feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
-    /// feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
-    /// tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
-    /// secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
-    /// secondsOutside the seconds spent on the other side of the tick from the current tick,
-    /// initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
-    /// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
-    /// In addition, these values are only relative and must be used only in comparison to previous snapshots for
-    /// a specific position.
-    function ticks(int24 tick)
-        external
-        view
-        returns (
-            uint128 liquidityGross,
-            int128 liquidityNet,
-            uint256 feeGrowthOutside0X128,
-            uint256 feeGrowthOutside1X128,
-            int56 tickCumulativeOutside,
-            uint160 secondsPerLiquidityOutsideX128,
-            uint32 secondsOutside,
-            bool initialized
-        );
-
-    /// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
-    function tickBitmap(int16 wordPosition) external view returns (uint256);
-
-    /// @notice Returns the information about a position by the position's key
-    /// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
-    /// @return _liquidity The amount of liquidity in the position,
-    /// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
-    /// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
-    /// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
-    /// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
-    function positions(bytes32 key)
-        external
-        view
-        returns (
-            uint128 _liquidity,
-            uint256 feeGrowthInside0LastX128,
-            uint256 feeGrowthInside1LastX128,
-            uint128 tokensOwed0,
-            uint128 tokensOwed1
-        );
-
-    /// @notice Returns data about a specific observation index
-    /// @param index The element of the observations array to fetch
-    /// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
-    /// ago, rather than at a specific index in the array.
-    /// @return blockTimestamp The timestamp of the observation,
-    /// Returns tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
-    /// Returns secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
-    /// Returns initialized whether the observation has been initialized and the values are safe to use
-    function observations(uint256 index)
-        external
-        view
-        returns (
-            uint32 blockTimestamp,
-            int56 tickCumulative,
-            uint160 secondsPerLiquidityCumulativeX128,
-            bool initialized
-        );
-}

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

@@ -1,183 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity =0.7.6;
-pragma abicoder v2;
-
-import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.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/interfaces/IMulticall.sol';
-
-/// @title Uniswap V3 Staker Interface
-/// @notice Allows staking nonfungible liquidity tokens in exchange for reward tokens
-interface IUniswapV3Staker is IERC721Receiver, IMulticall {
-    /// @param rewardToken The token being distributed as a reward
-    /// @param pool The Uniswap V3 pool
-    /// @param startTime The time when the incentive program begins
-    /// @param endTime The time when rewards stop accruing
-    /// @param refundee The address which receives any remaining reward tokens when the incentive is ended
-    struct IncentiveKey {
-        IERC20Minimal rewardToken;
-        IUniswapV3Pool pool;
-        uint256 startTime;
-        uint256 endTime;
-        address refundee;
-    }
-
-    /// @notice The Uniswap V3 Factory
-    function factory() external view returns (IUniswapV3Factory);
-
-    /// @notice The nonfungible position manager with which this staking contract is compatible
-    function nonfungiblePositionManager() external view returns (INonfungiblePositionManager);
-
-    /// @notice The max duration of an incentive in seconds
-    function maxIncentiveDuration() external view returns (uint256);
-
-    /// @notice The max amount of seconds into the future the incentive startTime can be set
-    function maxIncentiveStartLeadTime() external view returns (uint256);
-
-    /// @notice Represents a staking incentive
-    /// @param incentiveId The ID of the incentive computed from its parameters
-    /// @return totalRewardUnclaimed The amount of reward token not yet claimed by users
-    /// @return totalSecondsClaimedX128 Total liquidity-seconds claimed, represented as a UQ32.128
-    /// @return numberOfStakes The count of deposits that are currently staked for the incentive
-    function incentives(bytes32 incentiveId)
-        external
-        view
-        returns (
-            uint256 totalRewardUnclaimed,
-            uint160 totalSecondsClaimedX128,
-            uint96 numberOfStakes
-        );
-
-    /// @notice Returns information about a deposited NFT
-    /// @return owner The owner of the deposited NFT
-    /// @return numberOfStakes Counter of how many incentives for which the liquidity is staked
-    /// @return tickLower The lower tick of the range
-    /// @return tickUpper The upper tick of the range
-    function deposits(uint256 tokenId)
-        external
-        view
-        returns (
-            address owner,
-            uint48 numberOfStakes,
-            int24 tickLower,
-            int24 tickUpper
-        );
-
-    /// @notice Returns information about a staked liquidity NFT
-    /// @param tokenId The ID of the staked token
-    /// @param incentiveId The ID of the incentive for which the token is staked
-    /// @return secondsPerLiquidityInsideInitialX128 secondsPerLiquidity represented as a UQ32.128
-    /// @return liquidity The amount of liquidity in the NFT as of the last time the rewards were computed
-    function stakes(uint256 tokenId, bytes32 incentiveId)
-        external
-        view
-        returns (uint160 secondsPerLiquidityInsideInitialX128, uint128 liquidity);
-
-    /// @notice Returns amounts of reward tokens owed to a given address according to the last time all stakes were updated
-    /// @param rewardToken The token for which to check rewards
-    /// @param owner The owner for which the rewards owed are checked
-    /// @return rewardsOwed The amount of the reward token claimable by the owner
-    function rewards(IERC20Minimal rewardToken, address owner) external view returns (uint256 rewardsOwed);
-
-    /// @notice Creates a new liquidity mining incentive program
-    /// @param key Details of the incentive to create
-    /// @param reward The amount of reward tokens to be distributed
-    function createIncentive(IncentiveKey memory key, uint256 reward) external;
-
-    /// @notice Ends an incentive after the incentive end time has passed and all stakes have been withdrawn
-    /// @param key Details of the incentive to end
-    /// @return refund The remaining reward tokens when the incentive is ended
-    function endIncentive(IncentiveKey memory key) external returns (uint256 refund);
-
-    /// @notice Transfers ownership of a deposit from the sender to the given recipient
-    /// @param tokenId The ID of the token (and the deposit) to transfer
-    /// @param to The new owner of the deposit
-    function transferDeposit(uint256 tokenId, address to) external;
-
-    /// @notice Withdraws a Uniswap V3 LP token `tokenId` from this contract to the recipient `to`
-    /// @param tokenId The unique identifier of an Uniswap V3 LP token
-    /// @param to The address where the LP token will be sent
-    /// @param data An optional data array that will be passed along to the `to` address via the NFT safeTransferFrom
-    function withdrawToken(
-        uint256 tokenId,
-        address to,
-        bytes memory data
-    ) external;
-
-    /// @notice Stakes a Uniswap V3 LP token
-    /// @param key The key of the incentive for which to stake the NFT
-    /// @param tokenId The ID of the token to stake
-    function stakeToken(IncentiveKey memory key, uint256 tokenId) external;
-
-    /// @notice Unstakes a Uniswap V3 LP token
-    /// @param key The key of the incentive for which to unstake the NFT
-    /// @param tokenId The ID of the token to unstake
-    function unstakeToken(IncentiveKey memory key, uint256 tokenId) external;
-
-    /// @notice Transfers `amountRequested` of accrued `rewardToken` rewards from the contract to the recipient `to`
-    /// @param rewardToken The token being distributed as a reward
-    /// @param to The address where claimed rewards will be sent to
-    /// @param amountRequested The amount of reward tokens to claim. Claims entire reward amount if set to 0.
-    /// @return reward The amount of reward tokens claimed
-    function claimReward(
-        IERC20Minimal rewardToken,
-        address to,
-        uint256 amountRequested
-    ) external returns (uint256 reward);
-
-    /// @notice Calculates the reward amount that will be received for the given stake
-    /// @param key The key of the incentive
-    /// @param tokenId The ID of the token
-    /// @return reward The reward accrued to the NFT for the given incentive thus far
-    function getRewardInfo(IncentiveKey memory key, uint256 tokenId)
-        external
-        returns (uint256 reward, uint160 secondsInsideX128);
-
-    /// @notice Event emitted when a liquidity mining incentive has been created
-    /// @param rewardToken The token being distributed as a reward
-    /// @param pool The Uniswap V3 pool
-    /// @param startTime The time when the incentive program begins
-    /// @param endTime The time when rewards stop accruing
-    /// @param refundee The address which receives any remaining reward tokens after the end time
-    /// @param reward The amount of reward tokens to be distributed
-    event IncentiveCreated(
-        IERC20Minimal indexed rewardToken,
-        IUniswapV3Pool indexed pool,
-        uint256 startTime,
-        uint256 endTime,
-        address refundee,
-        uint256 reward
-    );
-
-    /// @notice Event that can be emitted when a liquidity mining incentive has ended
-    /// @param incentiveId The incentive which is ending
-    /// @param refund The amount of reward tokens refunded
-    event IncentiveEnded(bytes32 indexed incentiveId, uint256 refund);
-
-    /// @notice Emitted when ownership of a deposit changes
-    /// @param tokenId The ID of the deposit (and token) that is being transferred
-    /// @param oldOwner The owner before the deposit was transferred
-    /// @param newOwner The owner after the deposit was transferred
-    event DepositTransferred(uint256 indexed tokenId, address indexed oldOwner, address indexed newOwner);
-
-    /// @notice Event emitted when a Uniswap V3 LP token has been staked
-    /// @param tokenId The unique identifier of an Uniswap V3 LP token
-    /// @param liquidity The amount of liquidity staked
-    /// @param incentiveId The incentive in which the token is staking
-    event TokenStaked(uint256 indexed tokenId, bytes32 indexed incentiveId, uint128 liquidity);
-
-    /// @notice Event emitted when a Uniswap V3 LP token has been unstaked
-    /// @param tokenId The unique identifier of an Uniswap V3 LP token
-    /// @param incentiveId The incentive in which the token is staking
-    event TokenUnstaked(uint256 indexed tokenId, bytes32 indexed incentiveId);
-
-    /// @notice Event emitted when a reward token has been claimed
-    /// @param to The address where claimed rewards were sent to
-    /// @param reward The amount of reward tokens claimed
-    event RewardClaimed(address indexed to, uint256 reward);
-}

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

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity =0.7.6;
-pragma abicoder v2;
-
-import '../interfaces/IUniswapV3Staker.sol';
-
-library IncentiveId {
-    /// @notice Calculate the key for a staking incentive
-    /// @param key The components used to compute the incentive identifier
-    /// @return incentiveId The identifier for the incentive
-    function compute(IUniswapV3Staker.IncentiveKey memory key) internal pure returns (bytes32 incentiveId) {
-        return keccak256(abi.encode(key));
-    }
-}

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

@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.7.0;
-
-/**
- * @dev Standard math utilities missing in the Solidity language.
- */
-library Math {
-    /**
-     * @dev Returns the largest of two numbers.
-     */
-    function max(uint256 a, uint256 b) internal pure returns (uint256) {
-        return a >= b ? a : b;
-    }
-
-    /**
-     * @dev Returns the smallest of two numbers.
-     */
-    function min(uint256 a, uint256 b) internal pure returns (uint256) {
-        return a < b ? a : b;
-    }
-
-    /**
-     * @dev Returns the average of two numbers. The result is rounded towards
-     * zero.
-     */
-    function average(uint256 a, uint256 b) internal pure returns (uint256) {
-        // (a + b) / 2 can overflow, so we distribute
-        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
-    }
-}

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

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity =0.7.6;
-pragma abicoder v2;
-
-import '../interfaces/IMulticall.sol';
-
-/// @title Multicall
-/// @notice Enables calling multiple methods in a single call to the contract
-abstract contract Multicall is IMulticall {
-    /// @inheritdoc IMulticall
-    function multicall(bytes[] calldata data) external payable override returns (bytes[] memory results) {
-        results = new bytes[](data.length);
-        for (uint256 i = 0; i < data.length; i++) {
-            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
-
-            if (!success) {
-                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
-                if (result.length < 68) revert();
-                assembly {
-                    result := add(result, 0x04)
-                }
-                revert(abi.decode(result, (string)));
-            }
-
-            results[i] = result;
-        }
-    }
-}

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

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity =0.7.6;
-
-import '@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol';
-import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
-import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
-
-import '@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol';
-
-/// @notice Encapsulates the logic for getting info about a NFT token ID
-library NFTPositionInfo {
-    /// @param factory The address of the Uniswap V3 Factory used in computing the pool address
-    /// @param nonfungiblePositionManager The address of the nonfungible position manager to query
-    /// @param tokenId The unique identifier of an Uniswap V3 LP token
-    /// @return pool The address of the Uniswap V3 pool
-    /// @return tickLower The lower tick of the Uniswap V3 position
-    /// @return tickUpper The upper tick of the Uniswap V3 position
-    /// @return liquidity The amount of liquidity staked
-    function getPositionInfo(
-        IUniswapV3Factory factory,
-        INonfungiblePositionManager nonfungiblePositionManager,
-        uint256 tokenId
-    )
-        internal
-        view
-        returns (
-            IUniswapV3Pool pool,
-            int24 tickLower,
-            int24 tickUpper,
-            uint128 liquidity
-        )
-    {
-        address token0;
-        address token1;
-        uint24 fee;
-        (, , token0, token1, fee, tickLower, tickUpper, liquidity, , , , ) = nonfungiblePositionManager.positions(
-            tokenId
-        );
-
-        pool = IUniswapV3Pool(
-            PoolAddress.computeAddress(
-                address(factory),
-                PoolAddress.PoolKey({token0: token0, token1: token1, fee: fee})
-            )
-        );
-    }
-}

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

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity >=0.5.0;
-
-/// @title Provides functions for deriving a pool address from the factory, tokens, and the fee
-library PoolAddress {
-    bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
-
-    /// @notice The identifying key of the pool
-    struct PoolKey {
-        address token0;
-        address token1;
-        uint24 fee;
-    }
-
-    /// @notice Returns PoolKey: the ordered tokens with the matched fee levels
-    /// @param tokenA The first token of a pool, unsorted
-    /// @param tokenB The second token of a pool, unsorted
-    /// @param fee The fee level of the pool
-    /// @return Poolkey The pool details with ordered token0 and token1 assignments
-    function getPoolKey(
-        address tokenA,
-        address tokenB,
-        uint24 fee
-    ) internal pure returns (PoolKey memory) {
-        if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
-        return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
-    }
-
-    /// @notice Deterministically computes the pool address given the factory and PoolKey
-    /// @param factory The Uniswap V3 factory contract address
-    /// @param key The PoolKey
-    /// @return pool The contract address of the V3 pool
-    function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
-        require(key.token0 < key.token1);
-        pool = address(
-            uint256(
-                keccak256(
-                    abi.encodePacked(
-                        hex'ff',
-                        factory,
-                        keccak256(abi.encode(key.token0, key.token1, key.fee)),
-                        POOL_INIT_CODE_HASH
-                    )
-                )
-            )
-        );
-    }
-}