Port some of the old optimism tests to the new integration tests format (Synthetixio#1281)

* Basic integration tests for L2 deposits

* Basic integration tests for L2 deposits

* Polish deposit integration tests

* Progress porting withdrawal integration tests

* Working withdrawals in new integration tests

* Using watcher tool more

* Unify action and actionTo in integration tests

* Progress porting integration tests

* Remove comment

* Implemented exchanges in new integration tests

* Rename gas util

Author: eternauta1337

hardhat/tasks/task-test-integration-dual.js

@@ -7,7 +7,6 @@ const {
 
 task('test:integration:dual', 'run integrated layer 1 and layer 2 production tests')
 	.addFlag('deploy', 'Deploy l1 and l2 instances before running the tests')
-	.addFlag('connect', 'Connect already deployed l1 and l2 instances before running the tests')
 	.setAction(async (taskArguments, hre) => {
 		hre.config.paths.tests = './test/integration/dual/';
 
@@ -28,9 +27,7 @@ task('test:integration:dual', 'run integrated layer 1 and layer 2 production tes
 
 			await compileInstance({ useOvm: true });
 			await deployInstance({ useOvm: true, providerUrl, providerPort: providerPortL2 });
-		}
 
-		if (taskArguments.connect) {
 			await connectInstances({ providerUrl, providerPortL1, providerPortL2 });
 		}
 

hardhat/tasks/task-test-integration-l1.js

@@ -4,11 +4,16 @@ const { compileInstance, deployInstance } = require('../../test/integration/util
 task('test:integration:l1', 'run isolated layer 1 production tests')
 	.addFlag('compile', 'Compile an l1 instance before running the tests')
 	.addFlag('deploy', 'Deploy an l1 instance before running the tests')
+	.addOptionalParam(
+		'providerPort',
+		'The target port for the running local chain to test on',
+		'9545'
+	)
 	.setAction(async (taskArguments, hre) => {
 		hre.config.paths.tests = './test/integration/l1/';
 
 		const providerUrl = (hre.config.providerUrl = 'http://localhost');
-		const providerPort = (hre.config.providerPort = '9545');
+		const providerPort = (hre.config.providerPort = taskArguments.providerPort);
 
 		const timeout = 5 * 60 * 1000;
 		hre.config.mocha.timeout = timeout;

hardhat/tasks/task-test-integration-l2.js

@@ -4,11 +4,16 @@ const { compileInstance, deployInstance } = require('../../test/integration/util
 task('test:integration:l2', 'run isolated layer 2 production tests')
 	.addFlag('compile', 'Compile an l2 instance before running the tests')
 	.addFlag('deploy', 'Deploy an l2 instance before running the tests')
+	.addOptionalParam(
+		'providerPort',
+		'The target port for the running local chain to test on',
+		'9545'
+	)
 	.setAction(async (taskArguments, hre) => {
 		hre.config.paths.tests = './test/integration/l2/';
 
 		const providerUrl = (hre.config.providerUrl = 'http://localhost');
-		const providerPort = (hre.config.providerPort = '8545');
+		const providerPort = (hre.config.providerPort = taskArguments.providerPort);
 
 		const timeout = 5 * 60 * 1000;
 		hre.config.mocha.timeout = timeout;
@@ -22,7 +27,12 @@ task('test:integration:l2', 'run isolated layer 2 production tests')
 		}
 
 		if (taskArguments.deploy) {
-			await deployInstance({ useOvm: true, providerUrl, providerPort });
+			await deployInstance({
+				useOvm: true,
+				ignoreCustomParameters: true,
+				providerUrl,
+				providerPort,
+			});
 		}
 
 		await hre.run('test', taskArguments);

test/integration/behaviors/Synthetix.behavior.js

@@ -0,0 +1,51 @@
+const ethers = require('ethers');
+const { assert } = require('../../contracts/common');
+const { toBytes32 } = require('../../../index');
+const { ensureBalance } = require('../utils/balances');
+
+function itCanPerformExchanges({ ctx }) {
+	const sUSDAmount = ethers.utils.parseEther('100');
+
+	let owner;
+
+	let Synthetix, Exchanger, SynthsETH;
+
+	before('target contracts and users', () => {
+		({ Synthetix, Exchanger, SynthsETH } = ctx.contracts);
+
+		owner = ctx.owner;
+	});
+
+	before('ensure the owner has sUSD', async () => {
+		await ensureBalance({ ctx, symbol: 'sUSD', user: owner, balance: sUSDAmount });
+	});
+
+	describe('when the owner exchanges from sUSD to sETH', () => {
+		let balancesETH;
+
+		before('record balances', async () => {
+			balancesETH = await SynthsETH.balanceOf(owner.address);
+		});
+
+		before('perform the exchange', async () => {
+			Synthetix = Synthetix.connect(owner);
+
+			const tx = await Synthetix.exchange(toBytes32('sUSD'), sUSDAmount, toBytes32('sETH'));
+			await tx.wait();
+		});
+
+		it('receives the expected amount of sETH', async () => {
+			const [expectedAmount, ,] = await Exchanger.getAmountsForExchange(
+				sUSDAmount,
+				toBytes32('sUSD'),
+				toBytes32('sETH')
+			);
+
+			assert.bnEqual(await SynthsETH.balanceOf(owner.address), balancesETH.add(expectedAmount));
+		});
+	});
+}
+
+module.exports = {
+	itCanPerformExchanges,
+};

test/integration/behaviors/exchange.behavior.js

@@ -0,0 +1,80 @@
+const ethers = require('ethers');
+const { assert } = require('../../contracts/common');
+const { bootstrapDual } = require('../utils/bootstrap');
+const { finalizationOnL2 } = require('../utils/watchers');
+const { approveIfNeeded } = require('../utils/approve');
+
+describe('deposit() integration tests (L1, L2)', () => {
+	const ctx = this;
+	bootstrapDual({ ctx });
+
+	const amountToDeposit = ethers.utils.parseEther('10');
+
+	let owner;
+	let Synthetix, SynthetixBridgeToOptimism, SynthetixBridgeEscrow;
+
+	let ownerBalance, escrowBalance;
+
+	let depositReceipt;
+
+	describe('when the owner deposits SNX', () => {
+		before('target contracts and users', () => {
+			({ Synthetix, SynthetixBridgeToOptimism, SynthetixBridgeEscrow } = ctx.l1.contracts);
+
+			owner = ctx.l1.owner;
+		});
+
+		before('record balances', async () => {
+			ownerBalance = await Synthetix.balanceOf(owner.address);
+			escrowBalance = await Synthetix.balanceOf(SynthetixBridgeEscrow.address);
+		});
+
+		before('approve if needed', async () => {
+			await approveIfNeeded({
+				token: Synthetix,
+				owner,
+				beneficiary: SynthetixBridgeToOptimism,
+				amount: amountToDeposit,
+			});
+		});
+
+		before('make the deposit', async () => {
+			SynthetixBridgeToOptimism = SynthetixBridgeToOptimism.connect(owner);
+
+			const tx = await SynthetixBridgeToOptimism.deposit(amountToDeposit);
+			depositReceipt = await tx.wait();
+		});
+
+		it('decreases the owner balance', async () => {
+			const newOwnerBalance = await Synthetix.balanceOf(owner.address);
+
+			assert.bnEqual(newOwnerBalance, ownerBalance.sub(amountToDeposit));
+		});
+
+		it('increases the escrow balance', async () => {
+			const newEscrowBalance = await Synthetix.balanceOf(SynthetixBridgeEscrow.address);
+
+			assert.bnEqual(newEscrowBalance, escrowBalance.add(amountToDeposit));
+		});
+
+		describe('when the deposit gets picked up in L2', () => {
+			before('target contracts and users', () => {
+				({ Synthetix } = ctx.l2.contracts);
+
+				owner = ctx.l2.owner;
+			});
+
+			before('record balances', async () => {
+				ownerBalance = await Synthetix.balanceOf(owner.address);
+			});
+
+			before('wait for deposit finalization', async () => {
+				await finalizationOnL2({ ctx, transactionHash: depositReceipt.transactionHash });
+			});
+
+			it('increases the owner balance', async () => {
+				assert.bnEqual(await Synthetix.balanceOf(owner.address), ownerBalance.add(amountToDeposit));
+			});
+		});
+	});
+});

test/integration/dual/deposit.integration.js

@@ -0,0 +1,84 @@
+const ethers = require('ethers');
+const { assert } = require('../../contracts/common');
+const { bootstrapDual } = require('../utils/bootstrap');
+const { finalizationOnL2 } = require('../utils/watchers');
+const { approveIfNeeded } = require('../utils/approve');
+
+describe('depositTo() integration tests (L1, L2)', () => {
+	const ctx = this;
+	bootstrapDual({ ctx });
+
+	const amountToDeposit = ethers.utils.parseEther('10');
+
+	let owner, user;
+	let Synthetix, SynthetixBridgeToOptimism, SynthetixBridgeEscrow;
+
+	let ownerBalance, beneficiaryBalance, escrowBalance;
+
+	let depositReceipt;
+
+	describe('when the owner deposits SNX for a user', () => {
+		before('target contracts and users', () => {
+			({ Synthetix, SynthetixBridgeToOptimism, SynthetixBridgeEscrow } = ctx.l1.contracts);
+
+			owner = ctx.l1.owner;
+			user = ctx.l1.user;
+		});
+
+		before('record balances', async () => {
+			ownerBalance = await Synthetix.balanceOf(owner.address);
+			escrowBalance = await Synthetix.balanceOf(SynthetixBridgeEscrow.address);
+		});
+
+		before('approve if needed', async () => {
+			await approveIfNeeded({
+				token: Synthetix,
+				owner,
+				beneficiary: SynthetixBridgeToOptimism,
+				amount: amountToDeposit,
+			});
+		});
+
+		before('make the deposit', async () => {
+			SynthetixBridgeToOptimism = SynthetixBridgeToOptimism.connect(owner);
+
+			const tx = await SynthetixBridgeToOptimism.depositTo(user.address, amountToDeposit);
+			depositReceipt = await tx.wait();
+		});
+
+		it('decreases the owner balance', async () => {
+			const newOwnerBalance = await Synthetix.balanceOf(owner.address);
+
+			assert.bnEqual(newOwnerBalance, ownerBalance.sub(amountToDeposit));
+		});
+
+		it('increases the escrow balance', async () => {
+			const newEscrowBalance = await Synthetix.balanceOf(SynthetixBridgeEscrow.address);
+
+			assert.bnEqual(newEscrowBalance, escrowBalance.add(amountToDeposit));
+		});
+
+		describe('when the deposit gets picked up in L2', () => {
+			before('target contracts and users', () => {
+				({ Synthetix } = ctx.l2.contracts);
+
+				owner = ctx.l2.owner;
+			});
+
+			before('record balances', async () => {
+				beneficiaryBalance = await Synthetix.balanceOf(user.address);
+			});
+
+			before('wait for deposit finalization', async () => {
+				await finalizationOnL2({ ctx, transactionHash: depositReceipt.transactionHash });
+			});
+
+			it('increases the beneficiary balance', async () => {
+				assert.bnEqual(
+					await Synthetix.balanceOf(user.address),
+					beneficiaryBalance.add(amountToDeposit)
+				);
+			});
+		});
+	});
+});

test/integration/dual/depositTo.integration.test.js

@@ -0,0 +1,64 @@
+const ethers = require('ethers');
+const { assert } = require('../../contracts/common');
+const { bootstrapDual } = require('../utils/bootstrap');
+const { finalizationOnL2 } = require('../utils/watchers');
+const { approveIfNeeded } = require('../utils/approve');
+
+describe('depositReward() integration tests (L1, L2)', () => {
+	const ctx = this;
+	bootstrapDual({ ctx });
+
+	const amountToDeposit = ethers.utils.parseEther('10');
+
+	let owner;
+	let Synthetix, SynthetixBridgeToOptimism, FeePool;
+
+	let depositReceipt;
+
+	describe('when the owner deposits SNX for rewards', () => {
+		before('target contracts and users', () => {
+			({ Synthetix, SynthetixBridgeToOptimism } = ctx.l1.contracts);
+
+			owner = ctx.l1.owner;
+		});
+
+		before('approve if needed', async () => {
+			await approveIfNeeded({
+				token: Synthetix,
+				owner,
+				beneficiary: SynthetixBridgeToOptimism,
+				amount: amountToDeposit,
+			});
+		});
+
+		before('make the deposit', async () => {
+			SynthetixBridgeToOptimism = SynthetixBridgeToOptimism.connect(owner);
+
+			const tx = await SynthetixBridgeToOptimism.depositReward(amountToDeposit);
+			depositReceipt = await tx.wait();
+		});
+
+		describe('when the deposit gets picked up in L2', () => {
+			let currentFeePeriodRewards;
+
+			before('target contracts and users', () => {
+				({ FeePool } = ctx.l2.contracts);
+			});
+
+			before('record current fee period rewards', async () => {
+				currentFeePeriodRewards = (await FeePool.recentFeePeriods(0)).rewardsToDistribute;
+			});
+
+			before('wait for deposit finalization', async () => {
+				await finalizationOnL2({ ctx, transactionHash: depositReceipt.transactionHash });
+			});
+
+			it('increases the current fee periods rewards to distribute', async () => {
+				assert.bnEqual(
+					(await FeePool.recentFeePeriods(0)).rewardsToDistribute,
+					currentFeePeriodRewards.add(amountToDeposit)
+				);
+			});
+		});
+	});
+});