🦟 Add whitelist to liquidations

contracts/Interfaces/IVesselManagerOperations.sol

@@ -50,6 +50,7 @@ interface IVesselManagerOperations is ITrinityBase {
 	error VesselManagerOperations__VesselNotActive();
 	error VesselManagerOperations__InvalidParam();
 	error VesselManagerOperations__NotTimelock();
+	error VesselManagerOperations__LiquidatorNotWhitelisted();
 
 	// Structs ----------------------------------------------------------------------------------------------------------
 

contracts/VesselManagerOperations.sol

@@ -59,6 +59,10 @@ contract VesselManagerOperations is IVesselManagerOperations, UUPSUpgradeable, R
 	 * starting from the one with the lowest collateral ratio in the system, and moving upwards.
 	 */
 	function liquidateVessels(address _asset, uint256 _n) external override nonReentrant {
+		if (!IAdminContract(adminContract).getRedeemerIsWhitelisted(msg.sender)) {
+			revert VesselManagerOperations__LiquidatorNotWhitelisted();
+		}
+
 		LocalVariables_OuterLiquidationFunction memory vars;
 		LiquidationTotals memory totals;
 		vars.price = IPriceFeed(priceFeed).fetchPrice(_asset);
@@ -110,6 +114,9 @@ contract VesselManagerOperations is IVesselManagerOperations, UUPSUpgradeable, R
 	 * Attempt to liquidate a custom list of vessels provided by the caller.
 	 */
 	function batchLiquidateVessels(address _asset, address[] memory _vesselArray) public override nonReentrant {
+		if (!IAdminContract(adminContract).getRedeemerIsWhitelisted(msg.sender)) {
+			revert VesselManagerOperations__LiquidatorNotWhitelisted();
+		}
 		if (_vesselArray.length == 0 || _vesselArray.length > BATCH_SIZE_LIMIT) {
 			revert VesselManagerOperations__InvalidArraySize();
 		}
@@ -870,7 +877,10 @@ contract VesselManagerOperations is IVesselManagerOperations, UUPSUpgradeable, R
 		uint256 _price
 	) internal view {
 		address redeemer = msg.sender;
-		require(IAdminContract(adminContract).getRedeemerIsWhitelisted(redeemer), "VesselManagerOperations: Redeemer not whitelisted");
+		require(
+			IAdminContract(adminContract).getRedeemerIsWhitelisted(redeemer),
+			"VesselManagerOperations: Redeemer not whitelisted"
+		);
 
 		uint256 redemptionBlockTimestamp = IAdminContract(adminContract).getRedemptionBlockTimestamp(_asset);
 		if (redemptionBlockTimestamp > block.timestamp) {

test/trinity/BorrowerOperationsTest.js

@@ -40,6 +40,10 @@ const deploy = async (treasury, mintingAccounts) => {
 	vesselManagerOperations = contracts.core.vesselManagerOperations
 	shortTimelock = contracts.core.shortTimelock
 	longTimelock = contracts.core.longTimelock
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("BorrowerOperations", async accounts => {
@@ -60,7 +64,7 @@ contract("BorrowerOperations", async accounts => {
 
 	describe("BorrowerOperations Mechanisms", async () => {
 		before(async () => {
-			await deploy(treasury, [])
+			await deploy(treasury, accounts.slice(0, 20))
 
 			TRI_GAS_COMPENSATION_ERC20 = await adminContract.getDebtTokenGasCompensation(erc20.address)
 			MIN_NET_DEBT_ERC20 = await adminContract.getMinNetDebt(erc20.address)

test/trinity/GasCompensationTest.js

@@ -32,6 +32,10 @@ const deploy = async (treasury, mintingAccounts) => {
 	longTimelock = contracts.core.longTimelock
 
 	validCollateral = await adminContract.getValidCollateral()
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("Gas compensation tests", async accounts => {

test/trinity/StabilityPoolTest.js

@@ -36,6 +36,10 @@ const deploy = async (treasury, mintingAccounts) => {
 
 	// getDepositorGains() expects a sorted collateral array
 	validCollateral = validCollateral.slice(0).sort((a, b) => toBN(a.toLowerCase()).sub(toBN(b.toLowerCase())))
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("StabilityPool", async accounts => {

test/trinity/VesselManagerTest.js

@@ -45,6 +45,10 @@ const deploy = async (treasury, mintingAccounts) => {
 
 	// getDepositorGains() expects a sorted collateral array
 	validCollateral = validCollateral.slice(0).sort((a, b) => toBN(a.toLowerCase()).sub(toBN(b.toLowerCase())))
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 /* NOTE: Some tests involving ETH redemption fees do not test for specific fee values.
@@ -126,6 +130,24 @@ contract("VesselManager", async accounts => {
 		})
 
 		describe("Liquidations", async () => {
+			it("liquidate(): reverts when not whitelisted", async () => {
+				await openVessel({
+					asset: erc20.address,
+					ICR: toBN(dec(4, 18)),
+					extraParams: { from: alice },
+				})
+
+				await adminContract.setWhitelistedRedeemer(alice, false)
+
+				try {
+					const tx = await vesselManagerOperations.liquidate(erc20.address, alice, {from: alice})
+					assert.isFalse(tx.receipt.status)
+				} catch (err) {
+					assert.include(err.message, "revert")
+					assert.include(err.message, "VesselManagerOperations__LiquidatorNotWhitelisted()")
+				}
+			})
+
 			it("liquidate(): closes a Vessel that has ICR < MCR", async () => {
 				await openVessel({
 					asset: erc20.address,
@@ -1412,6 +1434,19 @@ contract("VesselManager", async accounts => {
 
 			// --- liquidateVessels() ---
 
+			it("liquidateVessels(): reverts when not whitelisted", async () => {
+				await adminContract.setWhitelistedRedeemer(alice, false)
+
+				try {
+					const tx = await vesselManagerOperations.liquidateVessels(erc20.address, 2, {from: alice})
+					assert.isFalse(tx.receipt.status)
+				} catch (err) {
+					console.log(err.message)
+					assert.include(err.message, "revert")
+					assert.include(err.message, "VesselManagerOperations__LiquidatorNotWhitelisted()")
+				}
+			})
+
 			it("liquidateVessels(): liquidates a Vessel that a) was skipped in a previous liquidation and b) has pending rewards", async () => {
 				// A, B, C, D, E open vessels
 
@@ -2442,6 +2477,19 @@ contract("VesselManager", async accounts => {
 		// --- batchLiquidateVessels() ---
 
 		describe("Batch Liquidations", async () => {
+			it("batchLiquidateVessels(): reverts when not whitelisted", async () => {
+				await adminContract.setWhitelistedRedeemer(alice, false)
+
+				try {
+					const tx = await vesselManagerOperations.batchLiquidateVessels(erc20.address, [], {from: alice})
+					assert.isFalse(tx.receipt.status)
+				} catch (err) {
+					console.log(err.message)
+					assert.include(err.message, "revert")
+					assert.include(err.message, "VesselManagerOperations__LiquidatorNotWhitelisted()")
+				}
+			})
+
 			it("batchLiquidateVessels(): liquidates a Vessel that a) was skipped in a previous liquidation and b) has pending rewards", async () => {
 				// A, B, C, D, E open vessels
 
@@ -3223,7 +3271,6 @@ contract("VesselManager", async accounts => {
 					// skip redemption
 					await time.increase(redemptionWait)
 
-					await adminContract.setWhitelistedRedeemer(dennis, true)
 					// this time tx should succeed
 					await vesselManagerOperations.redeemCollateral(
 						erc20.address,
@@ -3292,7 +3339,6 @@ contract("VesselManager", async accounts => {
 				// Dennis redeems 20 debt tokens
 				// Don't pay for gas, as it makes it easier to calculate the received collateral
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				const redemptionTx = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					redemptionAmount,
@@ -3393,7 +3439,6 @@ contract("VesselManager", async accounts => {
 				// skip redemption bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				// Dennis redeems 20 debt tokens
 				const redemptionTx = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
@@ -3494,7 +3539,6 @@ contract("VesselManager", async accounts => {
 				// skip redemption bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				// Dennis redeems 20 debt tokens
 				const redemptionTx = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
@@ -3607,7 +3651,6 @@ contract("VesselManager", async accounts => {
 				// Dennis redeems 20 debt tokens
 				// Don't pay for gas, as it makes it easier to calculate the received Ether
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				const redemptionTx = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					redemptionAmount,
@@ -3705,7 +3748,6 @@ contract("VesselManager", async accounts => {
 				// skip redemption bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(flyn, true)
 				// Flyn redeems collateral
 				await vesselManagerOperations.redeemCollateral(
 					erc20.address,
@@ -3802,7 +3844,6 @@ contract("VesselManager", async accounts => {
 
 				// Flyn redeems collateral with only two iterations
 
-				await adminContract.setWhitelistedRedeemer(flyn, true)
 				await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					attemptedRedemptionAmount_Asset,
@@ -3996,7 +4037,6 @@ contract("VesselManager", async accounts => {
 					// skip redemption bootstrapping phase
 					await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-					await adminContract.setWhitelistedRedeemer(alice, true)
 					// Alice redeems 1 debt token from Carol's Vessel
 					await vesselManagerOperations.redeemCollateral(
 						erc20.address,
@@ -4011,7 +4051,6 @@ contract("VesselManager", async accounts => {
 					)
 				}
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				// Dennis tries to redeem 20 debt tokens
 				const redemptionTx = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
@@ -4140,7 +4179,6 @@ contract("VesselManager", async accounts => {
 				// skip bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(carol, true)
 				await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					A_debt_Asset,
@@ -4219,7 +4257,6 @@ contract("VesselManager", async accounts => {
 				// skip bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(dennis, true)
 				const tx_Asset = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					redemptionAmount_Asset,
@@ -4807,7 +4844,6 @@ contract("VesselManager", async accounts => {
 					erin
 				)
 
-				await adminContract.setWhitelistedRedeemer(erin, true)
 				await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					dec(400, 18),
@@ -4906,7 +4942,6 @@ contract("VesselManager", async accounts => {
 					const { 0: upperPartialRedemptionHint_1_Asset, 1: lowerPartialRedemptionHint_1_Asset } =
 						await sortedVessels.findInsertPosition(erc20.address, partialRedemptionHintNICR_Asset, erin, erin)
 
-					await adminContract.setWhitelistedRedeemer(erin, true)
 					const redemptionTx_Asset = await vesselManagerOperations.redeemCollateral(
 						erc20.address,
 						dec(1000, 18),
@@ -5059,7 +5094,6 @@ contract("VesselManager", async accounts => {
 				// skip redemption bootstrapping phase
 				await th.fastForwardTime(timeValues.SECONDS_IN_ONE_WEEK * 2, web3.currentProvider)
 
-				await adminContract.setWhitelistedRedeemer(erin, true)
 				// Erin redeems 120 debt tokens
 				await ({ 0: firstRedemptionHint, 1: partialRedemptionHintNewICR } =
 					await vesselManagerOperations.getRedemptionHints(erc20.address, _120_, price, 0))
@@ -5094,7 +5128,6 @@ contract("VesselManager", async accounts => {
 				const { 0: upperPartialRedemptionHint_2, 1: lowerPartialRedemptionHint_2 } =
 					await sortedVessels.findInsertPosition(erc20.address, partialRedemptionHintNewICR, flyn, flyn)
 
-				await adminContract.setWhitelistedRedeemer(flyn, true)
 				const redemption_2 = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					_373_,
@@ -5126,7 +5159,6 @@ contract("VesselManager", async accounts => {
 				const { 0: upperPartialRedemptionHint_3, 1: lowerPartialRedemptionHint_3 } =
 					await sortedVessels.findInsertPosition(erc20.address, partialRedemptionHintNewICR, graham, graham)
 
-				await adminContract.setWhitelistedRedeemer(graham, true)
 				const redemption_3 = await vesselManagerOperations.redeemCollateral(
 					erc20.address,
 					_950_,
@@ -6402,7 +6434,6 @@ contract("VesselManager", async accounts => {
 					const { 0: firstRedemptionHint_Asset, 1: partialRedemptionHintNICR_Asset } =
 						await vesselManagerOperations.getRedemptionHints(erc20.address, TRIAmount_Asset, price, 0)
 
-					await adminContract.setWhitelistedRedeemer(alice, true)
 					// Don't pay for gas, as it makes it easier to calculate the received Ether
 					const redemptionTx_Asset = await vesselManagerOperations.redeemCollateral(
 						erc20.address,

test/trinity/VesselManager_LiquidationRewardsTest.js

@@ -28,6 +28,10 @@ const deploy = async (treasury, mintingAccounts) => {
 	vesselManagerOperations = contracts.core.vesselManagerOperations
 	shortTimelock = contracts.core.shortTimelock
 	longTimelock = contracts.core.longTimelock
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("VesselManager - Redistribution reward calculations", async accounts => {

test/trinity/VesselManager_RecoveryModeTest.js

@@ -42,6 +42,10 @@ const deploy = async (treasury, mintingAccounts) => {
 
 	// getDepositorGains() expects a sorted collateral array
 	validCollateral = validCollateral.slice(0).sort((a, b) => toBN(a.toLowerCase()).sub(toBN(b.toLowerCase())))
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("VesselManager - in Recovery Mode", async accounts => {

test/trinity/VesselManager_RecoveryMode_BatchLiquidationTest.js

@@ -39,6 +39,10 @@ const deploy = async (treasury, mintingAccounts) => {
 
 	// getDepositorGains() expects a sorted collateral array
 	validCollateral = validCollateral.slice(0).sort((a, b) => toBN(a.toLowerCase()).sub(toBN(b.toLowerCase())))
+
+	for(const account of mintingAccounts) {
+		await adminContract.setWhitelistedRedeemer(account, true)
+	}
 }
 
 contract("VesselManager - in Recovery Mode - back to normal mode in 1 tx", async accounts => {