@harvest-finance/harvest-strategy-arbitrum 0.0.1-security → 1.0.0

package/contracts/base/interface/gmx/EventUtils.sol

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+library EventUtils {
+    struct EmitPositionDecreaseParams {
+        bytes32 key;
+        address account;
+        address market;
+        address collateralToken;
+        bool isLong;
+    }
+
+    struct EventLogData {
+        AddressItems addressItems;
+        UintItems uintItems;
+        IntItems intItems;
+        BoolItems boolItems;
+        Bytes32Items bytes32Items;
+        BytesItems bytesItems;
+        StringItems stringItems;
+    }
+
+    struct AddressItems {
+        AddressKeyValue[] items;
+        AddressArrayKeyValue[] arrayItems;
+    }
+
+    struct UintItems {
+        UintKeyValue[] items;
+        UintArrayKeyValue[] arrayItems;
+    }
+
+    struct IntItems {
+        IntKeyValue[] items;
+        IntArrayKeyValue[] arrayItems;
+    }
+
+    struct BoolItems {
+        BoolKeyValue[] items;
+        BoolArrayKeyValue[] arrayItems;
+    }
+
+    struct Bytes32Items {
+        Bytes32KeyValue[] items;
+        Bytes32ArrayKeyValue[] arrayItems;
+    }
+
+    struct BytesItems {
+        BytesKeyValue[] items;
+        BytesArrayKeyValue[] arrayItems;
+    }
+
+    struct StringItems {
+        StringKeyValue[] items;
+        StringArrayKeyValue[] arrayItems;
+    }
+
+    struct AddressKeyValue {
+        string key;
+        address value;
+    }
+
+    struct AddressArrayKeyValue {
+        string key;
+        address[] value;
+    }
+
+    struct UintKeyValue {
+        string key;
+        uint256 value;
+    }
+
+    struct UintArrayKeyValue {
+        string key;
+        uint256[] value;
+    }
+
+    struct IntKeyValue {
+        string key;
+        int256 value;
+    }
+
+    struct IntArrayKeyValue {
+        string key;
+        int256[] value;
+    }
+
+    struct BoolKeyValue {
+        string key;
+        bool value;
+    }
+
+    struct BoolArrayKeyValue {
+        string key;
+        bool[] value;
+    }
+
+    struct Bytes32KeyValue {
+        string key;
+        bytes32 value;
+    }
+
+    struct Bytes32ArrayKeyValue {
+        string key;
+        bytes32[] value;
+    }
+
+    struct BytesKeyValue {
+        string key;
+        bytes value;
+    }
+
+    struct BytesArrayKeyValue {
+        string key;
+        bytes[] value;
+    }
+
+    struct StringKeyValue {
+        string key;
+        string value;
+    }
+
+    struct StringArrayKeyValue {
+        string key;
+        string[] value;
+    }
+
+    function initItems(AddressItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.AddressKeyValue[](size);
+    }
+
+    function initArrayItems(AddressItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.AddressArrayKeyValue[](size);
+    }
+
+    function setItem(AddressItems memory items, uint256 index, string memory key, address value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(AddressItems memory items, uint256 index, string memory key, address[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(UintItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.UintKeyValue[](size);
+    }
+
+    function initArrayItems(UintItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.UintArrayKeyValue[](size);
+    }
+
+    function setItem(UintItems memory items, uint256 index, string memory key, uint256 value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(UintItems memory items, uint256 index, string memory key, uint256[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(IntItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.IntKeyValue[](size);
+    }
+
+    function initArrayItems(IntItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.IntArrayKeyValue[](size);
+    }
+
+    function setItem(IntItems memory items, uint256 index, string memory key, int256 value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(IntItems memory items, uint256 index, string memory key, int256[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(BoolItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.BoolKeyValue[](size);
+    }
+
+    function initArrayItems(BoolItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.BoolArrayKeyValue[](size);
+    }
+
+    function setItem(BoolItems memory items, uint256 index, string memory key, bool value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(BoolItems memory items, uint256 index, string memory key, bool[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(Bytes32Items memory items, uint256 size) internal pure {
+        items.items = new EventUtils.Bytes32KeyValue[](size);
+    }
+
+    function initArrayItems(Bytes32Items memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.Bytes32ArrayKeyValue[](size);
+    }
+
+    function setItem(Bytes32Items memory items, uint256 index, string memory key, bytes32 value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(Bytes32Items memory items, uint256 index, string memory key, bytes32[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(BytesItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.BytesKeyValue[](size);
+    }
+
+    function initArrayItems(BytesItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.BytesArrayKeyValue[](size);
+    }
+
+    function setItem(BytesItems memory items, uint256 index, string memory key, bytes memory value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(BytesItems memory items, uint256 index, string memory key, bytes[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+
+    function initItems(StringItems memory items, uint256 size) internal pure {
+        items.items = new EventUtils.StringKeyValue[](size);
+    }
+
+    function initArrayItems(StringItems memory items, uint256 size) internal pure {
+        items.arrayItems = new EventUtils.StringArrayKeyValue[](size);
+    }
+
+    function setItem(StringItems memory items, uint256 index, string memory key, string memory value) internal pure {
+        items.items[index].key = key;
+        items.items[index].value = value;
+    }
+
+    function setItem(StringItems memory items, uint256 index, string memory key, string[] memory value) internal pure {
+        items.arrayItems[index].key = key;
+        items.arrayItems[index].value = value;
+    }
+}

package/contracts/base/interface/gmx/ICallbackReceiver.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import "./EventUtils.sol";
+
+interface ICallbackReceiver {
+    // @dev there is a limit on the number of fields a struct can have when being passed
+    // or returned as a memory variable which can cause "Stack too deep" errors
+    // use sub-structs to avoid this issue
+    // @param addresses address values
+    // @param numbers number values
+    // @param flags boolean values
+    struct DepositProps {
+        DepositAddresses addresses;
+        DepositNumbers numbers;
+        Flags flags;
+    }
+
+    // @dev there is a limit on the number of fields a struct can have when being passed
+    // or returned as a memory variable which can cause "Stack too deep" errors
+    // use sub-structs to avoid this issue
+    // @param addresses address values
+    // @param numbers number values
+    // @param flags boolean values
+    struct WithdrawalProps {
+        WithdrawalAddresses addresses;
+        WithdrawalNumbers numbers;
+        Flags flags;
+    }
+
+    // @param account the account depositing liquidity
+    // @param receiver the address to send the liquidity tokens to
+    // @param callbackContract the callback contract
+    // @param uiFeeReceiver the ui fee receiver
+    // @param market the market to deposit to
+    struct DepositAddresses {
+        address account;
+        address receiver;
+        address callbackContract;
+        address uiFeeReceiver;
+        address market;
+        address initialLongToken;
+        address initialShortToken;
+        address[] longTokenSwapPath;
+        address[] shortTokenSwapPath;
+    }
+
+    // @param initialLongTokenAmount the amount of long tokens to deposit
+    // @param initialShortTokenAmount the amount of short tokens to deposit
+    // @param minMarketTokens the minimum acceptable number of liquidity tokens
+    // @param updatedAtBlock the block that the deposit was last updated at
+    // sending funds back to the user in case the deposit gets cancelled
+    // @param executionFee the execution fee for keepers
+    // @param callbackGasLimit the gas limit for the callbackContract
+    struct DepositNumbers {
+        uint256 initialLongTokenAmount;
+        uint256 initialShortTokenAmount;
+        uint256 minMarketTokens;
+        uint256 updatedAtBlock;
+        uint256 updatedAtTime;
+        uint256 executionFee;
+        uint256 callbackGasLimit;
+    }
+
+    // @param account The account to withdraw for.
+    // @param receiver The address that will receive the withdrawn tokens.
+    // @param callbackContract The contract that will be called back.
+    // @param uiFeeReceiver The ui fee receiver.
+    // @param market The market on which the withdrawal will be executed.
+    struct WithdrawalAddresses {
+        address account;
+        address receiver;
+        address callbackContract;
+        address uiFeeReceiver;
+        address market;
+        address[] longTokenSwapPath;
+        address[] shortTokenSwapPath;
+    }
+
+    // @param marketTokenAmount The amount of market tokens that will be withdrawn.
+    // @param minLongTokenAmount The minimum amount of long tokens that must be withdrawn.
+    // @param minShortTokenAmount The minimum amount of short tokens that must be withdrawn.
+    // @param updatedAtBlock The block at which the withdrawal was last updated.
+    // @param executionFee The execution fee for the withdrawal.
+    // @param callbackGasLimit The gas limit for calling the callback contract.
+    struct WithdrawalNumbers {
+        uint256 marketTokenAmount;
+        uint256 minLongTokenAmount;
+        uint256 minShortTokenAmount;
+        uint256 updatedAtBlock;
+        uint256 updatedAtTime;
+        uint256 executionFee;
+        uint256 callbackGasLimit;
+    }
+
+    // @param shouldUnwrapNativeToken whether to unwrap the native token when
+    struct Flags {
+        bool shouldUnwrapNativeToken;
+    }
+    // @dev called after a deposit execution
+    // @param key the key of the deposit
+    // @param deposit the deposit that was executed
+    function afterDepositExecution(bytes32 key, DepositProps memory deposit, EventUtils.EventLogData memory eventData) external;
+
+    // @dev called after a deposit cancellation
+    // @param key the key of the deposit
+    // @param deposit the deposit that was cancelled
+    function afterDepositCancellation(bytes32 key, DepositProps memory deposit, EventUtils.EventLogData memory eventData) external;
+
+    // @dev called after a withdrawal execution
+    // @param key the key of the withdrawal
+    // @param withdrawal the withdrawal that was executed
+    function afterWithdrawalExecution(bytes32 key, WithdrawalProps memory withdrawal, EventUtils.EventLogData memory eventData) external;
+
+    // @dev called after a withdrawal cancellation
+    // @param key the key of the withdrawal
+    // @param withdrawal the withdrawal that was cancelled
+    function afterWithdrawalCancellation(bytes32 key, WithdrawalProps memory withdrawal, EventUtils.EventLogData memory eventData) external;
+}

package/contracts/base/interface/gmx/IDataStore.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IDataStore {
+    function getAddress(bytes32 key) external view returns (address);
+    function getUint(bytes32 key) external view returns (uint256);
+}

package/contracts/base/interface/gmx/IExchangeRouter.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IExchangeRouter {
+    struct CreateDepositParams {
+        address receiver;
+        address callbackContract;
+        address uiFeeReceiver;
+        address market;
+        address initialLongToken;
+        address initialShortToken;
+        address[] longTokenSwapPath;
+        address[] shortTokenSwapPath;
+        uint256 minMarketTokens;
+        bool shouldUnwrapNativeToken;
+        uint256 executionFee;
+        uint256 callbackGasLimit;
+    }
+    struct CreateWithdrawalParams {
+        address receiver;
+        address callbackContract;
+        address uiFeeReceiver;
+        address market;
+        address[] longTokenSwapPath;
+        address[] shortTokenSwapPath;
+        uint256 minLongTokenAmount;
+        uint256 minShortTokenAmount;
+        bool shouldUnwrapNativeToken;
+        uint256 executionFee;
+        uint256 callbackGasLimit;
+    }
+    
+    function sendWnt(address receiver, uint256 amount) external payable;
+    function sendTokens(address token, address receiver, uint256 amount) external payable;
+    function createDeposit(CreateDepositParams calldata params) external payable returns (bytes32);
+    function createWithdrawal(CreateWithdrawalParams calldata params) external payable returns (bytes32);
+    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
+}

package/contracts/base/interface/gmx/IGMXViewer.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IGMXViewer {
+    function getWithdrawalAmountOut(address market, uint256 amount, bool stalenessCheck) external view returns (uint256);
+    function getDepositAmountOut(address market, uint256 amount, bool stalenessCheck) external view returns (uint256);
+}

package/contracts/base/interface/gmx/IHandler.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IHandler {
+    struct SetPricesParams {
+        address[] tokens;
+        address[] providers;
+        bytes[] data;
+    }
+    function executeDeposit(bytes32 key, SetPricesParams calldata oracleParams) external;
+    function executeWithdrawal(bytes32 key, SetPricesParams calldata oracleParams) external;
+}

package/contracts/base/interface/gmx/IMarket.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IMarket {
+    function dataStore() external view returns (address);
+    function roleStore() external view returns (address);
+}

package/contracts/base/interface/gmx/IOracle.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IOracle {
+    function getPriceFeedMultiplier(address dataStore, address token) external view returns (uint256);
+}

package/contracts/base/interface/gmx/IPriceFeed.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IPriceFeed {
+    function latestRoundData() external view returns (
+        uint80 roundId,
+        int256 answer,
+        uint256 startedAt,
+        uint256 updatedAt,
+        uint80 answeredInRound
+    );
+}

package/contracts/base/interface/gmx/IReader.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "./IMarket.sol";
+
+interface IReader {
+    struct PriceProps {
+        uint256 min;
+        uint256 max;
+    }
+    struct MarketProps {
+        address marketToken;
+        address indexToken;
+        address longToken;
+        address shortToken;
+    }
+    struct MarketPrices {
+        PriceProps indexTokenPrice;
+        PriceProps longTokenPrice;
+        PriceProps shortTokenPrice;
+    }
+    enum SwapPricingType {
+        TwoStep,
+        Shift,
+        Atomic
+    }
+
+    function getMarket(address dataStore, address key) external view returns (MarketProps memory);
+
+    function getDepositAmountOut(
+        address dataStore,
+        MarketProps memory market,
+        MarketPrices memory prices,
+        uint256 longTokenAmount,
+        uint256 shortTokenAmount,
+        address uiFeeReceiver,
+        SwapPricingType swapPricingType,
+        bool includeVirtualInventoryImpact
+    ) external view returns (uint256);
+
+    function getWithdrawalAmountOut(
+        address dataStore,
+        MarketProps memory market,
+        MarketPrices memory prices,
+        uint256 marketTokenAmount,
+        address uiFeeReceiver,
+        SwapPricingType swapPricingType
+    ) external view returns (uint256, uint256);
+}

package/contracts/base/interface/gmx/IRoleStore.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IRoleStore {
+    function hasRole(address account, bytes32 roleKey) external view returns (bool);
+}

package/contracts/base/interface/ipor/Errors.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Errors in Ipor Fusion
+library Errors {
+    /// @notice Error when wrong address is used
+    error WrongAddress();
+    /// @notice Error when wrong value is used
+    error WrongValue();
+    /// @notice Error when wrong decimals are used
+    error WrongDecimals();
+    /// @notice Error when wrong array length is used
+    error WrongArrayLength();
+    /// @notice Error when wrong caller is used
+    error WrongCaller(address caller);
+    /// @notice Error when wrong quote currency is used
+    error UnsupportedQuoteCurrencyFromOracle();
+    /// @notice Error when unsupported price oracle middleware is used
+    error UnsupportedPriceOracleMiddleware();
+}

package/contracts/base/interface/ipor/FuseStorageLib.sol

@@ -0,0 +1,71 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Fuses storage library responsible for managing storage fuses in the Plasma Vault
+library FuseStorageLib {
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgFuses")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_FUSES = 0x48932b860eb451ad240d4fe2b46522e5a0ac079d201fe50d4e0be078c75b5400;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgFusesArray")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_FUSES_ARRAY = 0xad43e358bd6e59a5a0c80f6bf25fa771408af4d80f621cdc680c8dfbf607ab00;
+
+    /// @notice This memory is designed to use with Uniswap V3 fuses
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.UniswapV3TokenIds")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant UNISWAP_V3_TOKEN_IDS = 0x3651659bd419f7c37743f3e14a337c9f9d1cfc4d650d91508f44d1acbe960f00;
+
+    /// @notice This memory is designed to use with Ramses V2 fuses
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.RamsesV2TokenIds")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant RAMSES_V2_TOKEN_IDS = 0x1a3831a406f27d4d5d820158b29ce95a1e8e840bf416921917aa388e2461b700;
+
+    /// @custom:storage-location erc7201:io.ipor.CfgFuses
+    struct Fuses {
+        /// @dev fuse address => If index = 0 - is not granted, otherwise - granted
+        mapping(address fuse => uint256 index) value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.CfgFusesArray
+    struct FusesArray {
+        /// @dev value is a fuse address
+        address[] value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.UniswapV3TokenIds
+    struct UniswapV3TokenIds {
+        uint256[] tokenIds;
+        mapping(uint256 tokenId => uint256 index) indexes;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.RamsesV2TokenIds
+    struct RamsesV2TokenIds {
+        uint256[] tokenIds;
+        mapping(uint256 tokenId => uint256 index) indexes;
+    }
+
+    /// @notice Gets the fuses storage pointer
+    function getFuses() internal pure returns (Fuses storage fuses) {
+        assembly {
+            fuses.slot := CFG_FUSES
+        }
+    }
+
+    /// @notice Gets the fuses array storage pointer
+    function getFusesArray() internal pure returns (FusesArray storage fusesArray) {
+        assembly {
+            fusesArray.slot := CFG_FUSES_ARRAY
+        }
+    }
+
+    /// @notice Gets the UniswapV3TokenIds storage pointer
+    function getUniswapV3TokenIds() internal pure returns (UniswapV3TokenIds storage uniswapV3TokenIds) {
+        assembly {
+            uniswapV3TokenIds.slot := UNISWAP_V3_TOKEN_IDS
+        }
+    }
+    /// @notice Gets the UniswapV3TokenIds storage pointer
+    function getRamsesV2TokenIds() internal pure returns (RamsesV2TokenIds storage ramsesV2TokenIds) {
+        assembly {
+            ramsesV2TokenIds.slot := RAMSES_V2_TOKEN_IDS
+        }
+    }
+}