diff --git a/packages/authorizer/contracts/Authorized.sol b/packages/authorizer/contracts/Authorized.sol index 9eb61755..7410aaaa 100644 --- a/packages/authorizer/contracts/Authorized.sol +++ b/packages/authorizer/contracts/Authorized.sol @@ -84,7 +84,7 @@ contract Authorized is IAuthorized, Initializable, AuthorizedHelpers { * @param how Params to be authenticated */ function _authenticate(address who, bytes4 what, uint256[] memory how) internal view { - require(_isAuthorized(who, what, how), 'AUTH_SENDER_NOT_ALLOWED'); + if (!_isAuthorized(who, what, how)) revert AuthSenderNotAllowed(who, what, how); } /** diff --git a/packages/authorizer/contracts/Authorizer.sol b/packages/authorizer/contracts/Authorizer.sol index c4342071..cda255ed 100644 --- a/packages/authorizer/contracts/Authorizer.sol +++ b/packages/authorizer/contracts/Authorizer.sol @@ -164,8 +164,7 @@ contract Authorizer is IAuthorizer, AuthorizedHelpers, Initializable, Reentrancy */ function authorize(address who, address where, bytes4 what, Param[] memory params) public override nonReentrant { uint256[] memory how = authParams(who, where, what); - bool allowed = isAuthorized(msg.sender, address(this), IAuthorizer.authorize.selector, how); - require(allowed, 'AUTHORIZER_SENDER_NOT_ALLOWED'); + _authenticate(msg.sender, IAuthorizer.authorize.selector, how); _authorize(who, where, what, params); } @@ -177,11 +176,21 @@ contract Authorizer is IAuthorizer, AuthorizedHelpers, Initializable, Reentrancy */ function unauthorize(address who, address where, bytes4 what) public override nonReentrant { uint256[] memory how = authParams(who, where, what); - bool allowed = isAuthorized(msg.sender, address(this), IAuthorizer.unauthorize.selector, how); - require(allowed, 'AUTHORIZER_SENDER_NOT_ALLOWED'); + _authenticate(msg.sender, IAuthorizer.unauthorize.selector, how); _unauthorize(who, where, what); } + /** + * @dev Validates whether `who` is authorized 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 _authenticate(address who, bytes4 what, uint256[] memory how) internal view { + bool allowed = isAuthorized(who, address(this), what, how); + if (!allowed) revert AuthorizerSenderNotAllowed(who, address(this), what, how); + } + /** * @dev Tells whether `who` is allowed to call `what` on `where` with `how` * @param who Address asking permission for @@ -255,6 +264,6 @@ contract Authorizer is IAuthorizer, AuthorizedHelpers, Initializable, Reentrancy if (Op(param.op) == Op.LT) return how < param.value; if (Op(param.op) == Op.GTE) return how >= param.value; if (Op(param.op) == Op.LTE) return how <= param.value; - revert('AUTHORIZER_INVALID_PARAM_OP'); + revert AuthorizerInvalidParamOp(param.op); } } diff --git a/packages/authorizer/contracts/interfaces/IAuthorized.sol b/packages/authorizer/contracts/interfaces/IAuthorized.sol index bca4edab..69ddd507 100644 --- a/packages/authorizer/contracts/interfaces/IAuthorized.sol +++ b/packages/authorizer/contracts/interfaces/IAuthorized.sol @@ -18,6 +18,11 @@ 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 */ diff --git a/packages/authorizer/contracts/interfaces/IAuthorizer.sol b/packages/authorizer/contracts/interfaces/IAuthorizer.sol index 07181d02..0005133a 100644 --- a/packages/authorizer/contracts/interfaces/IAuthorizer.sol +++ b/packages/authorizer/contracts/interfaces/IAuthorizer.sol @@ -61,6 +61,16 @@ interface IAuthorizer { 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` */ diff --git a/packages/authorizer/test/Authorizer.test.ts b/packages/authorizer/test/Authorizer.test.ts index a203a698..589efa48 100644 --- a/packages/authorizer/test/Authorizer.test.ts +++ b/packages/authorizer/test/Authorizer.test.ts @@ -385,17 +385,17 @@ describe('Authorizer', () => { // try granting other permissions await expect(authorizer.connect(who).authorize(WHO, WHERE2, WHAT, [])).to.be.revertedWith( - 'AUTHORIZER_SENDER_NOT_ALLOWED' + 'AuthorizerSenderNotAllowed' ) await expect(authorizer.connect(who).authorize(WHO, WHERE, WHAT2, [])).to.be.revertedWith( - 'AUTHORIZER_SENDER_NOT_ALLOWED' + 'AuthorizerSenderNotAllowed' ) // rollback authorization await authorizer.unauthorize(who.address, authorizer.address, authorizeRole) expect(await authorizer.isAuthorized(who.address, authorizer.address, authorizeRole, [])).to.be.false await expect(authorizer.connect(who).authorize(WHO, WHERE, WHAT, [])).to.be.revertedWith( - 'AUTHORIZER_SENDER_NOT_ALLOWED' + 'AuthorizerSenderNotAllowed' ) }) }) @@ -437,7 +437,7 @@ describe('Authorizer', () => { context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(authorizer.authorize(WHO, WHERE, WHAT, [])).to.be.revertedWith('AUTHORIZER_SENDER_NOT_ALLOWED') + await expect(authorizer.authorize(WHO, WHERE, WHAT, [])).to.be.revertedWith('AuthorizerSenderNotAllowed') }) }) }) @@ -502,7 +502,7 @@ describe('Authorizer', () => { context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(authorizer.unauthorize(WHO, WHERE, WHAT)).to.be.revertedWith('AUTHORIZER_SENDER_NOT_ALLOWED') + await expect(authorizer.unauthorize(WHO, WHERE, WHAT)).to.be.revertedWith('AuthorizerSenderNotAllowed') }) }) }) @@ -560,7 +560,7 @@ describe('Authorizer', () => { authorizer .connect(admin) .changePermissions([{ where: WHERE2, grants: [{ who: WHO2, what: WHAT2, params: [] }], revokes: [] }]) - ).to.be.revertedWith('AUTHORIZER_SENDER_NOT_ALLOWED') + ).to.be.revertedWith('AuthorizerSenderNotAllowed') }) }) }) diff --git a/packages/connectors/contracts/bridge/axelar/AxelarConnector.sol b/packages/connectors/contracts/bridge/axelar/AxelarConnector.sol index 2c384db0..3c91978f 100644 --- a/packages/connectors/contracts/bridge/axelar/AxelarConnector.sol +++ b/packages/connectors/contracts/bridge/axelar/AxelarConnector.sol @@ -26,6 +26,26 @@ import './IAxelarGateway.sol'; * @dev Interfaces with Axelar to bridge tokens */ contract AxelarConnector { + /** + * @dev The recipient address is zero + */ + error AxelarBridgeRecipientZero(); + + /** + * @dev The source and destination chains are the same + */ + error AxelarBridgeSameChain(uint256 chainId); + + /** + * @dev The chain ID is not supported + */ + error AxelarBridgeUnknownChainId(uint256 chainId); + + /** + * @dev The post token balance is lower than the previous token balance minus the amount bridged + */ + error AxelarBridgeBadPostTokenBalance(uint256 postBalance, uint256 preBalance, uint256 amount); + // List of chain names supported by Axelar string private constant ETHEREUM_NAME = 'Ethereum'; string private constant POLYGON_NAME = 'Polygon'; @@ -61,19 +81,19 @@ contract AxelarConnector { * @param recipient Address that will receive the tokens on the destination chain */ function execute(uint256 chainId, address token, uint256 amountIn, address recipient) external { - require(block.chainid != chainId, 'AXELAR_BRIDGE_SAME_CHAIN'); - require(recipient != address(0), 'AXELAR_BRIDGE_RECIPIENT_ZERO'); + if (block.chainid == chainId) revert AxelarBridgeSameChain(chainId); + if (recipient == address(0)) revert AxelarBridgeRecipientZero(); string memory chainName = _getChainName(chainId); string memory symbol = IERC20Metadata(token).symbol(); - uint256 preBalanceIn = IERC20(token).balanceOf(address(this)); ERC20Helpers.approve(token, address(axelarGateway), amountIn); axelarGateway.sendToken(chainName, Strings.toHexString(recipient), symbol, amountIn); uint256 postBalanceIn = IERC20(token).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'AXELAR_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert AxelarBridgeBadPostTokenBalance(postBalanceIn, preBalanceIn, amountIn); } /** @@ -88,6 +108,6 @@ contract AxelarConnector { else if (chainId == BSC_ID) return BSC_NAME; else if (chainId == FANTOM_ID) return FANTOM_NAME; else if (chainId == AVALANCHE_ID) return AVALANCHE_NAME; - else revert('AXELAR_UNKNOWN_CHAIN_ID'); + else revert AxelarBridgeUnknownChainId(chainId); } } diff --git a/packages/connectors/contracts/bridge/connext/ConnextConnector.sol b/packages/connectors/contracts/bridge/connext/ConnextConnector.sol index 3d9b7584..d9a409b4 100644 --- a/packages/connectors/contracts/bridge/connext/ConnextConnector.sol +++ b/packages/connectors/contracts/bridge/connext/ConnextConnector.sol @@ -25,6 +25,36 @@ import './IConnext.sol'; * @dev Interfaces with Connext to bridge tokens */ contract ConnextConnector { + /** + * @dev The recipient address is zero + */ + error ConnextBridgeRecipientZero(); + + /** + * @dev The source and destination chains are the same + */ + error ConnextBridgeSameChain(uint256 chainId); + + /** + * @dev The chain ID is not supported + */ + error ConnextBridgeUnknownChainId(uint256 chainId); + + /** + * @dev The relayer fee is greater than the amount to be bridged + */ + error ConnextBridgeRelayerFeeGtAmount(uint256 relayerFee, uint256 amountIn); + + /** + * @dev The minimum amount out is greater than the amount to be bridged minus the relayer fee + */ + error ConnextBridgeMinAmountOutTooBig(uint256 minAmountOut, uint256 amountIn, uint256 relayerFee); + + /** + * @dev The post token balance is lower than the previous token balance minus the amount bridged + */ + error ConnextBridgeBadPostTokenBalance(uint256 postBalance, uint256 preBalance, uint256 amount); + // List of chain domains supported by Connext uint32 private constant ETHEREUM_DOMAIN = 6648936; uint32 private constant POLYGON_DOMAIN = 1886350457; @@ -69,10 +99,12 @@ contract ConnextConnector { address recipient, uint256 relayerFee ) external { - require(block.chainid != chainId, 'CONNEXT_BRIDGE_SAME_CHAIN'); - require(recipient != address(0), 'CONNEXT_BRIDGE_RECIPIENT_ZERO'); - require(relayerFee <= amountIn, 'CONNEXT_RELAYER_FEE_GT_AMOUNT_IN'); - require(minAmountOut <= amountIn - relayerFee, 'CONNEXT_MIN_AMOUNT_OUT_TOO_BIG'); + if (block.chainid == chainId) revert ConnextBridgeSameChain(chainId); + if (recipient == address(0)) revert ConnextBridgeRecipientZero(); + if (relayerFee > amountIn) revert ConnextBridgeRelayerFeeGtAmount(relayerFee, amountIn); + + bool isMinAmountTooBig = minAmountOut > amountIn - relayerFee; + if (isMinAmountTooBig) revert ConnextBridgeMinAmountOutTooBig(minAmountOut, amountIn, relayerFee); uint32 domain = _getChainDomain(chainId); uint256 amountInAfterFees = amountIn - relayerFee; @@ -96,7 +128,8 @@ contract ConnextConnector { ); uint256 postBalanceIn = IERC20(token).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'CONNEXT_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert ConnextBridgeBadPostTokenBalance(postBalanceIn, preBalanceIn, amountIn); } /** @@ -111,6 +144,6 @@ contract ConnextConnector { else if (chainId == OPTIMISM_ID) return OPTIMISM_DOMAIN; else if (chainId == GNOSIS_ID) return GNOSIS_DOMAIN; else if (chainId == BSC_ID) return BSC_DOMAIN; - else revert('CONNEXT_UNKNOWN_CHAIN_ID'); + else revert ConnextBridgeUnknownChainId(chainId); } } diff --git a/packages/connectors/contracts/bridge/hop/HopConnector.sol b/packages/connectors/contracts/bridge/hop/HopConnector.sol index 6842af0f..d17d7e42 100644 --- a/packages/connectors/contracts/bridge/hop/HopConnector.sol +++ b/packages/connectors/contracts/bridge/hop/HopConnector.sol @@ -33,6 +33,41 @@ contract HopConnector { using FixedPoint for uint256; using Denominations for address; + /** + * @dev The source and destination chains are the same + */ + error HopBridgeSameChain(uint256 chainId); + + /** + * @dev The bridge operation is not supported + */ + error HopBridgeOpNotSupported(); + + /** + * @dev The recipient address is zero + */ + error HopBridgeRecipientZero(); + + /** + * @dev The relayer was sent when not needed + */ + error HopBridgeRelayerNotNeeded(); + + /** + * @dev The deadline was sent when not needed + */ + error HopBridgeDeadlineNotNeeded(); + + /** + * @dev The deadline is in the past + */ + error HopBridgePastDeadline(uint256 deadline, uint256 currentTimestamp); + + /** + * @dev The post token balance is lower than the previous token balance minus the amount bridged + */ + error HopBridgeBadPostTokenBalance(uint256 postBalance, uint256 preBalance, uint256 amount); + // Ethereum mainnet chain ID = 1 uint256 private constant MAINNET_CHAIN_ID = 1; @@ -66,7 +101,7 @@ contract HopConnector { * @param recipient Address that will receive the tokens on the destination chain * @param bridge Address of the bridge component (i.e. hopBridge or hopAMM) * @param deadline Deadline to be used when bridging to L2 in order to swap the corresponding hToken - * @param relayer Only used when transfering from L1 to L2 if a 3rd party is relaying the transfer on the user's behalf + * @param relayer Only used when transferring from L1 to L2 if a 3rd party is relaying the transfer on the user's behalf * @param fee Fee to be sent to the bridge based on the source and destination chain (i.e. relayerFee or bonderFee) */ function execute( @@ -80,26 +115,26 @@ contract HopConnector { address relayer, uint256 fee ) external { - require(block.chainid != chainId, 'HOP_BRIDGE_SAME_CHAIN'); - require(recipient != address(0), 'HOP_BRIDGE_RECIPIENT_ZERO'); + if (block.chainid == chainId) revert HopBridgeSameChain(chainId); + if (recipient == address(0)) revert HopBridgeRecipientZero(); bool toL2 = !_isL1(chainId); bool fromL1 = _isL1(block.chainid); - uint256 preBalanceIn = IERC20(token).balanceOf(address(this)); if (fromL1 && toL2) _bridgeFromL1ToL2(chainId, token, amountIn, minAmountOut, recipient, bridge, deadline, relayer, fee); else if (!fromL1 && toL2) { - require(relayer == address(0), 'HOP_RELAYER_NOT_NEEDED'); + if (relayer != address(0)) revert HopBridgeRelayerNotNeeded(); _bridgeFromL2ToL2(chainId, token, amountIn, minAmountOut, recipient, bridge, deadline, fee); } else if (!fromL1 && !toL2) { - require(deadline == 0, 'HOP_DEADLINE_NOT_NEEDED'); + if (deadline != 0) revert HopBridgeDeadlineNotNeeded(); _bridgeFromL2ToL1(chainId, token, amountIn, minAmountOut, recipient, bridge, fee); - } else revert('HOP_BRIDGE_OP_NOT_SUPPORTED'); + } else revert HopBridgeOpNotSupported(); uint256 postBalanceIn = IERC20(token).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'HOP_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert HopBridgeBadPostTokenBalance(postBalanceIn, preBalanceIn, amountIn); } /** @@ -125,7 +160,7 @@ contract HopConnector { address relayer, uint256 relayerFee ) internal { - require(deadline > block.timestamp, 'HOP_BRIDGE_INVALID_DEADLINE'); + if (deadline <= block.timestamp) revert HopBridgePastDeadline(deadline, block.timestamp); uint256 value = _unwrapOrApproveTokens(hopBridge, token, amountIn); IHopL1Bridge(hopBridge).sendToL2{ value: value }( @@ -193,7 +228,7 @@ contract HopConnector { uint256 deadline, uint256 bonderFee ) internal { - require(deadline > block.timestamp, 'HOP_BRIDGE_INVALID_DEADLINE'); + if (deadline <= block.timestamp) revert HopBridgePastDeadline(deadline, block.timestamp); uint256 intermediateMinAmountOut = amountIn - ((amountIn - minAmountOut) / 2); IHopL2AMM(hopAMM).swapAndSend{ value: _unwrapOrApproveTokens(hopAMM, token, amountIn) }( diff --git a/packages/connectors/contracts/bridge/wormhole/WormholeConnector.sol b/packages/connectors/contracts/bridge/wormhole/WormholeConnector.sol index 5c2c5699..56904b09 100644 --- a/packages/connectors/contracts/bridge/wormhole/WormholeConnector.sol +++ b/packages/connectors/contracts/bridge/wormhole/WormholeConnector.sol @@ -26,6 +26,36 @@ import './IWormhole.sol'; * @dev Interfaces with Wormhole to bridge tokens through CCTP */ contract WormholeConnector { + /** + * @dev The recipient address is zero + */ + error WormholeBridgeRecipientZero(); + + /** + * @dev The source and destination chains are the same + */ + error WormholeBridgeSameChain(uint256 chainId); + + /** + * @dev The chain ID is not supported + */ + error WormholeBridgeUnknownChainId(uint256 chainId); + + /** + * @dev The relayer fee is greater than the amount to be bridged + */ + error WormholeBridgeRelayerFeeGtAmount(uint256 relayerFee, uint256 amountIn); + + /** + * @dev The minimum amount out is greater than the amount to be bridged minus the relayer fee + */ + error WormholeBridgeMinAmountOutTooBig(uint256 minAmountOut, uint256 amountIn, uint256 relayerFee); + + /** + * @dev The post token balance is lower than the previous token balance minus the amount bridged + */ + error WormholeBridgeBadPostTokenBalance(uint256 postBalance, uint256 preBalance, uint256 amount); + // List of Wormhole network IDs uint16 private constant ETHEREUM_WORMHOLE_NETWORK_ID = 2; uint16 private constant POLYGON_WORMHOLE_NETWORK_ID = 5; @@ -66,13 +96,15 @@ contract WormholeConnector { function execute(uint256 chainId, address token, uint256 amountIn, uint256 minAmountOut, address recipient) external { - require(block.chainid != chainId, 'WORMHOLE_BRIDGE_SAME_CHAIN'); - require(recipient != address(0), 'WORMHOLE_BRIDGE_RECIPIENT_ZERO'); + if (block.chainid == chainId) revert WormholeBridgeSameChain(chainId); + if (recipient == address(0)) revert WormholeBridgeRecipientZero(); uint16 wormholeNetworkId = _getWormholeNetworkId(chainId); uint256 relayerFee = wormholeCircleRelayer.relayerFee(wormholeNetworkId, token); - require(relayerFee <= amountIn, 'WORMHOLE_RELAYER_FEE_GT_AMT_IN'); - require(minAmountOut <= amountIn - relayerFee, 'WORMHOLE_MIN_AMOUNT_OUT_TOO_BIG'); + if (relayerFee > amountIn) revert WormholeBridgeRelayerFeeGtAmount(relayerFee, amountIn); + + bool isMinAmountTooBig = minAmountOut > amountIn - relayerFee; + if (isMinAmountTooBig) revert WormholeBridgeMinAmountOutTooBig(minAmountOut, amountIn, relayerFee); uint256 preBalanceIn = IERC20(token).balanceOf(address(this)); @@ -86,13 +118,14 @@ contract WormholeConnector { ); uint256 postBalanceIn = IERC20(token).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'WORMHOLE_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert WormholeBridgeBadPostTokenBalance(postBalanceIn, preBalanceIn, amountIn); } /** * @dev Tells the Wormhole network ID based on a chain ID * @param chainId ID of the chain being queried - * @return Wormhole network ID associated to the requested chain ID + * @return Wormhole network ID associated with the requested chain ID */ function _getWormholeNetworkId(uint256 chainId) internal pure returns (uint16) { if (chainId == ETHEREUM_ID) return ETHEREUM_WORMHOLE_NETWORK_ID; @@ -102,6 +135,6 @@ contract WormholeConnector { else if (chainId == BSC_ID) return BSC_WORMHOLE_NETWORK_ID; else if (chainId == FANTOM_ID) return FANTOM_WORMHOLE_NETWORK_ID; else if (chainId == AVALANCHE_ID) return AVALANCHE_WORMHOLE_NETWORK_ID; - else revert('WORMHOLE_UNKNOWN_CHAIN_ID'); + else revert WormholeBridgeUnknownChainId(chainId); } } diff --git a/packages/connectors/contracts/liquidity/convex/ConvexConnector.sol b/packages/connectors/contracts/liquidity/convex/ConvexConnector.sol index bcedf507..3702229e 100644 --- a/packages/connectors/contracts/liquidity/convex/ConvexConnector.sol +++ b/packages/connectors/contracts/liquidity/convex/ConvexConnector.sol @@ -28,6 +28,21 @@ import './ICvxBooster.sol'; contract ConvexConnector { using FixedPoint for uint256; + /** + * @dev Missing Convex pool for the requested Curve pool + */ + error ConvexCvxPoolNotFound(address curvePool); + + /** + * @dev Failed to deposit tokens into the Convex booster + */ + error ConvexBoosterDepositFailed(uint256 poolId, uint256 amount); + + /** + * @dev Failed to withdraw tokens from Convex pool + */ + error ConvexCvxPoolWithdrawFailed(address cvxPool, uint256 amount); + // Convex booster ICvxBooster public immutable booster; @@ -83,7 +98,8 @@ contract ConvexConnector { uint256 initialCvxPoolTokenBalance = cvxPool.balanceOf(address(this)); IERC20(curvePool).approve(address(booster), amount); - require(booster.deposit(poolId, amount), 'CONVEX_BOOSTER_DEPOSIT_FAILED'); + if (!booster.deposit(poolId, amount)) revert ConvexBoosterDepositFailed(poolId, amount); + uint256 finalCvxPoolTokenBalance = cvxPool.balanceOf(address(this)); return finalCvxPoolTokenBalance - initialCvxPoolTokenBalance; } @@ -97,9 +113,9 @@ contract ConvexConnector { if (amount == 0) return 0; address curvePool = getCurvePool(cvxPool); - // Unstake from Convex uint256 initialPoolTokenBalance = IERC20(curvePool).balanceOf(address(this)); - require(ICvxPool(cvxPool).withdraw(amount, true), 'CONVEX_CVX_POOL_WITHDRAW_FAILED'); + if (!ICvxPool(cvxPool).withdraw(amount, true)) revert ConvexCvxPoolWithdrawFailed(cvxPool, amount); + uint256 finalPoolTokenBalance = IERC20(curvePool).balanceOf(address(this)); return finalPoolTokenBalance - initialPoolTokenBalance; } @@ -114,6 +130,6 @@ contract ConvexConnector { return (i, ICvxPool(rewards)); } } - revert('CONVEX_CVX_POOL_NOT_FOUND'); + revert ConvexCvxPoolNotFound(curvePool); } } diff --git a/packages/connectors/contracts/liquidity/curve/Curve2CrvConnector.sol b/packages/connectors/contracts/liquidity/curve/Curve2CrvConnector.sol index 1a6dbac8..77fb03b7 100644 --- a/packages/connectors/contracts/liquidity/curve/Curve2CrvConnector.sol +++ b/packages/connectors/contracts/liquidity/curve/Curve2CrvConnector.sol @@ -27,6 +27,21 @@ import './I2CrvPool.sol'; contract Curve2CrvConnector { using FixedPoint for uint256; + /** + * @dev Failed to find the token in the 2CRV pool + */ + error Curve2CrvTokenNotFound(address pool, address token); + + /** + * @dev Token decimals exceed 18 + */ + error Curve2CrvTokenDecimalsAbove18(address token, uint256 decimals); + + /** + * @dev The slippage is above one + */ + error Curve2CrvSlippageAboveOne(uint256 slippage); + /** * @dev Adds liquidity to the 2CRV pool * @param pool Address of the 2CRV pool to join @@ -36,7 +51,7 @@ contract Curve2CrvConnector { */ function join(address pool, address tokenIn, uint256 amountIn, uint256 slippage) external returns (uint256) { if (amountIn == 0) return 0; - require(slippage <= FixedPoint.ONE, '2CRV_SLIPPAGE_ABOVE_ONE'); + if (slippage > FixedPoint.ONE) revert Curve2CrvSlippageAboveOne(slippage); (uint256 tokenIndex, uint256 tokenScale) = _findTokenInfo(pool, tokenIn); // Compute min amount out @@ -65,7 +80,7 @@ contract Curve2CrvConnector { returns (uint256 amountOut) { if (amountIn == 0) return 0; - require(slippage <= FixedPoint.ONE, '2CRV_INVALID_SLIPPAGE'); + if (slippage > FixedPoint.ONE) revert Curve2CrvSlippageAboveOne(slippage); (uint256 tokenIndex, uint256 tokenScale) = _findTokenInfo(pool, tokenOut); // Compute min amount out @@ -87,13 +102,13 @@ contract Curve2CrvConnector { try I2CrvPool(pool).coins(i) returns (address coin) { if (token == coin) { uint256 decimals = IERC20Metadata(token).decimals(); - require(decimals <= 18, '2CRV_TOKEN_ABOVE_18_DECIMALS'); + if (decimals > 18) revert Curve2CrvTokenDecimalsAbove18(token, decimals); return (i, 10**(18 - decimals)); } } catch { - revert('2CRV_TOKEN_NOT_FOUND'); + revert Curve2CrvTokenNotFound(pool, token); } } - revert('2CRV_TOKEN_NOT_FOUND'); + revert Curve2CrvTokenNotFound(pool, token); } } diff --git a/packages/connectors/contracts/swap/1inch-v5/OneInchV5Connector.sol b/packages/connectors/contracts/swap/1inch-v5/OneInchV5Connector.sol index 0a92c084..89b83944 100644 --- a/packages/connectors/contracts/swap/1inch-v5/OneInchV5Connector.sol +++ b/packages/connectors/contracts/swap/1inch-v5/OneInchV5Connector.sol @@ -27,6 +27,21 @@ import './IOneInchV5AggregationRouter.sol'; * @dev Interfaces with 1inch V5 to swap tokens */ contract OneInchV5Connector { + /** + * @dev The token in is the same as the token out + */ + error OneInchV5SwapSameToken(address token); + + /** + * @dev The amount out is lower than the minimum amount out + */ + error OneInchV5BadAmountOut(uint256 amountOut, uint256 minAmountOut); + + /** + * @dev The post token in balance is lower than the previous token in balance minus the amount in + */ + error OneInchV5BadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn); + // Reference to 1inch aggregation router v5 IOneInchV5AggregationRouter public immutable oneInchV5Router; @@ -41,7 +56,7 @@ contract OneInchV5Connector { /** * @dev Executes a token swap in 1Inch V5 * @param tokenIn Token to be sent - * @param tokenOut Token to received + * @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 1inch aggregation router @@ -50,7 +65,7 @@ contract OneInchV5Connector { external returns (uint256 amountOut) { - require(tokenIn != tokenOut, '1INCH_V5_SWAP_SAME_TOKEN'); + if (tokenIn == tokenOut) revert OneInchV5SwapSameToken(tokenIn); uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this)); uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this)); @@ -59,10 +74,11 @@ contract OneInchV5Connector { Address.functionCall(address(oneInchV5Router), data, '1INCH_V5_SWAP_FAILED'); uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, '1INCH_V5_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert OneInchV5BadPostTokenInBalance(postBalanceIn, preBalanceIn, amountIn); uint256 postBalanceOut = IERC20(tokenOut).balanceOf(address(this)); amountOut = postBalanceOut - preBalanceOut; - require(amountOut >= minAmountOut, '1INCH_V5_MIN_AMOUNT_OUT'); + if (amountOut < minAmountOut) revert OneInchV5BadAmountOut(amountOut, minAmountOut); } } diff --git a/packages/connectors/contracts/swap/hop/HopSwapConnector.sol b/packages/connectors/contracts/swap/hop/HopSwapConnector.sol index 8359a652..2989fa2e 100644 --- a/packages/connectors/contracts/swap/hop/HopSwapConnector.sol +++ b/packages/connectors/contracts/swap/hop/HopSwapConnector.sol @@ -25,6 +25,26 @@ import './IHopDex.sol'; * @dev Interfaces with Hop to swap tokens */ contract HopSwapConnector { + /** + * @dev The token in is the same as the token out + */ + error HopSwapSameToken(address token); + + /** + * @dev The dex address is zero + */ + error HopDexAddressZero(); + + /** + * @dev The amount out is lower than the minimum amount out + */ + error HopBadAmountOut(uint256 amountOut, uint256 minAmountOut); + + /** + * @dev The post token in balance is lower than the pre token in balance minus the amount in + */ + error HopBadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn); + /** * @dev Executes a token swap in Hop * @param tokenIn Token being sent @@ -37,8 +57,8 @@ contract HopSwapConnector { external returns (uint256 amountOut) { - require(tokenIn != tokenOut, 'HOP_SWAP_SAME_TOKEN'); - require(hopDexAddress != address(0), 'HOP_DEX_ADDRESS_ZERO'); + if (tokenIn == tokenOut) revert HopSwapSameToken(tokenIn); + if (hopDexAddress == address(0)) revert HopDexAddressZero(); uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this)); uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this)); @@ -51,10 +71,11 @@ contract HopSwapConnector { hopDex.swap(tokenInIndex, tokenOutIndex, amountIn, minAmountOut, block.timestamp); uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'HOP_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert HopBadPostTokenInBalance(postBalanceIn, preBalanceIn, amountIn); uint256 postBalanceOut = IERC20(tokenOut).balanceOf(address(this)); amountOut = postBalanceOut - preBalanceOut; - require(amountOut >= minAmountOut, 'HOP_MIN_AMOUNT_OUT'); + if (amountOut < minAmountOut) revert HopBadAmountOut(amountOut, minAmountOut); } } diff --git a/packages/connectors/contracts/swap/paraswap-v5/ParaswapV5Connector.sol b/packages/connectors/contracts/swap/paraswap-v5/ParaswapV5Connector.sol index 280c0fca..e2dc0422 100644 --- a/packages/connectors/contracts/swap/paraswap-v5/ParaswapV5Connector.sol +++ b/packages/connectors/contracts/swap/paraswap-v5/ParaswapV5Connector.sol @@ -26,6 +26,21 @@ import './IParaswapV5Augustus.sol'; * @dev Interfaces with Paraswap V5 to swap tokens */ contract ParaswapV5Connector { + /** + * @dev The token in is the same as the token out + */ + error ParaswapV5SwapSameToken(address token); + + /** + * @dev The amount out is lower than the minimum amount out + */ + error ParaswapV5BadAmountOut(uint256 amountOut, uint256 minAmountOut); + + /** + * @dev The post token in balance is lower than the previous token in balance minus the amount in + */ + error ParaswapV5BadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn); + // Reference to Paraswap V5 Augustus swapper IParaswapV5Augustus public immutable paraswapV5Augustus; @@ -49,7 +64,7 @@ contract ParaswapV5Connector { external returns (uint256 amountOut) { - require(tokenIn != tokenOut, 'PARASWAP_V5_SWAP_SAME_TOKEN'); + if (tokenIn == tokenOut) revert ParaswapV5SwapSameToken(tokenIn); uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this)); uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this)); @@ -59,10 +74,11 @@ contract ParaswapV5Connector { Address.functionCall(address(paraswapV5Augustus), data, 'PARASWAP_V5_SWAP_FAILED'); uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'PARASWAP_V5_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert ParaswapV5BadPostTokenInBalance(postBalanceIn, preBalanceIn, amountIn); uint256 postBalanceOut = IERC20(tokenOut).balanceOf(address(this)); amountOut = postBalanceOut - preBalanceOut; - require(amountOut >= minAmountOut, 'PARASWAP_V5_MIN_AMOUNT_OUT'); + if (amountOut < minAmountOut) revert ParaswapV5BadAmountOut(amountOut, minAmountOut); } } diff --git a/packages/connectors/contracts/swap/uniswap-v2/UniswapV2Connector.sol b/packages/connectors/contracts/swap/uniswap-v2/UniswapV2Connector.sol index ca56df5d..58a15384 100644 --- a/packages/connectors/contracts/swap/uniswap-v2/UniswapV2Connector.sol +++ b/packages/connectors/contracts/swap/uniswap-v2/UniswapV2Connector.sol @@ -28,6 +28,26 @@ import './IUniswapV2Router02.sol'; * @dev Interfaces with Uniswap V2 to swap tokens */ contract UniswapV2Connector { + /** + * @dev The token in is the same as the token out + */ + error UniswapV2SwapSameToken(address token); + + /** + * @dev The pool does not exist + */ + error UniswapV2InvalidPool(address tokenA, address tokenB); + + /** + * @dev The amount out is lower than the minimum amount out + */ + error UniswapV2BadAmountOut(uint256 amountOut, uint256 minAmountOut); + + /** + * @dev The post token in balance is lower than the previous token in balance minus the amount in + */ + error UniswapV2BadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn); + // Reference to UniswapV2 router IUniswapV2Router02 public immutable uniswapV2Router; @@ -54,7 +74,7 @@ contract UniswapV2Connector { uint256 minAmountOut, address[] memory hopTokens ) external returns (uint256 amountOut) { - require(tokenIn != tokenOut, 'UNI_V2_SWAP_SAME_TOKEN'); + if (tokenIn == tokenOut) revert UniswapV2SwapSameToken(tokenIn); uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this)); uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this)); @@ -65,11 +85,12 @@ contract UniswapV2Connector { : _batchSwap(tokenIn, tokenOut, amountIn, minAmountOut, hopTokens); uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'UNI_V2_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert UniswapV2BadPostTokenInBalance(postBalanceIn, preBalanceIn, amountIn); uint256 postBalanceOut = IERC20(tokenOut).balanceOf(address(this)); amountOut = postBalanceOut - preBalanceOut; - require(amountOut >= minAmountOut, 'UNI_V2_MIN_AMOUNT_OUT'); + if (amountOut < minAmountOut) revert UniswapV2BadAmountOut(amountOut, minAmountOut); } /** @@ -120,6 +141,6 @@ contract UniswapV2Connector { */ function _validatePool(address factory, address tokenA, address tokenB) private view { address pool = IUniswapV2Factory(factory).getPair(tokenA, tokenB); - require(pool != address(0), 'INVALID_UNISWAP_POOL'); + if (pool == address(0)) revert UniswapV2InvalidPool(tokenA, tokenB); } } diff --git a/packages/connectors/contracts/swap/uniswap-v3/UniswapV3Connector.sol b/packages/connectors/contracts/swap/uniswap-v3/UniswapV3Connector.sol index 3801f4f9..d23d0946 100644 --- a/packages/connectors/contracts/swap/uniswap-v3/UniswapV3Connector.sol +++ b/packages/connectors/contracts/swap/uniswap-v3/UniswapV3Connector.sol @@ -31,6 +31,31 @@ import './IUniswapV3PeripheryImmutableState.sol'; contract UniswapV3Connector { using BytesHelpers for bytes; + /** + * @dev The input length mismatch + */ + error UniswapV3InputLengthMismatch(); + + /** + * @dev The token in is the same as the token out + */ + error UniswapV3SwapSameToken(address token); + + /** + * @dev A pool with the given tokens and fee does not exist + */ + error UniswapV3InvalidPoolFee(address token0, address token1, uint24 fee); + + /** + * @dev The amount out is lower than the minimum amount out + */ + error UniswapV3BadAmountOut(uint256 amountOut, uint256 minAmountOut); + + /** + * @dev The post token in balance is lower than the previous token in balance minus the amount in + */ + error UniswapV3BadPostTokenInBalance(uint256 postBalanceIn, uint256 preBalanceIn, uint256 amountIn); + // Reference to UniswapV3 router IUniswapV3SwapRouter public immutable uniswapV3Router; @@ -61,8 +86,8 @@ contract UniswapV3Connector { address[] memory hopTokens, uint24[] memory hopFees ) external returns (uint256 amountOut) { - require(tokenIn != tokenOut, 'UNI_V3_SWAP_SAME_TOKEN'); - require(hopTokens.length == hopFees.length, 'UNI_V3_BAD_HOP_TOKENS_FEES_LEN'); + if (tokenIn == tokenOut) revert UniswapV3SwapSameToken(tokenIn); + if (hopTokens.length != hopFees.length) revert UniswapV3InputLengthMismatch(); uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this)); uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this)); @@ -73,11 +98,12 @@ contract UniswapV3Connector { : _batchSwap(tokenIn, tokenOut, amountIn, minAmountOut, fee, hopTokens, hopFees); uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this)); - require(postBalanceIn >= preBalanceIn - amountIn, 'UNI_V3_BAD_TOKEN_IN_BALANCE'); + bool isPostBalanceInUnexpected = postBalanceIn < preBalanceIn - amountIn; + if (isPostBalanceInUnexpected) revert UniswapV3BadPostTokenInBalance(postBalanceIn, preBalanceIn, amountIn); uint256 postBalanceOut = IERC20(tokenOut).balanceOf(address(this)); amountOut = postBalanceOut - preBalanceOut; - require(amountOut >= minAmountOut, 'UNI_V3_MIN_AMOUNT_OUT'); + if (amountOut < minAmountOut) revert UniswapV3BadAmountOut(amountOut, minAmountOut); } /** @@ -160,7 +186,8 @@ contract UniswapV3Connector { */ function _validatePool(address factory, address tokenA, address tokenB, uint24 fee) internal view { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); - require(IUniswapV3Factory(factory).getPool(token0, token1, fee) != address(0), 'UNI_V3_INVALID_POOL_FEE'); + address pool = IUniswapV3Factory(factory).getPool(token0, token1, fee); + if (pool == address(0)) revert UniswapV3InvalidPoolFee(token0, token1, fee); } /** diff --git a/packages/connectors/test/bridge/axelar/AxelarConnector.behavior.ts b/packages/connectors/test/bridge/axelar/AxelarConnector.behavior.ts index 1900673f..449389d9 100644 --- a/packages/connectors/test/bridge/axelar/AxelarConnector.behavior.ts +++ b/packages/connectors/test/bridge/axelar/AxelarConnector.behavior.ts @@ -3,6 +3,8 @@ import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-wit import { expect } from 'chai' import { BigNumber, Contract } from 'ethers' +/* eslint-disable no-secrets/no-secrets */ + export function itBehavesLikeAxelarConnector( sourceChainId: number, tokenAddress: string, @@ -47,7 +49,7 @@ export function itBehavesLikeAxelarConnector( it('reverts', async function () { await expect( this.connector.connect(whale).execute(destinationChainId, tokenAddress, amountIn, whale.address) - ).to.be.revertedWith('AXELAR_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('AxelarBridgeSameChain') }) } } @@ -94,7 +96,7 @@ export function itBehavesLikeAxelarConnector( it('reverts', async function () { await expect( this.connector.connect(whale).execute(destinationChainId, tokenAddress, amountIn, whale.address) - ).to.be.revertedWith('AXELAR_UNKNOWN_CHAIN_ID') + ).to.be.revertedWith('AxelarBridgeUnknownChainId') }) }) }) @@ -102,7 +104,7 @@ export function itBehavesLikeAxelarConnector( context('when the recipient is the zero address', async () => { it('reverts', async function () { await expect(this.connector.connect(whale).execute(0, tokenAddress, 0, ZERO_ADDRESS)).to.be.revertedWith( - 'AXELAR_BRIDGE_RECIPIENT_ZERO' + 'AxelarBridgeRecipientZero' ) }) }) diff --git a/packages/connectors/test/bridge/connext/ConnextConnector.behavior.ts b/packages/connectors/test/bridge/connext/ConnextConnector.behavior.ts index 0b565a83..39284ce9 100644 --- a/packages/connectors/test/bridge/connext/ConnextConnector.behavior.ts +++ b/packages/connectors/test/bridge/connext/ConnextConnector.behavior.ts @@ -3,6 +3,8 @@ import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-wit import { expect } from 'chai' import { BigNumber, Contract } from 'ethers' +/* eslint-disable no-secrets/no-secrets */ + export function itBehavesLikeConnextConnector( sourceChainId: number, tokenAddress: string, @@ -52,22 +54,26 @@ export function itBehavesLikeConnextConnector( }) context('when relayerFee is greater than amountIn', () => { + const relayerFee = amountIn.add(1) + it('reverts', async function () { await expect( this.connector .connect(whale) - .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address, amountIn.add(1)) - ).to.be.revertedWith('CONNEXT_RELAYER_FEE_GT_AMOUNT_IN') + .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address, relayerFee) + ).to.be.revertedWith('ConnextBridgeRelayerFeeGtAmount') }) }) context('when minAmountOut is greater than amountIn minus relayerFee', () => { + const minAmountOut = amountIn.add(1) + it('reverts', async function () { await expect( this.connector .connect(whale) - .execute(destinationChainId, tokenAddress, amountIn, amountIn.add(1), whale.address, relayerFee) - ).to.be.revertedWith('CONNEXT_MIN_AMOUNT_OUT_TOO_BIG') + .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address, relayerFee) + ).to.be.revertedWith('ConnextBridgeMinAmountOutTooBig') }) }) } else { @@ -76,7 +82,7 @@ export function itBehavesLikeConnextConnector( this.connector .connect(whale) .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address, relayerFee) - ).to.be.revertedWith('CONNEXT_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('ConnextBridgeSameChain') }) } } @@ -125,7 +131,7 @@ export function itBehavesLikeConnextConnector( this.connector .connect(whale) .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address, relayerFee) - ).to.be.revertedWith('CONNEXT_UNKNOWN_CHAIN_ID') + ).to.be.revertedWith('ConnextBridgeUnknownChainId') }) }) }) @@ -133,7 +139,7 @@ export function itBehavesLikeConnextConnector( context('when the recipient is the zero address', async () => { it('reverts', async function () { await expect(this.connector.connect(whale).execute(0, tokenAddress, 0, 0, ZERO_ADDRESS, 0)).to.be.revertedWith( - 'CONNEXT_BRIDGE_RECIPIENT_ZERO' + 'ConnextBridgeRecipientZero' ) }) }) diff --git a/packages/connectors/test/bridge/hop/HopConnector.mainnet.ts b/packages/connectors/test/bridge/hop/HopConnector.mainnet.ts index 0d45fb80..9a30240c 100644 --- a/packages/connectors/test/bridge/hop/HopConnector.mainnet.ts +++ b/packages/connectors/test/bridge/hop/HopConnector.mainnet.ts @@ -86,7 +86,7 @@ describe('HopConnector', () => { ZERO_ADDRESS, 0 ) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) } } @@ -123,7 +123,7 @@ describe('HopConnector', () => { connector .connect(whale) .execute(destinationChainId, WETH, 0, 0, whale.address, HOP_ETH_BRIDGE, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) }) @@ -135,7 +135,7 @@ describe('HopConnector', () => { connector .connect(whale) .execute(destinationChainId, WETH, 0, 0, whale.address, HOP_ETH_BRIDGE, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_OP_NOT_SUPPORTED') + ).to.be.revertedWith('HopBridgeOpNotSupported') }) }) }) @@ -144,7 +144,7 @@ describe('HopConnector', () => { it('reverts', async function () { await expect( connector.connect(whale).execute(0, WETH, 0, 0, ZERO_ADDRESS, ZERO_ADDRESS, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_RECIPIENT_ZERO') + ).to.be.revertedWith('HopBridgeRecipientZero') }) }) }) @@ -207,7 +207,7 @@ describe('HopConnector', () => { ZERO_ADDRESS, 0 ) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) } } @@ -242,7 +242,7 @@ describe('HopConnector', () => { it('reverts', async () => { await expect( connector.execute(destinationChainId, USDC, 0, 0, whale.address, HOP_USDC_BRIDGE, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) }) @@ -252,7 +252,7 @@ describe('HopConnector', () => { it('reverts', async () => { await expect( connector.execute(destinationChainId, USDC, 0, 0, whale.address, HOP_USDC_BRIDGE, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_OP_NOT_SUPPORTED') + ).to.be.revertedWith('HopBridgeOpNotSupported') }) }) }) @@ -261,7 +261,7 @@ describe('HopConnector', () => { it('reverts', async function () { await expect( connector.connect(whale).execute(0, USDC, 0, 0, ZERO_ADDRESS, HOP_USDC_BRIDGE, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_RECIPIENT_ZERO') + ).to.be.revertedWith('HopBridgeRecipientZero') }) }) }) diff --git a/packages/connectors/test/bridge/hop/HopL2ERC20Connector.behavior.ts b/packages/connectors/test/bridge/hop/HopL2ERC20Connector.behavior.ts index 884e74bb..bf064314 100644 --- a/packages/connectors/test/bridge/hop/HopL2ERC20Connector.behavior.ts +++ b/packages/connectors/test/bridge/hop/HopL2ERC20Connector.behavior.ts @@ -135,7 +135,7 @@ export function itBehavesLikeHopERC20Connector( ZERO_ADDRESS, bonderFee ) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) } } @@ -187,7 +187,7 @@ export function itBehavesLikeHopERC20Connector( it('reverts', async function () { await expect( this.connector.connect(whale).execute(0, tokenAddress, 0, 0, ZERO_ADDRESS, ZERO_ADDRESS, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_RECIPIENT_ZERO') + ).to.be.revertedWith('HopBridgeRecipientZero') }) }) } diff --git a/packages/connectors/test/bridge/hop/HopL2NativeConnector.behavior.ts b/packages/connectors/test/bridge/hop/HopL2NativeConnector.behavior.ts index 37918a98..575cbe83 100644 --- a/packages/connectors/test/bridge/hop/HopL2NativeConnector.behavior.ts +++ b/packages/connectors/test/bridge/hop/HopL2NativeConnector.behavior.ts @@ -137,7 +137,7 @@ export function itBehavesLikeHopNativeConnector( ZERO_ADDRESS, 0 ) - ).to.be.revertedWith('HOP_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('HopBridgeSameChain') }) } } @@ -202,7 +202,7 @@ export function itBehavesLikeHopNativeConnector( this.connector .connect(whale) .execute(0, wrappedNativeTokenAddress, 0, 0, ZERO_ADDRESS, ZERO_ADDRESS, 0, ZERO_ADDRESS, 0) - ).to.be.revertedWith('HOP_BRIDGE_RECIPIENT_ZERO') + ).to.be.revertedWith('HopBridgeRecipientZero') }) }) } diff --git a/packages/connectors/test/bridge/wormhole/WormholeConnector.behavior.ts b/packages/connectors/test/bridge/wormhole/WormholeConnector.behavior.ts index d4655703..7c3ae9ea 100644 --- a/packages/connectors/test/bridge/wormhole/WormholeConnector.behavior.ts +++ b/packages/connectors/test/bridge/wormhole/WormholeConnector.behavior.ts @@ -3,6 +3,8 @@ import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-wit import { expect } from 'chai' import { BigNumber, Contract } from 'ethers' +/* eslint-disable no-secrets/no-secrets */ + export function itBehavesLikeWormholeConnector( sourceChainId: number, tokenAddress: string, @@ -51,22 +53,26 @@ export function itBehavesLikeWormholeConnector( }) context('when relayerFee is greater than amountIn', () => { + const amountIn = relayerFee.sub(1) + it('reverts', async function () { await expect( this.connector .connect(whale) - .execute(destinationChainId, tokenAddress, relayerFee.sub(1), minAmountOut, whale.address) - ).to.be.revertedWith('WORMHOLE_RELAYER_FEE_GT_AMT_IN') + .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address) + ).to.be.revertedWith('WormholeBridgeRelayerFeeGtAmount') }) }) context('when minAmountOut is greater than amountIn minus relayerFee', () => { + const minAmountOut = amountIn.add(1) + it('reverts', async function () { await expect( this.connector .connect(whale) - .execute(destinationChainId, tokenAddress, amountIn, amountIn.add(1), whale.address) - ).to.be.revertedWith('WORMHOLE_MIN_AMOUNT_OUT_TOO_BIG') + .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address) + ).to.be.revertedWith('WormholeBridgeMinAmountOutTooBig') }) }) } else { @@ -75,7 +81,7 @@ export function itBehavesLikeWormholeConnector( this.connector .connect(whale) .execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address) - ).to.be.revertedWith('WORMHOLE_BRIDGE_SAME_CHAIN') + ).to.be.revertedWith('WormholeBridgeSameChain') }) } } @@ -98,7 +104,7 @@ export function itBehavesLikeWormholeConnector( it('reverts', async function () { await expect( this.connector.connect(whale).execute(destinationChainId, tokenAddress, amountIn, minAmountOut, whale.address) - ).to.be.revertedWith('WORMHOLE_UNKNOWN_CHAIN_ID') + ).to.be.revertedWith('WormholeBridgeUnknownChainId') }) }) }) @@ -106,7 +112,7 @@ export function itBehavesLikeWormholeConnector( context('when the recipient is the zero address', async () => { it('reverts', async function () { await expect(this.connector.connect(whale).execute(0, tokenAddress, 0, 0, ZERO_ADDRESS)).to.be.revertedWith( - 'WORMHOLE_BRIDGE_RECIPIENT_ZERO' + 'WormholeBridgeRecipientZero' ) }) }) diff --git a/packages/deployer/contracts/Deployer.sol b/packages/deployer/contracts/Deployer.sol index d31f60d8..f22758b3 100644 --- a/packages/deployer/contracts/Deployer.sol +++ b/packages/deployer/contracts/Deployer.sol @@ -25,8 +25,30 @@ import '@mimic-fi/v3-registry/contracts/interfaces/IRegistry.sol'; contract Deployer { using Address for address; - // Registry reference - IRegistry public immutable registry; + /** + * @dev The namespace is empty + */ + error DeployerNamespaceEmpty(); + + /** + * @dev The name is empty + */ + error DeployerNameEmpty(); + + /** + * @dev The implementation is not registered + */ + error DeployerImplementationNotRegistered(address implementation); + + /** + * @dev The implementation is stateless + */ + error DeployerImplementationStateless(address implementation); + + /** + * @dev The implementation is deprecated + */ + error DeployerImplementationDeprecated(address implementation); /** * @dev Emitted every time an authorizer is deployed @@ -38,7 +60,7 @@ contract Deployer { */ event PriceOracleDeployed(string namespace, string name, address instance, address implementation); - /**Bas + /** * @dev Emitted every time a smart vault is deployed */ event SmartVaultDeployed(string namespace, string name, address instance, address implementation); @@ -48,6 +70,9 @@ contract Deployer { */ event TaskDeployed(string namespace, string name, address instance, address implementation); + // Registry reference + IRegistry public immutable registry; + /** * @dev Creates a new Deployer contract * @param _registry Address of the Mimic Registry to be referenced @@ -165,9 +190,9 @@ contract Deployer { * @param implementation Address of the implementation to be checked */ function _validateImplementation(address implementation) internal view { - require(registry.isRegistered(implementation), 'DEPLOYER_IMPL_NOT_REGISTERED'); - require(!registry.isStateless(implementation), 'DEPLOYER_IMPL_STATELESS'); - require(!registry.isDeprecated(implementation), 'DEPLOYER_IMPL_DEPRECATED'); + if (!registry.isRegistered(implementation)) revert DeployerImplementationNotRegistered(implementation); + if (registry.isStateless(implementation)) revert DeployerImplementationStateless(implementation); + if (registry.isDeprecated(implementation)) revert DeployerImplementationDeprecated(implementation); } /** @@ -177,8 +202,8 @@ contract Deployer { internal returns (address) { - require(bytes(namespace).length > 0, 'DEPLOYER_NAMESPACE_EMPTY'); - require(bytes(name).length > 0, 'DEPLOYER_NAME_EMPTY'); + if (bytes(namespace).length == 0) revert DeployerNamespaceEmpty(); + if (bytes(name).length == 0) revert DeployerNameEmpty(); bytes memory bytecode = abi.encodePacked( hex'3d602d80600a3d3981f3363d3d373d3d3d363d73', diff --git a/packages/deployer/test/Deployer.test.ts b/packages/deployer/test/Deployer.test.ts index 573e9628..eaa5b786 100644 --- a/packages/deployer/test/Deployer.test.ts +++ b/packages/deployer/test/Deployer.test.ts @@ -125,7 +125,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deployAuthorizer(namespace, name, { impl: authorizer.address, owners: [sender.address] }) - ).to.be.revertedWith('DEPLOYER_IMPL_DEPRECATED') + ).to.be.revertedWith('DeployerImplementationDeprecated') }) }) }) @@ -134,7 +134,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deployAuthorizer(namespace, name, { impl: authorizer.address, owners: [sender.address] }) - ).to.be.revertedWith('DEPLOYER_IMPL_NOT_REGISTERED') + ).to.be.revertedWith('DeployerImplementationNotRegistered') }) }) }) @@ -262,7 +262,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deployPriceOracle(namespace, name, { impl: priceOracle.address, ...priceOracleParams }) - ).to.be.revertedWith('DEPLOYER_IMPL_DEPRECATED') + ).to.be.revertedWith('DeployerImplementationDeprecated') }) }) }) @@ -271,7 +271,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deployPriceOracle(namespace, name, { impl: priceOracle.address, ...priceOracleParams }) - ).to.be.revertedWith('DEPLOYER_IMPL_NOT_REGISTERED') + ).to.be.revertedWith('DeployerImplementationNotRegistered') }) }) }) @@ -390,7 +390,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deploySmartVault(namespace, name, { impl: smartVault.address, ...smartVaultParams }) - ).to.be.revertedWith('DEPLOYER_IMPL_DEPRECATED') + ).to.be.revertedWith('DeployerImplementationDeprecated') }) }) }) @@ -399,7 +399,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect( deployer.deploySmartVault(namespace, name, { impl: smartVault.address, ...smartVaultParams }) - ).to.be.revertedWith('DEPLOYER_IMPL_NOT_REGISTERED') + ).to.be.revertedWith('DeployerImplementationNotRegistered') }) }) }) @@ -520,7 +520,7 @@ describe('Deployer', () => { it('reverts', async () => { await expect(deployer.deployTask(namespace, name, { impl: task.address, initializeData })).to.be.revertedWith( - 'DEPLOYER_IMPL_DEPRECATED' + 'DeployerImplementationDeprecated' ) }) }) @@ -529,7 +529,7 @@ describe('Deployer', () => { context('when the implementation is not registered', () => { it('reverts', async () => { await expect(deployer.deployTask(namespace, name, { impl: task.address, initializeData })).to.be.revertedWith( - 'DEPLOYER_IMPL_NOT_REGISTERED' + 'DeployerImplementationNotRegistered' ) }) }) diff --git a/packages/fee-controller/contracts/FeeController.sol b/packages/fee-controller/contracts/FeeController.sol index 4c994bd7..0c7ffc3c 100644 --- a/packages/fee-controller/contracts/FeeController.sol +++ b/packages/fee-controller/contracts/FeeController.sol @@ -67,7 +67,7 @@ contract FeeController is IFeeController, Ownable { */ function getFee(address smartVault) external view override returns (uint256 max, uint256 pct, address collector) { Fee storage fee = _fees[smartVault]; - require(fee.maxPct > 0, 'FEE_CONTROLLER_SV_NOT_SET'); + if (fee.maxPct == 0) revert FeeControllerMaxPctNotSet(smartVault); pct = fee.pct; max = fee.maxPct; @@ -88,13 +88,13 @@ contract FeeController is IFeeController, Ownable { * @param maxPct Max fee percentage to be set */ function setMaxFeePercentage(address smartVault, uint256 maxPct) external override onlyOwner { - require(maxPct > 0, 'FEE_CONTROLLER_MAX_PCT_ZERO'); + if (maxPct == 0) revert FeeControllerMaxPctZero(); Fee storage fee = _fees[smartVault]; if (fee.maxPct == 0) { - require(maxPct < FixedPoint.ONE, 'FEE_CONTROLLER_MAX_PCT_ABOVE_ONE'); + if (maxPct >= FixedPoint.ONE) revert FeeControllerMaxPctAboveOne(); } else { - require(maxPct < fee.maxPct, 'FEE_CONTROLLER_MAX_PCT_ABOVE_PRE'); + if (maxPct >= fee.maxPct) revert FeeControllerMaxPctAbovePrevious(smartVault, maxPct, fee.maxPct); } fee.maxPct = maxPct; @@ -117,9 +117,9 @@ contract FeeController is IFeeController, Ownable { * @param collector Fee collector to be set */ function setFeeCollector(address smartVault, address collector) external override onlyOwner { - require(collector != address(0), 'FEE_CONTROLLER_COLLECTOR_ZERO'); + if (collector == address(0)) revert FeeControllerCollectorZero(); Fee storage fee = _fees[smartVault]; - require(fee.maxPct > 0, 'FEE_CONTROLLER_SV_NOT_SET'); + if (fee.maxPct == 0) revert FeeControllerMaxPctNotSet(smartVault); fee.collector = collector; emit FeeCollectorSet(smartVault, collector); } @@ -129,7 +129,7 @@ contract FeeController is IFeeController, Ownable { * @param collector Default fee collector to be set */ function _setDefaultFeeCollector(address collector) private { - require(collector != address(0), 'FEE_CONTROLLER_COLLECTOR_ZERO'); + if (collector == address(0)) revert FeeControllerCollectorZero(); defaultFeeCollector = collector; emit DefaultFeeCollectorSet(collector); } @@ -141,8 +141,8 @@ contract FeeController is IFeeController, Ownable { */ function _setFeePercentage(address smartVault, uint256 pct) private { Fee storage fee = _fees[smartVault]; - require(fee.maxPct > 0, 'FEE_CONTROLLER_SV_NOT_SET'); - require(pct <= fee.maxPct, 'FEE_CONTROLLER_PCT_ABOVE_MAX'); + if (fee.maxPct == 0) revert FeeControllerMaxPctNotSet(smartVault); + if (pct > fee.maxPct) revert FeeControllerPctAboveMax(smartVault, pct, fee.maxPct); fee.pct = pct; emit FeePercentageSet(smartVault, pct); } diff --git a/packages/fee-controller/contracts/interfaces/IFeeController.sol b/packages/fee-controller/contracts/interfaces/IFeeController.sol index 7ff354e5..b0926c52 100644 --- a/packages/fee-controller/contracts/interfaces/IFeeController.sol +++ b/packages/fee-controller/contracts/interfaces/IFeeController.sol @@ -18,6 +18,36 @@ pragma solidity >=0.8.0; * @dev Fee controller interface */ interface IFeeController { + /** + * @dev The collector to be set is zero + */ + error FeeControllerCollectorZero(); + + /** + * @dev The requested max percentage to be set is zero + */ + error FeeControllerMaxPctZero(); + + /** + * @dev The requested max percentage to be set is above one + */ + error FeeControllerMaxPctAboveOne(); + + /** + * @dev No max percentage has been set for the requested smart vault + */ + error FeeControllerMaxPctNotSet(address smartVault); + + /** + * @dev The requested percentage to be set is above the smart vault's max percentage + */ + error FeeControllerPctAboveMax(address smartVault, uint256 pct, uint256 maxPct); + + /** + * @dev The requested max percentage to be set is above the previous max percentage set + */ + error FeeControllerMaxPctAbovePrevious(address smartVault, uint256 requestedMaxPct, uint256 previousMaxPct); + /** * @dev Emitted every time a default fee collector is set */ diff --git a/packages/fee-controller/test/FeeController.test.ts b/packages/fee-controller/test/FeeController.test.ts index 6f774dd3..520edcf5 100644 --- a/packages/fee-controller/test/FeeController.test.ts +++ b/packages/fee-controller/test/FeeController.test.ts @@ -22,7 +22,7 @@ describe('FeeController', () => { it('sets the default collector correctly', async () => { expect(await feeController.defaultFeeCollector()).to.be.equal(collector.address) expect(await feeController.hasFee(smartVault)).to.be.false - await expect(feeController.getFee(smartVault)).to.be.revertedWith('FEE_CONTROLLER_SV_NOT_SET') + await expect(feeController.getFee(smartVault)).to.be.revertedWith('FeeControllerMaxPctNotSet') }) it('sets the owner correctly', async () => { @@ -53,7 +53,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setDefaultFeeCollector(newCollector)).to.be.revertedWith( - 'FEE_CONTROLLER_COLLECTOR_ZERO' + 'FeeControllerCollectorZero' ) }) }) @@ -125,7 +125,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setMaxFeePercentage(smartVault, newFeePct)).to.be.revertedWith( - 'FEE_CONTROLLER_MAX_PCT_ABOVE_ONE' + 'FeeControllerMaxPctAboveOne' ) }) }) @@ -173,7 +173,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setMaxFeePercentage(smartVault, maxPct)).to.be.revertedWith( - 'FEE_CONTROLLER_MAX_PCT_ABOVE_PRE' + 'FeeControllerMaxPctAbovePrevious' ) }) }) @@ -224,7 +224,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setFeePercentage(smartVault, feePct)).to.be.revertedWith( - 'FEE_CONTROLLER_PCT_ABOVE_MAX' + 'FeeControllerPctAboveMax' ) }) }) @@ -235,7 +235,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setFeePercentage(smartVault, feePct)).to.be.revertedWith( - 'FEE_CONTROLLER_SV_NOT_SET' + 'FeeControllerMaxPctNotSet' ) }) }) @@ -281,7 +281,7 @@ describe('FeeController', () => { context('when there was no max set for the given smart vault', () => { it('reverts', async () => { await expect(feeController.setFeeCollector(smartVault, newCollector)).to.be.revertedWith( - 'FEE_CONTROLLER_SV_NOT_SET' + 'FeeControllerMaxPctNotSet' ) }) }) @@ -292,7 +292,7 @@ describe('FeeController', () => { it('reverts', async () => { await expect(feeController.setFeeCollector(smartVault, collector)).to.be.revertedWith( - 'FEE_CONTROLLER_COLLECTOR_ZERO' + 'FeeControllerCollectorZero' ) }) }) diff --git a/packages/helpers/contracts/math/FixedPoint.sol b/packages/helpers/contracts/math/FixedPoint.sol index a06e5e28..df98dac3 100644 --- a/packages/helpers/contracts/math/FixedPoint.sol +++ b/packages/helpers/contracts/math/FixedPoint.sol @@ -22,13 +22,28 @@ 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; - require(a == 0 || product / a == b, 'MUL_OVERFLOW'); + if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b); return product / ONE; } } @@ -39,7 +54,7 @@ library FixedPoint { function mulUp(uint256 a, uint256 b) internal pure returns (uint256) { unchecked { uint256 product = a * b; - require(a == 0 || product / a == b, 'MUL_OVERFLOW'); + if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b); return product == 0 ? 0 : (((product - 1) / ONE) + 1); } } @@ -49,10 +64,10 @@ library FixedPoint { */ function divDown(uint256 a, uint256 b) internal pure returns (uint256) { unchecked { - require(b != 0, 'ZERO_DIVISION'); + if (b == 0) revert FixedPointZeroDivision(); if (a == 0) return 0; uint256 aInflated = a * ONE; - require(aInflated / a == ONE, 'DIV_INTERNAL'); + if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated); return aInflated / b; } } @@ -62,10 +77,10 @@ library FixedPoint { */ function divUp(uint256 a, uint256 b) internal pure returns (uint256) { unchecked { - require(b != 0, 'ZERO_DIVISION'); + if (b == 0) revert FixedPointZeroDivision(); if (a == 0) return 0; uint256 aInflated = a * ONE; - require(aInflated / a == ONE, 'DIV_INTERNAL'); + if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated); return ((aInflated - 1) / b) + 1; } } diff --git a/packages/helpers/contracts/utils/BytesHelpers.sol b/packages/helpers/contracts/utils/BytesHelpers.sol index db3d9f2a..4d6076ec 100644 --- a/packages/helpers/contracts/utils/BytesHelpers.sol +++ b/packages/helpers/contracts/utils/BytesHelpers.sol @@ -19,6 +19,11 @@ pragma solidity ^0.8.0; * @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 */ @@ -44,7 +49,7 @@ library BytesHelpers { * @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) { - require(self.length >= start + 32, 'BYTES_OUT_OF_BOUNDS'); + if (self.length < start + 32) revert BytesOutOfBounds(start, self.length); assembly { result := mload(add(add(self, 0x20), start)) } diff --git a/packages/helpers/contracts/utils/EnumerableMap.sol b/packages/helpers/contracts/utils/EnumerableMap.sol index 23358867..a932a23a 100644 --- a/packages/helpers/contracts/utils/EnumerableMap.sol +++ b/packages/helpers/contracts/utils/EnumerableMap.sol @@ -31,13 +31,21 @@ import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol'; library EnumerableMap { using EnumerableSet for EnumerableSet.AddressSet; - // AddressToUintMap - + /** + * @dev Address to uint map + * @param _keys Set of map keys + * @param _values Map of values + */ struct AddressToUintMap { EnumerableSet.AddressSet _keys; mapping (address => uint256) _values; } + /** + * @dev The key doesn't exist in the map + */ + error EnumerableMapNonExistentKey(address key); + /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). @@ -100,7 +108,7 @@ library EnumerableMap { * * Requirements: * - * - `index` must be strictly less than {length}. + * - `index` must be strictly lower than {length}. */ function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) { address key = map._keys.at(index); @@ -116,7 +124,7 @@ library EnumerableMap { */ function get(AddressToUintMap storage map, address key) internal view returns (uint256) { uint256 value = map._values[key]; - require(value != 0 || contains(map, key), 'EnumerableMap: nonexistent key'); + if (value == 0 && !contains(map, key)) revert EnumerableMapNonExistentKey(key); return value; } @@ -217,7 +225,7 @@ library EnumerableMap { */ function get(AddressToAddressMap storage map, address key) internal view returns (address) { address value = map._values[key]; - require(value != address(0) || contains(map, key), 'EnumerableMap: nonexistent key'); + if (value == address(0) && !contains(map, key)) revert EnumerableMapNonExistentKey(key); return value; } diff --git a/packages/helpers/test/contracts/math/FixedPoint.test.ts b/packages/helpers/test/contracts/math/FixedPoint.test.ts index 26376919..602bd902 100644 --- a/packages/helpers/test/contracts/math/FixedPoint.test.ts +++ b/packages/helpers/test/contracts/math/FixedPoint.test.ts @@ -34,7 +34,7 @@ describe('FixedPoint', () => { expect(await library.divUp(1, 1)).to.be.equal(fp(1)) expect(await library.divUp(0, fp(2))).to.be.equal(0) expect(await library.divUp(fp(2), fp(2))).to.be.equal(fp(1)) - await expect(library.divUp(fp(2), 0)).to.be.revertedWith('ZERO_DIVISION') + await expect(library.divUp(fp(2), 0)).to.be.revertedWith('FixedPointZeroDivision') }) }) @@ -43,7 +43,7 @@ describe('FixedPoint', () => { expect(await library.divDown(1, 1)).to.be.equal(fp(1)) expect(await library.divDown(0, fp(2))).to.be.equal(0) expect(await library.divDown(fp(2), fp(2))).to.be.equal(fp(1)) - await expect(library.divDown(fp(2), 0)).to.be.revertedWith('ZERO_DIVISION') + await expect(library.divDown(fp(2), 0)).to.be.revertedWith('FixedPointZeroDivision') }) }) }) diff --git a/packages/helpers/test/contracts/utils/BytesHelpers.test.ts b/packages/helpers/test/contracts/utils/BytesHelpers.test.ts index 1551ffd8..6dbcf6bf 100644 --- a/packages/helpers/test/contracts/utils/BytesHelpers.test.ts +++ b/packages/helpers/test/contracts/utils/BytesHelpers.test.ts @@ -21,8 +21,8 @@ describe('BytesHelpers', () => { }) it('reverts if out of bounds', async () => { - await expect(library.toUint256(bytes, 64)).to.be.revertedWith('BYTES_OUT_OF_BOUNDS') - await expect(library.toUint256(bytes, 33)).to.be.revertedWith('BYTES_OUT_OF_BOUNDS') + await expect(library.toUint256(bytes, 64)).to.be.revertedWith('BytesOutOfBounds') + await expect(library.toUint256(bytes, 33)).to.be.revertedWith('BytesOutOfBounds') }) }) diff --git a/packages/helpers/test/contracts/utils/EnumerableMap.test.ts b/packages/helpers/test/contracts/utils/EnumerableMap.test.ts index 5626cf9e..50b95157 100644 --- a/packages/helpers/test/contracts/utils/EnumerableMap.test.ts +++ b/packages/helpers/test/contracts/utils/EnumerableMap.test.ts @@ -147,7 +147,7 @@ describe('EnumerableMap', () => { }) it('missing value', async () => { - await expect(map.get(keyB)).to.be.revertedWith('EnumerableMap: nonexistent key') + await expect(map.get(keyB)).to.be.revertedWith('EnumerableMapNonExistentKey') }) }) @@ -299,7 +299,7 @@ describe('EnumerableMap', () => { }) it('missing value', async () => { - await expect(map.get(keyB)).to.be.revertedWith('EnumerableMap: nonexistent key') + await expect(map.get(keyB)).to.be.revertedWith('EnumerableMapNonExistentKey') }) }) diff --git a/packages/price-oracle/contracts/PriceOracle.sol b/packages/price-oracle/contracts/PriceOracle.sol index 60a83864..42784841 100644 --- a/packages/price-oracle/contracts/PriceOracle.sol +++ b/packages/price-oracle/contracts/PriceOracle.sol @@ -152,8 +152,8 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { uint256 baseDecimals = IERC20Metadata(base).decimals(); uint256 quoteDecimals = IERC20Metadata(quote).decimals(); - // No need for checked math as an uint8 + FP_DECIMALS (constant) will always fit in an uint256 - require(baseDecimals <= quoteDecimals + FP_DECIMALS, 'BASE_DECIMALS_TOO_BIG'); + bool areBaseDecimalsTooBig = baseDecimals > quoteDecimals + FP_DECIMALS; + if (areBaseDecimalsTooBig) revert PriceOracleBaseDecimalsTooBig(base, baseDecimals, quote, quoteDecimals); // No need for checked math as we are checking it manually beforehand uint256 resultDecimals = quoteDecimals + FP_DECIMALS - baseDecimals; @@ -176,7 +176,8 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { for (uint256 i = 0; i < prices.length; i++) { PriceData memory price = prices[i]; if (price.base == base && price.quote == quote) { - require(price.deadline >= block.timestamp, 'ORACLE_PRICE_OUTDATED'); + bool isPastDeadline = price.deadline < block.timestamp; + if (isPastDeadline) revert PriceOracleOutdatedPrice(base, quote, price.deadline, block.timestamp); return price.rate; } } @@ -226,7 +227,7 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { address quoteFeed = getFeed[quote][pivot]; if (baseFeed != address(0) && quoteFeed != address(0)) return _getPivotPrice(baseFeed, quoteFeed); - revert('ORACLE_MISSING_FEED'); + revert PriceOracleMissingFeed(base, quote); } /** @@ -249,11 +250,11 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { */ function _getInversePrice(address inverseFeed) internal view returns (uint256 price, uint256 decimals) { (uint256 inversePrice, uint256 inverseFeedDecimals) = _getFeedData(inverseFeed); - require(inverseFeedDecimals <= INVERSE_FEED_MAX_DECIMALS, 'FEED_DECIMALS_TOO_BIG'); + bool areInverseFeedDecimalsTooBig = inverseFeedDecimals > INVERSE_FEED_MAX_DECIMALS; + if (areInverseFeedDecimalsTooBig) revert PriceOracleInverseFeedDecimalsTooBig(inverseFeed, inverseFeedDecimals); // Prices are requested for different purposes, we are rounding down always to follow a single strategy price = FixedPoint.ONE.divDown(inversePrice); - // No need for checked math as we are checking it manually beforehand decimals = INVERSE_FEED_MAX_DECIMALS - inverseFeedDecimals; } @@ -272,13 +273,12 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { (uint256 basePrice, uint256 baseFeedDecimals) = _getFeedData(baseFeed); (uint256 quotePrice, uint256 quoteFeedDecimals) = _getFeedData(quoteFeed); - // No need for checked math as an uint8 + FP_DECIMALS (constant) will always fit in an uint256 - require(quoteFeedDecimals <= baseFeedDecimals + FP_DECIMALS, 'QUOTE_FEED_DECIMALS_TOO_BIG'); + bool areQuoteFeedDecimalsTooBig = quoteFeedDecimals > baseFeedDecimals + FP_DECIMALS; + if (areQuoteFeedDecimalsTooBig) revert PriceOracleQuoteFeedDecimalsTooBig(quoteFeedDecimals, baseFeedDecimals); // Price is base/quote = (base/pivot) / (quote/pivot) // Prices are requested for different purposes, we are rounding down always to follow a single strategy price = basePrice.divDown(quotePrice); - // No need for checked math as we are checking it manually beforehand decimals = baseFeedDecimals + FP_DECIMALS - quoteFeedDecimals; } @@ -305,7 +305,9 @@ contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable { (PriceData[] memory prices, bytes memory signature) = abi.decode(data, (PriceData[], bytes)); (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(getPricesDigest(prices), signature); - require(error == ECDSA.RecoverError.NoError && isSignerAllowed(recovered), 'ORACLE_INVALID_SIGNER'); + + bool isSignerValid = error == ECDSA.RecoverError.NoError && isSignerAllowed(recovered); + if (!isSignerValid) revert PriceOracleInvalidSigner(recovered); return prices; } diff --git a/packages/price-oracle/contracts/interfaces/IPriceOracle.sol b/packages/price-oracle/contracts/interfaces/IPriceOracle.sol index ebe81efc..1eb269b8 100644 --- a/packages/price-oracle/contracts/interfaces/IPriceOracle.sol +++ b/packages/price-oracle/contracts/interfaces/IPriceOracle.sol @@ -42,6 +42,36 @@ interface IPriceOracle is IAuthorized { 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 */ diff --git a/packages/price-oracle/test/PriceOracle.test.ts b/packages/price-oracle/test/PriceOracle.test.ts index d6a8c2a6..2f1e9daf 100644 --- a/packages/price-oracle/test/PriceOracle.test.ts +++ b/packages/price-oracle/test/PriceOracle.test.ts @@ -113,7 +113,7 @@ describe('PriceOracle', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(priceOracle.setSigner(owner.address, true)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(priceOracle.setSigner(owner.address, true)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -169,7 +169,7 @@ describe('PriceOracle', () => { context('when sender is not authorized', () => { it('reverts', async () => { - await expect(priceOracle.setFeed(BASE, QUOTE, FEED)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(priceOracle.setFeed(BASE, QUOTE, FEED)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -194,7 +194,7 @@ describe('PriceOracle', () => { }) it('reverts', async () => { - await expect(getPrice()).to.be.revertedWith('ORACLE_MISSING_FEED') + await expect(getPrice()).to.be.revertedWith('PriceOracleMissingFeed') }) }) @@ -208,7 +208,7 @@ describe('PriceOracle', () => { }) it('reverts', async () => { - await expect(getPrice()).to.be.revertedWith('BASE_DECIMALS_TOO_BIG') + await expect(getPrice()).to.be.revertedWith('PriceOracleBaseDecimalsTooBig') }) } @@ -491,7 +491,7 @@ describe('PriceOracle', () => { }) it('reverts', async () => { - await expect(getPrice()).to.be.revertedWith('BASE_DECIMALS_TOO_BIG') + await expect(getPrice()).to.be.revertedWith('PriceOracleBaseDecimalsTooBig') }) } @@ -787,7 +787,7 @@ describe('PriceOracle', () => { }) it('reverts', async () => { - await expect(getPrice()).to.be.revertedWith('BASE_DECIMALS_TOO_BIG') + await expect(getPrice()).to.be.revertedWith('PriceOracleBaseDecimalsTooBig') }) } @@ -1591,13 +1591,13 @@ describe('PriceOracle', () => { const itRevertsDueToMissingFeed = () => { it('reverts due to missing feed', async () => { - await expect(getPrice()).to.be.revertedWith('ORACLE_MISSING_FEED') + await expect(getPrice()).to.be.revertedWith('PriceOracleMissingFeed') }) } const itRevertsDueToInvalidSignature = () => { it('reverts due to invalid signature', async () => { - await expect(getPrice()).to.be.revertedWith('ORACLE_INVALID_SIGNER') + await expect(getPrice()).to.be.revertedWith('PriceOracleInvalidSigner') }) } @@ -1633,7 +1633,7 @@ describe('PriceOracle', () => { const itRevertsDueToOutdatedFeed = () => { it('reverts due to outdated feed', async () => { - await expect(getPrice()).to.be.revertedWith('ORACLE_PRICE_OUTDATED') + await expect(getPrice()).to.be.revertedWith('PriceOracleOutdatedPrice') }) } diff --git a/packages/registry/contracts/Registry.sol b/packages/registry/contracts/Registry.sol index db28dd34..46bea0a4 100644 --- a/packages/registry/contracts/Registry.sol +++ b/packages/registry/contracts/Registry.sol @@ -67,9 +67,9 @@ contract Registry is IRegistry, Ownable { * @param implementation Address of the implementation to be deprecated */ function deprecate(address implementation) external override onlyOwner { - require(implementation != address(0), 'REGISTRY_IMPL_ADDRESS_ZERO'); - require(isRegistered[implementation], 'REGISTRY_IMPL_NOT_REGISTERED'); - require(!isDeprecated[implementation], 'REGISTRY_IMPL_ALREADY_DEPRECATED'); + if (implementation == address(0)) revert RegistryImplementationAddressZero(); + if (!isRegistered[implementation]) revert RegistryImplementationNotRegistered(implementation); + if (isDeprecated[implementation]) revert RegistryImplementationDeprecated(implementation); isDeprecated[implementation] = true; emit Deprecated(implementation); @@ -82,8 +82,8 @@ contract Registry is IRegistry, Ownable { * @param stateless Whether the given implementation is considered stateless or not */ function _register(string memory name, address implementation, bool stateless) internal { - require(implementation != address(0), 'REGISTRY_IMPL_ADDRESS_ZERO'); - require(!isRegistered[implementation], 'REGISTRY_IMPL_ALREADY_REGISTERED'); + if (implementation == address(0)) revert RegistryImplementationAddressZero(); + if (isRegistered[implementation]) revert RegistryImplementationRegistered(implementation); isRegistered[implementation] = true; isStateless[implementation] = stateless; diff --git a/packages/registry/contracts/interfaces/IRegistry.sol b/packages/registry/contracts/interfaces/IRegistry.sol index 0d6b6c86..623fd233 100644 --- a/packages/registry/contracts/interfaces/IRegistry.sol +++ b/packages/registry/contracts/interfaces/IRegistry.sol @@ -20,6 +20,26 @@ import './IRegistry.sol'; * @dev Registry interface */ interface IRegistry { + /** + * @dev The implementation address is zero + */ + error RegistryImplementationAddressZero(); + + /** + * @dev The implementation is already registered + */ + error RegistryImplementationRegistered(address implementation); + + /** + * @dev The implementation is not registered + */ + error RegistryImplementationNotRegistered(address implementation); + + /** + * @dev The implementation is already deprecated + */ + error RegistryImplementationDeprecated(address implementation); + /** * @dev Emitted every time an implementation is registered */ diff --git a/packages/registry/test/Registry.test.ts b/packages/registry/test/Registry.test.ts index ec3a94e9..f1d7b4aa 100644 --- a/packages/registry/test/Registry.test.ts +++ b/packages/registry/test/Registry.test.ts @@ -82,7 +82,7 @@ describe('Registry', () => { it('reverts', async () => { await expect(registry.register(name, implementation, true)).to.be.revertedWith( - 'REGISTRY_IMPL_ALREADY_REGISTERED' + 'RegistryImplementationRegistered' ) }) }) @@ -155,7 +155,7 @@ describe('Registry', () => { it('reverts', async () => { await expect(registry.register(name, implementation, true)).to.be.revertedWith( - 'REGISTRY_IMPL_ALREADY_REGISTERED' + 'RegistryImplementationRegistered' ) }) }) @@ -182,7 +182,7 @@ describe('Registry', () => { context('when the requested implementation is not registered', () => { it('reverts', async () => { - await expect(registry.deprecate(implementation)).to.be.revertedWith('REGISTRY_IMPL_NOT_REGISTERED') + await expect(registry.deprecate(implementation)).to.be.revertedWith('RegistryImplementationNotRegistered') }) }) @@ -213,7 +213,7 @@ describe('Registry', () => { }) it('reverts', async () => { - await expect(registry.deprecate(implementation)).to.be.revertedWith('REGISTRY_IMPL_ALREADY_DEPRECATED') + await expect(registry.deprecate(implementation)).to.be.revertedWith('RegistryImplementationDeprecated') }) }) }) diff --git a/packages/relayer/contracts/Relayer.sol b/packages/relayer/contracts/Relayer.sol index 5005b6fe..f2a3ca74 100644 --- a/packages/relayer/contracts/Relayer.sol +++ b/packages/relayer/contracts/Relayer.sol @@ -96,7 +96,7 @@ contract Relayer is IRelayer, Ownable { * @param collector Address of the collector to be set for the given smart vault */ function setSmartVaultCollector(address smartVault, address collector) external override onlyOwner { - require(collector != address(0), 'RELAYER_COLLECTOR_ZERO'); + if (collector == address(0)) revert RelayerCollectorZero(); getSmartVaultCollector[smartVault] = collector; emit SmartVaultCollectorSet(smartVault, collector); } @@ -117,7 +117,7 @@ contract Relayer is IRelayer, Ownable { * @param amount Amount of native tokens to be deposited, must match msg.value */ function deposit(address smartVault, uint256 amount) external payable override { - require(msg.value == amount, 'RELAYER_DEPOSIT_INVALID_AMOUNT'); + if (msg.value != amount) revert RelayerValueDoesNotMatchAmount(msg.value, amount); uint256 amountPaid = _payQuota(smartVault, amount); uint256 toDeposit = amount - amountPaid; getSmartVaultBalance[smartVault] += toDeposit; @@ -130,38 +130,43 @@ contract Relayer is IRelayer, Ownable { */ function withdraw(uint256 amount) external override { uint256 balance = getSmartVaultBalance[msg.sender]; - require(amount <= balance, 'RELAYER_SMART_VAULT_NO_BALANCE'); + if (amount > balance) revert RelayerWithdrawInsufficientBalance(msg.sender, balance, amount); + getSmartVaultBalance[msg.sender] = balance - amount; emit Withdrawn(msg.sender, amount); + (bool success, ) = payable(msg.sender).call{ value: amount }(''); - require(success, 'RELAYER_WITHDRAW_FAILED'); + if (!success) revert RelayerWithdrawFailed(msg.sender, amount); } /** * @dev Executes a list of tasks * @param tasks Addresses of the tasks to execute - * @param datas List of calldata to execute each of the given tasks + * @param data List of calldata to execute each of the given tasks * @param continueIfFailed Whether the execution should fail in case one of the tasks fail */ - function execute(address[] memory tasks, bytes[] memory datas, bool continueIfFailed) external override { - require(isExecutorAllowed[msg.sender], 'RELAYER_EXECUTOR_NOT_ALLOWED'); - require(tasks.length > 0, 'RELAYER_EXECUTE_NO_INPUT'); - require(tasks.length == datas.length, 'RELAYER_EXECUTE_INPUT_BAD_LENGTH'); + function execute(address[] memory tasks, bytes[] memory data, bool continueIfFailed) external override { + if (!isExecutorAllowed[msg.sender]) revert RelayerExecutorNotAllowed(msg.sender); + if (tasks.length == 0) revert RelayerNoTaskGiven(); + if (tasks.length != data.length) revert RelayerInputLengthMismatch(); uint256 totalGasUsed = BASE_GAS; address smartVault = ITask(tasks[0]).smartVault(); for (uint256 i = 0; i < tasks.length; i++) { uint256 initialGas = gasleft(); address task = tasks[i]; - require(ITask(task).smartVault() == smartVault, 'RELAYER_INVALID_TASK_SMART_VAULT'); - require(ISmartVault(smartVault).hasPermissions(task), 'RELAYER_INVALID_TASK_PERMISSIONS'); - bytes memory data = datas[i]; + address taskSmartVault = ITask(task).smartVault(); + if (taskSmartVault != smartVault) revert RelayerMultipleTaskSmartVaults(task, taskSmartVault, smartVault); + + bool hasPermissions = ISmartVault(smartVault).hasPermissions(task); + if (!hasPermissions) revert RelayerTaskDoesNotHavePermissions(task, smartVault); + // solhint-disable-next-line avoid-low-level-calls - (bool taskSuccess, bytes memory result) = task.call(data); + (bool taskSuccess, bytes memory result) = task.call(data[i]); uint256 gasUsed = initialGas - gasleft(); totalGasUsed += gasUsed; - emit TaskExecuted(smartVault, task, data, taskSuccess, result, gasUsed); + emit TaskExecuted(smartVault, task, data[i], taskSuccess, result, gasUsed); if (!taskSuccess && !continueIfFailed) break; } @@ -177,9 +182,9 @@ contract Relayer is IRelayer, Ownable { * @param amount Amount of tokens to withdraw */ function rescueFunds(address token, address recipient, uint256 amount) external override onlyOwner { - require(token != address(0), 'RELAYER_EXT_WITHDRAW_TOKEN_ZERO'); - require(recipient != address(0), 'RELAYER_EXT_WITHDRAW_DEST_ZERO'); - require(amount > 0, 'RELAYER_EXT_WITHDRAW_AMOUNT_ZERO'); + if (token == address(0)) revert RelayerTokenZero(); + if (recipient == address(0)) revert RelayerRecipientZero(); + if (amount == 0) revert RelayerAmountZero(); IERC20(token).safeTransfer(recipient, amount); emit FundsRescued(token, recipient, amount); @@ -191,7 +196,7 @@ contract Relayer is IRelayer, Ownable { * @param allowed Whether the given executor should be allowed or not */ function _setExecutor(address executor, bool allowed) internal { - require(executor != address(0), 'RELAYER_EXECUTOR_ZERO'); + if (executor == address(0)) revert RelayerExecutorZero(); isExecutorAllowed[executor] = allowed; emit ExecutorSet(executor, allowed); } @@ -201,7 +206,7 @@ contract Relayer is IRelayer, Ownable { * @param collector Default fee collector to be set */ function _setDefaultCollector(address collector) internal { - require(collector != address(0), 'RELAYER_COLLECTOR_ZERO'); + if (collector == address(0)) revert RelayerCollectorZero(); defaultCollector = collector; emit DefaultCollectorSet(collector); } @@ -216,7 +221,8 @@ contract Relayer is IRelayer, Ownable { uint256 maxQuota = getSmartVaultMaxQuota[smartVault]; uint256 usedQuota = getSmartVaultUsedQuota[smartVault]; uint256 availableQuota = usedQuota >= maxQuota ? 0 : (maxQuota - usedQuota); - require(amount <= balance + availableQuota, 'RELAYER_SMART_VAULT_NO_BALANCE'); + bool hasEnoughBalance = amount <= balance + availableQuota; + if (!hasEnoughBalance) revert RelayerPaymentInsufficientBalance(smartVault, balance, availableQuota, amount); uint256 quota; if (balance >= amount) { @@ -228,7 +234,7 @@ contract Relayer is IRelayer, Ownable { } (bool paySuccess, ) = getApplicableCollector(smartVault).call{ value: amount - quota }(''); - require(paySuccess, 'RELAYER_COLLECTOR_SEND_FAILED'); + if (!paySuccess) revert RelayerPaymentFailed(smartVault, amount, quota); emit GasPaid(smartVault, amount, quota); } diff --git a/packages/relayer/contracts/interfaces/IRelayer.sol b/packages/relayer/contracts/interfaces/IRelayer.sol index 382a63ee..eb7a7ebd 100644 --- a/packages/relayer/contracts/interfaces/IRelayer.sol +++ b/packages/relayer/contracts/interfaces/IRelayer.sol @@ -18,6 +18,81 @@ pragma solidity >=0.8.0; * @dev Relayer interface */ interface IRelayer { + /** + * @dev The token is zero + */ + error RelayerTokenZero(); + + /** + * @dev The amount is zero + */ + error RelayerAmountZero(); + + /** + * @dev The collector is zero + */ + error RelayerCollectorZero(); + + /** + * @dev The recipient is zero + */ + error RelayerRecipientZero(); + + /** + * @dev The executor is zero + */ + error RelayerExecutorZero(); + + /** + * @dev Relayer no task given to execute + */ + error RelayerNoTaskGiven(); + + /** + * @dev Relayer input length mismatch + */ + error RelayerInputLengthMismatch(); + + /** + * @dev The sender is not allowed + */ + error RelayerExecutorNotAllowed(address sender); + + /** + * @dev Trying to execute tasks from different smart vaults + */ + error RelayerMultipleTaskSmartVaults(address task, address taskSmartVault, address expectedSmartVault); + + /** + * @dev The task to execute does not have permissions on the associated smart vault + */ + error RelayerTaskDoesNotHavePermissions(address task, address smartVault); + + /** + * @dev The smart vault balance plus the available quota are lower than the amount to pay the relayer + */ + error RelayerPaymentInsufficientBalance(address smartVault, uint256 balance, uint256 quota, uint256 amount); + + /** + * @dev It failed to send amount minus quota to the smart vault's collector + */ + error RelayerPaymentFailed(address smartVault, uint256 amount, uint256 quota); + + /** + * @dev The smart vault balance is lower than the amount to withdraw + */ + error RelayerWithdrawInsufficientBalance(address sender, uint256 balance, uint256 amount); + + /** + * @dev It failed to send the amount to the sender + */ + error RelayerWithdrawFailed(address sender, uint256 amount); + + /** + * @dev The value sent and the amount differ + */ + error RelayerValueDoesNotMatchAmount(uint256 value, uint256 amount); + /** * @dev Emitted every time an executor is configured */ @@ -159,10 +234,10 @@ interface IRelayer { /** * @dev Executes a list of tasks * @param tasks Addresses of the tasks to execute - * @param datas List of calldata to execute each of the given tasks + * @param data List of calldata to execute each of the given tasks * @param continueIfFailed Whether the execution should fail in case one of the tasks fail */ - function execute(address[] memory tasks, bytes[] memory datas, bool continueIfFailed) external; + function execute(address[] memory tasks, bytes[] memory data, bool continueIfFailed) external; /** * @dev Withdraw ERC20 tokens to an external account. To be used in case of accidental token transfers. diff --git a/packages/relayer/test/Relayer.test.ts b/packages/relayer/test/Relayer.test.ts index f47a743a..c343e1c6 100644 --- a/packages/relayer/test/Relayer.test.ts +++ b/packages/relayer/test/Relayer.test.ts @@ -18,6 +18,8 @@ import { BigNumber, Contract } from 'ethers' import { defaultAbiCoder } from 'ethers/lib/utils' import { ethers } from 'hardhat' +/* eslint-disable no-secrets/no-secrets */ + describe('Relayer', () => { let relayer: Contract let executor: SignerWithAddress, collector: SignerWithAddress, owner: SignerWithAddress @@ -110,7 +112,7 @@ describe('Relayer', () => { const collector = ZERO_ADDRESS it('reverts', async () => { - await expect(relayer.setDefaultCollector(collector)).to.be.revertedWith('RELAYER_COLLECTOR_ZERO') + await expect(relayer.setDefaultCollector(collector)).to.be.revertedWith('RelayerCollectorZero') }) }) }) @@ -152,7 +154,7 @@ describe('Relayer', () => { it('reverts', async () => { await expect(relayer.setSmartVaultCollector(smartVault.address, collector)).to.be.revertedWith( - 'RELAYER_COLLECTOR_ZERO' + 'RelayerCollectorZero' ) }) }) @@ -352,7 +354,7 @@ describe('Relayer', () => { it('reverts', async () => { await expect(relayer.deposit(smartVault.address, amount, { value })).to.revertedWith( - 'RELAYER_DEPOSIT_INVALID_AMOUNT' + 'RelayerValueDoesNotMatchAmount' ) }) }) @@ -411,7 +413,7 @@ describe('Relayer', () => { const amount = balance.add(1) it('reverts', async () => { - await expect(relayer.connect(smartVault).withdraw(amount)).to.revertedWith('RELAYER_SMART_VAULT_NO_BALANCE') + await expect(relayer.connect(smartVault).withdraw(amount)).to.revertedWith('RelayerWithdrawInsufficientBalance') }) }) }) @@ -656,7 +658,7 @@ describe('Relayer', () => { context('when the available quota is not enough', () => { it('reverts', async () => { await expect(relayer.execute([task.address], ['0x'], false)).to.be.revertedWith( - 'RELAYER_SMART_VAULT_NO_BALANCE' + 'RelayerPaymentInsufficientBalance' ) }) }) @@ -666,7 +668,7 @@ describe('Relayer', () => { context('when the task does not have permissions over the associated smart vault', () => { it('reverts', async () => { await expect(relayer.execute([task.address], ['0x'], false)).to.be.revertedWith( - 'RELAYER_INVALID_TASK_PERMISSIONS' + 'RelayerTaskDoesNotHavePermissions' ) }) }) @@ -674,7 +676,7 @@ describe('Relayer', () => { context('when the sender is not an executor', () => { it('reverts', async () => { - await expect(relayer.execute([task.address], ['0x'], false)).to.be.revertedWith('RELAYER_EXECUTOR_NOT_ALLOWED') + await expect(relayer.execute([task.address], ['0x'], false)).to.be.revertedWith('RelayerExecutorNotAllowed') }) }) }) @@ -769,7 +771,7 @@ describe('Relayer', () => { const amount = 0 it('reverts', async () => { await expect(relayer.rescueFunds(token.address, recipient.address, amount)).to.be.revertedWith( - 'RELAYER_EXT_WITHDRAW_AMOUNT_ZERO' + 'RelayerAmountZero' ) }) }) @@ -779,7 +781,7 @@ describe('Relayer', () => { const recipientAddr = ZERO_ADDRESS it('reverts', async () => { await expect(relayer.rescueFunds(token.address, recipientAddr, amount)).to.be.revertedWith( - 'RELAYER_EXT_WITHDRAW_DEST_ZERO' + 'RelayerRecipientZero' ) }) }) @@ -788,9 +790,7 @@ describe('Relayer', () => { context('when the token is the zero address', () => { const tokenAddr = ZERO_ADDRESS it('reverts', async () => { - await expect(relayer.rescueFunds(tokenAddr, recipient.address, amount)).to.be.revertedWith( - 'RELAYER_EXT_WITHDRAW_TOKEN_ZERO' - ) + await expect(relayer.rescueFunds(tokenAddr, recipient.address, amount)).to.be.revertedWith('RelayerTokenZero') }) }) }) diff --git a/packages/smart-vault/contracts/SmartVault.sol b/packages/smart-vault/contracts/SmartVault.sol index 989a9626..9d2dc790 100644 --- a/packages/smart-vault/contracts/SmartVault.sol +++ b/packages/smart-vault/contracts/SmartVault.sol @@ -63,7 +63,7 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { * @dev Modifier to tag smart vault functions in order to check if it is paused */ modifier notPaused() { - require(!isPaused, 'SMART_VAULT_PAUSED'); + if (isPaused) revert SmartVaultPaused(); _; } @@ -125,16 +125,16 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { * @dev Pauses a smart vault. Sender must be authorized. */ function pause() external override auth { - require(!isPaused, 'SMART_VAULT_ALREADY_PAUSED'); + if (isPaused) revert SmartVaultPaused(); isPaused = true; emit Paused(); } /** - * @dev Unpauses a samrt vault. Sender must be authorized. + * @dev Unpauses a smart vault. Sender must be authorized. */ function unpause() external override auth { - require(isPaused, 'SMART_VAULT_ALREADY_UNPAUSED'); + if (!isPaused) revert SmartVaultUnpaused(); isPaused = false; emit Unpaused(); } @@ -183,8 +183,8 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { notPaused authP(authParams(id, token, amount, add)) { - require(id != bytes32(0), 'SMART_VAULT_CONNECTOR_ID_ZERO'); - require(token != address(0), 'SMART_VAULT_CONNECTOR_TOKEN_ZERO'); + if (id == bytes32(0)) revert SmartVaultBalanceConnectorIdZero(); + if (token == address(0)) revert SmartVaultTokenZero(); (add ? _increaseBalanceConnector : _decreaseBalanceConnector)(id, token, amount); } @@ -231,8 +231,9 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { * @param amount Amount of native tokens to be wrapped */ function wrap(uint256 amount) external override nonReentrant notPaused authP(authParams(amount)) { - require(amount > 0, 'SMART_VAULT_WRAP_AMOUNT_ZERO'); - require(address(this).balance >= amount, 'SMART_VAULT_WRAP_NO_BALANCE'); + if (amount == 0) revert SmartVaultAmountZero(); + uint256 balance = address(this).balance; + if (balance < amount) revert SmartVaultInsufficientNativeTokenBalance(balance, amount); IWrappedNativeToken(wrappedNativeToken).deposit{ value: amount }(); emit Wrapped(amount); } @@ -242,7 +243,7 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { * @param amount Amount of wrapped native tokens to unwrapped */ function unwrap(uint256 amount) external override nonReentrant notPaused authP(authParams(amount)) { - require(amount > 0, 'SMART_VAULT_UNWRAP_AMOUNT_ZERO'); + if (amount == 0) revert SmartVaultAmountZero(); IWrappedNativeToken(wrappedNativeToken).withdraw(amount); emit Unwrapped(amount); } @@ -260,7 +261,7 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { notPaused authP(authParams(token, from, amount)) { - require(amount > 0, 'SMART_VAULT_COLLECT_AMOUNT_ZERO'); + if (amount == 0) revert SmartVaultAmountZero(); IERC20(token).safeTransferFrom(from, address(this), amount); emit Collected(token, from, amount); } @@ -278,8 +279,8 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { notPaused authP(authParams(token, recipient, amount)) { - require(amount > 0, 'SMART_VAULT_WITHDRAW_AMOUNT_ZERO'); - require(recipient != address(0), 'SMART_VAULT_WITHDRAW_DEST_ZERO'); + if (amount == 0) revert SmartVaultAmountZero(); + if (recipient == address(0)) revert SmartVaultRecipientZero(); (, uint256 pct, address collector) = IFeeController(feeController).getFee(address(this)); uint256 feeAmount = amount.mulDown(pct); @@ -329,7 +330,7 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { */ function _decreaseBalanceConnector(bytes32 id, address token, uint256 amount) internal { uint256 value = getBalanceConnector[id][token]; - require(value >= amount, 'SMART_VAULT_CONNECTOR_NO_BALANCE'); + if (value < amount) revert SmartVaultBalanceConnectorInsufficientBalance(id, token, value, amount); getBalanceConnector[id][token] = value - amount; emit BalanceConnectorUpdated(id, token, amount, false); } @@ -340,8 +341,8 @@ contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable { */ function _validateConnector(address connector) private view { if (isConnectorCheckIgnored[connector]) return; - require(IRegistry(registry).isRegistered(connector), 'SMART_VAULT_CON_NOT_REGISTERED'); - require(IRegistry(registry).isStateless(connector), 'SMART_VAULT_CON_NOT_STATELESS'); - require(!IRegistry(registry).isDeprecated(connector), 'SMART_VAULT_CON_DEPRECATED'); + if (!IRegistry(registry).isRegistered(connector)) revert SmartVaultConnectorNotRegistered(connector); + if (!IRegistry(registry).isStateless(connector)) revert SmartVaultConnectorNotStateless(connector); + if (IRegistry(registry).isDeprecated(connector)) revert SmartVaultConnectorDeprecated(connector); } } diff --git a/packages/smart-vault/contracts/interfaces/ISmartVault.sol b/packages/smart-vault/contracts/interfaces/ISmartVault.sol index cc96523f..e9b23f57 100644 --- a/packages/smart-vault/contracts/interfaces/ISmartVault.sol +++ b/packages/smart-vault/contracts/interfaces/ISmartVault.sol @@ -20,6 +20,61 @@ 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 */ diff --git a/packages/smart-vault/test/SmartVaults.test.ts b/packages/smart-vault/test/SmartVaults.test.ts index 6cedd398..d6493f68 100644 --- a/packages/smart-vault/test/SmartVaults.test.ts +++ b/packages/smart-vault/test/SmartVaults.test.ts @@ -19,6 +19,8 @@ import { expect } from 'chai' import { Contract } from 'ethers' import { ethers } from 'hardhat' +/* eslint-disable no-secrets/no-secrets */ + describe('SmartVault', () => { let smartVault: Contract let authorizer: Contract, registry: Contract, feeController: Contract, wrappedNT: Contract @@ -103,14 +105,14 @@ describe('SmartVault', () => { }) it('cannot be paused', async () => { - await expect(smartVault.pause()).to.be.revertedWith('SMART_VAULT_ALREADY_PAUSED') + await expect(smartVault.pause()).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.pause()).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.pause()).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -125,7 +127,7 @@ describe('SmartVault', () => { context('when the smart vault is not paused', () => { it('cannot be unpaused', async () => { - await expect(smartVault.unpause()).to.be.revertedWith('SMART_VAULT_ALREADY_UNPAUSED') + await expect(smartVault.unpause()).to.be.revertedWith('SmartVaultUnpaused') }) }) @@ -148,7 +150,7 @@ describe('SmartVault', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.unpause()).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.unpause()).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -189,14 +191,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.setPriceOracle(priceOracle.address)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.setPriceOracle(priceOracle.address)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.setPriceOracle(priceOracle.address)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.setPriceOracle(priceOracle.address)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -265,7 +267,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect(smartVault.overrideConnectorCheck(connector.address, true)).to.be.revertedWith( - 'SMART_VAULT_PAUSED' + 'SmartVaultPaused' ) }) }) @@ -274,7 +276,7 @@ describe('SmartVault', () => { context('when sender is not authorized', () => { it('reverts', async () => { await expect(smartVault.overrideConnectorCheck(connector.address, true)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -352,7 +354,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect( smartVault.updateBalanceConnector(connector, token.address, amount, add) - ).to.be.revertedWith('SMART_VAULT_CONNECTOR_NO_BALANCE') + ).to.be.revertedWith('SmartVaultBalanceConnectorInsufficientBalance') }) }) }) @@ -363,7 +365,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect(smartVault.updateBalanceConnector(connector, token, amount, true)).to.be.revertedWith( - 'SMART_VAULT_CONNECTOR_TOKEN_ZERO' + 'SmartVaultTokenZero' ) }) }) @@ -374,7 +376,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect(smartVault.updateBalanceConnector(connector, ZERO_ADDRESS, amount, true)).to.be.revertedWith( - 'SMART_VAULT_CONNECTOR_ID_ZERO' + 'SmartVaultBalanceConnectorIdZero' ) }) }) @@ -383,7 +385,7 @@ describe('SmartVault', () => { context('when the sender is not authorized', () => { it('reverts', async () => { await expect(smartVault.updateBalanceConnector(ZERO_BYTES32, ZERO_ADDRESS, amount, true)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -451,7 +453,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect(smartVault.execute(connector.address, data)).to.be.revertedWith( - 'SMART_VAULT_CON_DEPRECATED' + 'SmartVaultConnectorDeprecated' ) }) }) @@ -466,7 +468,7 @@ describe('SmartVault', () => { it('reverts', async () => { await expect(smartVault.execute(connector.address, data)).to.be.revertedWith( - 'SMART_VAULT_CON_NOT_STATELESS' + 'SmartVaultConnectorNotStateless' ) }) }) @@ -476,7 +478,7 @@ describe('SmartVault', () => { context('when the connector check is not overridden', async () => { it('reverts', async () => { await expect(smartVault.execute(connector.address, data)).to.be.revertedWith( - 'SMART_VAULT_CON_NOT_REGISTERED' + 'SmartVaultConnectorNotRegistered' ) }) }) @@ -501,14 +503,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.execute(connector.address, data)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.execute(connector.address, data)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.execute(connector.address, data)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.execute(connector.address, data)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -571,14 +573,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.call(target.address, '0x', value)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.call(target.address, '0x', value)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.call(target.address, '0x', value)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.call(target.address, '0x', value)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -650,16 +652,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.collect(token.address, from.address, amount)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.collect(token.address, from.address, amount)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.collect(token.address, from.address, amount)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(smartVault.collect(token.address, from.address, amount)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -793,9 +793,7 @@ describe('SmartVault', () => { context('when the fee percentage was not set', async () => { it('reverts', async () => { - await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, amount)).to.be.revertedWith( - 'FEE_CONTROLLER_SV_NOT_SET' - ) + await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, amount)).to.be.reverted }) }) }) @@ -808,16 +806,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, 0)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, 0)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, 0)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(smartVault.withdraw(ZERO_ADDRESS, recipient.address, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -859,7 +855,7 @@ describe('SmartVault', () => { context('when the smart vault does not have enough native tokens', () => { it('reverts', async () => { - await expect(smartVault.wrap(amount)).to.be.revertedWith('SMART_VAULT_WRAP_NO_BALANCE') + await expect(smartVault.wrap(amount)).to.be.revertedWith('SmartVaultInsufficientNativeTokenBalance') }) }) }) @@ -872,14 +868,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.wrap(amount)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.wrap(amount)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.wrap(amount)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.wrap(amount)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -935,14 +931,14 @@ describe('SmartVault', () => { }) it('reverts', async () => { - await expect(smartVault.unwrap(amount)).to.be.revertedWith('SMART_VAULT_PAUSED') + await expect(smartVault.unwrap(amount)).to.be.revertedWith('SmartVaultPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(smartVault.unwrap(amount)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(smartVault.unwrap(amount)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/contracts/base/BaseTask.sol b/packages/tasks/contracts/base/BaseTask.sol index 75627ac9..6730a41b 100644 --- a/packages/tasks/contracts/base/BaseTask.sol +++ b/packages/tasks/contracts/base/BaseTask.sol @@ -136,7 +136,7 @@ abstract contract BaseTask is IBaseTask, Authorized { * @param next Balance connector id of the next task in the workflow */ function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual { - require(previous != next || previous == bytes32(0), 'TASK_SAME_BALANCE_CONNECTORS'); + if (previous == next && previous != bytes32(0)) revert TaskSameBalanceConnectors(previous); previousBalanceConnectorId = previous; nextBalanceConnectorId = next; emit BalanceConnectorsSet(previous, next); @@ -147,7 +147,7 @@ abstract contract BaseTask is IBaseTask, Authorized { */ function _getPrice(address base, address quote) internal view virtual returns (uint256) { address priceOracle = ISmartVault(smartVault).priceOracle(); - require(priceOracle != address(0), 'TASK_PRICE_ORACLE_NOT_SET'); + if (priceOracle == address(0)) revert TaskSmartVaultPriceOracleNotSet(base, quote); return IPriceOracle(priceOracle).getPrice(_wrappedIfNative(base), _wrappedIfNative(quote)); } diff --git a/packages/tasks/contracts/base/GasLimitedTask.sol b/packages/tasks/contracts/base/GasLimitedTask.sol index 5c1b8afb..a7082b91 100644 --- a/packages/tasks/contracts/base/GasLimitedTask.sol +++ b/packages/tasks/contracts/base/GasLimitedTask.sol @@ -117,26 +117,30 @@ abstract contract GasLimitedTask is IGasLimitedTask, Authorized { */ function _beforeGasLimitedTask(address, uint256) internal virtual { __initialGas__ = gasleft(); - require(gasPriceLimit == 0 || tx.gasprice <= gasPriceLimit, 'TASK_GAS_PRICE_LIMIT'); - require(priorityFeeLimit == 0 || tx.gasprice - block.basefee <= priorityFeeLimit, 'TASK_PRIORITY_FEE_LIMIT'); + bool isGasPriceAllowed = gasPriceLimit == 0 || tx.gasprice <= gasPriceLimit; + if (!isGasPriceAllowed) revert TaskGasPriceLimitExceeded(tx.gasprice, gasPriceLimit); + + uint256 priorityFee = tx.gasprice - block.basefee; + bool isPriorityFeeAllowed = priorityFeeLimit == 0 || priorityFee <= priorityFeeLimit; + if (!isPriorityFeeAllowed) revert TaskPriorityFeeLimitExceeded(priorityFee, priorityFeeLimit); } /** * @dev Validates transaction cost limit */ function _afterGasLimitedTask(address token, uint256 amount) internal virtual { - require(__initialGas__ > 0, 'TASK_GAS_NOT_INITIALIZED'); + if (__initialGas__ == 0) revert TaskGasNotInitialized(); uint256 totalGas = __initialGas__ - gasleft(); uint256 totalCost = totalGas * tx.gasprice; - require(txCostLimit == 0 || totalCost <= txCostLimit, 'TASK_TX_COST_LIMIT'); + if (txCostLimit > 0 && totalCost > txCostLimit) revert TaskTxCostLimitExceeded(totalCost, txCostLimit); delete __initialGas__; - if (txCostLimitPct > 0) { - require(amount > 0, 'TASK_TX_COST_LIMIT_PCT'); + if (txCostLimitPct > 0 && amount > 0) { uint256 price = _getPrice(ISmartVault(this.smartVault()).wrappedNativeToken(), token); uint256 totalCostInToken = totalCost.mulUp(price); - require(totalCostInToken.divUp(amount) <= txCostLimitPct, 'TASK_TX_COST_LIMIT_PCT'); + uint256 txCostPct = totalCostInToken.divUp(amount); + if (txCostPct > txCostLimitPct) revert TaskTxCostLimitPctExceeded(txCostPct, txCostLimitPct); } } @@ -172,7 +176,7 @@ abstract contract GasLimitedTask is IGasLimitedTask, Authorized { * @param newTxCostLimitPct New transaction cost limit percentage to be set */ function _setTxCostLimitPct(uint256 newTxCostLimitPct) internal { - require(newTxCostLimitPct <= FixedPoint.ONE, 'TASK_TX_COST_LIMIT_PCT_ABOVE_ONE'); + if (newTxCostLimitPct > FixedPoint.ONE) revert TaskTxCostLimitPctAboveOne(); txCostLimitPct = newTxCostLimitPct; emit TxCostLimitPctSet(newTxCostLimitPct); } diff --git a/packages/tasks/contracts/base/PausableTask.sol b/packages/tasks/contracts/base/PausableTask.sol index 3161bf74..539ce981 100644 --- a/packages/tasks/contracts/base/PausableTask.sol +++ b/packages/tasks/contracts/base/PausableTask.sol @@ -46,7 +46,7 @@ abstract contract PausableTask is IPausableTask, Authorized { * @dev Pauses a task */ function pause() external override auth { - require(!isPaused, 'TASK_ALREADY_PAUSED'); + if (isPaused) revert TaskPaused(); isPaused = true; emit Paused(); } @@ -55,7 +55,7 @@ abstract contract PausableTask is IPausableTask, Authorized { * @dev Unpauses a task */ function unpause() external override auth { - require(isPaused, 'TASK_ALREADY_UNPAUSED'); + if (!isPaused) revert TaskUnpaused(); isPaused = false; emit Unpaused(); } @@ -64,7 +64,7 @@ abstract contract PausableTask is IPausableTask, Authorized { * @dev Before pausable task hook */ function _beforePausableTask(address, uint256) internal virtual { - require(!isPaused, 'TASK_PAUSED'); + if (isPaused) revert TaskPaused(); } /** diff --git a/packages/tasks/contracts/base/TimeLockedTask.sol b/packages/tasks/contracts/base/TimeLockedTask.sol index 1235601d..0f20ad04 100644 --- a/packages/tasks/contracts/base/TimeLockedTask.sol +++ b/packages/tasks/contracts/base/TimeLockedTask.sol @@ -96,13 +96,13 @@ abstract contract TimeLockedTask is ITimeLockedTask, Authorized { * @dev Before time locked task hook */ function _beforeTimeLockedTask(address, uint256) internal virtual { - require(block.timestamp >= timeLockExpiration, 'TASK_TIME_LOCK_NOT_EXPIRED'); + if (block.timestamp < timeLockExpiration) revert TaskTimeLockNotExpired(timeLockExpiration, block.timestamp); if (timeLockExecutionPeriod > 0) { uint256 diff = block.timestamp - timeLockExpiration; uint256 periods = diff / timeLockDelay; uint256 offset = diff - (periods * timeLockDelay); - require(offset <= timeLockExecutionPeriod, 'TASK_TIME_LOCK_WAIT_NEXT_PERIOD'); + if (offset > timeLockExecutionPeriod) revert TaskTimeLockWaitNextPeriod(offset, timeLockExecutionPeriod); } } @@ -128,7 +128,7 @@ abstract contract TimeLockedTask is ITimeLockedTask, Authorized { * @param delay New delay to be set */ function _setTimeLockDelay(uint256 delay) internal { - require(delay >= timeLockExecutionPeriod, 'TASK_DELAY_GT_EXECUTION_PERIOD'); + if (delay < timeLockExecutionPeriod) revert TaskExecutionPeriodGtDelay(timeLockExecutionPeriod, delay); timeLockDelay = delay; emit TimeLockDelaySet(delay); } @@ -147,7 +147,7 @@ abstract contract TimeLockedTask is ITimeLockedTask, Authorized { * @param period New execution period to be set */ function _setTimeLockExecutionPeriod(uint256 period) internal { - require(period <= timeLockDelay, 'TASK_EXECUTION_PERIOD_GT_DELAY'); + if (period > timeLockDelay) revert TaskExecutionPeriodGtDelay(period, timeLockDelay); timeLockExecutionPeriod = period; emit TimeLockExecutionPeriodSet(period); } diff --git a/packages/tasks/contracts/base/TokenIndexedTask.sol b/packages/tasks/contracts/base/TokenIndexedTask.sol index e8be037e..8d0a13a0 100644 --- a/packages/tasks/contracts/base/TokenIndexedTask.sol +++ b/packages/tasks/contracts/base/TokenIndexedTask.sol @@ -81,7 +81,7 @@ abstract contract TokenIndexedTask is ITokenIndexedTask, Authorized { * @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 { - require(tokens.length == added.length, 'TASK_ACCEPTANCE_BAD_LENGTH'); + if (tokens.length != added.length) revert TaskAcceptanceInputLengthMismatch(); for (uint256 i = 0; i < tokens.length; i++) { _setTokenAcceptanceList(tokens[i], added[i]); } @@ -93,7 +93,7 @@ abstract contract TokenIndexedTask is ITokenIndexedTask, Authorized { function _beforeTokenIndexedTask(address token, uint256) internal virtual { bool containsToken = _tokens.contains(token); bool isTokenAllowed = tokensAcceptanceType == TokensAcceptanceType.AllowList ? containsToken : !containsToken; - require(isTokenAllowed, 'TASK_TOKEN_NOT_ALLOWED'); + if (!isTokenAllowed) revert TaskTokenNotAllowed(token); } /** @@ -118,7 +118,7 @@ abstract contract TokenIndexedTask is ITokenIndexedTask, Authorized { * @param added Whether the token should be added or removed from the list */ function _setTokenAcceptanceList(address token, bool added) internal { - require(token != address(0), 'TASK_ACCEPTANCE_TOKEN_ZERO'); + if (token == address(0)) revert TaskAcceptanceTokenZero(); added ? _tokens.add(token) : _tokens.remove(token); emit TokensAcceptanceListSet(token, added); } diff --git a/packages/tasks/contracts/base/TokenThresholdTask.sol b/packages/tasks/contracts/base/TokenThresholdTask.sol index 560476aa..97d83193 100644 --- a/packages/tasks/contracts/base/TokenThresholdTask.sol +++ b/packages/tasks/contracts/base/TokenThresholdTask.sol @@ -142,7 +142,7 @@ abstract contract TokenThresholdTask is ITokenThresholdTask, Authorized { uint256 convertedAmount = threshold.token == token ? amount : amount.mulDown(_getPrice(token, threshold.token)); bool isValid = convertedAmount >= threshold.min && (threshold.max == 0 || convertedAmount <= threshold.max); - require(isValid, 'TASK_TOKEN_THRESHOLD_NOT_MET'); + if (!isValid) revert TaskTokenThresholdNotMet(threshold.token, convertedAmount, threshold.min, threshold.max); } /** @@ -173,7 +173,7 @@ abstract contract TokenThresholdTask is ITokenThresholdTask, Authorized { function _setCustomTokenThreshold(address token, address thresholdToken, uint256 thresholdMin, uint256 thresholdMax) internal { - require(token != address(0), 'TASK_THRESHOLD_TOKEN_ZERO'); + if (token == address(0)) revert TaskThresholdTokenZero(); _setTokenThreshold(_customThresholds[token], thresholdToken, thresholdMin, thresholdMax); emit CustomTokenThresholdSet(token, thresholdToken, thresholdMin, thresholdMax); } @@ -189,7 +189,7 @@ abstract contract TokenThresholdTask is ITokenThresholdTask, Authorized { // 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); - require(isZeroThreshold || isNonZeroThreshold, 'TASK_INVALID_THRESHOLD_INPUT'); + if (!isZeroThreshold && !isNonZeroThreshold) revert TaskInvalidThresholdInput(token, min, max); threshold.token = token; threshold.min = min; diff --git a/packages/tasks/contracts/base/VolumeLimitedTask.sol b/packages/tasks/contracts/base/VolumeLimitedTask.sol index 2bcf0de9..571838d9 100644 --- a/packages/tasks/contracts/base/VolumeLimitedTask.sol +++ b/packages/tasks/contracts/base/VolumeLimitedTask.sol @@ -154,7 +154,7 @@ abstract contract VolumeLimitedTask is IVolumeLimitedTask, Authorized { uint256 amountInLimitToken = limit.token == token ? amount : amount.mulDown(_getPrice(token, limit.token)); uint256 processedVolume = amountInLimitToken + (block.timestamp < limit.nextResetTime ? limit.accrued : 0); - require(processedVolume <= limit.amount, 'TASK_VOLUME_LIMIT_EXCEEDED'); + if (processedVolume > limit.amount) revert TaskVolumeLimitExceeded(limit.token, limit.amount, processedVolume); } /** @@ -193,7 +193,7 @@ abstract contract VolumeLimitedTask is IVolumeLimitedTask, Authorized { function _setCustomVolumeLimit(address token, address limitToken, uint256 limitAmount, uint256 limitPeriod) internal { - require(token != address(0), 'TASK_VOLUME_LIMIT_TOKEN_ZERO'); + if (token == address(0)) revert TaskVolumeLimitTokenZero(); _setVolumeLimit(_customVolumeLimits[token], limitToken, limitAmount, limitPeriod); emit CustomVolumeLimitSet(token, limitToken, limitAmount, limitPeriod); } @@ -209,7 +209,7 @@ abstract contract VolumeLimitedTask is IVolumeLimitedTask, Authorized { // 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; - require(isZeroLimit || isNonZeroLimit, 'TASK_INVALID_VOLUME_LIMIT_INPUT'); + 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; diff --git a/packages/tasks/contracts/bridge/BaseBridgeTask.sol b/packages/tasks/contracts/bridge/BaseBridgeTask.sol index 5e750651..63b603c9 100644 --- a/packages/tasks/contracts/bridge/BaseBridgeTask.sol +++ b/packages/tasks/contracts/bridge/BaseBridgeTask.sol @@ -187,10 +187,12 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { */ function _beforeBaseBridgeTask(address token, uint256 amount, uint256 slippage) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); - require(getDestinationChain(token) != 0, 'TASK_DESTINATION_CHAIN_NOT_SET'); - require(slippage <= getMaxSlippage(token), 'TASK_SLIPPAGE_TOO_HIGH'); + if (token == address(0)) revert TaskTokenZero(); + if (amount == 0) revert TaskAmountZero(); + if (getDestinationChain(token) == 0) revert TaskDestinationChainNotSet(); + + uint256 maxSlippage = getMaxSlippage(token); + if (slippage > maxSlippage) revert TaskSlippageAboveMax(slippage, maxSlippage); } /** @@ -206,7 +208,7 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param next Balance connector id of the next task in the workflow */ function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual override { - require(next == bytes32(0), 'TASK_NEXT_CONNECTOR_NOT_ZERO'); + if (next != bytes32(0)) revert TaskNextConnectorNotZero(next); super._setBalanceConnectors(previous, next); } @@ -215,7 +217,7 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param newConnector Address of the connector to be set */ function _setConnector(address newConnector) internal { - require(newConnector != address(0), 'TASK_CONNECTOR_ZERO'); + if (newConnector == address(0)) revert TaskConnectorZero(); connector = newConnector; emit ConnectorSet(newConnector); } @@ -225,7 +227,7 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param newRecipient Address of the new recipient to be set */ function _setRecipient(address newRecipient) internal { - require(newRecipient != address(0), 'TASK_RECIPIENT_ZERO'); + if (newRecipient == address(0)) revert TaskRecipientZero(); recipient = newRecipient; emit RecipientSet(newRecipient); } @@ -235,7 +237,7 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param destinationChain Default destination chain to be set */ function _setDefaultDestinationChain(uint256 destinationChain) internal { - require(destinationChain != block.chainid, 'TASK_BRIDGE_CURRENT_CHAIN_ID'); + if (destinationChain == block.chainid) revert TaskBridgeCurrentChainId(destinationChain); defaultDestinationChain = destinationChain; emit DefaultDestinationChainSet(destinationChain); } @@ -245,7 +247,7 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param maxSlippage Default max slippage to be set */ function _setDefaultMaxSlippage(uint256 maxSlippage) internal { - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); defaultMaxSlippage = maxSlippage; emit DefaultMaxSlippageSet(maxSlippage); } @@ -256,8 +258,8 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param destinationChain Destination chain to be set */ function _setCustomDestinationChain(address token, uint256 destinationChain) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(destinationChain != block.chainid, 'TASK_BRIDGE_CURRENT_CHAIN_ID'); + if (token == address(0)) revert TaskTokenZero(); + if (destinationChain == block.chainid) revert TaskBridgeCurrentChainId(destinationChain); customDestinationChain[token] = destinationChain; emit CustomDestinationChainSet(token, destinationChain); } @@ -268,8 +270,8 @@ abstract contract BaseBridgeTask is IBaseBridgeTask, Task { * @param maxSlippage Max slippage to be set */ function _setCustomMaxSlippage(address token, uint256 maxSlippage) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (token == address(0)) revert TaskTokenZero(); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); customMaxSlippage[token] = maxSlippage; emit CustomMaxSlippageSet(token, maxSlippage); } diff --git a/packages/tasks/contracts/bridge/ConnextBridger.sol b/packages/tasks/contracts/bridge/ConnextBridger.sol index 718d3c82..24c48fbb 100644 --- a/packages/tasks/contracts/bridge/ConnextBridger.sol +++ b/packages/tasks/contracts/bridge/ConnextBridger.sol @@ -82,10 +82,10 @@ contract ConnextBridger is IConnextBridger, BaseBridgeTask { } /** - * @dev Tells the relayer fee that should be used for a token + * @dev Tells the max fee percentage that should be used for a token * @param token Address of the token being queried */ - function getRelayerFee(address token) public view virtual override returns (uint256) { + function getMaxFeePct(address token) public view virtual override returns (uint256) { uint256 relayerFee = customRelayerFee[token]; return relayerFee == 0 ? defaultRelayerFee : relayerFee; } @@ -140,7 +140,9 @@ contract ConnextBridger is IConnextBridger, BaseBridgeTask { virtual { _beforeBaseBridgeTask(token, amount, slippage); - require(relayerFee.divUp(amount) <= getRelayerFee(token), 'TASK_FEE_TOO_HIGH'); + uint256 maxFeePct = getMaxFeePct(token); + uint256 feePct = relayerFee.divUp(amount); + if (feePct > maxFeePct) revert TaskFeePctAboveMax(feePct, maxFeePct); } /** @@ -165,7 +167,7 @@ contract ConnextBridger is IConnextBridger, BaseBridgeTask { * @param relayerFee Relayer fee to be set */ function _setCustomRelayerFee(address token, uint256 relayerFee) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); customRelayerFee[token] = relayerFee; emit CustomRelayerFeeSet(token, relayerFee); } diff --git a/packages/tasks/contracts/bridge/HopBridger.sol b/packages/tasks/contracts/bridge/HopBridger.sol index 89f276e0..1ffd3baf 100644 --- a/packages/tasks/contracts/bridge/HopBridger.sol +++ b/packages/tasks/contracts/bridge/HopBridger.sol @@ -200,8 +200,10 @@ contract HopBridger is IHopBridger, BaseBridgeTask { */ function _beforeHopBridger(address token, uint256 amount, uint256 slippage, uint256 fee) internal virtual { _beforeBaseBridgeTask(token, amount, slippage); - require(tokenHopEntrypoint[token] != address(0), 'TASK_MISSING_HOP_ENTRYPOINT'); - require(fee.divUp(amount) <= getMaxFeePct(token), 'TASK_FEE_TOO_HIGH'); + if (tokenHopEntrypoint[token] == address(0)) revert TaskMissingHopEntrypoint(); + uint256 maxFeePct = getMaxFeePct(token); + uint256 feePct = fee.divUp(amount); + if (feePct > maxFeePct) revert TaskFeePctAboveMax(feePct, maxFeePct); } /** @@ -223,7 +225,7 @@ contract HopBridger is IHopBridger, BaseBridgeTask { * @dev Sets the max deadline */ function _setMaxDeadline(uint256 _maxDeadline) internal { - require(_maxDeadline > 0, 'TASK_MAX_DEADLINE_ZERO'); + if (_maxDeadline == 0) revert TaskMaxDeadlineZero(); maxDeadline = _maxDeadline; emit MaxDeadlineSet(_maxDeadline); } @@ -243,7 +245,7 @@ contract HopBridger is IHopBridger, BaseBridgeTask { * @param entrypoint Hop entrypoint to be set */ function _setTokenHopEntrypoint(address token, address entrypoint) internal { - require(token != address(0), 'TASK_HOP_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); tokenHopEntrypoint[token] = entrypoint; emit TokenHopEntrypointSet(token, entrypoint); } @@ -254,7 +256,7 @@ contract HopBridger is IHopBridger, BaseBridgeTask { * @param maxFeePct Max fee percentage to be set for the given token */ function _setCustomMaxFeePct(address token, uint256 maxFeePct) internal { - require(token != address(0), 'TASK_HOP_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); customMaxFeePct[token] = maxFeePct; emit CustomMaxFeePctSet(token, maxFeePct); } diff --git a/packages/tasks/contracts/interfaces/base/IBaseTask.sol b/packages/tasks/contracts/interfaces/base/IBaseTask.sol index 5fcfdce7..37b4f9be 100644 --- a/packages/tasks/contracts/interfaces/base/IBaseTask.sol +++ b/packages/tasks/contracts/interfaces/base/IBaseTask.sol @@ -24,6 +24,16 @@ interface IBaseTask is IAuthorized { // 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 base, address quote); + /** * @dev Emitted every time a task is executed */ diff --git a/packages/tasks/contracts/interfaces/base/IGasLimitedTask.sol b/packages/tasks/contracts/interfaces/base/IGasLimitedTask.sol index 9d5cc19d..2cb63b6d 100644 --- a/packages/tasks/contracts/interfaces/base/IGasLimitedTask.sol +++ b/packages/tasks/contracts/interfaces/base/IGasLimitedTask.sol @@ -20,6 +20,36 @@ 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 price limit is set */ diff --git a/packages/tasks/contracts/interfaces/base/IPausableTask.sol b/packages/tasks/contracts/interfaces/base/IPausableTask.sol index de53595d..c95a3dec 100644 --- a/packages/tasks/contracts/interfaces/base/IPausableTask.sol +++ b/packages/tasks/contracts/interfaces/base/IPausableTask.sol @@ -20,6 +20,16 @@ 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 */ diff --git a/packages/tasks/contracts/interfaces/base/ITimeLockedTask.sol b/packages/tasks/contracts/interfaces/base/ITimeLockedTask.sol index 1a41ec3f..9c0a228f 100644 --- a/packages/tasks/contracts/interfaces/base/ITimeLockedTask.sol +++ b/packages/tasks/contracts/interfaces/base/ITimeLockedTask.sol @@ -20,6 +20,21 @@ import './IBaseTask.sol'; * @dev Time-locked task interface */ interface ITimeLockedTask is IBaseTask { + /** + * @dev The time-lock has not expired + */ + error TaskTimeLockNotExpired(uint256 expiration, uint256 currentTimestamp); + + /** + * @dev The execution period has expired + */ + error TaskTimeLockWaitNextPeriod(uint256 offset, uint256 executionPeriod); + + /** + * @dev The execution period is greater than the time-lock delay + */ + error TaskExecutionPeriodGtDelay(uint256 executionPeriod, uint256 delay); + /** * @dev Emitted every time a new time-lock delay is set */ diff --git a/packages/tasks/contracts/interfaces/base/ITokenIndexedTask.sol b/packages/tasks/contracts/interfaces/base/ITokenIndexedTask.sol index b5a48ea8..c7306867 100644 --- a/packages/tasks/contracts/interfaces/base/ITokenIndexedTask.sol +++ b/packages/tasks/contracts/interfaces/base/ITokenIndexedTask.sol @@ -28,6 +28,21 @@ interface ITokenIndexedTask is IBaseTask { 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 */ diff --git a/packages/tasks/contracts/interfaces/base/ITokenThresholdTask.sol b/packages/tasks/contracts/interfaces/base/ITokenThresholdTask.sol index ac1ac18b..2ab6e224 100644 --- a/packages/tasks/contracts/interfaces/base/ITokenThresholdTask.sol +++ b/packages/tasks/contracts/interfaces/base/ITokenThresholdTask.sol @@ -29,6 +29,21 @@ interface ITokenThresholdTask is IBaseTask { uint256 max; } + /** + * @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 */ diff --git a/packages/tasks/contracts/interfaces/base/IVolumeLimitedTask.sol b/packages/tasks/contracts/interfaces/base/IVolumeLimitedTask.sol index 83acb6a7..8cc83702 100644 --- a/packages/tasks/contracts/interfaces/base/IVolumeLimitedTask.sol +++ b/packages/tasks/contracts/interfaces/base/IVolumeLimitedTask.sol @@ -32,6 +32,21 @@ interface IVolumeLimitedTask is IBaseTask { uint256 nextResetTime; } + /** + * @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 */ diff --git a/packages/tasks/contracts/interfaces/bridge/IBaseBridgeTask.sol b/packages/tasks/contracts/interfaces/bridge/IBaseBridgeTask.sol index 03c55582..803a6880 100644 --- a/packages/tasks/contracts/interfaces/bridge/IBaseBridgeTask.sol +++ b/packages/tasks/contracts/interfaces/bridge/IBaseBridgeTask.sol @@ -20,6 +20,56 @@ import '../ITask.sol'; * @dev Base bridge task interface */ interface IBaseBridgeTask is ITask { + /** + * @dev The token is zero + */ + error TaskTokenZero(); + + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The recipient is zero + */ + error TaskRecipientZero(); + + /** + * @dev The connector is zero + */ + error TaskConnectorZero(); + + /** + * @dev The next balance connector is not zero + */ + error TaskNextConnectorNotZero(bytes32 id); + + /** + * @dev The destination chain is not set + */ + error TaskDestinationChainNotSet(); + + /** + * @dev The destination chain id is the same as the current chain id + */ + error TaskBridgeCurrentChainId(uint256 destinationChain); + + /** + * @dev The slippage to be set is greater than one + */ + error TaskSlippageAboveOne(); + + /** + * @dev The requested slippage is greater than the maximum slippage + */ + error TaskSlippageAboveMax(uint256 slippage, uint256 maxSlippage); + + /** + * @dev The requested fee percentage is greater than the maximum fee percentage + */ + error TaskFeePctAboveMax(uint256 feePct, uint256 maxFeePct); + /** * @dev Emitted every time the connector is set */ diff --git a/packages/tasks/contracts/interfaces/bridge/IConnextBridger.sol b/packages/tasks/contracts/interfaces/bridge/IConnextBridger.sol index 4cb8ca55..f54e4385 100644 --- a/packages/tasks/contracts/interfaces/bridge/IConnextBridger.sol +++ b/packages/tasks/contracts/interfaces/bridge/IConnextBridger.sol @@ -41,10 +41,10 @@ interface IConnextBridger is IBaseBridgeTask { function customRelayerFee(address token) external view returns (uint256); /** - * @dev Tells the relayer fee that should be used for a token + * @dev Tells the max fee percentage that should be used for a token * @param token Address of the token being queried */ - function getRelayerFee(address token) external view returns (uint256); + function getMaxFeePct(address token) external view returns (uint256); /** * @dev Sets the default relayer fee diff --git a/packages/tasks/contracts/interfaces/bridge/IHopBridger.sol b/packages/tasks/contracts/interfaces/bridge/IHopBridger.sol index 1ae43dda..6cc018b4 100644 --- a/packages/tasks/contracts/interfaces/bridge/IHopBridger.sol +++ b/packages/tasks/contracts/interfaces/bridge/IHopBridger.sol @@ -20,6 +20,16 @@ import './IBaseBridgeTask.sol'; * @dev Hop bridger task interface */ interface IHopBridger is IBaseBridgeTask { + /** + * @dev The max deadline is zero + */ + error TaskMaxDeadlineZero(); + + /** + * @dev The Hop entrypoint is zero + */ + error TaskMissingHopEntrypoint(); + /** * @dev Emitted every time the relayer is set */ diff --git a/packages/tasks/contracts/interfaces/liquidity/convex/IBaseConvexTask.sol b/packages/tasks/contracts/interfaces/liquidity/convex/IBaseConvexTask.sol index f8dc8528..a92b0099 100644 --- a/packages/tasks/contracts/interfaces/liquidity/convex/IBaseConvexTask.sol +++ b/packages/tasks/contracts/interfaces/liquidity/convex/IBaseConvexTask.sol @@ -20,6 +20,16 @@ import '../../ITask.sol'; * @dev Base Convex task interface */ interface IBaseConvexTask is ITask { + /** + * @dev The token is zero + */ + error TaskTokenZero(); + + /** + * @dev The connector is zero + */ + error TaskConnectorZero(); + /** * @dev Emitted every time the connector is set */ diff --git a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexClaimer.sol b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexClaimer.sol index 4c330e60..535f9cf0 100644 --- a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexClaimer.sol +++ b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexClaimer.sol @@ -20,6 +20,21 @@ import './IBaseConvexTask.sol'; * @dev Convex claimer task interface */ interface IConvexClaimer is IBaseConvexTask { + /** + * @dev The amount is not zero + */ + error TaskAmountNotZero(); + + /** + * @dev The previous balance connector is not zero + */ + error TaskPreviousConnectorNotZero(bytes32 id); + + /** + * @dev The length of the claim result mismatch + */ + error TaskClaimResultLengthMismatch(); + /** * @dev Executes the Convex claimer task */ diff --git a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexExiter.sol b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexExiter.sol index 5045bb54..bf5a7bd4 100644 --- a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexExiter.sol +++ b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexExiter.sol @@ -20,6 +20,11 @@ import './IBaseConvexTask.sol'; * @dev Convex exiter task interface */ interface IConvexExiter is IBaseConvexTask { + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + /** * @dev Executes the Convex exiter task */ diff --git a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexJoiner.sol b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexJoiner.sol index faeb8422..ecfa1f49 100644 --- a/packages/tasks/contracts/interfaces/liquidity/convex/IConvexJoiner.sol +++ b/packages/tasks/contracts/interfaces/liquidity/convex/IConvexJoiner.sol @@ -20,6 +20,11 @@ import './IBaseConvexTask.sol'; * @dev Convex joiner task interface */ interface IConvexJoiner is IBaseConvexTask { + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + /** * @dev Executes the Convex joiner task */ diff --git a/packages/tasks/contracts/interfaces/liquidity/curve/IBaseCurveTask.sol b/packages/tasks/contracts/interfaces/liquidity/curve/IBaseCurveTask.sol index a059f0b9..a5bc72df 100644 --- a/packages/tasks/contracts/interfaces/liquidity/curve/IBaseCurveTask.sol +++ b/packages/tasks/contracts/interfaces/liquidity/curve/IBaseCurveTask.sol @@ -20,6 +20,36 @@ import '../../ITask.sol'; * @dev Base Curve task interface */ interface IBaseCurveTask 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 requested slippage is greater than the maximum slippage + */ + error TaskSlippageAboveMax(uint256 slippage, uint256 maxSlippage); + /** * @dev Emitted every time the connector is set */ diff --git a/packages/tasks/contracts/interfaces/primitives/ICollector.sol b/packages/tasks/contracts/interfaces/primitives/ICollector.sol index b0bfd8f6..56afd626 100644 --- a/packages/tasks/contracts/interfaces/primitives/ICollector.sol +++ b/packages/tasks/contracts/interfaces/primitives/ICollector.sol @@ -20,6 +20,26 @@ import '../ITask.sol'; * @dev Collector task interface */ interface ICollector is ITask { + /** + * @dev The token is zero + */ + error TaskTokenZero(); + + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The tokens source is zero + */ + error TaskTokensSourceZero(); + + /** + * @dev The previous balance connector is not zero + */ + error TaskPreviousConnectorNotZero(bytes32 id); + /** * @dev Emitted every time the tokens source is set */ diff --git a/packages/tasks/contracts/interfaces/primitives/IUnwrapper.sol b/packages/tasks/contracts/interfaces/primitives/IUnwrapper.sol index 9770493b..4aecde36 100644 --- a/packages/tasks/contracts/interfaces/primitives/IUnwrapper.sol +++ b/packages/tasks/contracts/interfaces/primitives/IUnwrapper.sol @@ -20,6 +20,16 @@ import '../ITask.sol'; * @dev Unwrapper task interface */ interface IUnwrapper is ITask { + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The token is not the wrapped native token + */ + error TaskTokenNotWrapped(); + /** * @dev Executes the unwrapper task */ diff --git a/packages/tasks/contracts/interfaces/primitives/IWithdrawer.sol b/packages/tasks/contracts/interfaces/primitives/IWithdrawer.sol index 079c6d0a..1e42b0e2 100644 --- a/packages/tasks/contracts/interfaces/primitives/IWithdrawer.sol +++ b/packages/tasks/contracts/interfaces/primitives/IWithdrawer.sol @@ -20,6 +20,31 @@ import '../ITask.sol'; * @dev Withdrawer task interface */ interface IWithdrawer is ITask { + /** + * @dev The token is zero + */ + error TaskTokenZero(); + + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The recipient is zero + */ + error TaskRecipientZero(); + + /** + * @dev The recipient to be set is the smart vault + */ + error TaskRecipientEqualsSmartVault(address recipient); + + /** + * @dev The next balance connector is not zero + */ + error TaskNextConnectorNotZero(bytes32 id); + /** * @dev Emitted every time the recipient is set */ diff --git a/packages/tasks/contracts/interfaces/primitives/IWrapper.sol b/packages/tasks/contracts/interfaces/primitives/IWrapper.sol index 1ae6271c..d9ababa3 100644 --- a/packages/tasks/contracts/interfaces/primitives/IWrapper.sol +++ b/packages/tasks/contracts/interfaces/primitives/IWrapper.sol @@ -20,6 +20,16 @@ import '../ITask.sol'; * @dev Wrapper task interface */ interface IWrapper is ITask { + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The token is not the native token + */ + error TaskTokenNotNative(); + /** * @dev Executes the wrapper task */ diff --git a/packages/tasks/contracts/interfaces/relayer/IBaseRelayerFundTask.sol b/packages/tasks/contracts/interfaces/relayer/IBaseRelayerFundTask.sol index 6eaf5e30..32be0c8c 100644 --- a/packages/tasks/contracts/interfaces/relayer/IBaseRelayerFundTask.sol +++ b/packages/tasks/contracts/interfaces/relayer/IBaseRelayerFundTask.sol @@ -20,6 +20,26 @@ import '../ITask.sol'; * @dev Base relayer fund task interface */ interface IBaseRelayerFundTask is ITask { + /** + * @dev The relayer is zero + */ + error TaskRelayerZero(); + + /** + * @dev The task initializer is disabled + */ + error TaskInitializerDisabled(); + + /** + * @dev The deposited amount is above the minimum threshold + */ + error TaskDepositAboveMinThreshold(uint256 deposited, uint256 min); + + /** + * @dev The requested amount would result in a new balance above the maximum threshold plus the used quota + */ + error TaskDepositAboveMaxThreshold(uint256 newBalance, uint256 max, uint256 usedQuota); + /** * @dev Emitted every time the relayer is set */ diff --git a/packages/tasks/contracts/interfaces/relayer/IRelayerDepositor.sol b/packages/tasks/contracts/interfaces/relayer/IRelayerDepositor.sol index d1de92b3..46818139 100644 --- a/packages/tasks/contracts/interfaces/relayer/IRelayerDepositor.sol +++ b/packages/tasks/contracts/interfaces/relayer/IRelayerDepositor.sol @@ -20,6 +20,16 @@ import '../ITask.sol'; * @dev Relayer depositor task interface */ interface IRelayerDepositor is ITask { + /** + * @dev The amount is zero + */ + error TaskAmountZero(); + + /** + * @dev The relayer is zero + */ + error TaskRelayerZero(); + /** * @dev Emitted every time the relayer is set */ diff --git a/packages/tasks/contracts/interfaces/swap/IBaseSwapTask.sol b/packages/tasks/contracts/interfaces/swap/IBaseSwapTask.sol index e43ca89a..916d85eb 100644 --- a/packages/tasks/contracts/interfaces/swap/IBaseSwapTask.sol +++ b/packages/tasks/contracts/interfaces/swap/IBaseSwapTask.sol @@ -20,6 +20,36 @@ 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 */ diff --git a/packages/tasks/contracts/interfaces/swap/IHopL2Swapper.sol b/packages/tasks/contracts/interfaces/swap/IHopL2Swapper.sol index c30c5d6e..fde89714 100644 --- a/packages/tasks/contracts/interfaces/swap/IHopL2Swapper.sol +++ b/packages/tasks/contracts/interfaces/swap/IHopL2Swapper.sol @@ -20,6 +20,16 @@ import './IBaseSwapTask.sol'; * @dev L2 Hop swapper task interface */ interface IHopL2Swapper is IBaseSwapTask { + /** + * @dev The amm for the token is not set + */ + error TaskMissingHopTokenAmm(); + + /** + * @dev The hToken to be set is not the hToken of the Hop L2 amm to be used + */ + error TaskHopTokenAmmMismatch(address hToken, address amm); + /** * @dev Emitted every time an AMM is set for a token */ diff --git a/packages/tasks/contracts/interfaces/swap/IParaswapV5Swapper.sol b/packages/tasks/contracts/interfaces/swap/IParaswapV5Swapper.sol index 3d678a2f..5c5ed09b 100644 --- a/packages/tasks/contracts/interfaces/swap/IParaswapV5Swapper.sol +++ b/packages/tasks/contracts/interfaces/swap/IParaswapV5Swapper.sol @@ -20,6 +20,21 @@ import './IBaseSwapTask.sol'; * @dev Paraswap v5 swapper task interface */ interface IParaswapV5Swapper is IBaseSwapTask { + /** + * @dev The quote signer is zero + */ + error TaskQuoteSignerZero(); + + /** + * @dev The signer to be set is not the quote signer + */ + error TaskInvalidQuoteSigner(address signer, address quoteSigner); + + /** + * @dev The deadline is in the past + */ + error TaskQuoteSignerPastDeadline(uint256 deadline, uint256 currentTimestamp); + /** * @dev Emitted every time a quote signer is set */ diff --git a/packages/tasks/contracts/liquidity/convex/BaseConvexTask.sol b/packages/tasks/contracts/liquidity/convex/BaseConvexTask.sol index 1f533af9..ece37d37 100644 --- a/packages/tasks/contracts/liquidity/convex/BaseConvexTask.sol +++ b/packages/tasks/contracts/liquidity/convex/BaseConvexTask.sol @@ -63,7 +63,7 @@ abstract contract BaseConvexTask is IBaseConvexTask, Task { */ function _beforeBaseConvexTask(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); } /** @@ -78,7 +78,7 @@ abstract contract BaseConvexTask is IBaseConvexTask, Task { * @param newConnector New connector to be set */ function _setConnector(address newConnector) internal { - require(newConnector != address(0), 'TASK_CONNECTOR_ZERO'); + if (newConnector == address(0)) revert TaskConnectorZero(); connector = newConnector; emit ConnectorSet(newConnector); } diff --git a/packages/tasks/contracts/liquidity/convex/ConvexClaimer.sol b/packages/tasks/contracts/liquidity/convex/ConvexClaimer.sol index ef0ffc17..f9a3003f 100644 --- a/packages/tasks/contracts/liquidity/convex/ConvexClaimer.sol +++ b/packages/tasks/contracts/liquidity/convex/ConvexClaimer.sol @@ -91,7 +91,7 @@ contract ConvexClaimer is IConvexClaimer, BaseConvexTask { */ function _beforeConvexClaimer(address token, uint256 amount) internal virtual { _beforeBaseConvexTask(token, amount); - require(amount == 0, 'TASK_AMOUNT_NOT_ZERO'); + if (amount != 0) revert TaskAmountNotZero(); } /** @@ -103,7 +103,7 @@ contract ConvexClaimer is IConvexClaimer, BaseConvexTask { address[] memory tokensOut, uint256[] memory amountsOut ) internal virtual { - require(tokensOut.length == amountsOut.length, 'CLAIMER_INVALID_RESULT_LEN'); + if (tokensOut.length != amountsOut.length) revert TaskClaimResultLengthMismatch(); for (uint256 i = 0; i < tokensOut.length; i++) _increaseBalanceConnector(tokensOut[i], amountsOut[i]); _afterBaseConvexTask(tokenIn, amountIn); } @@ -114,7 +114,7 @@ contract ConvexClaimer is IConvexClaimer, BaseConvexTask { * @param next Balance connector id of the next task in the workflow */ function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual override { - require(previous == bytes32(0), 'TASK_PREVIOUS_CONNECTOR_NOT_ZERO'); + if (previous != bytes32(0)) revert TaskPreviousConnectorNotZero(previous); super._setBalanceConnectors(previous, next); } } diff --git a/packages/tasks/contracts/liquidity/convex/ConvexExiter.sol b/packages/tasks/contracts/liquidity/convex/ConvexExiter.sol index aef6d4a1..588f0de9 100644 --- a/packages/tasks/contracts/liquidity/convex/ConvexExiter.sol +++ b/packages/tasks/contracts/liquidity/convex/ConvexExiter.sol @@ -79,7 +79,7 @@ contract ConvexExiter is IConvexExiter, BaseConvexTask { */ function _beforeConvexExiter(address token, uint256 amount) internal virtual { _beforeBaseConvexTask(token, amount); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (amount == 0) revert TaskAmountZero(); } /** diff --git a/packages/tasks/contracts/liquidity/convex/ConvexJoiner.sol b/packages/tasks/contracts/liquidity/convex/ConvexJoiner.sol index 625b37d4..23796d8c 100644 --- a/packages/tasks/contracts/liquidity/convex/ConvexJoiner.sol +++ b/packages/tasks/contracts/liquidity/convex/ConvexJoiner.sol @@ -79,7 +79,7 @@ contract ConvexJoiner is IConvexJoiner, BaseConvexTask { */ function _beforeConvexJoiner(address token, uint256 amount) internal virtual { _beforeBaseConvexTask(token, amount); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (amount == 0) revert TaskAmountZero(); } /** diff --git a/packages/tasks/contracts/liquidity/curve/BaseCurveTask.sol b/packages/tasks/contracts/liquidity/curve/BaseCurveTask.sol index 2efaf790..d8fed6f3 100644 --- a/packages/tasks/contracts/liquidity/curve/BaseCurveTask.sol +++ b/packages/tasks/contracts/liquidity/curve/BaseCurveTask.sol @@ -160,10 +160,12 @@ abstract contract BaseCurveTask is IBaseCurveTask, Task { */ function _beforeBaseCurveTask(address token, uint256 amount, uint256 slippage) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); - require(getTokenOut(token) != address(0), 'TASK_TOKEN_OUT_NOT_SET'); - require(slippage <= getMaxSlippage(token), 'TASK_SLIPPAGE_TOO_HIGH'); + 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); } /** @@ -182,7 +184,7 @@ abstract contract BaseCurveTask is IBaseCurveTask, Task { * @param newConnector New connector to be set */ function _setConnector(address newConnector) internal { - require(newConnector != address(0), 'TASK_CONNECTOR_ZERO'); + if (newConnector == address(0)) revert TaskConnectorZero(); connector = newConnector; emit ConnectorSet(newConnector); } @@ -201,7 +203,7 @@ abstract contract BaseCurveTask is IBaseCurveTask, Task { * @param maxSlippage Default max slippage to be set */ function _setDefaultMaxSlippage(uint256 maxSlippage) internal { - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); defaultMaxSlippage = maxSlippage; emit DefaultMaxSlippageSet(maxSlippage); } @@ -212,7 +214,7 @@ abstract contract BaseCurveTask is IBaseCurveTask, Task { * @param tokenOut Address of the token out to be set */ function _setCustomTokenOut(address token, address tokenOut) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); customTokenOut[token] = tokenOut; emit CustomTokenOutSet(token, tokenOut); } @@ -223,8 +225,8 @@ abstract contract BaseCurveTask is IBaseCurveTask, Task { * @param maxSlippage Max slippage to be set */ function _setCustomMaxSlippage(address token, uint256 maxSlippage) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (token == address(0)) revert TaskTokenZero(); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); customMaxSlippage[token] = maxSlippage; emit CustomMaxSlippageSet(token, maxSlippage); } diff --git a/packages/tasks/contracts/primitives/Collector.sol b/packages/tasks/contracts/primitives/Collector.sol index 3fda269a..325dd075 100644 --- a/packages/tasks/contracts/primitives/Collector.sol +++ b/packages/tasks/contracts/primitives/Collector.sol @@ -92,8 +92,8 @@ contract Collector is ICollector, Task { */ function _beforeCollector(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (token == address(0)) revert TaskTokenZero(); + if (amount == 0) revert TaskAmountZero(); } /** @@ -110,7 +110,7 @@ contract Collector is ICollector, Task { * @param next Balance connector id of the next task in the workflow */ function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual override { - require(previous == bytes32(0), 'TASK_PREVIOUS_CONNECTOR_NOT_ZERO'); + if (previous != bytes32(0)) revert TaskPreviousConnectorNotZero(previous); super._setBalanceConnectors(previous, next); } @@ -119,7 +119,7 @@ contract Collector is ICollector, Task { * @param tokensSource Address of the tokens source to be set */ function _setTokensSource(address tokensSource) internal virtual { - require(tokensSource != address(0), 'TASK_TOKENS_SOURCE_ZERO'); + if (tokensSource == address(0)) revert TaskTokensSourceZero(); _tokensSource = tokensSource; emit TokensSourceSet(tokensSource); } diff --git a/packages/tasks/contracts/primitives/Depositor.sol b/packages/tasks/contracts/primitives/Depositor.sol index bdc96df9..32f9e7c8 100644 --- a/packages/tasks/contracts/primitives/Depositor.sol +++ b/packages/tasks/contracts/primitives/Depositor.sol @@ -30,6 +30,11 @@ import '../interfaces/primitives/ICollector.sol'; contract Depositor is ICollector, Collector { using SafeERC20 for IERC20; + /** + * @dev The tokens source to be set is not the contract itself + */ + error TaskDepositorBadTokensSource(address tokensSource); + /** * @dev It allows receiving native token transfers */ @@ -60,7 +65,7 @@ contract Depositor is ICollector, Collector { * @param tokensSource Address of the tokens source to be set */ function _setTokensSource(address tokensSource) internal override { - require(tokensSource == address(this), 'TASK_DEPOSITOR_BAD_TOKENS_SOURCE'); + if (tokensSource != address(this)) revert TaskDepositorBadTokensSource(tokensSource); super._setTokensSource(tokensSource); } } diff --git a/packages/tasks/contracts/primitives/Unwrapper.sol b/packages/tasks/contracts/primitives/Unwrapper.sol index 9aba6fd2..47bf85cd 100644 --- a/packages/tasks/contracts/primitives/Unwrapper.sol +++ b/packages/tasks/contracts/primitives/Unwrapper.sol @@ -72,8 +72,8 @@ contract Unwrapper is IUnwrapper, Task { */ function _beforeUnwrapper(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(token == _wrappedNativeToken(), 'TASK_TOKEN_NOT_WRAPPED'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (token != _wrappedNativeToken()) revert TaskTokenNotWrapped(); + if (amount == 0) revert TaskAmountZero(); } /** diff --git a/packages/tasks/contracts/primitives/Withdrawer.sol b/packages/tasks/contracts/primitives/Withdrawer.sol index 5528ae24..b34ad241 100644 --- a/packages/tasks/contracts/primitives/Withdrawer.sol +++ b/packages/tasks/contracts/primitives/Withdrawer.sol @@ -83,8 +83,8 @@ contract Withdrawer is IWithdrawer, Task { */ function _beforeWithdrawer(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (token == address(0)) revert TaskTokenZero(); + if (amount == 0) revert TaskAmountZero(); } /** @@ -99,8 +99,8 @@ contract Withdrawer is IWithdrawer, Task { * @param newRecipient Address of the new recipient to be set */ function _setRecipient(address newRecipient) internal { - require(newRecipient != address(0), 'TASK_RECIPIENT_ZERO'); - require(newRecipient != smartVault, 'TASK_RECIPIENT_SMART_VAULT'); + if (newRecipient == address(0)) revert TaskRecipientZero(); + if (newRecipient == smartVault) revert TaskRecipientEqualsSmartVault(newRecipient); recipient = newRecipient; emit RecipientSet(newRecipient); } @@ -111,7 +111,7 @@ contract Withdrawer is IWithdrawer, Task { * @param next Balance connector id of the next task in the workflow */ function _setBalanceConnectors(bytes32 previous, bytes32 next) internal virtual override { - require(next == bytes32(0), 'TASK_NEXT_CONNECTOR_NOT_ZERO'); + if (next != bytes32(0)) revert TaskNextConnectorNotZero(next); super._setBalanceConnectors(previous, next); } } diff --git a/packages/tasks/contracts/primitives/Wrapper.sol b/packages/tasks/contracts/primitives/Wrapper.sol index 0392a6c9..893c80f0 100644 --- a/packages/tasks/contracts/primitives/Wrapper.sol +++ b/packages/tasks/contracts/primitives/Wrapper.sol @@ -73,8 +73,8 @@ contract Wrapper is IWrapper, Task { */ function _beforeWrapper(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(token == Denominations.NATIVE_TOKEN, 'TASK_TOKEN_NOT_NATIVE'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (token != Denominations.NATIVE_TOKEN) revert TaskTokenNotNative(); + if (amount == 0) revert TaskAmountZero(); } /** diff --git a/packages/tasks/contracts/relayer/BaseRelayerFundTask.sol b/packages/tasks/contracts/relayer/BaseRelayerFundTask.sol index cc2b43bb..c5d2e515 100644 --- a/packages/tasks/contracts/relayer/BaseRelayerFundTask.sol +++ b/packages/tasks/contracts/relayer/BaseRelayerFundTask.sol @@ -86,11 +86,12 @@ abstract contract BaseRelayerFundTask is IBaseRelayerFundTask, Task { uint256 depositedInThresholdToken = _getDepositedInThresholdToken(threshold.token); uint256 usedQuotaInThresholdToken = _getUsedQuotaInThresholdToken(threshold.token); - require(depositedInThresholdToken < threshold.min + usedQuotaInThresholdToken, 'TASK_TOKEN_THRESHOLD_NOT_MET'); - require( - amountInThresholdToken + depositedInThresholdToken <= threshold.max + usedQuotaInThresholdToken, - 'TASK_AMOUNT_ABOVE_THRESHOLD' - ); + bool isAboveMin = depositedInThresholdToken >= threshold.min + usedQuotaInThresholdToken; + if (isAboveMin) revert TaskDepositAboveMinThreshold(depositedInThresholdToken, threshold.min); + + uint256 newBalance = amountInThresholdToken + depositedInThresholdToken; + bool isAboveMax = newBalance > threshold.max + usedQuotaInThresholdToken; + if (isAboveMax) revert TaskDepositAboveMaxThreshold(newBalance, threshold.max, usedQuotaInThresholdToken); } /** @@ -116,7 +117,7 @@ abstract contract BaseRelayerFundTask is IBaseRelayerFundTask, Task { * @param newRelayer Address of the relayer to be set */ function _setRelayer(address newRelayer) internal { - require(newRelayer != address(0), 'TASK_FUNDER_RELAYER_ZERO'); + if (newRelayer == address(0)) revert TaskRelayerZero(); relayer = newRelayer; emit RelayerSet(newRelayer); } diff --git a/packages/tasks/contracts/relayer/CollectorRelayerFunder.sol b/packages/tasks/contracts/relayer/CollectorRelayerFunder.sol index f697e7e6..a7df668d 100644 --- a/packages/tasks/contracts/relayer/CollectorRelayerFunder.sol +++ b/packages/tasks/contracts/relayer/CollectorRelayerFunder.sol @@ -26,7 +26,7 @@ contract CollectorRelayerFunder is BaseRelayerFundTask, Collector { * @dev Disables the default collector initializer */ function initialize(CollectConfig memory) external pure override { - revert('COLLECTOR_INITIALIZER_DISABLED'); + revert TaskInitializerDisabled(); } /** diff --git a/packages/tasks/contracts/relayer/OneInchV5RelayerFunder.sol b/packages/tasks/contracts/relayer/OneInchV5RelayerFunder.sol index a98973bb..14e1cba8 100644 --- a/packages/tasks/contracts/relayer/OneInchV5RelayerFunder.sol +++ b/packages/tasks/contracts/relayer/OneInchV5RelayerFunder.sol @@ -26,7 +26,7 @@ contract OneInchV5RelayerFunder is BaseRelayerFundTask, OneInchV5Swapper { * @dev Disables the default 1inch v5 swapper initializer */ function initialize(OneInchV5SwapConfig memory) external pure override { - revert('SWAPPER_INITIALIZER_DISABLED'); + revert TaskInitializerDisabled(); } /** diff --git a/packages/tasks/contracts/relayer/RelayerDepositor.sol b/packages/tasks/contracts/relayer/RelayerDepositor.sol index c0082fb5..6828390b 100644 --- a/packages/tasks/contracts/relayer/RelayerDepositor.sol +++ b/packages/tasks/contracts/relayer/RelayerDepositor.sol @@ -84,7 +84,7 @@ contract RelayerDepositor is IRelayerDepositor, Task { */ function _beforeRelayerDepositor(address token, uint256 amount) internal virtual { _beforeTask(token, amount); - require(amount > 0, 'TASK_AMOUNT_ZERO'); + if (amount == 0) revert TaskAmountZero(); } /** @@ -99,7 +99,7 @@ contract RelayerDepositor is IRelayerDepositor, Task { * @param newRelayer Address of the relayer to be set */ function _setRelayer(address newRelayer) internal { - require(newRelayer != address(0), 'TASK_RELAYER_DEPOSITOR_ZERO'); + if (newRelayer == address(0)) revert TaskRelayerZero(); relayer = newRelayer; emit RelayerSet(newRelayer); } diff --git a/packages/tasks/contracts/relayer/UnwrapperRelayerFunder.sol b/packages/tasks/contracts/relayer/UnwrapperRelayerFunder.sol index cdab99f4..fbe7a2f9 100644 --- a/packages/tasks/contracts/relayer/UnwrapperRelayerFunder.sol +++ b/packages/tasks/contracts/relayer/UnwrapperRelayerFunder.sol @@ -26,7 +26,7 @@ contract UnwrapperRelayerFunder is BaseRelayerFundTask, Unwrapper { * @dev Disables the default unwrapper initializer */ function initialize(UnwrapConfig memory) external pure override { - revert('UNWRAPPER_INITIALIZER_DISABLED'); + revert TaskInitializerDisabled(); } /** diff --git a/packages/tasks/contracts/swap/BaseSwapTask.sol b/packages/tasks/contracts/swap/BaseSwapTask.sol index 7cce5e68..e52e5f7d 100644 --- a/packages/tasks/contracts/swap/BaseSwapTask.sol +++ b/packages/tasks/contracts/swap/BaseSwapTask.sol @@ -164,10 +164,12 @@ abstract contract BaseSwapTask is IBaseSwapTask, Task { */ function _beforeBaseSwapTask(address token, uint256 amount, uint256 slippage) internal virtual { _beforeTask(token, amount); - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(amount > 0, 'TASK_AMOUNT_ZERO'); - require(getTokenOut(token) != address(0), 'TASK_TOKEN_OUT_NOT_SET'); - require(slippage <= getMaxSlippage(token), 'TASK_SLIPPAGE_TOO_HIGH'); + 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); } /** @@ -186,7 +188,7 @@ abstract contract BaseSwapTask is IBaseSwapTask, Task { * @param newConnector Address of the connector to be set */ function _setConnector(address newConnector) internal { - require(newConnector != address(0), 'TASK_CONNECTOR_ZERO'); + if (newConnector == address(0)) revert TaskConnectorZero(); connector = newConnector; emit ConnectorSet(newConnector); } @@ -205,7 +207,7 @@ abstract contract BaseSwapTask is IBaseSwapTask, Task { * @param maxSlippage Default max slippage to be set */ function _setDefaultMaxSlippage(uint256 maxSlippage) internal { - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); defaultMaxSlippage = maxSlippage; emit DefaultMaxSlippageSet(maxSlippage); } @@ -216,7 +218,7 @@ abstract contract BaseSwapTask is IBaseSwapTask, Task { * @param tokenOut Address of the token out to be set */ function _setCustomTokenOut(address token, address tokenOut) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); + if (token == address(0)) revert TaskTokenZero(); customTokenOut[token] = tokenOut; emit CustomTokenOutSet(token, tokenOut); } @@ -227,8 +229,8 @@ abstract contract BaseSwapTask is IBaseSwapTask, Task { * @param maxSlippage Max slippage to be set */ function _setCustomMaxSlippage(address token, uint256 maxSlippage) internal { - require(token != address(0), 'TASK_TOKEN_ZERO'); - require(maxSlippage <= FixedPoint.ONE, 'TASK_SLIPPAGE_ABOVE_ONE'); + if (token == address(0)) revert TaskTokenZero(); + if (maxSlippage > FixedPoint.ONE) revert TaskSlippageAboveOne(); customMaxSlippage[token] = maxSlippage; emit CustomMaxSlippageSet(token, maxSlippage); } diff --git a/packages/tasks/contracts/swap/HopL2Swapper.sol b/packages/tasks/contracts/swap/HopL2Swapper.sol index 6472619d..c87a6a05 100644 --- a/packages/tasks/contracts/swap/HopL2Swapper.sol +++ b/packages/tasks/contracts/swap/HopL2Swapper.sol @@ -117,7 +117,7 @@ contract HopL2Swapper is IHopL2Swapper, BaseSwapTask { */ function _beforeHopL2Swapper(address token, uint256 amount, uint256 slippage) internal virtual { _beforeBaseSwapTask(token, amount, slippage); - require(tokenAmm[token] != address(0), 'TASK_MISSING_HOP_TOKEN_AMM'); + if (tokenAmm[token] == address(0)) revert TaskMissingHopTokenAmm(); } /** @@ -139,8 +139,8 @@ contract HopL2Swapper is IHopL2Swapper, BaseSwapTask { * @param amm AMM to be set */ function _setTokenAmm(address hToken, address amm) internal { - require(hToken != address(0), 'TASK_HOP_TOKEN_ZERO'); - require(amm == address(0) || hToken == IHopL2Amm(amm).hToken(), 'TASK_HOP_TOKEN_AMM_MISMATCH'); + if (hToken == address(0)) revert TaskTokenZero(); + if (amm != address(0) && hToken != IHopL2Amm(amm).hToken()) revert TaskHopTokenAmmMismatch(hToken, amm); tokenAmm[hToken] = amm; emit TokenAmmSet(hToken, amm); diff --git a/packages/tasks/contracts/swap/ParaswapV5Swapper.sol b/packages/tasks/contracts/swap/ParaswapV5Swapper.sol index aaf7acec..01cf7403 100644 --- a/packages/tasks/contracts/swap/ParaswapV5Swapper.sol +++ b/packages/tasks/contracts/swap/ParaswapV5Swapper.sol @@ -137,8 +137,8 @@ contract ParaswapV5Swapper is IParaswapV5Swapper, BaseSwapTask { abi.encodePacked(tokenIn, tokenOut, isBuy, amountIn, minAmountOut, expectedAmountOut, deadline, data) ); address signer = ECDSA.recover(ECDSA.toEthSignedMessageHash(message), sig); - require(signer == quoteSigner, 'TASK_INVALID_QUOTE_SIGNER'); - require(block.timestamp <= deadline, 'TASK_QUOTE_SIGNER_DEADLINE'); + if (signer != quoteSigner) revert TaskInvalidQuoteSigner(signer, quoteSigner); + if (block.timestamp > deadline) revert TaskQuoteSignerPastDeadline(deadline, block.timestamp); } /** @@ -159,7 +159,7 @@ contract ParaswapV5Swapper is IParaswapV5Swapper, BaseSwapTask { * @param newQuoteSigner Address of the new quote signer to be set */ function _setQuoteSigner(address newQuoteSigner) internal { - require(newQuoteSigner != address(0), 'TASK_QUOTE_SIGNER_ZERO'); + if (newQuoteSigner == address(0)) revert TaskQuoteSignerZero(); quoteSigner = newQuoteSigner; emit QuoteSignerSet(newQuoteSigner); } diff --git a/packages/tasks/test/base/BaseTask.test.ts b/packages/tasks/test/base/BaseTask.test.ts index 0a6b6c44..a24eff7f 100644 --- a/packages/tasks/test/base/BaseTask.test.ts +++ b/packages/tasks/test/base/BaseTask.test.ts @@ -157,7 +157,7 @@ describe('BaseTask', () => { const next = '0x0000000000000000000000000000000000000000000000000000000000000001' it('reverts', async () => { - await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith('TASK_SAME_BALANCE_CONNECTORS') + await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith('TaskSameBalanceConnectors') }) }) }) @@ -172,9 +172,7 @@ describe('BaseTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -223,7 +221,7 @@ describe('BaseTask', () => { context('when there is not enough balance in the connector', () => { it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('SMART_VAULT_CONNECTOR_NO_BALANCE') + await expect(task.call(token, amount)).to.be.reverted }) }) }) diff --git a/packages/tasks/test/base/GasLimitedTask.test.ts b/packages/tasks/test/base/GasLimitedTask.test.ts index fd0d6021..2ea6083e 100644 --- a/packages/tasks/test/base/GasLimitedTask.test.ts +++ b/packages/tasks/test/base/GasLimitedTask.test.ts @@ -14,6 +14,8 @@ import { Contract } from 'ethers' import { deployEnvironment } from '../../src/setup' +/* eslint-disable no-secrets/no-secrets */ + describe('GasLimitedTask', () => { let task: Contract let smartVault: Contract, authorizer: Contract, owner: SignerWithAddress @@ -85,7 +87,7 @@ describe('GasLimitedTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setGasPriceLimit(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setGasPriceLimit(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -129,7 +131,7 @@ describe('GasLimitedTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setPriorityFeeLimit(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setPriorityFeeLimit(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -173,7 +175,7 @@ describe('GasLimitedTask', () => { context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(task.setTxCostLimit(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTxCostLimit(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -216,14 +218,14 @@ describe('GasLimitedTask', () => { const txCostLimitPct = fp(1.1) it('reverts', async () => { - await expect(task.setTxCostLimitPct(txCostLimitPct)).to.be.revertedWith('TASK_TX_COST_LIMIT_PCT_ABOVE_ONE') + await expect(task.setTxCostLimitPct(txCostLimitPct)).to.be.revertedWith('TaskTxCostLimitPctAboveOne') }) }) }) context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(task.setTxCostLimitPct(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTxCostLimitPct(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -266,7 +268,7 @@ describe('GasLimitedTask', () => { }) it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TASK_TX_COST_LIMIT') + await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TaskTxCostLimitExceeded') }) }) }) @@ -289,7 +291,9 @@ describe('GasLimitedTask', () => { context('when the tx moves less than the cost limit percentage', () => { it('reverts', async () => { - await expect(task.call(NATIVE_TOKEN_ADDRESS, 1, { gasPrice })).to.be.revertedWith('TASK_TX_COST_LIMIT_PCT') + await expect(task.call(NATIVE_TOKEN_ADDRESS, 1, { gasPrice })).to.be.revertedWith( + 'TaskTxCostLimitPctExceeded' + ) }) }) }) @@ -308,7 +312,7 @@ describe('GasLimitedTask', () => { }) it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TASK_GAS_PRICE_LIMIT') + await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TaskGasPriceLimitExceeded') }) }) @@ -322,7 +326,7 @@ describe('GasLimitedTask', () => { }) it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TASK_GAS_PRICE_LIMIT') + await expect(task.call(ZERO_ADDRESS, 0, { gasPrice })).to.be.revertedWith('TaskGasPriceLimitExceeded') }) }) }) diff --git a/packages/tasks/test/base/PausableTask.test.ts b/packages/tasks/test/base/PausableTask.test.ts index d32c9ace..815bd540 100644 --- a/packages/tasks/test/base/PausableTask.test.ts +++ b/packages/tasks/test/base/PausableTask.test.ts @@ -55,14 +55,14 @@ describe('PausableTask', () => { }) it('cannot be paused', async () => { - await expect(task.pause()).to.be.revertedWith('TASK_ALREADY_PAUSED') + await expect(task.pause()).to.be.revertedWith('TaskPaused') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.pause()).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.pause()).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -77,7 +77,7 @@ describe('PausableTask', () => { context('when the task is not paused', () => { it('cannot be unpaused', async () => { - await expect(task.unpause()).to.be.revertedWith('TASK_ALREADY_UNPAUSED') + await expect(task.unpause()).to.be.revertedWith('TaskUnpaused') }) }) @@ -100,7 +100,7 @@ describe('PausableTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.unpause()).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.unpause()).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -124,7 +124,7 @@ describe('PausableTask', () => { }) it('cannot be executed', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_PAUSED') + await expect(task.call(token, amount)).to.be.revertedWith('TaskPaused') }) }) }) diff --git a/packages/tasks/test/base/TimeLockedTask.test.ts b/packages/tasks/test/base/TimeLockedTask.test.ts index c739ad32..ad82456a 100644 --- a/packages/tasks/test/base/TimeLockedTask.test.ts +++ b/packages/tasks/test/base/TimeLockedTask.test.ts @@ -16,6 +16,8 @@ import { BigNumber, Contract } from 'ethers' import { deployEnvironment } from '../../src/setup' +/* eslint-disable no-secrets/no-secrets */ + describe('TimeLockedTask', () => { let task: Contract let smartVault: Contract, authorizer: Contract, owner: SignerWithAddress @@ -95,14 +97,14 @@ describe('TimeLockedTask', () => { }) it('reverts', async () => { - await expect(task.setTimeLockDelay(delay)).to.be.revertedWith('TASK_DELAY_GT_EXECUTION_PERIOD') + await expect(task.setTimeLockDelay(delay)).to.be.revertedWith('TaskExecutionPeriodGtDelay') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTimeLockDelay(delay)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTimeLockDelay(delay)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -137,7 +139,7 @@ describe('TimeLockedTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTimeLockExpiration(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTimeLockExpiration(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -189,14 +191,14 @@ describe('TimeLockedTask', () => { }) it('reverts', async () => { - await expect(task.setTimeLockExecutionPeriod(period)).to.be.revertedWith('TASK_EXECUTION_PERIOD_GT_DELAY') + await expect(task.setTimeLockExecutionPeriod(period)).to.be.revertedWith('TaskExecutionPeriodGtDelay') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTimeLockExecutionPeriod(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTimeLockExecutionPeriod(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -253,7 +255,7 @@ describe('TimeLockedTask', () => { const tx = await task.call() await assertEvent(tx, 'TimeLockExpirationSet') - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') const previousExpiration = await task.timeLockExpiration() await advanceTime(newTimeLockDelay) @@ -284,7 +286,7 @@ describe('TimeLockedTask', () => { it('must wait to be valid again after the first execution', async () => { await task.call() - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') const previousExpiration = await task.timeLockExpiration() await advanceTime(delay) @@ -359,7 +361,7 @@ describe('TimeLockedTask', () => { const initialDelay = await task.timeLockDelay() const initialExpiration = await task.timeLockExpiration() - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') await advanceTime(initialExpirationTimestamp) const tx = await task.call() @@ -404,7 +406,7 @@ describe('TimeLockedTask', () => { }) it('can be validated once right after the initial delay', async () => { - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') await setNextBlockTimestamp(initialExpirationTimestamp) const tx = await task.call() @@ -414,7 +416,7 @@ describe('TimeLockedTask', () => { expect(await task.timeLockExpiration()).to.be.equal(initialExpirationTimestamp.add(delay)) expect(await task.timeLockExecutionPeriod()).to.be.equal(executionPeriod) - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') await setNextBlockTimestamp(initialExpirationTimestamp.add(delay * 2).add(executionPeriod)) const tx2 = await task.call() @@ -426,10 +428,10 @@ describe('TimeLockedTask', () => { }) it('cannot be validated after the execution period', async () => { - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') await setNextBlockTimestamp(initialExpirationTimestamp.add(executionPeriod).add(1)) - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_WAIT_NEXT_PERIOD') + await expect(task.call()).to.be.revertedWith('TaskTimeLockWaitNextPeriod') await setNextBlockTimestamp(initialExpirationTimestamp.add(delay)) const tx = await task.call() @@ -439,7 +441,7 @@ describe('TimeLockedTask', () => { expect(await task.timeLockExpiration()).to.be.equal(initialExpirationTimestamp.add(delay * 2)) expect(await task.timeLockExecutionPeriod()).to.be.equal(executionPeriod) - await expect(task.call()).to.be.revertedWith('TASK_TIME_LOCK_NOT_EXPIRED') + await expect(task.call()).to.be.revertedWith('TaskTimeLockNotExpired') }) it('can be changed at any time in the future without affecting the previous expiration date', async () => { diff --git a/packages/tasks/test/base/TokenIndexedTask.test.ts b/packages/tasks/test/base/TokenIndexedTask.test.ts index 46d74b85..358f7aed 100644 --- a/packages/tasks/test/base/TokenIndexedTask.test.ts +++ b/packages/tasks/test/base/TokenIndexedTask.test.ts @@ -94,7 +94,7 @@ describe('TokenIndexedTask', () => { context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(task.setTokensAcceptanceType(0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTokensAcceptanceType(0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -170,7 +170,7 @@ describe('TokenIndexedTask', () => { context('when an address zero is given', () => { it('reverts', async () => { await expect(task.setTokensAcceptanceList([ZERO_ADDRESS], [true])).to.be.revertedWith( - 'TASK_ACCEPTANCE_TOKEN_ZERO' + 'TaskAcceptanceTokenZero' ) }) }) @@ -178,7 +178,7 @@ describe('TokenIndexedTask', () => { context('when the sender is not allowed', () => { it('reverts', async () => { - await expect(task.setTokensAcceptanceList([], [])).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTokensAcceptanceList([], [])).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -203,8 +203,8 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenB)).to.be.false expect(await task.isTokenAllowed(tokenC)).to.be.false await expect(task.call(tokenA)).not.to.be.reverted - await expect(task.call(tokenB)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') - await expect(task.call(tokenC)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenB)).to.be.revertedWith('TaskTokenNotAllowed') + await expect(task.call(tokenC)).to.be.revertedWith('TaskTokenNotAllowed') await task.connect(owner).setTokensAcceptanceList([tokenC], [true]) @@ -212,7 +212,7 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenB)).to.be.false expect(await task.isTokenAllowed(tokenC)).to.be.true await expect(task.call(tokenA)).not.to.be.reverted - await expect(task.call(tokenB)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenB)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenC)).not.to.be.reverted await task.connect(owner).setTokensAcceptanceList([tokenB], [true]) @@ -230,8 +230,8 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenA)).to.be.false expect(await task.isTokenAllowed(tokenB)).to.be.false expect(await task.isTokenAllowed(tokenC)).to.be.true - await expect(task.call(tokenA)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') - await expect(task.call(tokenB)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenA)).to.be.revertedWith('TaskTokenNotAllowed') + await expect(task.call(tokenB)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenC)).not.to.be.reverted await task.connect(owner).setTokensAcceptanceType(TYPE.DENY_LIST) @@ -240,9 +240,9 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenA)).to.be.false expect(await task.isTokenAllowed(tokenB)).to.be.true expect(await task.isTokenAllowed(tokenC)).to.be.false - await expect(task.call(tokenA)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenA)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenB)).not.to.be.reverted - await expect(task.call(tokenC)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenC)).to.be.revertedWith('TaskTokenNotAllowed') }) }) @@ -259,7 +259,7 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenA)).to.be.false expect(await task.isTokenAllowed(tokenB)).to.be.true expect(await task.isTokenAllowed(tokenC)).to.be.true - await expect(task.call(tokenA)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenA)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenB)).not.to.be.reverted await expect(task.call(tokenC)).not.to.be.reverted @@ -268,18 +268,18 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenA)).to.be.false expect(await task.isTokenAllowed(tokenB)).to.be.true expect(await task.isTokenAllowed(tokenC)).to.be.false - await expect(task.call(tokenA)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenA)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenB)).not.to.be.reverted - await expect(task.call(tokenC)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenC)).to.be.revertedWith('TaskTokenNotAllowed') await task.connect(owner).setTokensAcceptanceList([tokenB], [true]) expect(await task.isTokenAllowed(tokenA)).to.be.false expect(await task.isTokenAllowed(tokenB)).to.be.false expect(await task.isTokenAllowed(tokenC)).to.be.false - await expect(task.call(tokenA)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') - await expect(task.call(tokenB)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') - await expect(task.call(tokenC)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenA)).to.be.revertedWith('TaskTokenNotAllowed') + await expect(task.call(tokenB)).to.be.revertedWith('TaskTokenNotAllowed') + await expect(task.call(tokenC)).to.be.revertedWith('TaskTokenNotAllowed') await task.connect(owner).setTokensAcceptanceList([tokenA], [false]) await task.connect(owner).setTokensAcceptanceList([tokenB], [false]) @@ -289,7 +289,7 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenC)).to.be.false await expect(task.call(tokenA)).not.to.be.reverted await expect(task.call(tokenB)).not.to.be.reverted - await expect(task.call(tokenC)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenC)).to.be.revertedWith('TaskTokenNotAllowed') await task.connect(owner).setTokensAcceptanceType(TYPE.ALLOW_LIST) await task.connect(owner).setTokensAcceptanceList([tokenA, tokenB], [true, false]) @@ -298,7 +298,7 @@ describe('TokenIndexedTask', () => { expect(await task.isTokenAllowed(tokenB)).to.be.false expect(await task.isTokenAllowed(tokenC)).to.be.true await expect(task.call(tokenA)).not.to.be.reverted - await expect(task.call(tokenB)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenB)).to.be.revertedWith('TaskTokenNotAllowed') await expect(task.call(tokenC)).not.to.be.reverted }) }) diff --git a/packages/tasks/test/base/TokenThresholdTask.test.ts b/packages/tasks/test/base/TokenThresholdTask.test.ts index 28931218..7e7c2906 100644 --- a/packages/tasks/test/base/TokenThresholdTask.test.ts +++ b/packages/tasks/test/base/TokenThresholdTask.test.ts @@ -123,7 +123,7 @@ describe('TokenThresholdTask', () => { it('reverts', async () => { await expect(task.setDefaultTokenThreshold(token, min, max)).to.be.revertedWith( - 'TASK_INVALID_THRESHOLD_INPUT' + 'TaskInvalidThresholdInput' ) }) }) @@ -133,7 +133,7 @@ describe('TokenThresholdTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setDefaultTokenThreshold(token, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setDefaultTokenThreshold(token, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -210,7 +210,7 @@ describe('TokenThresholdTask', () => { it('reverts', async () => { await expect(task.setCustomTokenThreshold(token, thresholdToken, min, max)).to.be.revertedWith( - 'TASK_INVALID_THRESHOLD_INPUT' + 'TaskInvalidThresholdInput' ) }) }) @@ -223,7 +223,7 @@ describe('TokenThresholdTask', () => { it('reverts', async () => { await expect(task.setCustomTokenThreshold(token, ZERO_ADDRESS, 0, 0)).to.be.revertedWith( - 'TASK_THRESHOLD_TOKEN_ZERO' + 'TaskThresholdTokenZero' ) }) }) @@ -232,7 +232,7 @@ describe('TokenThresholdTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { await expect(task.setCustomTokenThreshold(ZERO_ADDRESS, ZERO_ADDRESS, 0, 0)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -252,7 +252,7 @@ describe('TokenThresholdTask', () => { } const assertInvalid = async (token: Contract | string, amount: BigNumberish) => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') } context('when there is no default threshold set', () => { diff --git a/packages/tasks/test/base/VolumeLimitedTask.test.ts b/packages/tasks/test/base/VolumeLimitedTask.test.ts index 10514680..33fa1a43 100644 --- a/packages/tasks/test/base/VolumeLimitedTask.test.ts +++ b/packages/tasks/test/base/VolumeLimitedTask.test.ts @@ -112,7 +112,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -126,7 +126,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -136,7 +136,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -154,7 +154,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -164,7 +164,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -178,7 +178,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setDefaultVolumeLimit(token, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -308,7 +308,7 @@ describe('VolumeLimitedTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setDefaultVolumeLimit(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setDefaultVolumeLimit(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -376,7 +376,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -390,7 +390,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -400,7 +400,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -418,7 +418,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -428,7 +428,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -442,7 +442,7 @@ describe('VolumeLimitedTask', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(token.address, limitToken, amount, period)).to.be.revertedWith( - 'TASK_INVALID_VOLUME_LIMIT_INPUT' + 'TaskInvalidVolumeLimitInput' ) }) }) @@ -584,7 +584,7 @@ describe('VolumeLimitedTask', () => { context('when the sender is not authorized', () => { it('reverts', async () => { await expect(task.setCustomVolumeLimit(ZERO_ADDRESS, ZERO_ADDRESS, 0, 0)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -608,7 +608,7 @@ describe('VolumeLimitedTask', () => { const itCannotBeExecuted = () => { it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_VOLUME_LIMIT_EXCEEDED') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskVolumeLimitExceeded') }) } diff --git a/packages/tasks/test/bridge/AxelarBridger.test.ts b/packages/tasks/test/bridge/AxelarBridger.test.ts index a4131455..e353c20c 100644 --- a/packages/tasks/test/bridge/AxelarBridger.test.ts +++ b/packages/tasks/test/bridge/AxelarBridger.test.ts @@ -154,7 +154,7 @@ describe('AxelarBridger', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amountIn)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amountIn)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -167,14 +167,14 @@ describe('AxelarBridger', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amountIn)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(token.address, amountIn)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) context('when the destination chain was not set', () => { it('reverts', async () => { - await expect(task.call(token.address, amountIn)).to.be.revertedWith('TASK_DESTINATION_CHAIN_NOT_SET') + await expect(task.call(token.address, amountIn)).to.be.revertedWith('TaskDestinationChainNotSet') }) }) }) @@ -183,7 +183,7 @@ describe('AxelarBridger', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -192,14 +192,14 @@ describe('AxelarBridger', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/bridge/BaseBridgeTask.behavior.ts b/packages/tasks/test/bridge/BaseBridgeTask.behavior.ts index 23e56fdf..6d7595c5 100644 --- a/packages/tasks/test/bridge/BaseBridgeTask.behavior.ts +++ b/packages/tasks/test/bridge/BaseBridgeTask.behavior.ts @@ -45,9 +45,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { const next = '0x0000000000000000000000000000000000000000000000000000000000000002' it('reverts', async function () { - await expect(this.task.setBalanceConnectors(previous, next)).to.be.revertedWith( - 'TASK_NEXT_CONNECTOR_NOT_ZERO' - ) + await expect(this.task.setBalanceConnectors(previous, next)).to.be.revertedWith('TaskNextConnectorNotZero') }) }) }) @@ -63,7 +61,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { await expect(this.task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -101,14 +99,14 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { const connector = ZERO_ADDRESS it('reverts', async function () { - await expect(this.task.setConnector(connector)).to.be.revertedWith('TASK_CONNECTOR_ZERO') + await expect(this.task.setConnector(connector)).to.be.revertedWith('TaskConnectorZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -139,14 +137,14 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { const recipient = ZERO_ADDRESS it('reverts', async function () { - await expect(this.task.setRecipient(recipient)).to.be.revertedWith('TASK_RECIPIENT_ZERO') + await expect(this.task.setRecipient(recipient)).to.be.revertedWith('TaskRecipientZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setRecipient(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setRecipient(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -183,9 +181,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { const chainId = 31337 // Hardhat destination chain it('reverts', async function () { - await expect(this.task.setDefaultDestinationChain(chainId)).to.be.revertedWith( - 'TASK_BRIDGE_CURRENT_CHAIN_ID' - ) + await expect(this.task.setDefaultDestinationChain(chainId)).to.be.revertedWith('TaskBridgeCurrentChainId') }) }) } @@ -242,7 +238,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultDestinationChain(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultDestinationChain(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -304,7 +300,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { it('reverts', async function () { await expect(this.task.setCustomDestinationChain(token.address, chainId)).to.be.revertedWith( - 'TASK_BRIDGE_CURRENT_CHAIN_ID' + 'TaskBridgeCurrentChainId' ) }) }) @@ -346,7 +342,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setCustomDestinationChain(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setCustomDestinationChain(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -381,14 +377,14 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { const slippage = fp(1).add(1) it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TASK_SLIPPAGE_ABOVE_ONE') + await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TaskSlippageAboveOne') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -430,7 +426,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { it('reverts', async function () { await expect(this.task.setCustomMaxSlippage(token.address, slippage)).to.be.revertedWith( - 'TASK_SLIPPAGE_ABOVE_ONE' + 'TaskSlippageAboveOne' ) }) }) @@ -438,7 +434,7 @@ export function itBehavesLikeBaseBridgeTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/bridge/ConnextBridger.test.ts b/packages/tasks/test/bridge/ConnextBridger.test.ts index 398b0d32..85ca4c1f 100644 --- a/packages/tasks/test/bridge/ConnextBridger.test.ts +++ b/packages/tasks/test/bridge/ConnextBridger.test.ts @@ -91,7 +91,7 @@ describe('ConnextBridger', () => { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(task.setDefaultRelayerFee(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setDefaultRelayerFee(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -127,7 +127,7 @@ describe('ConnextBridger', () => { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(task.setCustomRelayerFee(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setCustomRelayerFee(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -238,7 +238,7 @@ describe('ConnextBridger', () => { context('when the relayer fee is too high', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, 0, relayerFee)).to.be.revertedWith( - 'TASK_FEE_TOO_HIGH' + 'TaskFeePctAboveMax' ) }) }) @@ -247,7 +247,7 @@ describe('ConnextBridger', () => { context('when the slippage is above the limit', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, 0)).to.be.revertedWith( - 'TASK_SLIPPAGE_TOO_HIGH' + 'TaskSlippageAboveMax' ) }) }) @@ -266,7 +266,7 @@ describe('ConnextBridger', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, relayerFee)).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskTokenThresholdNotMet' ) }) }) @@ -281,7 +281,7 @@ describe('ConnextBridger', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, relayerFee)).to.be.revertedWith( - 'TASK_TOKEN_NOT_ALLOWED' + 'TaskTokenNotAllowed' ) }) }) @@ -290,7 +290,7 @@ describe('ConnextBridger', () => { context('when the destination chain was not set', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, relayerFee)).to.be.revertedWith( - 'TASK_DESTINATION_CHAIN_NOT_SET' + 'TaskDestinationChainNotSet' ) }) }) @@ -300,7 +300,7 @@ describe('ConnextBridger', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount, 0, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount, 0, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -309,14 +309,14 @@ describe('ConnextBridger', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/bridge/HopBridger.test.ts b/packages/tasks/test/bridge/HopBridger.test.ts index 2d59d690..167ba93e 100644 --- a/packages/tasks/test/bridge/HopBridger.test.ts +++ b/packages/tasks/test/bridge/HopBridger.test.ts @@ -94,7 +94,7 @@ describe('HopBridger', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -127,14 +127,14 @@ describe('HopBridger', () => { const deadline = 0 it('reverts', async () => { - await expect(task.setMaxDeadline(deadline)).to.be.revertedWith('TASK_MAX_DEADLINE_ZERO') + await expect(task.setMaxDeadline(deadline)).to.be.revertedWith('TaskMaxDeadlineZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setMaxDeadline(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setMaxDeadline(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -164,7 +164,7 @@ describe('HopBridger', () => { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(task.setDefaultMaxFeePct(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setDefaultMaxFeePct(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -200,7 +200,7 @@ describe('HopBridger', () => { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(task.setCustomMaxFeePct(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setCustomMaxFeePct(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -293,16 +293,14 @@ describe('HopBridger', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.setTokenHopEntrypoint(token, ZERO_ADDRESS)).to.be.revertedWith('TASK_HOP_TOKEN_ZERO') + await expect(task.setTokenHopEntrypoint(token, ZERO_ADDRESS)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTokenHopEntrypoint(ZERO_ADDRESS, ZERO_ADDRESS)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(task.setTokenHopEntrypoint(ZERO_ADDRESS, ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -419,7 +417,7 @@ describe('HopBridger', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, fee)).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskTokenThresholdNotMet' ) }) }) @@ -434,7 +432,7 @@ describe('HopBridger', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, fee)).to.be.revertedWith( - 'TASK_TOKEN_NOT_ALLOWED' + 'TaskTokenNotAllowed' ) }) }) @@ -443,7 +441,7 @@ describe('HopBridger', () => { context('when the destination chain was not set', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage, fee)).to.be.revertedWith( - 'TASK_DESTINATION_CHAIN_NOT_SET' + 'TaskDestinationChainNotSet' ) }) }) @@ -453,7 +451,7 @@ describe('HopBridger', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount, 0, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount, 0, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -462,14 +460,14 @@ describe('HopBridger', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/bridge/WormholeBridger.test.ts b/packages/tasks/test/bridge/WormholeBridger.test.ts index 4559cd11..b14f828b 100644 --- a/packages/tasks/test/bridge/WormholeBridger.test.ts +++ b/packages/tasks/test/bridge/WormholeBridger.test.ts @@ -159,7 +159,7 @@ describe('WormholeBridger', () => { context('when the slippage is above the limit', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage)).to.be.revertedWith( - 'TASK_SLIPPAGE_TOO_HIGH' + 'TaskSlippageAboveMax' ) }) }) @@ -178,7 +178,7 @@ describe('WormholeBridger', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage)).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskTokenThresholdNotMet' ) }) }) @@ -192,7 +192,7 @@ describe('WormholeBridger', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amountIn, slippage)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(token.address, amountIn, slippage)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) @@ -200,7 +200,7 @@ describe('WormholeBridger', () => { context('when the destination chain was not set', () => { it('reverts', async () => { await expect(task.call(token.address, amountIn, slippage)).to.be.revertedWith( - 'TASK_DESTINATION_CHAIN_NOT_SET' + 'TaskDestinationChainNotSet' ) }) }) @@ -210,7 +210,7 @@ describe('WormholeBridger', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -219,14 +219,14 @@ describe('WormholeBridger', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/convex/BaseConvexTask.behavior.ts b/packages/tasks/test/liquidity/convex/BaseConvexTask.behavior.ts index 0fd259bb..22269002 100644 --- a/packages/tasks/test/liquidity/convex/BaseConvexTask.behavior.ts +++ b/packages/tasks/test/liquidity/convex/BaseConvexTask.behavior.ts @@ -43,14 +43,14 @@ export function itBehavesLikeBaseConvexTask(executionType: string): void { const connector = ZERO_ADDRESS it('reverts', async function () { - await expect(this.task.setConnector(connector)).to.be.revertedWith('TASK_CONNECTOR_ZERO') + await expect(this.task.setConnector(connector)).to.be.revertedWith('TaskConnectorZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/convex/ConvexClaimer.test.ts b/packages/tasks/test/liquidity/convex/ConvexClaimer.test.ts index 0b861bc6..3e8e8ffb 100644 --- a/packages/tasks/test/liquidity/convex/ConvexClaimer.test.ts +++ b/packages/tasks/test/liquidity/convex/ConvexClaimer.test.ts @@ -99,7 +99,7 @@ describe('ConvexClaimer', () => { const amount = 1 it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_AMOUNT_NOT_ZERO') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskAmountNotZero') }) }) }) @@ -108,14 +108,14 @@ describe('ConvexClaimer', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/convex/ConvexExiter.test.ts b/packages/tasks/test/liquidity/convex/ConvexExiter.test.ts index 229a75d9..f2a22ac8 100644 --- a/packages/tasks/test/liquidity/convex/ConvexExiter.test.ts +++ b/packages/tasks/test/liquidity/convex/ConvexExiter.test.ts @@ -149,7 +149,7 @@ describe('ConvexExiter', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -158,7 +158,7 @@ describe('ConvexExiter', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -167,14 +167,14 @@ describe('ConvexExiter', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/convex/ConvexJoiner.test.ts b/packages/tasks/test/liquidity/convex/ConvexJoiner.test.ts index ca241304..54c23496 100644 --- a/packages/tasks/test/liquidity/convex/ConvexJoiner.test.ts +++ b/packages/tasks/test/liquidity/convex/ConvexJoiner.test.ts @@ -149,7 +149,7 @@ describe('ConvexJoiner', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -158,7 +158,7 @@ describe('ConvexJoiner', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -167,14 +167,14 @@ describe('ConvexJoiner', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/curve/BaseCurveTask.behavior.ts b/packages/tasks/test/liquidity/curve/BaseCurveTask.behavior.ts index d844f7dc..e54ff5f6 100644 --- a/packages/tasks/test/liquidity/curve/BaseCurveTask.behavior.ts +++ b/packages/tasks/test/liquidity/curve/BaseCurveTask.behavior.ts @@ -43,14 +43,14 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { const connector = ZERO_ADDRESS it('reverts', async function () { - await expect(this.task.setConnector(connector)).to.be.revertedWith('TASK_CONNECTOR_ZERO') + await expect(this.task.setConnector(connector)).to.be.revertedWith('TaskConnectorZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -86,7 +86,7 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultTokenOut(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultTokenOut(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -124,7 +124,7 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { await expect(this.task.setCustomTokenOut(token.address, tokenOut.address)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -160,14 +160,14 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { const slippage = fp(1).add(1) it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TASK_SLIPPAGE_ABOVE_ONE') + await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TaskSlippageAboveOne') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -209,7 +209,7 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { it('reverts', async function () { await expect(this.task.setCustomMaxSlippage(token.address, slippage)).to.be.revertedWith( - 'TASK_SLIPPAGE_ABOVE_ONE' + 'TaskSlippageAboveOne' ) }) }) @@ -217,7 +217,7 @@ export function itBehavesLikeBaseCurveTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/curve/Curve2CrvExiter.test.ts b/packages/tasks/test/liquidity/curve/Curve2CrvExiter.test.ts index 93bc6f40..81251ce3 100644 --- a/packages/tasks/test/liquidity/curve/Curve2CrvExiter.test.ts +++ b/packages/tasks/test/liquidity/curve/Curve2CrvExiter.test.ts @@ -170,7 +170,7 @@ describe('Curve2CrvExiter', () => { const slippage = fp(0.01) it('reverts', async () => { - await expect(task.call(token.address, amount, slippage)).to.be.revertedWith('TASK_SLIPPAGE_TOO_HIGH') + await expect(task.call(token.address, amount, slippage)).to.be.revertedWith('TaskSlippageAboveMax') }) }) }) @@ -185,14 +185,14 @@ describe('Curve2CrvExiter', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when there is no token out set', () => { it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_TOKEN_OUT_NOT_SET') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskTokenOutNotSet') }) }) }) @@ -201,7 +201,7 @@ describe('Curve2CrvExiter', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -210,14 +210,14 @@ describe('Curve2CrvExiter', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/liquidity/curve/Curve2CrvJoiner.test.ts b/packages/tasks/test/liquidity/curve/Curve2CrvJoiner.test.ts index 1e627e67..642575bf 100644 --- a/packages/tasks/test/liquidity/curve/Curve2CrvJoiner.test.ts +++ b/packages/tasks/test/liquidity/curve/Curve2CrvJoiner.test.ts @@ -170,7 +170,7 @@ describe('Curve2CrvJoiner', () => { const slippage = fp(0.01) it('reverts', async () => { - await expect(task.call(token.address, amount, slippage)).to.be.revertedWith('TASK_SLIPPAGE_TOO_HIGH') + await expect(task.call(token.address, amount, slippage)).to.be.revertedWith('TaskSlippageAboveMax') }) }) }) @@ -185,14 +185,14 @@ describe('Curve2CrvJoiner', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when there is no token out set', () => { it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_TOKEN_OUT_NOT_SET') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskTokenOutNotSet') }) }) }) @@ -201,7 +201,7 @@ describe('Curve2CrvJoiner', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token.address, amount, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -210,14 +210,14 @@ describe('Curve2CrvJoiner', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(token, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/primitives/Collector.test.ts b/packages/tasks/test/primitives/Collector.test.ts index 45fcbc49..2707e6c3 100644 --- a/packages/tasks/test/primitives/Collector.test.ts +++ b/packages/tasks/test/primitives/Collector.test.ts @@ -78,9 +78,7 @@ describe('Collector', () => { const previous = '0x0000000000000000000000000000000000000000000000000000000000000002' it('reverts', async () => { - await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith( - 'TASK_PREVIOUS_CONNECTOR_NOT_ZERO' - ) + await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith('TaskPreviousConnectorNotZero') }) }) }) @@ -95,9 +93,7 @@ describe('Collector', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -132,14 +128,14 @@ describe('Collector', () => { const newSource = ZERO_ADDRESS it('reverts', async () => { - await expect(task.setTokensSource(newSource)).to.be.revertedWith('TASK_TOKENS_SOURCE_ZERO') + await expect(task.setTokensSource(newSource)).to.be.revertedWith('TaskTokensSourceZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -238,21 +234,21 @@ describe('Collector', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when the given token is not allowed', () => { it('reverts', async () => { - await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(token.address, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(token.address, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/primitives/Depositor.test.ts b/packages/tasks/test/primitives/Depositor.test.ts index e03735a0..9d8bea1e 100644 --- a/packages/tasks/test/primitives/Depositor.test.ts +++ b/packages/tasks/test/primitives/Depositor.test.ts @@ -81,14 +81,14 @@ describe('Depositor', () => { context('when the new address is another', async () => { it('reverts', async () => { - await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('TASK_DEPOSITOR_BAD_TOKENS_SOURCE') + await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('TaskDepositorBadTokensSource') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTokensSource(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -161,21 +161,21 @@ describe('Depositor', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when the given token is not allowed', () => { it('reverts', async () => { - await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(token.address, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(token.address, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/primitives/Unwrapper.test.ts b/packages/tasks/test/primitives/Unwrapper.test.ts index a607491d..a9fb7fad 100644 --- a/packages/tasks/test/primitives/Unwrapper.test.ts +++ b/packages/tasks/test/primitives/Unwrapper.test.ts @@ -123,7 +123,7 @@ describe('Unwrapper', () => { }) it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -132,7 +132,7 @@ describe('Unwrapper', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -141,14 +141,14 @@ describe('Unwrapper', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_NOT_WRAPPED') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenNotWrapped') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/primitives/Withdrawer.test.ts b/packages/tasks/test/primitives/Withdrawer.test.ts index 0a76be69..d78afa98 100644 --- a/packages/tasks/test/primitives/Withdrawer.test.ts +++ b/packages/tasks/test/primitives/Withdrawer.test.ts @@ -16,6 +16,8 @@ import { ethers } from 'hardhat' import { buildEmptyTaskConfig, deployEnvironment, Mimic } from '../../src/setup' +/* eslint-disable no-secrets/no-secrets */ + describe('Withdrawer', () => { let task: Contract let smartVault: Contract, authorizer: Contract, mimic: Mimic, owner: SignerWithAddress, recipient: SignerWithAddress @@ -78,7 +80,7 @@ describe('Withdrawer', () => { const next = '0x0000000000000000000000000000000000000000000000000000000000000002' it('reverts', async () => { - await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith('TASK_NEXT_CONNECTOR_NOT_ZERO') + await expect(task.setBalanceConnectors(previous, next)).to.be.revertedWith('TaskNextConnectorNotZero') }) }) }) @@ -93,9 +95,7 @@ describe('Withdrawer', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' - ) + await expect(task.setBalanceConnectors(ZERO_BYTES32, ZERO_BYTES32)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -135,7 +135,7 @@ describe('Withdrawer', () => { }) it('reverts', async () => { - await expect(task.setRecipient(newRecipient)).to.be.revertedWith('TASK_RECIPIENT_SMART_VAULT') + await expect(task.setRecipient(newRecipient)).to.be.revertedWith('TaskRecipientEqualsSmartVault') }) }) }) @@ -144,14 +144,14 @@ describe('Withdrawer', () => { const newRecipient = ZERO_ADDRESS it('reverts', async () => { - await expect(task.setRecipient(newRecipient)).to.be.revertedWith('TASK_RECIPIENT_ZERO') + await expect(task.setRecipient(newRecipient)).to.be.revertedWith('TaskRecipientZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setRecipient(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setRecipient(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -240,21 +240,21 @@ describe('Withdrawer', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when the given token is not allowed', () => { it('reverts', async () => { - await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(token.address, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(token.address, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/primitives/Wrapper.test.ts b/packages/tasks/test/primitives/Wrapper.test.ts index bd5899b6..a06482e7 100644 --- a/packages/tasks/test/primitives/Wrapper.test.ts +++ b/packages/tasks/test/primitives/Wrapper.test.ts @@ -118,7 +118,7 @@ describe('Wrapper', () => { }) it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -127,7 +127,7 @@ describe('Wrapper', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -136,14 +136,14 @@ describe('Wrapper', () => { const token = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('TASK_TOKEN_NOT_NATIVE') + await expect(task.call(token, 0)).to.be.revertedWith('TaskTokenNotNative') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/relayer/BaseRelayerFundTask.behavior.ts b/packages/tasks/test/relayer/BaseRelayerFundTask.behavior.ts index 37bc4575..a5e2a480 100644 --- a/packages/tasks/test/relayer/BaseRelayerFundTask.behavior.ts +++ b/packages/tasks/test/relayer/BaseRelayerFundTask.behavior.ts @@ -35,14 +35,14 @@ export function itBehavesLikeBaseRelayerFundTask(executionType: string): void { context('when the relayer is zero', () => { it('reverts', async function () { - await expect(this.task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('TASK_FUNDER_RELAYER_ZERO') + await expect(this.task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('TaskRelayerZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setRelayer(this.relayer.address)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setRelayer(this.relayer.address)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/relayer/CollectorRelayerFunder.test.ts b/packages/tasks/test/relayer/CollectorRelayerFunder.test.ts index 831bccc5..2b4abe37 100644 --- a/packages/tasks/test/relayer/CollectorRelayerFunder.test.ts +++ b/packages/tasks/test/relayer/CollectorRelayerFunder.test.ts @@ -17,6 +17,8 @@ import { Contract } from 'ethers' import { buildEmptyTaskConfig, deployEnvironment } from '../../src/setup' import { itBehavesLikeBaseRelayerFundTask } from './BaseRelayerFundTask.behavior' +/* eslint-disable no-secrets/no-secrets */ + describe('CollectorRelayerFunder', () => { let task: Contract, relayer: Contract let smartVault: Contract, authorizer: Contract, priceOracle: Contract @@ -54,7 +56,7 @@ describe('CollectorRelayerFunder', () => { tokensSource: tokensSource.address, taskConfig: buildEmptyTaskConfig(owner, smartVault), }) - ).to.be.revertedWith('COLLECTOR_INITIALIZER_DISABLED') + ).to.be.revertedWith('TaskInitializerDisabled') }) it('has a relayer reference', async () => { @@ -187,7 +189,7 @@ describe('CollectorRelayerFunder', () => { const bigAmount = amount.add(diff.add(1)) it('reverts', async () => { - await expect(task.call(token.address, bigAmount)).to.be.revertedWith('TASK_AMOUNT_ABOVE_THRESHOLD') + await expect(task.call(token.address, bigAmount)).to.be.revertedWith('TaskDepositAboveMaxThreshold') }) }) }) @@ -210,21 +212,21 @@ describe('CollectorRelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(token.address, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token.address, amount)).to.be.revertedWith('TaskDepositAboveMinThreshold') }) }) }) context('when the given token is not allowed', () => { it('reverts', async () => { - await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(NATIVE_TOKEN_ADDRESS, 0)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(token.address, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(token.address, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/relayer/OneInchV5RelayerFunder.test.ts b/packages/tasks/test/relayer/OneInchV5RelayerFunder.test.ts index b0e24929..e3a9a3a2 100644 --- a/packages/tasks/test/relayer/OneInchV5RelayerFunder.test.ts +++ b/packages/tasks/test/relayer/OneInchV5RelayerFunder.test.ts @@ -18,6 +18,8 @@ import { Contract } from 'ethers' import { buildEmptyTaskConfig, deployEnvironment } from '../../src/setup' import { itBehavesLikeBaseRelayerFundTask } from './BaseRelayerFundTask.behavior' +/* eslint-disable no-secrets/no-secrets */ + describe('OneInchV5RelayerFunder', () => { let task: Contract, relayer: Contract let smartVault: Contract, authorizer: Contract, priceOracle: Contract, connector: Contract, owner: SignerWithAddress @@ -73,7 +75,7 @@ describe('OneInchV5RelayerFunder', () => { taskConfig: buildEmptyTaskConfig(owner, smartVault), }, }) - ).to.be.revertedWith('SWAPPER_INITIALIZER_DISABLED') + ).to.be.revertedWith('TaskInitializerDisabled') }) it('has a relayer reference', async () => { @@ -249,7 +251,7 @@ describe('OneInchV5RelayerFunder', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amount, slippage, data)).to.be.revertedWith( - 'TASK_AMOUNT_ABOVE_THRESHOLD' + 'TaskDepositAboveMaxThreshold' ) }) }) @@ -260,7 +262,7 @@ describe('OneInchV5RelayerFunder', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, slippage, '0x')).to.be.revertedWith( - 'TASK_SLIPPAGE_TOO_HIGH' + 'TaskSlippageAboveMax' ) }) }) @@ -280,7 +282,7 @@ describe('OneInchV5RelayerFunder', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskDepositAboveMinThreshold' ) }) }) @@ -303,7 +305,7 @@ describe('OneInchV5RelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TASK_TOKEN_OUT_NOT_SET') + await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TaskTokenOutNotSet') }) }) }) @@ -316,7 +318,7 @@ describe('OneInchV5RelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, 0, 0, '0x')).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenIn.address, 0, 0, '0x')).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) @@ -339,7 +341,7 @@ describe('OneInchV5RelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -355,7 +357,7 @@ describe('OneInchV5RelayerFunder', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0, '0x')).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0, '0x')).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/relayer/RelayerDepositor.test.ts b/packages/tasks/test/relayer/RelayerDepositor.test.ts index a062ba1b..6d3d507a 100644 --- a/packages/tasks/test/relayer/RelayerDepositor.test.ts +++ b/packages/tasks/test/relayer/RelayerDepositor.test.ts @@ -65,14 +65,14 @@ describe('RelayerDepositor', () => { context('when the relayer is zero', () => { it('reverts', async () => { - await expect(task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('TASK_RELAYER_DEPOSITOR_ZERO') + await expect(task.setRelayer(ZERO_ADDRESS)).to.be.revertedWith('TaskRelayerZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setRelayer(relayer.address)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setRelayer(relayer.address)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -142,7 +142,7 @@ describe('RelayerDepositor', () => { }) it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(token, amount)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) @@ -151,14 +151,14 @@ describe('RelayerDepositor', () => { const amount = 0 it('reverts', async () => { - await expect(task.call(token, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(token, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(token, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(token, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/relayer/UnwrapperRelayerFunder.test.ts b/packages/tasks/test/relayer/UnwrapperRelayerFunder.test.ts index 45a6383b..19f387a7 100644 --- a/packages/tasks/test/relayer/UnwrapperRelayerFunder.test.ts +++ b/packages/tasks/test/relayer/UnwrapperRelayerFunder.test.ts @@ -18,6 +18,8 @@ import { Contract } from 'ethers' import { buildEmptyTaskConfig, deployEnvironment, Mimic } from '../../src/setup' import { itBehavesLikeBaseRelayerFundTask } from './BaseRelayerFundTask.behavior' +/* eslint-disable no-secrets/no-secrets */ + describe('UnwrapperRelayerFunder', () => { let task: Contract, relayer: Contract let smartVault: Contract, authorizer: Contract, priceOracle: Contract, mimic: Mimic, owner: SignerWithAddress @@ -52,7 +54,7 @@ describe('UnwrapperRelayerFunder', () => { task.initialize({ taskConfig: buildEmptyTaskConfig(owner, smartVault), }) - ).to.be.revertedWith('UNWRAPPER_INITIALIZER_DISABLED') + ).to.be.revertedWith('TaskInitializerDisabled') }) it('has a relayer reference', async () => { @@ -156,7 +158,7 @@ describe('UnwrapperRelayerFunder', () => { const bigAmount = amount.add(diff.add(1)) it('reverts', async () => { - await expect(task.call(tokenAddr, bigAmount)).to.be.revertedWith('TASK_AMOUNT_ABOVE_THRESHOLD') + await expect(task.call(tokenAddr, bigAmount)).to.be.revertedWith('TaskDepositAboveMaxThreshold') }) }) }) @@ -178,7 +180,7 @@ describe('UnwrapperRelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(tokenAddr, amount)).to.be.revertedWith('TASK_TOKEN_THRESHOLD_NOT_MET') + await expect(task.call(tokenAddr, amount)).to.be.revertedWith('TaskDepositAboveMinThreshold') }) }) }) @@ -194,7 +196,7 @@ describe('UnwrapperRelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(tokenAddr, amount)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(tokenAddr, amount)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -221,14 +223,14 @@ describe('UnwrapperRelayerFunder', () => { }) it('reverts', async () => { - await expect(task.call(token.address, 0)).to.be.revertedWith('TASK_TOKEN_NOT_WRAPPED') + await expect(task.call(token.address, 0)).to.be.revertedWith('TaskTokenNotWrapped') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/swap/BaseSwapTask.behavior.ts b/packages/tasks/test/swap/BaseSwapTask.behavior.ts index a32233f1..62428a85 100644 --- a/packages/tasks/test/swap/BaseSwapTask.behavior.ts +++ b/packages/tasks/test/swap/BaseSwapTask.behavior.ts @@ -40,7 +40,7 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setConnector(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -76,7 +76,7 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultTokenOut(ZERO_ADDRESS)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultTokenOut(ZERO_ADDRESS)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -114,7 +114,7 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { await expect(this.task.setCustomTokenOut(token.address, tokenOut.address)).to.be.revertedWith( - 'AUTH_SENDER_NOT_ALLOWED' + 'AuthSenderNotAllowed' ) }) }) @@ -150,14 +150,14 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { const slippage = fp(1).add(1) it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TASK_SLIPPAGE_ABOVE_ONE') + await expect(this.task.setDefaultMaxSlippage(slippage)).to.be.revertedWith('TaskSlippageAboveOne') }) }) }) context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setDefaultMaxSlippage(1)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -199,7 +199,7 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { it('reverts', async function () { await expect(this.task.setCustomMaxSlippage(token.address, slippage)).to.be.revertedWith( - 'TASK_SLIPPAGE_ABOVE_ONE' + 'TaskSlippageAboveOne' ) }) }) @@ -207,7 +207,7 @@ export function itBehavesLikeBaseSwapTask(executionType: string): void { context('when the sender is not authorized', () => { it('reverts', async function () { - await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(this.task.setCustomMaxSlippage(ZERO_ADDRESS, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/swap/HopL2Swapper.test.ts b/packages/tasks/test/swap/HopL2Swapper.test.ts index 3d7a5c70..a153823d 100644 --- a/packages/tasks/test/swap/HopL2Swapper.test.ts +++ b/packages/tasks/test/swap/HopL2Swapper.test.ts @@ -151,14 +151,14 @@ describe('HopL2Swapper', () => { const hToken = ZERO_ADDRESS it('reverts', async () => { - await expect(task.setTokenAmm(hToken, amm.address)).to.be.revertedWith('TASK_HOP_TOKEN_ZERO') + await expect(task.setTokenAmm(hToken, amm.address)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setTokenAmm(hToken.address, amm.address)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setTokenAmm(hToken.address, amm.address)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -299,7 +299,7 @@ describe('HopL2Swapper', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, slippage)).to.be.revertedWith( - 'TASK_SLIPPAGE_TOO_HIGH' + 'TaskSlippageAboveMax' ) }) }) @@ -313,23 +313,21 @@ describe('HopL2Swapper', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' - ) + await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TaskTokenThresholdNotMet') }) }) }) context('when the given token does not have an AMM set', () => { it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TASK_MISSING_HOP_TOKEN_AMM') + await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TaskMissingHopTokenAmm') }) }) }) context('when the token out is not set', () => { it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TASK_TOKEN_OUT_NOT_SET') + await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TaskTokenOutNotSet') }) }) }) @@ -342,7 +340,7 @@ describe('HopL2Swapper', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, 0, 0)).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenIn.address, 0, 0)).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) @@ -351,7 +349,7 @@ describe('HopL2Swapper', () => { const amountIn = 0 it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(tokenIn.address, amountIn, 0)).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -360,14 +358,14 @@ describe('HopL2Swapper', () => { const tokenIn = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(tokenIn, 0, 0)).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(tokenIn, 0, 0)).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/swap/OneInchV5Swapper.test.ts b/packages/tasks/test/swap/OneInchV5Swapper.test.ts index bf0090a2..c8464d1d 100644 --- a/packages/tasks/test/swap/OneInchV5Swapper.test.ts +++ b/packages/tasks/test/swap/OneInchV5Swapper.test.ts @@ -192,7 +192,7 @@ describe('OneInchV5Swapper', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, slippage, '0x')).to.be.revertedWith( - 'TASK_SLIPPAGE_TOO_HIGH' + 'TaskSlippageAboveMax' ) }) }) @@ -207,7 +207,7 @@ describe('OneInchV5Swapper', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskTokenThresholdNotMet' ) }) }) @@ -215,7 +215,7 @@ describe('OneInchV5Swapper', () => { context('when the token out is not set', () => { it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TASK_TOKEN_OUT_NOT_SET') + await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TaskTokenOutNotSet') }) }) }) @@ -228,7 +228,7 @@ describe('OneInchV5Swapper', () => { }) it('reverts', async () => { - await expect(task.call(tokenIn.address, 0, 0, '0x')).to.be.revertedWith('TASK_TOKEN_NOT_ALLOWED') + await expect(task.call(tokenIn.address, 0, 0, '0x')).to.be.revertedWith('TaskTokenNotAllowed') }) }) }) @@ -237,7 +237,7 @@ describe('OneInchV5Swapper', () => { const amountIn = 0 it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TASK_AMOUNT_ZERO') + await expect(task.call(tokenIn.address, amountIn, 0, '0x')).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -246,14 +246,14 @@ describe('OneInchV5Swapper', () => { const tokenIn = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(tokenIn, 0, 0, '0x')).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(tokenIn, 0, 0, '0x')).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 0, '0x')).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 0, '0x')).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) diff --git a/packages/tasks/test/swap/ParaswapV5Swapper.test.ts b/packages/tasks/test/swap/ParaswapV5Swapper.test.ts index 3afebd4c..ca85e0bb 100644 --- a/packages/tasks/test/swap/ParaswapV5Swapper.test.ts +++ b/packages/tasks/test/swap/ParaswapV5Swapper.test.ts @@ -94,7 +94,7 @@ describe('ParaswapV5Swapper', () => { context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.setQuoteSigner(quoteSigner.address)).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.setQuoteSigner(quoteSigner.address)).to.be.revertedWith('AuthSenderNotAllowed') }) }) }) @@ -322,7 +322,7 @@ describe('ParaswapV5Swapper', () => { data, signature ) - ).to.be.revertedWith('TASK_QUOTE_SIGNER_DEADLINE') + ).to.be.revertedWith('TaskQuoteSignerPastDeadline') }) }) }) @@ -333,7 +333,7 @@ describe('ParaswapV5Swapper', () => { await expect( task.call(tokenIn.address, amountIn, minAmountOut, expectedAmountOut, 0, data, signature) - ).to.be.revertedWith('TASK_QUOTE_SIGNER_DEADLINE') + ).to.be.revertedWith('TaskQuoteSignerPastDeadline') }) }) }) @@ -345,7 +345,7 @@ describe('ParaswapV5Swapper', () => { it('reverts', async () => { await expect( task.call(tokenIn.address, amountIn, minAmountOut, expectedAmountOut, 0, '0x', '0x') - ).to.be.revertedWith('TASK_SLIPPAGE_TOO_HIGH') + ).to.be.revertedWith('TaskSlippageAboveMax') }) }) }) @@ -359,7 +359,7 @@ describe('ParaswapV5Swapper', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, 1, 1, 0, '0x', '0x')).to.be.revertedWith( - 'TASK_TOKEN_THRESHOLD_NOT_MET' + 'TaskTokenThresholdNotMet' ) }) }) @@ -368,7 +368,7 @@ describe('ParaswapV5Swapper', () => { context('when the token out is not set', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, 1, 1, 0, '0x', '0x')).to.be.revertedWith( - 'TASK_TOKEN_OUT_NOT_SET' + 'TaskTokenOutNotSet' ) }) }) @@ -383,7 +383,7 @@ describe('ParaswapV5Swapper', () => { it('reverts', async () => { await expect(task.call(tokenIn.address, amountIn, 1, 1, 0, '0x', '0x')).to.be.revertedWith( - 'TASK_TOKEN_NOT_ALLOWED' + 'TaskTokenNotAllowed' ) }) }) @@ -393,9 +393,7 @@ describe('ParaswapV5Swapper', () => { const amountIn = 0 it('reverts', async () => { - await expect(task.call(tokenIn.address, amountIn, 1, 1, 0, '0x', '0x')).to.be.revertedWith( - 'TASK_AMOUNT_ZERO' - ) + await expect(task.call(tokenIn.address, amountIn, 1, 1, 0, '0x', '0x')).to.be.revertedWith('TaskAmountZero') }) }) }) @@ -404,14 +402,14 @@ describe('ParaswapV5Swapper', () => { const tokenIn = ZERO_ADDRESS it('reverts', async () => { - await expect(task.call(tokenIn, 0, 1, 1, 0, '0x', '0x')).to.be.revertedWith('TASK_TOKEN_ZERO') + await expect(task.call(tokenIn, 0, 1, 1, 0, '0x', '0x')).to.be.revertedWith('TaskTokenZero') }) }) }) context('when the sender is not authorized', () => { it('reverts', async () => { - await expect(task.call(ZERO_ADDRESS, 0, 1, 1, 0, '0x', '0x')).to.be.revertedWith('AUTH_SENDER_NOT_ALLOWED') + await expect(task.call(ZERO_ADDRESS, 0, 1, 1, 0, '0x', '0x')).to.be.revertedWith('AuthSenderNotAllowed') }) }) })