Add integration tests for settle and claim (Synthetixio#1310)

* Support settlements in exchanging behavior

* Testing claims in integration tests

* Address PR feedback, increase timeouts, improve test for forking

* Bigger tolerance for debt comparison

* Approve bridge tokens during bootstrap

Author: eternauta1337

hardhat.config.js

@@ -50,12 +50,14 @@ module.exports = {
 			allowUnlimitedContractSize: true,
 			gasPrice: GAS_PRICE,
 			initialDate: new Date(inflationStartTimestampInSecs * 1000).toISOString(),
+			timeout: 600000,
 			// Note: forking settings are injected at runtime by hardhat/tasks/task-node.js
 		},
 		localhost: {
 			gas: 12e6,
 			blockGasLimit: 12e6,
 			url: 'http://localhost:8545',
+			timeout: 600000,
 		},
 	},
 	gasReporter: {

package-lock.json

@@ -2,18 +2,18 @@ const ethers = require('ethers');
 const { assert } = require('../../contracts/common');
 const { toBytes32 } = require('../../../index');
 const { ensureBalance } = require('../utils/balances');
-const { ignoreMinimumStakeTime } = require('../utils/stakeTime');
+const { ignoreWaitingPeriod } = require('../utils/exchanging');
 
 function itCanExchange({ ctx }) {
-	describe('exchanging', () => {
+	describe('exchanging and settling', () => {
 		const sUSDAmount = ethers.utils.parseEther('100');
 
 		let owner;
-		let balancesETH, balancesUSD;
-		let Synthetix, Exchanger, SynthsETH, SynthsUSD;
+		let balancesETH, originialPendingSettlements;
+		let Synthetix, Exchanger, SynthsETH;
 
 		before('target contracts and users', () => {
-			({ Synthetix, Exchanger, SynthsETH, SynthsUSD } = ctx.contracts);
+			({ Synthetix, Exchanger, SynthsETH } = ctx.contracts);
 
 			owner = ctx.users.owner;
 		});
@@ -27,6 +27,12 @@ function itCanExchange({ ctx }) {
 				balancesETH = await SynthsETH.balanceOf(owner.address);
 			});
 
+			before('record pending settlements', async () => {
+				const { numEntries } = await Exchanger.settlementOwing(owner.address, toBytes32('sETH'));
+
+				originialPendingSettlements = numEntries;
+			});
+
 			before('perform the exchange', async () => {
 				Synthetix = Synthetix.connect(owner);
 
@@ -44,30 +50,24 @@ function itCanExchange({ ctx }) {
 				assert.bnEqual(await SynthsETH.balanceOf(owner.address), balancesETH.add(expectedAmount));
 			});
 
-			// TODO: Disabled until we understand time granularity in the ops tool L2 chain
-			describe.skip('when the owner exchanges sETH to sUSD', () => {
-				ignoreMinimumStakeTime({ ctx });
+			it('shows that the user now has pending settlements', async () => {
+				const { numEntries } = await Exchanger.settlementOwing(owner.address, toBytes32('sETH'));
 
-				before('record balances', async () => {
-					balancesUSD = await SynthsUSD.balanceOf(owner.address);
-					balancesETH = await SynthsETH.balanceOf(owner.address);
-				});
+				assert.bnEqual(numEntries, originialPendingSettlements.add(ethers.constants.One));
+			});
 
-				before('perform the exchange', async () => {
-					Synthetix = Synthetix.connect(owner);
+			describe('when settle is called', () => {
+				ignoreWaitingPeriod({ ctx });
 
-					const tx = await Synthetix.exchange(toBytes32('sETH'), balancesETH, toBytes32('sUSD'));
+				before('settle', async () => {
+					const tx = await Synthetix.settle(toBytes32('sETH'));
 					await tx.wait();
 				});
 
-				it('receives the expected amount of sUSD', async () => {
-					const [expectedAmount, ,] = await Exchanger.getAmountsForExchange(
-						balancesETH,
-						toBytes32('sETH'),
-						toBytes32('sUSD')
-					);
+				it('shows that the user no longer has pending settlements', async () => {
+					const { numEntries } = await Exchanger.settlementOwing(owner.address, toBytes32('sETH'));
 
-					assert.bnEqual(await SynthsUSD.balanceOf(owner.address), balancesUSD.add(expectedAmount));
+					assert.bnEqual(numEntries, ethers.constants.Zero);
 				});
 			});
 		});

test/integration/behaviors/exchange.behavior.js

@@ -1,19 +1,22 @@
 const ethers = require('ethers');
+const { toBytes32 } = require('../../../index');
 const { assert } = require('../../contracts/common');
+const { exchangeSomething, ignoreFeePeriodDuration } = require('../utils/exchanging');
 const { ensureBalance } = require('../utils/balances');
-const { ignoreMinimumStakeTime } = require('../utils/stakeTime');
+const { ignoreMinimumStakeTime } = require('../utils/staking');
+const { skipIfL2 } = require('../utils/l2');
 
-function itCanMintAndBurn({ ctx }) {
-	describe('staking', () => {
+function itCanStake({ ctx }) {
+	describe('staking and claiming', () => {
 		const SNXAmount = ethers.utils.parseEther('100');
-		const sUSDamount = ethers.utils.parseEther('1');
+		const amountToIssueAndBurnsUSD = ethers.utils.parseEther('1');
 
 		let user;
-		let Synthetix, SynthsUSD;
-		let balancesUSD;
+		let Synthetix, SynthsUSD, FeePool;
+		let balancesUSD, debtsUSD;
 
 		before('target contracts and users', () => {
-			({ Synthetix, SynthsUSD } = ctx.contracts);
+			({ Synthetix, SynthsUSD, FeePool } = ctx.contracts);
 
 			user = ctx.users.someUser;
 		});
@@ -30,41 +33,90 @@ function itCanMintAndBurn({ ctx }) {
 			before('issue sUSD', async () => {
 				Synthetix = Synthetix.connect(user);
 
-				const tx = await Synthetix.issueSynths(sUSDamount);
+				const tx = await Synthetix.issueSynths(amountToIssueAndBurnsUSD);
 				await tx.wait();
 			});
 
 			it('issues the expected amount of sUSD', async () => {
-				assert.bnEqual(await SynthsUSD.balanceOf(user.address), balancesUSD.add(sUSDamount));
+				assert.bnEqual(
+					await SynthsUSD.balanceOf(user.address),
+					balancesUSD.add(amountToIssueAndBurnsUSD)
+				);
+			});
+
+			describe('claiming', () => {
+				// TODO: Disabled until Optimism supports 5s time granularity.
+				// We can set fee period duration to 5s, but we dont want this test
+				// to wait 3m, which is the current time granularity.
+				skipIfL2({
+					ctx,
+					reason:
+						'ops L2 time granularity needs to be less than 3m, so we cant close the fee period',
+				});
+
+				before('exchange something', async () => {
+					await exchangeSomething({ ctx });
+				});
+
+				describe('when the fee period closes', () => {
+					ignoreFeePeriodDuration({ ctx });
+
+					before('close the current fee period', async () => {
+						FeePool = FeePool.connect(ctx.users.owner);
+
+						const tx = await FeePool.closeCurrentFeePeriod();
+						await tx.wait();
+					});
+
+					describe('when the user claims rewards', () => {
+						before('record balances', async () => {
+							balancesUSD = await SynthsUSD.balanceOf(user.address);
+						});
+
+						before('claim', async () => {
+							FeePool = FeePool.connect(user);
+
+							const tx = await FeePool.claimFees();
+							await tx.wait();
+						});
+
+						it('shows a slight increase in the users sUSD balance', async () => {
+							assert.bnGt(await SynthsUSD.balanceOf(user.address), balancesUSD);
+						});
+					});
+				});
 			});
 		});
 
 		describe('when the user burns sUSD', () => {
 			ignoreMinimumStakeTime({ ctx });
 
-			before('record values', async () => {
-				balancesUSD = await SynthsUSD.balanceOf(user.address);
+			before('record debt', async () => {
+				debtsUSD = await Synthetix.debtBalanceOf(user.address, toBytes32('sUSD'));
 			});
 
 			before('burn sUSD', async () => {
 				Synthetix = Synthetix.connect(user);
 
-				const tx = await Synthetix.burnSynths(sUSDamount);
+				const tx = await Synthetix.burnSynths(amountToIssueAndBurnsUSD);
 				await tx.wait();
 			});
 
-			it('burnt the expected amount of sUSD', async () => {
-				const newBalancesUSD = await SynthsUSD.balanceOf(user.address);
-				const expected = balancesUSD.sub(sUSDamount);
-				const delta = newBalancesUSD.sub(expected);
-				const variance = ethers.utils.parseUnits('2', 'gwei');
+			it('reduced the expected amount of debt', async () => {
+				const newDebtsUSD = await Synthetix.debtBalanceOf(user.address, toBytes32('sUSD'));
+				const debtReduction = debtsUSD.sub(newDebtsUSD);
 
-				assert.bnLt(delta, variance);
+				const tolerance = ethers.utils.parseUnits('40', 'gwei');
+				assert.bnClose(
+					debtReduction.toString(),
+					amountToIssueAndBurnsUSD.toString(),
+					tolerance.toString()
+				);
 			});
 		});
 	});
 }
 
 module.exports = {
-	itCanMintAndBurn,
+	itCanStake,
 };

test/integration/behaviors/stake.behavior.js

@@ -1,13 +1,13 @@
 const { bootstrapL1 } = require('../utils/bootstrap');
 const { itCanExchange } = require('../behaviors/exchange.behavior');
-const { itCanMintAndBurn } = require('../behaviors/stake.behavior');
+const { itCanStake } = require('../behaviors/stake.behavior');
 const { itBehavesLikeAnERC20 } = require('../behaviors/erc20.behavior');
 
 describe('Synthetix integration tests (L1)', () => {
 	const ctx = this;
 	bootstrapL1({ ctx });
 
 	itCanExchange({ ctx });
-	itCanMintAndBurn({ ctx });
+	itCanStake({ ctx });
 	itBehavesLikeAnERC20({ ctx });
 });

test/integration/l1/Synthetix.l1.integration.js

@@ -1,13 +1,13 @@
 const { bootstrapL2 } = require('../utils/bootstrap');
 const { itCanExchange } = require('../behaviors/exchange.behavior');
-const { itCanMintAndBurn } = require('../behaviors/stake.behavior');
+const { itCanStake } = require('../behaviors/stake.behavior');
 const { itBehavesLikeAnERC20 } = require('../behaviors/erc20.behavior');
 
 describe('Synthetix integration tests (L2)', () => {
 	const ctx = this;
 	bootstrapL2({ ctx });
 
 	itCanExchange({ ctx });
-	itCanMintAndBurn({ ctx });
+	itCanStake({ ctx });
 	itBehavesLikeAnERC20({ ctx });
 });

test/integration/l2/Synthetix.l2.integration.js

@@ -6,6 +6,7 @@ const { Watcher } = require('@eth-optimism/watcher');
 const { connectContracts } = require('./contracts');
 const { updateExchangeRatesIfNeeded } = require('./rates');
 const { ensureBalance } = require('./balances');
+const { approveBridge } = require('./bridge');
 
 function bootstrapL1({ ctx }) {
 	before('bootstrap layer 1 instance', async () => {
@@ -82,6 +83,8 @@ function bootstrapDual({ ctx }) {
 		await updateExchangeRatesIfNeeded({ ctx: ctx.l1 });
 		await updateExchangeRatesIfNeeded({ ctx: ctx.l2 });
 
+		await approveBridge({ ctx: ctx.l1, amount: ethers.utils.parseEther('100000000') });
+
 		await ensureBalance({
 			ctx: ctx.l2,
 			symbol: 'SNX',

test/integration/utils/bootstrap.js

@@ -1,3 +1,4 @@
+const ethers = require('ethers');
 const { finalizationOnL2 } = require('./watchers');
 
 async function deposit({ ctx, from, to, amount }) {
@@ -23,7 +24,30 @@ async function withdraw() {
 	// TODO
 }
 
+async function approveBridge({ ctx, amount }) {
+	const { Synthetix, SynthetixBridgeToOptimism } = ctx.contracts;
+	let { SynthetixBridgeEscrow } = ctx.contracts;
+	SynthetixBridgeEscrow = SynthetixBridgeEscrow.connect(ctx.users.owner);
+
+	let tx;
+
+	tx = await SynthetixBridgeEscrow.approveBridge(
+		Synthetix.address,
+		SynthetixBridgeToOptimism.address,
+		ethers.constants.Zero
+	);
+	await tx.wait();
+
+	tx = await SynthetixBridgeEscrow.approveBridge(
+		Synthetix.address,
+		SynthetixBridgeToOptimism.address,
+		amount
+	);
+	await tx.wait();
+}
+
 module.exports = {
 	deposit,
 	withdraw,
+	approveBridge,
 };

test/integration/utils/bridge.js

@@ -0,0 +1,65 @@
+const ethers = require('ethers');
+const { ensureBalance } = require('./balances');
+const { forceSetSystemSetting } = require('./settings');
+const { toBytes32 } = require('../../../index');
+const { wait } = require('./wait');
+
+function ignoreWaitingPeriod({ ctx }) {
+	before('record and reduce waitingPeriodSecs', async () => {
+		let { SystemSettings } = ctx.contracts;
+		SystemSettings = SystemSettings.connect(ctx.users.owner);
+
+		ctx.waitingPeriodSecs = await SystemSettings.waitingPeriodSecs();
+
+		const tx = await SystemSettings.setWaitingPeriodSecs(0);
+		await tx.wait();
+	});
+
+	after('restore waiting period', async () => {
+		let { SystemSettings } = ctx.contracts;
+		SystemSettings = SystemSettings.connect(ctx.users.owner);
+
+		const tx = await SystemSettings.setWaitingPeriodSecs(ctx.waitingPeriodSecs);
+		await tx.wait();
+	});
+}
+
+async function exchangeSomething({ ctx }) {
+	let { Synthetix } = ctx.contracts;
+	Synthetix = Synthetix.connect(ctx.users.owner);
+
+	const sUSDAmount = ethers.utils.parseEther('10');
+	await ensureBalance({ ctx, symbol: 'sUSD', user: ctx.users.owner, balance: sUSDAmount });
+
+	const tx = await Synthetix.exchange(toBytes32('sUSD'), sUSDAmount, toBytes32('sETH'));
+	await tx.wait();
+}
+
+function ignoreFeePeriodDuration({ ctx }) {
+	before('record and reduce feePeriodDuration', async () => {
+		const { SystemSettings } = ctx.contracts;
+
+		ctx.feePeriodDuration = await SystemSettings.feePeriodDuration();
+
+		// SystemSettings.setFeePeriodDuration() enforces a minimum value of 1 day,
+		// which is not ideal for tests.
+		// Instead, we force it by writing to flexible storage directly.
+		await forceSetSystemSetting({ ctx, settingName: 'feePeriodDuration', newValue: 5 });
+
+		await wait({ seconds: 5 });
+	});
+
+	after('restore feePeriodDuration', async () => {
+		let { SystemSettings } = ctx.contracts;
+		SystemSettings = SystemSettings.connect(ctx.users.owner);
+
+		const tx = await SystemSettings.setFeePeriodDuration(ctx.feePeriodDuration);
+		await tx.wait();
+	});
+}
+
+module.exports = {
+	ignoreWaitingPeriod,
+	exchangeSomething,
+	ignoreFeePeriodDuration,
+};