Contract Name:
KyberSwapV2Swapper
Contract Source Code:
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol';
import './AuthorizedHelpers.sol';
import './interfaces/IAuthorized.sol';
import './interfaces/IAuthorizer.sol';
/**
* @title Authorized
* @dev Implementation using an authorizer as its access-control mechanism. It offers `auth` and `authP` modifiers to
* tag its own functions in order to control who can access them against the authorizer referenced.
*/
contract Authorized is IAuthorized, Initializable, AuthorizedHelpers {
// Authorizer reference
address public override authorizer;
/**
* @dev Modifier that should be used to tag protected functions
*/
modifier auth() {
_authenticate(msg.sender, msg.sig);
_;
}
/**
* @dev Modifier that should be used to tag protected functions with params
*/
modifier authP(uint256[] memory params) {
_authenticate(msg.sender, msg.sig, params);
_;
}
/**
* @dev Creates a new authorized contract. Note that initializers are disabled at creation time.
*/
constructor() {
_disableInitializers();
}
/**
* @dev Initializes the authorized contract. It does call upper contracts initializers.
* @param _authorizer Address of the authorizer to be set
*/
function __Authorized_init(address _authorizer) internal onlyInitializing {
__Authorized_init_unchained(_authorizer);
}
/**
* @dev Initializes the authorized contract. It does not call upper contracts initializers.
* @param _authorizer Address of the authorizer to be set
*/
function __Authorized_init_unchained(address _authorizer) internal onlyInitializing {
authorizer = _authorizer;
}
/**
* @dev Reverts if `who` is not allowed to call `what`
* @param who Address to be authenticated
* @param what Function selector to be authenticated
*/
function _authenticate(address who, bytes4 what) internal view {
_authenticate(who, what, new uint256[](0));
}
/**
* @dev Reverts if `who` is not allowed to call `what` with `how`
* @param who Address to be authenticated
* @param what Function selector to be authenticated
* @param how Params to be authenticated
*/
function _authenticate(address who, bytes4 what, uint256[] memory how) internal view {
if (!_isAuthorized(who, what, how)) revert AuthSenderNotAllowed(who, what, how);
}
/**
* @dev Tells whether `who` has any permission on this contract
* @param who Address asking permissions for
*/
function _hasPermissions(address who) internal view returns (bool) {
return IAuthorizer(authorizer).hasPermissions(who, address(this));
}
/**
* @dev Tells whether `who` is allowed to call `what`
* @param who Address asking permission for
* @param what Function selector asking permission for
*/
function _isAuthorized(address who, bytes4 what) internal view returns (bool) {
return _isAuthorized(who, what, new uint256[](0));
}
/**
* @dev Tells whether `who` is allowed to call `what` with `how`
* @param who Address asking permission for
* @param what Function selector asking permission for
* @param how Params asking permission for
*/
function _isAuthorized(address who, bytes4 what, uint256[] memory how) internal view returns (bool) {
return IAuthorizer(authorizer).isAuthorized(who, address(this), what, how);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
/**
* @title AuthorizedHelpers
* @dev Syntax sugar methods to operate with authorizer params easily
*/
contract AuthorizedHelpers {
function authParams(address p1) internal pure returns (uint256[] memory r) {
return authParams(uint256(uint160(p1)));
}
function authParams(bytes32 p1) internal pure returns (uint256[] memory r) {
return authParams(uint256(p1));
}
function authParams(uint256 p1) internal pure returns (uint256[] memory r) {
r = new uint256[](1);
r[0] = p1;
}
function authParams(address p1, bool p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = p2 ? 1 : 0;
}
function authParams(address p1, uint256 p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = p2;
}
function authParams(address p1, address p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
}
function authParams(bytes32 p1, bytes32 p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(p1);
r[1] = uint256(p2);
}
function authParams(address p1, address p2, uint256 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = p3;
}
function authParams(address p1, address p2, address p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = uint256(uint160(p3));
}
function authParams(address p1, address p2, bytes4 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = uint256(uint32(p3));
}
function authParams(address p1, uint256 p2, uint256 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
}
function authParams(uint256 p1, uint256 p2, uint256 p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = p1;
r[1] = p2;
r[2] = p3;
r[3] = p4;
}
function authParams(address p1, address p2, uint256 p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = p3;
r[3] = p4;
}
function authParams(address p1, uint256 p2, address p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = uint256(uint160(p3));
r[3] = p4;
}
function authParams(address p1, uint256 p2, uint256 p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
r[3] = p4;
}
function authParams(bytes32 p1, address p2, uint256 p3, bool p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(p1);
r[1] = uint256(uint160(p2));
r[2] = p3;
r[3] = p4 ? 1 : 0;
}
function authParams(address p1, uint256 p2, uint256 p3, uint256 p4, uint256 p5)
internal
pure
returns (uint256[] memory r)
{
r = new uint256[](5);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
r[3] = p4;
r[4] = p5;
}
function authParams(address p1, bytes32 p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = uint256(p2);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
/**
* @dev Authorized interface
*/
interface IAuthorized {
/**
* @dev Sender `who` is not allowed to call `what` with `how`
*/
error AuthSenderNotAllowed(address who, bytes4 what, uint256[] how);
/**
* @dev Tells the address of the authorizer reference
*/
function authorizer() external view returns (address);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
/**
* @dev Authorizer interface
*/
interface IAuthorizer {
/**
* @dev Permission change
* @param where Address of the contract to change a permission for
* @param changes List of permission changes to be executed
*/
struct PermissionChange {
address where;
GrantPermission[] grants;
RevokePermission[] revokes;
}
/**
* @dev Grant permission data
* @param who Address to be authorized
* @param what Function selector to be authorized
* @param params List of params to restrict the given permission
*/
struct GrantPermission {
address who;
bytes4 what;
Param[] params;
}
/**
* @dev Revoke permission data
* @param who Address to be unauthorized
* @param what Function selector to be unauthorized
*/
struct RevokePermission {
address who;
bytes4 what;
}
/**
* @dev Params used to validate permissions params against
* @param op ID of the operation to compute in order to validate a permission param
* @param value Comparison value
*/
struct Param {
uint8 op;
uint248 value;
}
/**
* @dev Sender is not authorized to call `what` on `where` with `how`
*/
error AuthorizerSenderNotAllowed(address who, address where, bytes4 what, uint256[] how);
/**
* @dev The operation param is invalid
*/
error AuthorizerInvalidParamOp(uint8 op);
/**
* @dev Emitted every time `who`'s permission to perform `what` on `where` is granted with `params`
*/
event Authorized(address indexed who, address indexed where, bytes4 indexed what, Param[] params);
/**
* @dev Emitted every time `who`'s permission to perform `what` on `where` is revoked
*/
event Unauthorized(address indexed who, address indexed where, bytes4 indexed what);
/**
* @dev Tells whether `who` has any permission on `where`
* @param who Address asking permission for
* @param where Target address asking permission for
*/
function hasPermissions(address who, address where) external view returns (bool);
/**
* @dev Tells the number of permissions `who` has on `where`
* @param who Address asking permission for
* @param where Target address asking permission for
*/
function getPermissionsLength(address who, address where) external view returns (uint256);
/**
* @dev Tells whether `who` has permission to call `what` on `where`. Note `how` is not evaluated here,
* which means `who` might be authorized on or not depending on the call at the moment of the execution
* @param who Address asking permission for
* @param where Target address asking permission for
* @param what Function selector asking permission for
*/
function hasPermission(address who, address where, bytes4 what) external view returns (bool);
/**
* @dev Tells whether `who` is allowed to call `what` on `where` with `how`
* @param who Address asking permission for
* @param where Target address asking permission for
* @param what Function selector asking permission for
* @param how Params asking permission for
*/
function isAuthorized(address who, address where, bytes4 what, uint256[] memory how) external view returns (bool);
/**
* @dev Tells the params set for a given permission
* @param who Address asking permission params of
* @param where Target address asking permission params of
* @param what Function selector asking permission params of
*/
function getPermissionParams(address who, address where, bytes4 what) external view returns (Param[] memory);
/**
* @dev Executes a list of permission changes
* @param changes List of permission changes to be executed
*/
function changePermissions(PermissionChange[] memory changes) external;
/**
* @dev Authorizes `who` to call `what` on `where` restricted by `params`
* @param who Address to be authorized
* @param where Target address to be granted for
* @param what Function selector to be granted
* @param params Optional params to restrict a permission attempt
*/
function authorize(address who, address where, bytes4 what, Param[] memory params) external;
/**
* @dev Unauthorizes `who` to call `what` on `where`. Sender must be authorized.
* @param who Address to be authorized
* @param where Target address to be revoked for
* @param what Function selector to be revoked
*/
function unauthorize(address who, address where, bytes4 what) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
/**
* @title KyberSwap V2 connector interface
*/
interface IKyberSwapV2Connector {
/**
* @dev The token in is the same as the token out
*/
error KyberSwapV2SwapSameToken(address token);
/**
* @dev The amount out is lower than the minimum amount out
*/
error KyberSwapV2BadAmountOut(uint256 amountOut, uint256 minAmountOut);
/**
* @dev The post token in balance is lower than the previous token in balance minus the amount in
*/
error KyberSwapV2BadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn);
/**
* @dev Tells the reference to KyberSwap aggregation router v2
*/
function kyberSwapV2Router() external view returns (address);
/**
* @dev Executes a token swap in KyberSwap V2
* @param tokenIn Token to be sent
* @param tokenOut Token to be received
* @param amountIn Amount of token in to be swapped
* @param minAmountOut Minimum amount of token out willing to receive
* @param data Calldata to be sent to the KyberSwap aggregation router
*/
function execute(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, bytes memory data)
external
returns (uint256 amountOut);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
/**
* @title FixedPoint
* @dev Math library to operate with fixed point values with 18 decimals
*/
library FixedPoint {
// 1 in fixed point value: 18 decimal places
uint256 internal constant ONE = 1e18;
/**
* @dev Multiplication overflow
*/
error FixedPointMulOverflow(uint256 a, uint256 b);
/**
* @dev Division by zero
*/
error FixedPointZeroDivision();
/**
* @dev Division internal error
*/
error FixedPointDivInternal(uint256 a, uint256 aInflated);
/**
* @dev Multiplies two fixed point numbers rounding down
*/
function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
uint256 product = a * b;
if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b);
return product / ONE;
}
}
/**
* @dev Multiplies two fixed point numbers rounding up
*/
function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
uint256 product = a * b;
if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b);
return product == 0 ? 0 : (((product - 1) / ONE) + 1);
}
}
/**
* @dev Divides two fixed point numbers rounding down
*/
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
if (b == 0) revert FixedPointZeroDivision();
if (a == 0) return 0;
uint256 aInflated = a * ONE;
if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated);
return aInflated / b;
}
}
/**
* @dev Divides two fixed point numbers rounding up
*/
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
if (b == 0) revert FixedPointZeroDivision();
if (a == 0) return 0;
uint256 aInflated = a * ONE;
if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated);
return ((aInflated - 1) / b) + 1;
}
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
/**
* @title BytesHelpers
* @dev Provides a list of Bytes helper methods
*/
library BytesHelpers {
/**
* @dev The length is shorter than start plus 32
*/
error BytesOutOfBounds(uint256 start, uint256 length);
/**
* @dev Concatenates an address to a bytes array
*/
function concat(bytes memory self, address value) internal pure returns (bytes memory) {
return abi.encodePacked(self, value);
}
/**
* @dev Concatenates an uint24 to a bytes array
*/
function concat(bytes memory self, uint24 value) internal pure returns (bytes memory) {
return abi.encodePacked(self, value);
}
/**
* @dev Decodes a bytes array into an uint256
*/
function toUint256(bytes memory self) internal pure returns (uint256) {
return toUint256(self, 0);
}
/**
* @dev Reads an uint256 from a bytes array starting at a given position
*/
function toUint256(bytes memory self, uint256 start) internal pure returns (uint256 result) {
if (self.length < start + 32) revert BytesOutOfBounds(start, self.length);
assembly {
result := mload(add(add(self, 0x20), start))
}
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
/**
* @title Denominations
* @dev Provides a list of ground denominations for those tokens that cannot be represented by an ERC20.
* For now, the only needed is the native token that could be ETH, MATIC, or other depending on the layer being operated.
*/
library Denominations {
address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
// Fiat currencies follow https://en.wikipedia.org/wiki/ISO_4217
address internal constant USD = address(840);
function isNativeToken(address token) internal pure returns (bool) {
return token == NATIVE_TOKEN;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorized.sol';
/**
* @title IPriceOracle
* @dev Price oracle interface
*
* Tells the price of a token (base) in a given quote based the following rule: the response is expressed using the
* corresponding number of decimals so that when performing a fixed point product of it by a `base` amount it results
* in a value expressed in `quote` decimals. For example, if `base` is ETH and `quote` is USDC, then the returned
* value is expected to be expressed using 6 decimals:
*
* FixedPoint.mul(X[ETH], price[USDC/ETH]) = FixedPoint.mul(X[18], price[6]) = X * price [6]
*/
interface IPriceOracle is IAuthorized {
/**
* @dev Price data
* @param base Token to rate
* @param quote Token used for the price rate
* @param rate Price of a token (base) expressed in `quote`
* @param deadline Expiration timestamp until when the given quote is considered valid
*/
struct PriceData {
address base;
address quote;
uint256 rate;
uint256 deadline;
}
/**
* @dev The signer is not allowed
*/
error PriceOracleInvalidSigner(address signer);
/**
* @dev The feed for the given (base, quote) pair doesn't exist
*/
error PriceOracleMissingFeed(address base, address quote);
/**
* @dev The price deadline is in the past
*/
error PriceOracleOutdatedPrice(address base, address quote, uint256 deadline, uint256 currentTimestamp);
/**
* @dev The base decimals are bigger than the quote decimals plus the fixed point decimals
*/
error PriceOracleBaseDecimalsTooBig(address base, uint256 baseDecimals, address quote, uint256 quoteDecimals);
/**
* @dev The inverse feed decimals are bigger than the maximum inverse feed decimals
*/
error PriceOracleInverseFeedDecimalsTooBig(address inverseFeed, uint256 inverseFeedDecimals);
/**
* @dev The quote feed decimals are bigger than the base feed decimals plus the fixed point decimals
*/
error PriceOracleQuoteFeedDecimalsTooBig(uint256 quoteFeedDecimals, uint256 baseFeedDecimals);
/**
* @dev Emitted every time a signer is changed
*/
event SignerSet(address indexed signer, bool allowed);
/**
* @dev Emitted every time a feed is set for (base, quote) pair
*/
event FeedSet(address indexed base, address indexed quote, address feed);
/**
* @dev Tells whether an address is as an allowed signer or not
* @param signer Address of the signer being queried
*/
function isSignerAllowed(address signer) external view returns (bool);
/**
* @dev Tells the list of allowed signers
*/
function getAllowedSigners() external view returns (address[] memory);
/**
* @dev Tells the digest expected to be signed by the off-chain oracle signers for a list of prices
* @param prices List of prices to be signed
*/
function getPricesDigest(PriceData[] memory prices) external view returns (bytes32);
/**
* @dev Tells the price of a token `base` expressed in a token `quote`
* @param base Token to rate
* @param quote Token used for the price rate
*/
function getPrice(address base, address quote) external view returns (uint256);
/**
* @dev Tells the price of a token `base` expressed in a token `quote`
* @param base Token to rate
* @param quote Token used for the price rate
* @param data Encoded data to validate in order to compute the requested rate
*/
function getPrice(address base, address quote, bytes memory data) external view returns (uint256);
/**
* @dev Tells the feed address for (base, quote) pair. It returns the zero address if there is no one set.
* @param base Token to be rated
* @param quote Token used for the price rate
*/
function getFeed(address base, address quote) external view returns (address);
/**
* @dev Sets a signer condition
* @param signer Address of the signer to be set
* @param allowed Whether the requested signer is allowed
*/
function setSigner(address signer, bool allowed) external;
/**
* @dev Sets a feed for a (base, quote) pair
* @param base Token base to be set
* @param quote Token quote to be set
* @param feed Feed to be set
*/
function setFeed(address base, address quote, address feed) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorized.sol';
/**
* @dev Smart Vault interface
*/
interface ISmartVault is IAuthorized {
/**
* @dev The smart vault is paused
*/
error SmartVaultPaused();
/**
* @dev The smart vault is unpaused
*/
error SmartVaultUnpaused();
/**
* @dev The token is zero
*/
error SmartVaultTokenZero();
/**
* @dev The amount is zero
*/
error SmartVaultAmountZero();
/**
* @dev The recipient is zero
*/
error SmartVaultRecipientZero();
/**
* @dev The connector is deprecated
*/
error SmartVaultConnectorDeprecated(address connector);
/**
* @dev The connector is not registered
*/
error SmartVaultConnectorNotRegistered(address connector);
/**
* @dev The connector is not stateless
*/
error SmartVaultConnectorNotStateless(address connector);
/**
* @dev The connector ID is zero
*/
error SmartVaultBalanceConnectorIdZero();
/**
* @dev The balance connector's balance is lower than the requested amount to be deducted
*/
error SmartVaultBalanceConnectorInsufficientBalance(bytes32 id, address token, uint256 balance, uint256 amount);
/**
* @dev The smart vault's native token balance is lower than the requested amount to be deducted
*/
error SmartVaultInsufficientNativeTokenBalance(uint256 balance, uint256 amount);
/**
* @dev Emitted every time a smart vault is paused
*/
event Paused();
/**
* @dev Emitted every time a smart vault is unpaused
*/
event Unpaused();
/**
* @dev Emitted every time the price oracle is set
*/
event PriceOracleSet(address indexed priceOracle);
/**
* @dev Emitted every time a connector check is overridden
*/
event ConnectorCheckOverridden(address indexed connector, bool ignored);
/**
* @dev Emitted every time a balance connector is updated
*/
event BalanceConnectorUpdated(bytes32 indexed id, address indexed token, uint256 amount, bool added);
/**
* @dev Emitted every time `execute` is called
*/
event Executed(address indexed connector, bytes data, bytes result);
/**
* @dev Emitted every time `call` is called
*/
event Called(address indexed target, bytes data, uint256 value, bytes result);
/**
* @dev Emitted every time `wrap` is called
*/
event Wrapped(uint256 amount);
/**
* @dev Emitted every time `unwrap` is called
*/
event Unwrapped(uint256 amount);
/**
* @dev Emitted every time `collect` is called
*/
event Collected(address indexed token, address indexed from, uint256 amount);
/**
* @dev Emitted every time `withdraw` is called
*/
event Withdrawn(address indexed token, address indexed recipient, uint256 amount, uint256 fee);
/**
* @dev Tells if the smart vault is paused or not
*/
function isPaused() external view returns (bool);
/**
* @dev Tells the address of the price oracle
*/
function priceOracle() external view returns (address);
/**
* @dev Tells the address of the Mimic's registry
*/
function registry() external view returns (address);
/**
* @dev Tells the address of the Mimic's fee controller
*/
function feeController() external view returns (address);
/**
* @dev Tells the address of the wrapped native token
*/
function wrappedNativeToken() external view returns (address);
/**
* @dev Tells if a connector check is ignored
* @param connector Address of the connector being queried
*/
function isConnectorCheckIgnored(address connector) external view returns (bool);
/**
* @dev Tells the balance to a balance connector for a token
* @param id Balance connector identifier
* @param token Address of the token querying the balance connector for
*/
function getBalanceConnector(bytes32 id, address token) external view returns (uint256);
/**
* @dev Tells whether someone has any permission over the smart vault
*/
function hasPermissions(address who) external view returns (bool);
/**
* @dev Pauses a smart vault
*/
function pause() external;
/**
* @dev Unpauses a smart vault
*/
function unpause() external;
/**
* @dev Sets the price oracle
* @param newPriceOracle Address of the new price oracle to be set
*/
function setPriceOracle(address newPriceOracle) external;
/**
* @dev Overrides connector checks
* @param connector Address of the connector to override its check
* @param ignored Whether the connector check should be ignored
*/
function overrideConnectorCheck(address connector, bool ignored) external;
/**
* @dev Updates a balance connector
* @param id Balance connector identifier to be updated
* @param token Address of the token to update the balance connector for
* @param amount Amount to be updated to the balance connector
* @param add Whether the balance connector should be increased or decreased
*/
function updateBalanceConnector(bytes32 id, address token, uint256 amount, bool add) external;
/**
* @dev Executes a connector inside of the Smart Vault context
* @param connector Address of the connector that will be executed
* @param data Call data to be used for the delegate-call
* @return result Call response if it was successful, otherwise it reverts
*/
function execute(address connector, bytes memory data) external returns (bytes memory result);
/**
* @dev Executes an arbitrary call from the Smart Vault
* @param target Address where the call will be sent
* @param data Call data to be used for the call
* @param value Value in wei that will be attached to the call
* @return result Call response if it was successful, otherwise it reverts
*/
function call(address target, bytes memory data, uint256 value) external returns (bytes memory result);
/**
* @dev Wrap an amount of native tokens to the wrapped ERC20 version of it
* @param amount Amount of native tokens to be wrapped
*/
function wrap(uint256 amount) external;
/**
* @dev Unwrap an amount of wrapped native tokens
* @param amount Amount of wrapped native tokens to unwrapped
*/
function unwrap(uint256 amount) external;
/**
* @dev Collect tokens from an external account to the Smart Vault
* @param token Address of the token to be collected
* @param from Address where the tokens will be transferred from
* @param amount Amount of tokens to be transferred
*/
function collect(address token, address from, uint256 amount) external;
/**
* @dev Withdraw tokens to an external account
* @param token Address of the token to be withdrawn
* @param recipient Address where the tokens will be transferred to
* @param amount Amount of tokens to withdraw
*/
function withdraw(address token, address recipient, uint256 amount) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// ----------------------------------------------------------------------------
// DateTime Library v2.0
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library DateTime {
uint256 constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 constant SECONDS_PER_HOUR = 60 * 60;
uint256 constant SECONDS_PER_MINUTE = 60;
int256 constant OFFSET19700101 = 2440588;
uint256 constant DOW_MON = 1;
uint256 constant DOW_TUE = 2;
uint256 constant DOW_WED = 3;
uint256 constant DOW_THU = 4;
uint256 constant DOW_FRI = 5;
uint256 constant DOW_SAT = 6;
uint256 constant DOW_SUN = 7;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(uint256 year, uint256 month, uint256 day) internal pure returns (uint256 _days) {
require(year >= 1970);
int256 _year = int256(year);
int256 _month = int256(month);
int256 _day = int256(day);
int256 __days = _day - 32075 + (1461 * (_year + 4800 + (_month - 14) / 12)) / 4
+ (367 * (_month - 2 - ((_month - 14) / 12) * 12)) / 12
- (3 * ((_year + 4900 + (_month - 14) / 12) / 100)) / 4 - OFFSET19700101;
_days = uint256(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint256 _days) internal pure returns (uint256 year, uint256 month, uint256 day) {
unchecked {
int256 __days = int256(_days);
int256 L = __days + 68569 + OFFSET19700101;
int256 N = (4 * L) / 146097;
L = L - (146097 * N + 3) / 4;
int256 _year = (4000 * (L + 1)) / 1461001;
L = L - (1461 * _year) / 4 + 31;
int256 _month = (80 * L) / 2447;
int256 _day = L - (2447 * _month) / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint256(_year);
month = uint256(_month);
day = uint256(_day);
}
}
function timestampFromDate(uint256 year, uint256 month, uint256 day) internal pure returns (uint256 timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
)
internal
pure
returns (uint256 timestamp)
{
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR
+ minute * SECONDS_PER_MINUTE + second;
}
function timestampToDate(uint256 timestamp) internal pure returns (uint256 year, uint256 month, uint256 day) {
unchecked {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
}
function timestampToDateTime(uint256 timestamp)
internal
pure
returns (uint256 year, uint256 month, uint256 day, uint256 hour, uint256 minute, uint256 second)
{
unchecked {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
}
function isValidDate(uint256 year, uint256 month, uint256 day) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(uint256 year, uint256 month, uint256 day, uint256 hour, uint256 minute, uint256 second)
internal
pure
returns (bool valid)
{
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint256 timestamp) internal pure returns (bool leapYear) {
(uint256 year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint256 year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint256 timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint256 timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint256 timestamp) internal pure returns (uint256 daysInMonth) {
(uint256 year, uint256 month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint256 year, uint256 month) internal pure returns (uint256 daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint256 timestamp) internal pure returns (uint256 dayOfWeek) {
uint256 _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = ((_days + 3) % 7) + 1;
}
function getYear(uint256 timestamp) internal pure returns (uint256 year) {
(year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint256 timestamp) internal pure returns (uint256 month) {
(, month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint256 timestamp) internal pure returns (uint256 day) {
(,, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint256 timestamp) internal pure returns (uint256 hour) {
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint256 timestamp) internal pure returns (uint256 minute) {
uint256 secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint256 timestamp) internal pure returns (uint256 second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year += _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = ((month - 1) % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year -= _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = (yearMonth % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _years) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear,,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear,,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _months) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, uint256 fromMonth,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear, uint256 toMonth,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-helpers/contracts/utils/Denominations.sol';
import '@mimic-fi/v3-price-oracle/contracts/interfaces/IPriceOracle.sol';
import '@mimic-fi/v3-smart-vault/contracts/interfaces/ISmartVault.sol';
import '../interfaces/base/IBaseTask.sol';
/**
* @title BaseTask
* @dev Base task implementation with a Smart Vault reference and using the Authorizer
*/
abstract contract BaseTask is IBaseTask, Authorized {
// Smart Vault reference
address public override smartVault;
// Optional balance connector id for the previous task in the workflow
bytes32 internal previousBalanceConnectorId;
// Optional balance connector id for the next task in the workflow
bytes32 internal nextBalanceConnectorId;
/**
* @dev Base task config. Only used in the initializer.
* @param smartVault Address of the smart vault this task will reference, it cannot be changed once set
* @param previousBalanceConnectorId Balance connector id for the previous task in the workflow
* @param nextBalanceConnectorId Balance connector id for the next task in the workflow
*/
struct BaseConfig {
address smartVault;
bytes32 previousBalanceConnectorId;
bytes32 nextBalanceConnectorId;
}
/**
* @dev Initializes the base task. It does call upper contracts initializers.
* @param config Base task config
*/
function __BaseTask_init(BaseConfig memory config) internal onlyInitializing {
__Authorized_init(ISmartVault(config.smartVault).authorizer());
__BaseTask_init_unchained(config);
}
/**
* @dev Initializes the base task. It does not call upper contracts initializers.
* @param config Base task config
*/
function __BaseTask_init_unchained(BaseConfig memory config) internal onlyInitializing {
smartVault = config.smartVault;
_setBalanceConnectors(config.previousBalanceConnectorId, config.nextBalanceConnectorId);
}
/**
* @dev Tells the address from where the token amounts to execute this task are fetched.
* Since by default tasks are supposed to use balance connectors, the tokens source has to be the smart vault.
* In case a task does not need to rely on a previous balance connector, it must override this function to specify
* where it is getting its tokens from.
*/
function getTokensSource() external view virtual override returns (address) {
return smartVault;
}
/**
* @dev Tells the amount a task should use for a token. By default tasks are expected to use balance connectors.
* In case a task relies on an external tokens source, it must override how the task amount is calculated.
* @param token Address of the token being queried
*/
function getTaskAmount(address token) public view virtual override returns (uint256) {
return ISmartVault(smartVault).getBalanceConnector(previousBalanceConnectorId, token);
}
/**
* @dev Tells the previous and next balance connectors id of the previous task in the workflow
*/
function getBalanceConnectors() external view returns (bytes32 previous, bytes32 next) {
previous = previousBalanceConnectorId;
next = nextBalanceConnectorId;
}
/**
* @dev Sets the balance connectors
* @param previous Balance connector id of the previous task in the workflow
* @param next Balance connector id of the next task in the workflow
*/
function setBalanceConnectors(bytes32 previous, bytes32 next) external override authP(authParams(previous, next)) {
_setBalanceConnectors(previous, next);
}
/**
* @dev Tells the wrapped native token address if the given address is the native token
* @param token Address of the token to be checked
*/
function _wrappedIfNative(address token) internal view returns (address) {
return Denominations.isNativeToken(token) ? _wrappedNativeToken() : token;
}
/**
* @dev Tells whether a token is the native or the wrapped native token
* @param token Address of the token to be checked
*/
function _isWrappedOrNative(address token) internal view returns (bool) {
return Denominations.isNativeToken(token) || token == _wrappedNativeToken();
}
/**
* @dev Tells the wrapped native token address
*/
function _wrappedNativeToken() internal view returns (address) {
return ISmartVault(smartVault).wrappedNativeToken();
}
/**
* @dev Fetches a base/quote price from the smart vault's price oracle
* @param base Token to rate
* @param quote Token used for the price rate
*/
function _getPrice(address base, address quote) internal view virtual returns (uint256) {
address priceOracle = ISmartVault(smartVault).priceOracle();
if (priceOracle == address(0)) revert TaskSmartVaultPriceOracleNotSet(smartVault);
bytes memory extraCallData = _decodeExtraCallData();
return
extraCallData.length == 0
? IPriceOracle(priceOracle).getPrice(_wrappedIfNative(base), _wrappedIfNative(quote))
: IPriceOracle(priceOracle).getPrice(_wrappedIfNative(base), _wrappedIfNative(quote), extraCallData);
}
/**
* @dev Before base task hook
*/
function _beforeBaseTask(address token, uint256 amount) internal virtual {
_decreaseBalanceConnector(token, amount);
}
/**
* @dev After base task hook
*/
function _afterBaseTask(address, uint256) internal virtual {
emit Executed();
}
/**
* @dev Decreases the previous balance connector in the smart vault if defined
* @param token Address of the token to update the previous balance connector of
* @param amount Amount to be updated
*/
function _decreaseBalanceConnector(address token, uint256 amount) internal {
if (previousBalanceConnectorId != bytes32(0)) {
ISmartVault(smartVault).updateBalanceConnector(previousBalanceConnectorId, token, amount, false);
}
}
/**
* @dev Increases the next balance connector in the smart vault if defined
* @param token Address of the token to update the next balance connector of
* @param amount Amount to be updated
*/
function _increaseBalanceConnector(address token, uint256 amount) internal {
if (nextBalanceConnectorId != bytes32(0)) {
ISmartVault(smartVault).updateBalanceConnector(nextBalanceConnectorId, token, amount, true);
}
}
/**
* @dev Sets the balance connectors
* @param previous Balance connector id of the previous task in the workflow
* @param next Balance connector id of the next task in the workflow
*/
function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual {
if (previous == next && previous != bytes32(0)) revert TaskSameBalanceConnectors(previous);
previousBalanceConnectorId = previous;
nextBalanceConnectorId = next;
emit BalanceConnectorsSet(previous, next);
}
/**
* @dev Decodes any potential extra calldata stored in the calldata space. Tasks relying on the extra calldata
* pattern, assume that the last word of the calldata stores the extra calldata length so it can be decoded. Note
* that tasks relying on this pattern must contemplate this function may return bogus data if no extra calldata
* was given.
*/
function _decodeExtraCallData() private pure returns (bytes memory data) {
uint256 length = uint256(_decodeLastCallDataWord());
if (msg.data.length < length) return new bytes(0);
data = new bytes(length);
assembly {
calldatacopy(add(data, 0x20), sub(sub(calldatasize(), length), 0x20), length)
}
}
/**
* @dev Returns the last calldata word. This function returns zero if the calldata is not long enough.
*/
function _decodeLastCallDataWord() private pure returns (bytes32 result) {
if (msg.data.length < 36) return bytes32(0);
assembly {
result := calldataload(sub(calldatasize(), 0x20))
}
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-smart-vault/contracts/interfaces/ISmartVault.sol';
import '../interfaces/base/IGasLimitedTask.sol';
/**
* @dev Gas config for tasks. It allows setting different gas-related configs, specially useful to control relayed txs.
*/
abstract contract GasLimitedTask is IGasLimitedTask, Authorized {
using FixedPoint for uint256;
// Variable used to allow a better developer experience to reimburse tx gas cost
// solhint-disable-next-line var-name-mixedcase
uint256 private __initialGas__;
// Gas limits config
GasLimitConfig internal gasLimits;
/**
* @dev Gas limits config
* @param gasPriceLimit Gas price limit expressed in the native token
* @param priorityFeeLimit Priority fee limit expressed in the native token
* @param txCostLimit Transaction cost limit to be set
* @param txCostLimitPct Transaction cost limit percentage to be set
*/
struct GasLimitConfig {
uint256 gasPriceLimit;
uint256 priorityFeeLimit;
uint256 txCostLimit;
uint256 txCostLimitPct;
}
/**
* @dev Initializes the gas limited task. It does call upper contracts initializers.
* @param config Gas limited task config
*/
function __GasLimitedTask_init(GasLimitConfig memory config) internal onlyInitializing {
__GasLimitedTask_init_unchained(config);
}
/**
* @dev Initializes the gas limited task. It does not call upper contracts initializers.
* @param config Gas limited task config
*/
function __GasLimitedTask_init_unchained(GasLimitConfig memory config) internal onlyInitializing {
_setGasLimits(config.gasPriceLimit, config.priorityFeeLimit, config.txCostLimit, config.txCostLimitPct);
}
/**
* @dev Tells the gas limits config
*/
function getGasLimits()
external
view
returns (uint256 gasPriceLimit, uint256 priorityFeeLimit, uint256 txCostLimit, uint256 txCostLimitPct)
{
return (gasLimits.gasPriceLimit, gasLimits.priorityFeeLimit, gasLimits.txCostLimit, gasLimits.txCostLimitPct);
}
/**
* @dev Sets the gas limits config
* @param newGasPriceLimit New gas price limit to be set
* @param newPriorityFeeLimit New priority fee limit to be set
* @param newTxCostLimit New tx cost limit to be set
* @param newTxCostLimitPct New tx cost percentage limit to be set
*/
function setGasLimits(
uint256 newGasPriceLimit,
uint256 newPriorityFeeLimit,
uint256 newTxCostLimit,
uint256 newTxCostLimitPct
) external override authP(authParams(newGasPriceLimit, newPriorityFeeLimit, newTxCostLimit, newTxCostLimitPct)) {
_setGasLimits(newGasPriceLimit, newPriorityFeeLimit, newTxCostLimit, newTxCostLimitPct);
}
/**
* @dev Fetches a base/quote price
*/
function _getPrice(address base, address quote) internal view virtual returns (uint256);
/**
* @dev Initializes gas limited tasks and validates gas price limit
*/
function _beforeGasLimitedTask(address, uint256) internal virtual {
__initialGas__ = gasleft();
GasLimitConfig memory config = gasLimits;
bool isGasPriceAllowed = config.gasPriceLimit == 0 || tx.gasprice <= config.gasPriceLimit;
if (!isGasPriceAllowed) revert TaskGasPriceLimitExceeded(tx.gasprice, config.gasPriceLimit);
if (config.priorityFeeLimit > 0) {
uint256 priorityFee = tx.gasprice - block.basefee;
bool isPriorityFeeAllowed = priorityFee <= config.priorityFeeLimit;
if (!isPriorityFeeAllowed) revert TaskPriorityFeeLimitExceeded(priorityFee, config.priorityFeeLimit);
}
}
/**
* @dev Validates transaction cost limit
*/
function _afterGasLimitedTask(address token, uint256 amount) internal virtual {
if (__initialGas__ == 0) revert TaskGasNotInitialized();
GasLimitConfig memory config = gasLimits;
uint256 totalGas = __initialGas__ - gasleft();
uint256 totalCost = totalGas * tx.gasprice;
bool isTxCostAllowed = config.txCostLimit == 0 || totalCost <= config.txCostLimit;
if (!isTxCostAllowed) revert TaskTxCostLimitExceeded(totalCost, config.txCostLimit);
delete __initialGas__;
if (config.txCostLimitPct > 0 && amount > 0) {
uint256 price = _getPrice(ISmartVault(this.smartVault()).wrappedNativeToken(), token);
uint256 totalCostInToken = totalCost.mulUp(price);
uint256 txCostPct = totalCostInToken.divUp(amount);
if (txCostPct > config.txCostLimitPct) revert TaskTxCostLimitPctExceeded(txCostPct, config.txCostLimitPct);
}
}
/**
* @dev Sets the gas limits config
* @param newGasPriceLimit New gas price limit to be set
* @param newPriorityFeeLimit New priority fee limit to be set
* @param newTxCostLimit New tx cost limit to be set
* @param newTxCostLimitPct New tx cost percentage limit to be set
*/
function _setGasLimits(
uint256 newGasPriceLimit,
uint256 newPriorityFeeLimit,
uint256 newTxCostLimit,
uint256 newTxCostLimitPct
) internal {
if (newTxCostLimitPct > FixedPoint.ONE) revert TaskTxCostLimitPctAboveOne();
gasLimits.gasPriceLimit = newGasPriceLimit;
gasLimits.priorityFeeLimit = newPriorityFeeLimit;
gasLimits.txCostLimit = newTxCostLimit;
gasLimits.txCostLimitPct = newTxCostLimitPct;
emit GasLimitsSet(newGasPriceLimit, newPriorityFeeLimit, newTxCostLimit, newTxCostLimitPct);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '../interfaces/base/IPausableTask.sol';
/**
* @dev Pausable config for tasks
*/
abstract contract PausableTask is IPausableTask, Authorized {
using FixedPoint for uint256;
// Whether the task is paused or not
bool public override isPaused;
/**
* @dev Initializes the pausable task. It does call upper contracts initializers.
*/
function __PausableTask_init() internal onlyInitializing {
__PausableTask_init_unchained();
}
/**
* @dev Initializes the pausable task. It does not call upper contracts initializers.
*/
function __PausableTask_init_unchained() internal onlyInitializing {
// solhint-disable-previous-line no-empty-blocks
}
/**
* @dev Pauses a task
*/
function pause() external override auth {
if (isPaused) revert TaskPaused();
isPaused = true;
emit Paused();
}
/**
* @dev Unpauses a task
*/
function unpause() external override auth {
if (!isPaused) revert TaskUnpaused();
isPaused = false;
emit Unpaused();
}
/**
* @dev Before pausable task hook
*/
function _beforePausableTask(address, uint256) internal virtual {
if (isPaused) revert TaskPaused();
}
/**
* @dev After pausable task hook
*/
function _afterPausableTask(address, uint256) internal virtual {
// solhint-disable-previous-line no-empty-blocks
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.3;
import '@quant-finance/solidity-datetime/contracts/DateTime.sol';
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '../interfaces/base/ITimeLockedTask.sol';
/**
* @dev Time lock config for tasks. It allows limiting the frequency of a task.
*/
abstract contract TimeLockedTask is ITimeLockedTask, Authorized {
using DateTime for uint256;
uint256 private constant DAYS_28 = 60 * 60 * 24 * 28;
/**
* @dev Time-locks supports different frequency modes
* @param Seconds To indicate the execution must occur every certain number of seconds
* @param OnDay To indicate the execution must occur on day number from 1 to 28 every certain months
* @param OnLastMonthDay To indicate the execution must occur on the last day of the month every certain months
*/
enum Mode {
Seconds,
OnDay,
OnLastMonthDay
}
// Time lock mode
Mode internal _mode;
// Time lock frequency
uint256 internal _frequency;
// Future timestamp since when the task can be executed
uint256 internal _allowedAt;
// Next future timestamp since when the task can be executed to be set, only used internally
uint256 internal _nextAllowedAt;
// Period in seconds during when a time-locked task can be executed since the allowed timestamp
uint256 internal _window;
/**
* @dev Time lock config params. Only used in the initializer.
* @param mode Time lock mode
* @param frequency Time lock frequency value
* @param allowedAt Time lock allowed date
* @param window Time lock execution window
*/
struct TimeLockConfig {
uint8 mode;
uint256 frequency;
uint256 allowedAt;
uint256 window;
}
/**
* @dev Initializes the time locked task. It does not call upper contracts initializers.
* @param config Time locked task config
*/
function __TimeLockedTask_init(TimeLockConfig memory config) internal onlyInitializing {
__TimeLockedTask_init_unchained(config);
}
/**
* @dev Initializes the time locked task. It does call upper contracts initializers.
* @param config Time locked task config
*/
function __TimeLockedTask_init_unchained(TimeLockConfig memory config) internal onlyInitializing {
_setTimeLock(config.mode, config.frequency, config.allowedAt, config.window);
}
/**
* @dev Tells the time-lock related information
*/
function getTimeLock() external view returns (uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window) {
return (uint8(_mode), _frequency, _allowedAt, _window);
}
/**
* @dev Sets a new time lock
*/
function setTimeLock(uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window)
external
override
authP(authParams(mode, frequency, allowedAt, window))
{
_setTimeLock(mode, frequency, allowedAt, window);
}
/**
* @dev Before time locked task hook
*/
function _beforeTimeLockedTask(address, uint256) internal virtual {
// Load storage variables
Mode mode = _mode;
uint256 frequency = _frequency;
uint256 allowedAt = _allowedAt;
uint256 window = _window;
// First we check the current timestamp is not in the past
if (block.timestamp < allowedAt) revert TaskTimeLockActive(block.timestamp, allowedAt);
if (mode == Mode.Seconds) {
if (frequency == 0) return;
// If no window is set, the next allowed date is simply moved the number of seconds set as frequency.
// Otherwise, the offset must be validated and the next allowed date is set to the next period.
if (window == 0) _nextAllowedAt = block.timestamp + frequency;
else {
uint256 diff = block.timestamp - allowedAt;
uint256 periods = diff / frequency;
uint256 offset = diff - (periods * frequency);
if (offset > window) revert TaskTimeLockActive(block.timestamp, allowedAt);
_nextAllowedAt = allowedAt + ((periods + 1) * frequency);
}
} else {
if (block.timestamp >= allowedAt && block.timestamp <= allowedAt + window) {
// Check the current timestamp has not passed the allowed date set
_nextAllowedAt = _getNextAllowedDate(allowedAt, frequency);
} else {
// Check the current timestamp is not before the current allowed date
uint256 currentAllowedDay = mode == Mode.OnDay ? allowedAt.getDay() : block.timestamp.getDaysInMonth();
uint256 currentAllowedAt = _getCurrentAllowedDate(allowedAt, currentAllowedDay);
if (block.timestamp < currentAllowedAt) revert TaskTimeLockActive(block.timestamp, currentAllowedAt);
// Check the current timestamp has not passed the allowed execution window
uint256 extendedCurrentAllowedAt = currentAllowedAt + window;
bool exceedsExecutionWindow = block.timestamp > extendedCurrentAllowedAt;
if (exceedsExecutionWindow) revert TaskTimeLockActive(block.timestamp, extendedCurrentAllowedAt);
// Finally set the next allowed date to the corresponding number of months from the current date
_nextAllowedAt = _getNextAllowedDate(currentAllowedAt, frequency);
}
}
}
/**
* @dev After time locked task hook
*/
function _afterTimeLockedTask(address, uint256) internal virtual {
if (_nextAllowedAt == 0) return;
_setTimeLockAllowedAt(_nextAllowedAt);
_nextAllowedAt = 0;
}
/**
* @dev Sets a new time lock
*/
function _setTimeLock(uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window) internal {
if (mode == uint8(Mode.Seconds)) {
// The execution window and timestamp are optional, but both must be given or none
// If given the execution window cannot be larger than the number of seconds
// Also, if these are given the frequency must be checked as well, otherwise it could be unsetting the lock
if (window > 0 || allowedAt > 0) {
if (frequency == 0) revert TaskInvalidFrequency(mode, frequency);
if (window == 0 || window > frequency) revert TaskInvalidAllowedWindow(mode, window);
if (allowedAt == 0) revert TaskInvalidAllowedDate(mode, allowedAt);
}
} else {
// The other modes can be "on-day" or "on-last-day" where the frequency represents a number of months
// There is no limit for the frequency, it simply cannot be zero
if (frequency == 0) revert TaskInvalidFrequency(mode, frequency);
// The execution window cannot be larger than the number of months considering months of 28 days
if (window == 0 || window > frequency * DAYS_28) revert TaskInvalidAllowedWindow(mode, window);
// The allowed date cannot be zero
if (allowedAt == 0) revert TaskInvalidAllowedDate(mode, allowedAt);
// If the mode is "on-day", the allowed date must be valid for every month, then the allowed day cannot be
// larger than 28. But if the mode is "on-last-day", the allowed date day must be the last day of the month
if (mode == uint8(Mode.OnDay)) {
if (allowedAt.getDay() > 28) revert TaskInvalidAllowedDate(mode, allowedAt);
} else if (mode == uint8(Mode.OnLastMonthDay)) {
if (allowedAt.getDay() != allowedAt.getDaysInMonth()) revert TaskInvalidAllowedDate(mode, allowedAt);
} else {
revert TaskInvalidFrequencyMode(mode);
}
}
_mode = Mode(mode);
_frequency = frequency;
_allowedAt = allowedAt;
_window = window;
emit TimeLockSet(mode, frequency, allowedAt, window);
}
/**
* @dev Sets the time-lock execution allowed timestamp
* @param allowedAt New execution allowed timestamp to be set
*/
function _setTimeLockAllowedAt(uint256 allowedAt) internal {
_allowedAt = allowedAt;
emit TimeLockAllowedAtSet(allowedAt);
}
/**
* @dev Tells the corresponding allowed date based on a current timestamp
*/
function _getCurrentAllowedDate(uint256 allowedAt, uint256 day) private view returns (uint256) {
(uint256 year, uint256 month, ) = block.timestamp.timestampToDate();
return _getAllowedDateFor(allowedAt, year, month, day);
}
/**
* @dev Tells the next allowed date based on a current allowed date considering a number of months to increase
*/
function _getNextAllowedDate(uint256 allowedAt, uint256 monthsToIncrease) private view returns (uint256) {
(uint256 year, uint256 month, uint256 day) = allowedAt.timestampToDate();
uint256 increasedMonth = month + monthsToIncrease;
uint256 nextMonth = increasedMonth % 12;
uint256 nextYear = year + (increasedMonth / 12);
uint256 nextDay = _mode == Mode.OnLastMonthDay ? DateTime._getDaysInMonth(nextYear, nextMonth) : day;
return _getAllowedDateFor(allowedAt, nextYear, nextMonth, nextDay);
}
/**
* @dev Builds an allowed date using a specific year, month, and day
*/
function _getAllowedDateFor(uint256 allowedAt, uint256 year, uint256 month, uint256 day)
private
pure
returns (uint256)
{
return
DateTime.timestampFromDateTime(
year,
month,
day,
allowedAt.getHour(),
allowedAt.getMinute(),
allowedAt.getSecond()
);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.3;
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '../interfaces/base/ITokenIndexedTask.sol';
/**
* @dev Token indexed task. It defines a token acceptance list to tell which are the tokens supported by the
* task. Tokens acceptance can be configured either as an allow list or as a deny list.
*/
abstract contract TokenIndexedTask is ITokenIndexedTask, Authorized {
using EnumerableSet for EnumerableSet.AddressSet;
// Acceptance list type
TokensAcceptanceType public override tokensAcceptanceType;
// Enumerable set of tokens included in the acceptance list
EnumerableSet.AddressSet internal _tokens;
/**
* @dev Token index config. Only used in the initializer.
* @param acceptanceType Token acceptance type to be set
* @param tokens List of token addresses to be set for the acceptance list
*/
struct TokenIndexConfig {
TokensAcceptanceType acceptanceType;
address[] tokens;
}
/**
* @dev Initializes the token indexed task. It does not call upper contracts initializers.
* @param config Token indexed task config
*/
function __TokenIndexedTask_init(TokenIndexConfig memory config) internal onlyInitializing {
__TokenIndexedTask_init_unchained(config);
}
/**
* @dev Initializes the token indexed task. It does call upper contracts initializers.
* @param config Token indexed task config
*/
function __TokenIndexedTask_init_unchained(TokenIndexConfig memory config) internal onlyInitializing {
_setTokensAcceptanceType(config.acceptanceType);
for (uint256 i = 0; i < config.tokens.length; i++) {
_setTokenAcceptanceList(config.tokens[i], true);
}
}
/**
* @dev Tells whether a token is allowed or not
* @param token Address of the token being queried
*/
function isTokenAllowed(address token) public view override returns (bool) {
bool containsToken = _tokens.contains(token);
return tokensAcceptanceType == TokensAcceptanceType.AllowList ? containsToken : !containsToken;
}
/**
* @dev Sets the tokens acceptance type of the task
* @param newTokensAcceptanceType New token acceptance type to be set
*/
function setTokensAcceptanceType(TokensAcceptanceType newTokensAcceptanceType)
external
override
authP(authParams(uint8(newTokensAcceptanceType)))
{
_setTokensAcceptanceType(newTokensAcceptanceType);
}
/**
* @dev Updates the list of tokens of the tokens acceptance list
* @param tokens List of tokens to be updated from the acceptance list
* @param added Whether each of the given tokens should be added or removed from the list
*/
function setTokensAcceptanceList(address[] memory tokens, bool[] memory added) external override auth {
if (tokens.length != added.length) revert TaskAcceptanceInputLengthMismatch();
for (uint256 i = 0; i < tokens.length; i++) {
_setTokenAcceptanceList(tokens[i], added[i]);
}
}
/**
* @dev Before token indexed task hook
*/
function _beforeTokenIndexedTask(address token, uint256) internal virtual {
if (!isTokenAllowed(token)) revert TaskTokenNotAllowed(token);
}
/**
* @dev After token indexed task hook
*/
function _afterTokenIndexedTask(address token, uint256) internal virtual {
// solhint-disable-previous-line no-empty-blocks
}
/**
* @dev Sets the tokens acceptance type of the task
* @param newTokensAcceptanceType New token acceptance type to be set
*/
function _setTokensAcceptanceType(TokensAcceptanceType newTokensAcceptanceType) internal {
tokensAcceptanceType = newTokensAcceptanceType;
emit TokensAcceptanceTypeSet(newTokensAcceptanceType);
}
/**
* @dev Updates a token from the tokens acceptance list
* @param token Token to be updated from the acceptance list
* @param added Whether the token should be added or removed from the list
*/
function _setTokenAcceptanceList(address token, bool added) internal {
if (token == address(0)) revert TaskAcceptanceTokenZero();
added ? _tokens.add(token) : _tokens.remove(token);
emit TokensAcceptanceListSet(token, added);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.3;
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '../interfaces/base/ITokenThresholdTask.sol';
/**
* @dev Token threshold task. It mainly works with token threshold configs that can be used to tell if
* a specific token amount is compliant with certain minimum or maximum values. Token threshold tasks
* make use of a default threshold config as a fallback in case there is no custom threshold defined for the token
* being evaluated.
*/
abstract contract TokenThresholdTask is ITokenThresholdTask, Authorized {
using FixedPoint for uint256;
// Default threshold
Threshold internal _defaultThreshold;
// Custom thresholds per token
mapping (address => Threshold) internal _customThresholds;
/**
* @dev Threshold defined by a token address and min/max values
*/
struct Threshold {
address token;
uint256 min;
uint256 max;
}
/**
* @dev Custom token threshold config. Only used in the initializer.
*/
struct CustomThresholdConfig {
address token;
Threshold threshold;
}
/**
* @dev Token threshold config. Only used in the initializer.
* @param defaultThreshold Default threshold to be set
* @param customThresholdConfigs List of custom threshold configs to be set
*/
struct TokenThresholdConfig {
Threshold defaultThreshold;
CustomThresholdConfig[] customThresholdConfigs;
}
/**
* @dev Initializes the token threshold task. It does not call upper contracts initializers.
* @param config Token threshold task config
*/
function __TokenThresholdTask_init(TokenThresholdConfig memory config) internal onlyInitializing {
__TokenThresholdTask_init_unchained(config);
}
/**
* @dev Initializes the token threshold task. It does call upper contracts initializers.
* @param config Token threshold task config
*/
function __TokenThresholdTask_init_unchained(TokenThresholdConfig memory config) internal onlyInitializing {
Threshold memory defaultThreshold = config.defaultThreshold;
_setDefaultTokenThreshold(defaultThreshold.token, defaultThreshold.min, defaultThreshold.max);
for (uint256 i = 0; i < config.customThresholdConfigs.length; i++) {
CustomThresholdConfig memory customThresholdConfig = config.customThresholdConfigs[i];
Threshold memory custom = customThresholdConfig.threshold;
_setCustomTokenThreshold(customThresholdConfig.token, custom.token, custom.min, custom.max);
}
}
/**
* @dev Tells the default token threshold
*/
function defaultTokenThreshold() external view override returns (address thresholdToken, uint256 min, uint256 max) {
Threshold memory threshold = _defaultThreshold;
return (threshold.token, threshold.min, threshold.max);
}
/**
* @dev Tells the token threshold defined for a specific token
* @param token Address of the token being queried
*/
function customTokenThreshold(address token)
external
view
override
returns (address thresholdToken, uint256 min, uint256 max)
{
Threshold memory threshold = _customThresholds[token];
return (threshold.token, threshold.min, threshold.max);
}
/**
* @dev Tells the threshold that should be used for a token, it prioritizes custom thresholds over the default one
* @param token Address of the token being queried
*/
function getTokenThreshold(address token)
external
view
virtual
override
returns (address thresholdToken, uint256 min, uint256 max)
{
Threshold memory threshold = _getTokenThreshold(token);
return (threshold.token, threshold.min, threshold.max);
}
/**
* @dev Sets a new default threshold config
* @param thresholdToken New threshold token to be set
* @param min New threshold minimum to be set
* @param max New threshold maximum to be set
*/
function setDefaultTokenThreshold(address thresholdToken, uint256 min, uint256 max)
external
override
authP(authParams(thresholdToken, min, max))
{
_setDefaultTokenThreshold(thresholdToken, min, max);
}
/**
* @dev Sets a custom token threshold
* @param token Address of the token to set a custom threshold for
* @param thresholdToken New custom threshold token to be set
* @param min New custom threshold minimum to be set
* @param max New custom threshold maximum to be set
*/
function setCustomTokenThreshold(address token, address thresholdToken, uint256 min, uint256 max)
external
override
authP(authParams(token, thresholdToken, min, max))
{
_setCustomTokenThreshold(token, thresholdToken, min, max);
}
/**
* @dev Fetches a base/quote price
*/
function _getPrice(address base, address quote) internal view virtual returns (uint256);
/**
* @dev Tells the threshold that should be used for a token, it prioritizes custom thresholds over the default one
* @param token Address of the token being queried
*/
function _getTokenThreshold(address token) internal view returns (Threshold memory) {
Threshold storage customThreshold = _customThresholds[token];
return customThreshold.token == address(0) ? _defaultThreshold : customThreshold;
}
/**
* @dev Before token threshold task hook
*/
function _beforeTokenThresholdTask(address token, uint256 amount) internal virtual {
Threshold memory threshold = _getTokenThreshold(token);
if (threshold.token == address(0)) return;
uint256 convertedAmount = threshold.token == token ? amount : amount.mulDown(_getPrice(token, threshold.token));
bool isValid = convertedAmount >= threshold.min && (threshold.max == 0 || convertedAmount <= threshold.max);
if (!isValid) revert TaskTokenThresholdNotMet(threshold.token, convertedAmount, threshold.min, threshold.max);
}
/**
* @dev After token threshold task hook
*/
function _afterTokenThresholdTask(address, uint256) internal virtual {
// solhint-disable-previous-line no-empty-blocks
}
/**
* @dev Sets a new default threshold config
* @param thresholdToken New threshold token to be set
* @param min New threshold minimum to be set
* @param max New threshold maximum to be set
*/
function _setDefaultTokenThreshold(address thresholdToken, uint256 min, uint256 max) internal {
_setTokenThreshold(_defaultThreshold, thresholdToken, min, max);
emit DefaultTokenThresholdSet(thresholdToken, min, max);
}
/**
* @dev Sets a custom of tokens thresholds
* @param token Address of the token to set a custom threshold for
* @param thresholdToken New custom threshold token to be set
* @param min New custom threshold minimum to be set
* @param max New custom threshold maximum to be set
*/
function _setCustomTokenThreshold(address token, address thresholdToken, uint256 min, uint256 max) internal {
if (token == address(0)) revert TaskThresholdTokenZero();
_setTokenThreshold(_customThresholds[token], thresholdToken, min, max);
emit CustomTokenThresholdSet(token, thresholdToken, min, max);
}
/**
* @dev Sets a threshold
* @param threshold Threshold to be updated
* @param token New threshold token to be set
* @param min New threshold minimum to be set
* @param max New threshold maximum to be set
*/
function _setTokenThreshold(Threshold storage threshold, address token, uint256 min, uint256 max) private {
// If there is no threshold, all values must be zero
bool isZeroThreshold = token == address(0) && min == 0 && max == 0;
bool isNonZeroThreshold = token != address(0) && (max == 0 || max >= min);
if (!isZeroThreshold && !isNonZeroThreshold) revert TaskInvalidThresholdInput(token, min, max);
threshold.token = token;
threshold.min = min;
threshold.max = max;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.17;
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '../interfaces/base/IVolumeLimitedTask.sol';
/**
* @dev Volume limit config for tasks. It allows setting volume limit per period of time.
*/
abstract contract VolumeLimitedTask is IVolumeLimitedTask, Authorized {
using FixedPoint for uint256;
// Default volume limit
VolumeLimit internal _defaultVolumeLimit;
// Custom volume limits per token
mapping (address => VolumeLimit) internal _customVolumeLimits;
/**
* @dev Volume limit config
* @param token Address to measure the volume limit
*/
struct VolumeLimit {
address token;
uint256 amount;
uint256 accrued;
uint256 period;
uint256 nextResetTime;
}
/**
* @dev Volume limit params. Only used in the initializer.
*/
struct VolumeLimitParams {
address token;
uint256 amount;
uint256 period;
}
/**
* @dev Custom token volume limit config. Only used in the initializer.
*/
struct CustomVolumeLimitConfig {
address token;
VolumeLimitParams volumeLimit;
}
/**
* @dev Volume limit config. Only used in the initializer.
*/
struct VolumeLimitConfig {
VolumeLimitParams defaultVolumeLimit;
CustomVolumeLimitConfig[] customVolumeLimitConfigs;
}
/**
* @dev Initializes the volume limited task. It does call upper contracts initializers.
* @param config Volume limited task config
*/
function __VolumeLimitedTask_init(VolumeLimitConfig memory config) internal onlyInitializing {
__VolumeLimitedTask_init_unchained(config);
}
/**
* @dev Initializes the volume limited task. It does not call upper contracts initializers.
* @param config Volume limited task config
*/
function __VolumeLimitedTask_init_unchained(VolumeLimitConfig memory config) internal onlyInitializing {
VolumeLimitParams memory defaultLimit = config.defaultVolumeLimit;
_setDefaultVolumeLimit(defaultLimit.token, defaultLimit.amount, defaultLimit.period);
for (uint256 i = 0; i < config.customVolumeLimitConfigs.length; i++) {
CustomVolumeLimitConfig memory customVolumeLimitConfig = config.customVolumeLimitConfigs[i];
VolumeLimitParams memory custom = customVolumeLimitConfig.volumeLimit;
_setCustomVolumeLimit(customVolumeLimitConfig.token, custom.token, custom.amount, custom.period);
}
}
/**
* @dev Tells the default volume limit set
*/
function defaultVolumeLimit()
external
view
override
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime)
{
VolumeLimit memory limit = _defaultVolumeLimit;
return (limit.token, limit.amount, limit.accrued, limit.period, limit.nextResetTime);
}
/**
* @dev Tells the custom volume limit set for a specific token
* @param token Address of the token being queried
*/
function customVolumeLimit(address token)
external
view
override
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime)
{
VolumeLimit memory limit = _customVolumeLimits[token];
return (limit.token, limit.amount, limit.accrued, limit.period, limit.nextResetTime);
}
/**
* @dev Tells the volume limit that should be used for a token, it prioritizes custom limits over the default one
* @param token Address of the token being queried
*/
function getVolumeLimit(address token)
external
view
override
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime)
{
VolumeLimit memory limit = _getVolumeLimit(token);
return (limit.token, limit.amount, limit.accrued, limit.period, limit.nextResetTime);
}
/**
* @dev Sets a the default volume limit config
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function setDefaultVolumeLimit(address limitToken, uint256 limitAmount, uint256 limitPeriod)
external
override
authP(authParams(limitToken, limitAmount, limitPeriod))
{
_setDefaultVolumeLimit(limitToken, limitAmount, limitPeriod);
}
/**
* @dev Sets a custom volume limit
* @param token Address of the token to set a custom volume limit for
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function setCustomVolumeLimit(address token, address limitToken, uint256 limitAmount, uint256 limitPeriod)
external
override
authP(authParams(token, limitToken, limitAmount, limitPeriod))
{
_setCustomVolumeLimit(token, limitToken, limitAmount, limitPeriod);
}
/**
* @dev Fetches a base/quote price
*/
function _getPrice(address base, address quote) internal view virtual returns (uint256);
/**
* @dev Tells the volume limit that should be used for a token, it prioritizes custom limits over the default one
* @param token Address of the token being queried
*/
function _getVolumeLimit(address token) internal view returns (VolumeLimit storage) {
VolumeLimit storage customLimit = _customVolumeLimits[token];
return customLimit.token == address(0) ? _defaultVolumeLimit : customLimit;
}
/**
* @dev Before volume limited task hook
*/
function _beforeVolumeLimitedTask(address token, uint256 amount) internal virtual {
VolumeLimit memory limit = _getVolumeLimit(token);
if (limit.token == address(0)) return;
uint256 amountInLimitToken = limit.token == token ? amount : amount.mulDown(_getPrice(token, limit.token));
uint256 processedVolume = amountInLimitToken + (block.timestamp < limit.nextResetTime ? limit.accrued : 0);
if (processedVolume > limit.amount) revert TaskVolumeLimitExceeded(limit.token, limit.amount, processedVolume);
}
/**
* @dev After volume limited task hook
*/
function _afterVolumeLimitedTask(address token, uint256 amount) internal virtual {
VolumeLimit storage limit = _getVolumeLimit(token);
if (limit.token == address(0)) return;
uint256 amountInLimitToken = limit.token == token ? amount : amount.mulDown(_getPrice(token, limit.token));
if (block.timestamp >= limit.nextResetTime) {
limit.accrued = 0;
limit.nextResetTime = block.timestamp + limit.period;
}
limit.accrued += amountInLimitToken;
}
/**
* @dev Sets the default volume limit
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function _setDefaultVolumeLimit(address limitToken, uint256 limitAmount, uint256 limitPeriod) internal {
_setVolumeLimit(_defaultVolumeLimit, limitToken, limitAmount, limitPeriod);
emit DefaultVolumeLimitSet(limitToken, limitAmount, limitPeriod);
}
/**
* @dev Sets a custom volume limit
* @param token Address of the token to set a custom volume limit for
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function _setCustomVolumeLimit(address token, address limitToken, uint256 limitAmount, uint256 limitPeriod)
internal
{
if (token == address(0)) revert TaskVolumeLimitTokenZero();
_setVolumeLimit(_customVolumeLimits[token], limitToken, limitAmount, limitPeriod);
emit CustomVolumeLimitSet(token, limitToken, limitAmount, limitPeriod);
}
/**
* @dev Sets a volume limit
* @param limit Volume limit to be updated
* @param token Address of the token to measure the volume limit
* @param amount Amount of tokens to be applied for the volume limit
* @param period Frequency to Amount of tokens to be applied for the volume limit
*/
function _setVolumeLimit(VolumeLimit storage limit, address token, uint256 amount, uint256 period) private {
// If there is no limit, all values must be zero
bool isZeroLimit = token == address(0) && amount == 0 && period == 0;
bool isNonZeroLimit = token != address(0) && amount > 0 && period > 0;
if (!isZeroLimit && !isNonZeroLimit) revert TaskInvalidVolumeLimitInput(token, amount, period);
// Changing the period only affects the end time of the next period, but not the end date of the current one
limit.period = period;
// Changing the amount does not affect the totalizator, it only applies when updating the accrued amount.
// Note that it can happen that the new amount is lower than the accrued amount if the amount is lowered.
// However, there shouldn't be any accounting issues with that.
limit.amount = amount;
// Therefore, only clean the totalizators if the limit is being removed
if (isZeroLimit) {
limit.accrued = 0;
limit.nextResetTime = 0;
} else {
// If limit is not zero, set the next reset time if it wasn't set already
// Otherwise, if the token is being changed the accrued amount must be updated accordingly
if (limit.nextResetTime == 0) {
limit.accrued = 0;
limit.nextResetTime = block.timestamp + period;
} else if (limit.token != token) {
uint256 price = _getPrice(limit.token, token);
limit.accrued = limit.accrued.mulDown(price);
}
}
// Finally simply set the new requested token
limit.token = token;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorized.sol';
/**
* @dev Base task interface
*/
interface IBaseTask is IAuthorized {
// Execution type serves for relayers in order to distinguish how each task must be executed
// solhint-disable-next-line func-name-mixedcase
function EXECUTION_TYPE() external view returns (bytes32);
/**
* @dev The balance connectors are the same
*/
error TaskSameBalanceConnectors(bytes32 connectorId);
/**
* @dev The smart vault's price oracle is not set
*/
error TaskSmartVaultPriceOracleNotSet(address smartVault);
/**
* @dev Emitted every time a task is executed
*/
event Executed();
/**
* @dev Emitted every time the balance connectors are set
*/
event BalanceConnectorsSet(bytes32 indexed previous, bytes32 indexed next);
/**
* @dev Tells the address of the Smart Vault tied to it, it cannot be changed
*/
function smartVault() external view returns (address);
/**
* @dev Tells the address from where the token amounts to execute this task are fetched.
* This address must be the Smart Vault in case the previous balance connector is set.
*/
function getTokensSource() external view returns (address);
/**
* @dev Tells the amount a task should use for a token
* @param token Address of the token being queried
*/
function getTaskAmount(address token) external view returns (uint256);
/**
* @dev Tells the previous and next balance connectors id of the previous task in the workflow
*/
function getBalanceConnectors() external view returns (bytes32 previous, bytes32 next);
/**
* @dev Sets the balance connector IDs
* @param previous Balance connector id of the previous task in the workflow
* @param next Balance connector id of the next task in the workflow
*/
function setBalanceConnectors(bytes32 previous, bytes32 next) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Gas limited task interface
*/
interface IGasLimitedTask is IBaseTask {
/**
* @dev The tx initial gas cache has not been initialized
*/
error TaskGasNotInitialized();
/**
* @dev The gas price used is greater than the limit
*/
error TaskGasPriceLimitExceeded(uint256 gasPrice, uint256 gasPriceLimit);
/**
* @dev The priority fee used is greater than the priority fee limit
*/
error TaskPriorityFeeLimitExceeded(uint256 priorityFee, uint256 priorityFeeLimit);
/**
* @dev The transaction cost is greater than the transaction cost limit
*/
error TaskTxCostLimitExceeded(uint256 txCost, uint256 txCostLimit);
/**
* @dev The transaction cost percentage is greater than the transaction cost limit percentage
*/
error TaskTxCostLimitPctExceeded(uint256 txCostPct, uint256 txCostLimitPct);
/**
* @dev The new transaction cost limit percentage is greater than one
*/
error TaskTxCostLimitPctAboveOne();
/**
* @dev Emitted every time the gas limits are set
*/
event GasLimitsSet(uint256 gasPriceLimit, uint256 priorityFeeLimit, uint256 txCostLimit, uint256 txCostLimitPct);
/**
* @dev Tells the gas limits config
*/
function getGasLimits()
external
view
returns (uint256 gasPriceLimit, uint256 priorityFeeLimit, uint256 txCostLimit, uint256 txCostLimitPct);
/**
* @dev Sets the gas limits config
* @param newGasPriceLimit New gas price limit to be set
* @param newPriorityFeeLimit New priority fee limit to be set
* @param newTxCostLimit New tx cost limit to be set
* @param newTxCostLimitPct New tx cost percentage limit to be set
*/
function setGasLimits(
uint256 newGasPriceLimit,
uint256 newPriorityFeeLimit,
uint256 newTxCostLimit,
uint256 newTxCostLimitPct
) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Pausable task interface
*/
interface IPausableTask is IBaseTask {
/**
* @dev The task is paused
*/
error TaskPaused();
/**
* @dev The task is unpaused
*/
error TaskUnpaused();
/**
* @dev Emitted every time a task is paused
*/
event Paused();
/**
* @dev Emitted every time a task is unpaused
*/
event Unpaused();
/**
* @dev Tells the task is paused or not
*/
function isPaused() external view returns (bool);
/**
* @dev Pauses a task
*/
function pause() external;
/**
* @dev Unpauses a task
*/
function unpause() external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Time-locked task interface
*/
interface ITimeLockedTask is IBaseTask {
/**
* @dev The time lock frequency mode requested is invalid
*/
error TaskInvalidFrequencyMode(uint8 mode);
/**
* @dev The time lock frequency is not valid
*/
error TaskInvalidFrequency(uint8 mode, uint256 frequency);
/**
* @dev The time lock allowed date is not valid
*/
error TaskInvalidAllowedDate(uint8 mode, uint256 date);
/**
* @dev The time lock allowed window is not valid
*/
error TaskInvalidAllowedWindow(uint8 mode, uint256 window);
/**
* @dev The time lock is still active
*/
error TaskTimeLockActive(uint256 currentTimestamp, uint256 expiration);
/**
* @dev Emitted every time a new time lock is set
*/
event TimeLockSet(uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window);
/**
* @dev Emitted every time a new expiration timestamp is set
*/
event TimeLockAllowedAtSet(uint256 allowedAt);
/**
* @dev Tells all the time-lock related information
*/
function getTimeLock() external view returns (uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window);
/**
* @dev Sets the time-lock
* @param mode Time lock mode
* @param frequency Time lock frequency
* @param allowedAt Future timestamp since when the task can be executed
* @param window Period in seconds during when a time-locked task can be executed since the allowed timestamp
*/
function setTimeLock(uint8 mode, uint256 frequency, uint256 allowedAt, uint256 window) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Token indexed task interface
*/
interface ITokenIndexedTask is IBaseTask {
/**
* @dev Acceptance list types: either deny-list to express "all except" or allow-list to express "only"
*/
enum TokensAcceptanceType {
DenyList,
AllowList
}
/**
* @dev The acceptance token is zero
*/
error TaskAcceptanceTokenZero();
/**
* @dev The tokens acceptance input length mismatch
*/
error TaskAcceptanceInputLengthMismatch();
/**
* @dev The token is not allowed
*/
error TaskTokenNotAllowed(address token);
/**
* @dev Emitted every time a tokens acceptance type is set
*/
event TokensAcceptanceTypeSet(TokensAcceptanceType acceptanceType);
/**
* @dev Emitted every time a token is added or removed from the acceptance list
*/
event TokensAcceptanceListSet(address indexed token, bool added);
/**
* @dev Tells the acceptance type of the config
*/
function tokensAcceptanceType() external view returns (TokensAcceptanceType);
/**
* @dev Tells whether a token is allowed or not
* @param token Address of the token being queried
*/
function isTokenAllowed(address token) external view returns (bool);
/**
* @dev Sets the tokens acceptance type of the task
* @param newTokensAcceptanceType New token acceptance type to be set
*/
function setTokensAcceptanceType(TokensAcceptanceType newTokensAcceptanceType) external;
/**
* @dev Updates the list of tokens of the tokens acceptance list
* @param tokens List of tokens to be updated from the acceptance list
* @param added Whether each of the given tokens should be added or removed from the list
*/
function setTokensAcceptanceList(address[] memory tokens, bool[] memory added) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General External License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General External License for more details.
// You should have received a copy of the GNU General External License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Token threshold task interface
*/
interface ITokenThresholdTask is IBaseTask {
/**
* @dev The token threshold token is zero
*/
error TaskThresholdTokenZero();
/**
* @dev The token threshold to be set is invalid
*/
error TaskInvalidThresholdInput(address token, uint256 min, uint256 max);
/**
* @dev The token threshold has not been met
*/
error TaskTokenThresholdNotMet(address token, uint256 amount, uint256 min, uint256 max);
/**
* @dev Emitted every time a default threshold is set
*/
event DefaultTokenThresholdSet(address token, uint256 min, uint256 max);
/**
* @dev Emitted every time a token threshold is set
*/
event CustomTokenThresholdSet(address indexed token, address thresholdToken, uint256 min, uint256 max);
/**
* @dev Tells the default token threshold
*/
function defaultTokenThreshold() external view returns (address thresholdToken, uint256 min, uint256 max);
/**
* @dev Tells the custom threshold defined for a specific token
* @param token Address of the token being queried
*/
function customTokenThreshold(address token)
external
view
returns (address thresholdToken, uint256 min, uint256 max);
/**
* @dev Tells the threshold that should be used for a token
* @param token Address of the token being queried
*/
function getTokenThreshold(address token) external view returns (address thresholdToken, uint256 min, uint256 max);
/**
* @dev Sets a new default threshold config
* @param thresholdToken New threshold token to be set
* @param min New threshold minimum to be set
* @param max New threshold maximum to be set
*/
function setDefaultTokenThreshold(address thresholdToken, uint256 min, uint256 max) external;
/**
* @dev Sets a custom token threshold
* @param token Address of the token to set a custom threshold
* @param thresholdToken New custom threshold token to be set
* @param min New custom threshold minimum to be set
* @param max New custom threshold maximum to be set
*/
function setCustomTokenThreshold(address token, address thresholdToken, uint256 min, uint256 max) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseTask.sol';
/**
* @dev Volume limited task interface
*/
interface IVolumeLimitedTask is IBaseTask {
/**
* @dev The volume limit token is zero
*/
error TaskVolumeLimitTokenZero();
/**
* @dev The volume limit to be set is invalid
*/
error TaskInvalidVolumeLimitInput(address token, uint256 amount, uint256 period);
/**
* @dev The volume limit has been exceeded
*/
error TaskVolumeLimitExceeded(address token, uint256 limit, uint256 volume);
/**
* @dev Emitted every time a default volume limit is set
*/
event DefaultVolumeLimitSet(address indexed limitToken, uint256 amount, uint256 period);
/**
* @dev Emitted every time a custom volume limit is set
*/
event CustomVolumeLimitSet(address indexed token, address indexed limitToken, uint256 amount, uint256 period);
/**
* @dev Tells the default volume limit set
*/
function defaultVolumeLimit()
external
view
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime);
/**
* @dev Tells the custom volume limit set for a specific token
* @param token Address of the token being queried
*/
function customVolumeLimit(address token)
external
view
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime);
/**
* @dev Tells the volume limit that should be used for a token
* @param token Address of the token being queried
*/
function getVolumeLimit(address token)
external
view
returns (address limitToken, uint256 amount, uint256 accrued, uint256 period, uint256 nextResetTime);
/**
* @dev Sets a the default volume limit config
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function setDefaultVolumeLimit(address limitToken, uint256 limitAmount, uint256 limitPeriod) external;
/**
* @dev Sets a custom volume limit
* @param token Address of the token to set a custom volume limit for
* @param limitToken Address of the token to measure the volume limit
* @param limitAmount Amount of tokens to be applied for the volume limit
* @param limitPeriod Frequency to Amount of tokens to be applied for the volume limit
*/
function setCustomVolumeLimit(address token, address limitToken, uint256 limitAmount, uint256 limitPeriod) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './base/IBaseTask.sol';
import './base/IPausableTask.sol';
import './base/IGasLimitedTask.sol';
import './base/ITimeLockedTask.sol';
import './base/ITokenIndexedTask.sol';
import './base/ITokenThresholdTask.sol';
import './base/IVolumeLimitedTask.sol';
// solhint-disable no-empty-blocks
/**
* @dev Task interface
*/
interface ITask is
IBaseTask,
IPausableTask,
IGasLimitedTask,
ITimeLockedTask,
ITokenIndexedTask,
ITokenThresholdTask,
IVolumeLimitedTask
{
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import '../ITask.sol';
/**
* @dev Base swap task interface
*/
interface IBaseSwapTask is ITask {
/**
* @dev The token is zero
*/
error TaskTokenZero();
/**
* @dev The amount is zero
*/
error TaskAmountZero();
/**
* @dev The connector is zero
*/
error TaskConnectorZero();
/**
* @dev The token out is not set
*/
error TaskTokenOutNotSet();
/**
* @dev The slippage to be set is greater than one
*/
error TaskSlippageAboveOne();
/**
* @dev The slippage is greater than the maximum slippage
*/
error TaskSlippageAboveMax(uint256 slippage, uint256 maxSlippage);
/**
* @dev Emitted every time the connector is set
*/
event ConnectorSet(address indexed connector);
/**
* @dev Emitted every time the default token out is set
*/
event DefaultTokenOutSet(address indexed tokenOut);
/**
* @dev Emitted every time the default max slippage is set
*/
event DefaultMaxSlippageSet(uint256 maxSlippage);
/**
* @dev Emitted every time a custom token out is set
*/
event CustomTokenOutSet(address indexed token, address tokenOut);
/**
* @dev Emitted every time a custom max slippage is set
*/
event CustomMaxSlippageSet(address indexed token, uint256 maxSlippage);
/**
* @dev Tells the connector tied to the task
*/
function connector() external view returns (address);
/**
* @dev Tells the default token out
*/
function defaultTokenOut() external view returns (address);
/**
* @dev Tells the default max slippage
*/
function defaultMaxSlippage() external view returns (uint256);
/**
* @dev Tells the token out defined for a specific token
* @param token Address of the token being queried
*/
function customTokenOut(address token) external view returns (address);
/**
* @dev Tells the max slippage defined for a specific token
* @param token Address of the token being queried
*/
function customMaxSlippage(address token) external view returns (uint256);
/**
* @dev Tells the token out that should be used for a token
*/
function getTokenOut(address token) external view returns (address);
/**
* @dev Tells the max slippage that should be used for a token
*/
function getMaxSlippage(address token) external view returns (uint256);
/**
* @dev Sets a new connector
* @param newConnector Address of the connector to be set
*/
function setConnector(address newConnector) external;
/**
* @dev Sets the default token out
* @param tokenOut Address of the default token out to be set
*/
function setDefaultTokenOut(address tokenOut) external;
/**
* @dev Sets the default max slippage
* @param maxSlippage Default max slippage to be set
*/
function setDefaultMaxSlippage(uint256 maxSlippage) external;
/**
* @dev Sets a custom token out
* @param token Address of the token to set a custom token out for
* @param tokenOut Address of the token out to be set
*/
function setCustomTokenOut(address token, address tokenOut) external;
/**
* @dev Sets a custom max slippage
* @param token Address of the token to set a custom max slippage for
* @param maxSlippage Max slippage to be set
*/
function setCustomMaxSlippage(address token, uint256 maxSlippage) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.8.0;
import './IBaseSwapTask.sol';
/**
* @dev KyberSwap swapper task interface
*/
interface IKyberSwapV2Swapper is IBaseSwapTask {
/**
* @dev Execution function
*/
function call(address tokenIn, uint256 amountIn, uint256 slippage, bytes memory data) external;
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-helpers/contracts/utils/Denominations.sol';
import '../Task.sol';
import '../interfaces/swap/IBaseSwapTask.sol';
/**
* @title Base swap task
* @dev Task that offers the basic components for more detailed swap tasks
*/
abstract contract BaseSwapTask is IBaseSwapTask, Task {
using FixedPoint for uint256;
// Connector address
address public override connector;
// Default token out
address public override defaultTokenOut;
// Default maximum slippage in fixed point
uint256 public override defaultMaxSlippage;
// Token out per token
mapping (address => address) public override customTokenOut;
// Maximum slippage per token address
mapping (address => uint256) public override customMaxSlippage;
/**
* @dev Custom token out config. Only used in the initializer.
*/
struct CustomTokenOut {
address token;
address tokenOut;
}
/**
* @dev Custom max slippage config. Only used in the initializer.
*/
struct CustomMaxSlippage {
address token;
uint256 maxSlippage;
}
/**
* @dev Base swap config. Only used in the initializer.
*/
struct BaseSwapConfig {
address connector;
address tokenOut;
uint256 maxSlippage;
CustomTokenOut[] customTokensOut;
CustomMaxSlippage[] customMaxSlippages;
TaskConfig taskConfig;
}
/**
* @dev Initializes the base swap task. It does call upper contracts initializers.
* @param config Base swap config
*/
function __BaseSwapTask_init(BaseSwapConfig memory config) internal onlyInitializing {
__Task_init(config.taskConfig);
__BaseSwapTask_init_unchained(config);
}
/**
* @dev Initializes the base swap task. It does not call upper contracts initializers.
* @param config Base swap config
*/
function __BaseSwapTask_init_unchained(BaseSwapConfig memory config) internal onlyInitializing {
_setConnector(config.connector);
_setDefaultTokenOut(config.tokenOut);
_setDefaultMaxSlippage(config.maxSlippage);
for (uint256 i = 0; i < config.customTokensOut.length; i++) {
_setCustomTokenOut(config.customTokensOut[i].token, config.customTokensOut[i].tokenOut);
}
for (uint256 i = 0; i < config.customMaxSlippages.length; i++) {
_setCustomMaxSlippage(config.customMaxSlippages[i].token, config.customMaxSlippages[i].maxSlippage);
}
}
/**
* @dev Tells the token out that should be used for a token
*/
function getTokenOut(address token) public view virtual override returns (address) {
address tokenOut = customTokenOut[token];
return tokenOut == address(0) ? defaultTokenOut : tokenOut;
}
/**
* @dev Tells the max slippage that should be used for a token
*/
function getMaxSlippage(address token) public view virtual override returns (uint256) {
uint256 maxSlippage = customMaxSlippage[token];
return maxSlippage == 0 ? defaultMaxSlippage : maxSlippage;
}
/**
* @dev Sets a new connector
* @param newConnector Address of the connector to be set
*/
function setConnector(address newConnector) external override authP(authParams(newConnector)) {
_setConnector(newConnector);
}
/**
* @dev Sets the default token out
* @param tokenOut Address of the default token out to be set
*/
function setDefaultTokenOut(address tokenOut) external override authP(authParams(tokenOut)) {
_setDefaultTokenOut(tokenOut);
}
/**
* @dev Sets the default max slippage
* @param maxSlippage Default max slippage to be set
*/
function setDefaultMaxSlippage(uint256 maxSlippage) external override authP(authParams(maxSlippage)) {
_setDefaultMaxSlippage(maxSlippage);
}
/**
* @dev Sets a custom token out
* @param token Address of the token to set a custom token out for
* @param tokenOut Address of the token out to be set
*/
function setCustomTokenOut(address token, address tokenOut) external override authP(authParams(token, tokenOut)) {
_setCustomTokenOut(token, tokenOut);
}
/**
* @dev Sets a custom max slippage
* @param token Address of the token to set a custom max slippage for
* @param maxSlippage Max slippage to be set
*/
function setCustomMaxSlippage(address token, uint256 maxSlippage)
external
override
authP(authParams(token, maxSlippage))
{
_setCustomMaxSlippage(token, maxSlippage);
}
/**
* @dev Before base swap task hook
*/
function _beforeBaseSwapTask(address token, uint256 amount, uint256 slippage) internal virtual {
_beforeTask(token, amount);
if (token == address(0)) revert TaskTokenZero();
if (amount == 0) revert TaskAmountZero();
if (getTokenOut(token) == address(0)) revert TaskTokenOutNotSet();
uint256 maxSlippage = getMaxSlippage(token);
if (slippage > maxSlippage) revert TaskSlippageAboveMax(slippage, maxSlippage);
}
/**
* @dev After base swap task hook
*/
function _afterBaseSwapTask(address tokenIn, uint256 amountIn, uint256, address tokenOut, uint256 amountOut)
internal
virtual
{
_increaseBalanceConnector(tokenOut, amountOut);
_afterTask(tokenIn, amountIn);
}
/**
* @dev Sets a new connector
* @param newConnector Address of the connector to be set
*/
function _setConnector(address newConnector) internal {
if (newConnector == address(0)) revert TaskConnectorZero();
connector = newConnector;
emit ConnectorSet(newConnector);
}
/**
* @dev Sets the default token out
* @param tokenOut Default token out to be set
*/
function _setDefaultTokenOut(address tokenOut) internal {
defaultTokenOut = tokenOut;
emit DefaultTokenOutSet(tokenOut);
}
/**
* @dev Sets the default max slippage
* @param maxSlippage Default max slippage to be set
*/
function _setDefaultMaxSlippage(uint256 maxSlippage) internal {
if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne();
defaultMaxSlippage = maxSlippage;
emit DefaultMaxSlippageSet(maxSlippage);
}
/**
* @dev Sets a custom token out for a token
* @param token Address of the token to set the custom token out for
* @param tokenOut Address of the token out to be set
*/
function _setCustomTokenOut(address token, address tokenOut) internal {
if (token == address(0)) revert TaskTokenZero();
customTokenOut[token] = tokenOut;
emit CustomTokenOutSet(token, tokenOut);
}
/**
* @dev Sets a custom max slippage for a token
* @param token Address of the token to set the custom max slippage for
* @param maxSlippage Max slippage to be set
*/
function _setCustomMaxSlippage(address token, uint256 maxSlippage) internal {
if (token == address(0)) revert TaskTokenZero();
if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne();
customMaxSlippage[token] = maxSlippage;
emit CustomMaxSlippageSet(token, maxSlippage);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-helpers/contracts/utils/BytesHelpers.sol';
import '@mimic-fi/v3-connectors/contracts/interfaces/kyberswap/IKyberSwapV2Connector.sol';
import './BaseSwapTask.sol';
import '../interfaces/swap/IKyberSwapV2Swapper.sol';
/**
* @title KyberSwap v2 swapper
* @dev Task that extends the base swap task to use KyberSwap v2
*/
contract KyberSwapV2Swapper is IKyberSwapV2Swapper, BaseSwapTask {
using FixedPoint for uint256;
using BytesHelpers for bytes;
// Execution type for relayers
bytes32 public constant override EXECUTION_TYPE = keccak256('KYBER_SWAP_V2_SWAPPER');
/**
* @dev KyberSwap v2 swap config. Only used in the initializer.
*/
struct KyberSwapV2SwapConfig {
BaseSwapConfig baseSwapConfig;
}
/**
* @dev Initializes the KyberSwap v2 swapper
* @param config KyberSwap v2 swap config
*/
function initialize(KyberSwapV2SwapConfig memory config) external virtual initializer {
__KyberSwapV2Swapper_init(config);
}
/**
* @dev Initializes the KyberSwap v2 swapper. It does call upper contracts initializers.
* @param config KyberSwap v2 swap config
*/
function __KyberSwapV2Swapper_init(KyberSwapV2SwapConfig memory config) internal onlyInitializing {
__BaseSwapTask_init(config.baseSwapConfig);
__KyberSwapV2Swapper_init_unchained(config);
}
/**
* @dev Initializes the KyberSwap v2 swapper. It does not call upper contracts initializers.
* @param config KyberSwap v2 swap config
*/
function __KyberSwapV2Swapper_init_unchained(KyberSwapV2SwapConfig memory config) internal onlyInitializing {
// solhint-disable-previous-line no-empty-blocks
}
/**
* @dev Executes the KyberSwap V2 swapper task
*/
function call(address tokenIn, uint256 amountIn, uint256 slippage, bytes memory data)
external
override
authP(authParams(tokenIn, amountIn, slippage))
{
if (amountIn == 0) amountIn = getTaskAmount(tokenIn);
_beforeKyberSwapV2Swapper(tokenIn, amountIn, slippage);
address tokenOut = getTokenOut(tokenIn);
uint256 price = _getPrice(tokenIn, tokenOut);
uint256 minAmountOut = amountIn.mulUp(price).mulUp(FixedPoint.ONE - slippage);
bytes memory connectorData = abi.encodeWithSelector(
IKyberSwapV2Connector.execute.selector,
tokenIn,
tokenOut,
amountIn,
minAmountOut,
data
);
bytes memory result = ISmartVault(smartVault).execute(connector, connectorData);
_afterKyberSwapV2Swapper(tokenIn, amountIn, slippage, tokenOut, result.toUint256());
}
/**
* @dev Before KyberSwap v2 swapper hook
*/
function _beforeKyberSwapV2Swapper(address token, uint256 amount, uint256 slippage) internal virtual {
_beforeBaseSwapTask(token, amount, slippage);
}
/**
* @dev After KyberSwap v2 swapper hook
*/
function _afterKyberSwapV2Swapper(
address tokenIn,
uint256 amountIn,
uint256 slippage,
address tokenOut,
uint256 amountOut
) internal virtual {
_afterBaseSwapTask(tokenIn, amountIn, slippage, tokenOut, amountOut);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import './interfaces/ITask.sol';
import './base/BaseTask.sol';
import './base/PausableTask.sol';
import './base/GasLimitedTask.sol';
import './base/TimeLockedTask.sol';
import './base/TokenIndexedTask.sol';
import './base/TokenThresholdTask.sol';
import './base/VolumeLimitedTask.sol';
/**
* @title Task
* @dev Shared components across all tasks
*/
abstract contract Task is
ITask,
BaseTask,
PausableTask,
GasLimitedTask,
TimeLockedTask,
TokenIndexedTask,
TokenThresholdTask,
VolumeLimitedTask
{
/**
* @dev Task config. Only used in the initializer.
*/
struct TaskConfig {
BaseConfig baseConfig;
GasLimitConfig gasLimitConfig;
TimeLockConfig timeLockConfig;
TokenIndexConfig tokenIndexConfig;
TokenThresholdConfig tokenThresholdConfig;
VolumeLimitConfig volumeLimitConfig;
}
/**
* @dev Initializes the task. It does call upper contracts initializers.
* @param config Task config
*/
function __Task_init(TaskConfig memory config) internal onlyInitializing {
__BaseTask_init(config.baseConfig);
__PausableTask_init();
__GasLimitedTask_init(config.gasLimitConfig);
__TimeLockedTask_init(config.timeLockConfig);
__TokenIndexedTask_init(config.tokenIndexConfig);
__TokenThresholdTask_init(config.tokenThresholdConfig);
__VolumeLimitedTask_init(config.volumeLimitConfig);
__Task_init_unchained(config);
}
/**
* @dev Initializes the task. It does not call upper contracts initializers.
* @param config Task config
*/
function __Task_init_unchained(TaskConfig memory config) internal onlyInitializing {
// solhint-disable-previous-line no-empty-blocks
}
/**
* @dev Fetches a base/quote price
*/
function _getPrice(address base, address quote)
internal
view
override(BaseTask, GasLimitedTask, TokenThresholdTask, VolumeLimitedTask)
returns (uint256)
{
return BaseTask._getPrice(base, quote);
}
/**
* @dev Before task hook
*/
function _beforeTask(address token, uint256 amount) internal virtual {
_beforeBaseTask(token, amount);
_beforePausableTask(token, amount);
_beforeGasLimitedTask(token, amount);
_beforeTimeLockedTask(token, amount);
_beforeTokenIndexedTask(token, amount);
_beforeTokenThresholdTask(token, amount);
_beforeVolumeLimitedTask(token, amount);
}
/**
* @dev After task hook
*/
function _afterTask(address token, uint256 amount) internal virtual {
_afterVolumeLimitedTask(token, amount);
_afterTokenThresholdTask(token, amount);
_afterTokenIndexedTask(token, amount);
_afterTimeLockedTask(token, amount);
_afterGasLimitedTask(token, amount);
_afterPausableTask(token, amount);
_afterBaseTask(token, amount);
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
contract KyberSwapV2ConnectorMock {
event LogExecute(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, bytes data);
function execute(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, bytes memory data)
external
returns (uint256)
{
emit LogExecute(tokenIn, tokenOut, amountIn, minAmountOut, data);
return minAmountOut;
}
}