@oldzeppelin/contract 1.1.1

package/test/PriceOracle.test.ts

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { expect } from 'chai'
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers'
+import {
+	constants,
+	_signDepositRequest,
+	_signWithdrawRequest,
+	convertDecimals,
+} from './_helpers'
+import {
+	UFarmFundFixture,
+	_poolSwapUniV2,
+	MockedAggregatorFixture,
+} from './_fixtures'
+import {
+	_BNsqrt,
+} from './_helpers'
+
+describe('PriceOracle', async () => {
+	it('Mocked aggregator test', async () => {
+		const { feedInstancesTokenToUSDT } = await loadFixture(MockedAggregatorFixture)
+
+		const daiPrice = await feedInstancesTokenToUSDT.DAI.latestAnswer()
+		const daiFeedDecimals = await feedInstancesTokenToUSDT.DAI.decimals()
+		expect(daiPrice).to.be.lessThanOrEqual(
+			(10n ** BigInt(daiFeedDecimals) * 105n) / 100n,
+			'DAI price is too high',
+		)
+		expect(daiPrice).to.be.greaterThanOrEqual(
+			(10n ** BigInt(daiFeedDecimals) * 95n) / 100n,
+			'DAI price is too low',
+		)
+
+		const wethPrice = await feedInstancesTokenToUSDT.WETH.latestAnswer()
+		const wethFeedDecimals = await feedInstancesTokenToUSDT.WETH.decimals()
+		expect(wethPrice).to.be.lessThanOrEqual(
+			(1800n * 10n ** BigInt(wethFeedDecimals) * 105n) / 100n,
+			'WETH price is too high',
+		)
+		expect(wethPrice).to.be.greaterThanOrEqual(
+			(1800n * 10n ** BigInt(wethFeedDecimals) * 95n) / 100n,
+			'WETH price is too low',
+		)
+	})
+	it('Price oracle getCostERC20() function test', async () => {
+		const { feedInstancesTokenToUSDT, tokens, PriceOracle_instance } = await loadFixture(
+			UFarmFundFixture,
+		)
+		const [daiPrice, daiFeedDecimals, usdtDecimals] = await Promise.all([
+			feedInstancesTokenToUSDT.DAI.latestAnswer(),
+			feedInstancesTokenToUSDT.DAI.decimals(),
+			tokens.USDT.decimals(),
+		])
+		const daiCost = await PriceOracle_instance.getCostERC20(
+			tokens.DAI.address,
+			constants.ONE,
+			tokens.USDT.address,
+		)
+		expect(daiCost).to.eq(
+			convertDecimals(daiPrice, daiFeedDecimals, usdtDecimals),
+			'DAI cost should be equal to price for 1 DAI in USDT',
+		)
+
+		const [wethPrice, wethFeedDecimals] = await Promise.all([
+			feedInstancesTokenToUSDT.WETH.latestAnswer(),
+			feedInstancesTokenToUSDT.WETH.decimals(),
+		])
+		const wethCost = await PriceOracle_instance.getCostERC20(
+			tokens.WETH.address,
+			constants.ONE,
+			tokens.USDT.address,
+		)
+		expect(wethCost).to.eq(
+			convertDecimals(wethPrice, wethFeedDecimals, usdtDecimals),
+			'WETH cost should be equal to price for 1 WETH in USDT',
+		)
+	})
+	it("Should check wsteth/eth oracle calculations", async () => {
+		
+	})
+})

package/test/TestCases.MD

@@ -0,0 +1,109 @@
+# Another tests of Fees
+
+## Test Case: All Fees are Calculated Correctly During Withdrawal, Final HWM is zero
+
+1. Bob deposits 2000 USDT to the pool.
+2. Manager exchanges 1000 USDT to ETH.
+3. 30 days passed.
+4. The exchange rate of ETH bumps by 1/3.
+5. The pool calculates fees as:
+   1. Total cost should be equal to 1000 USDT + UniswapCostOfETHinPool() = 1000 USDT + 1000 USDT \* 4/3 = 2333.33 USDT
+   2. Initial HWM should be equal to 2000 USDT
+   3. Performance fee = Profit \* Performance commission rate
+      (~2300 - 2000) \* 10% = 30 USDT at the time of withdrawal.
+   4. Management fee = Annual Fee Period \* Management Commission \* Assets Under Management = (30 days / 365 days) \* 2% \* 2000 USDT = 12 USDT
+   5. Protocol fee = Annual Fee Period \* Protocol Commission \* Assets Under Management = (30 days / 365 days) \* 3% \* 2000 USDT = 18 USDT
+   6. HWM should be equal to 0 
+
+## Test Case: All Fees are Calculated Correctly During Deposit and HWM Decreases after Fee Calculation
+
+1. Bob deposits 2000 USDT to the pool.
+2. Manager exchanges 1000 USDT to ETH.
+3. The exchange rate of ETH bumps by 1/3.
+4. 12 hours passed.
+4. The pool calculates fees as:
+   1. Management Fee = Total cost after changing rate * Management Commission * Fee Period
+   2. Protocol Fee = Total cost after changing rate * Protocol Commission * Fee Period
+   3. Performance Fee = Profit * Performance commission rate
+
+## Test Case: All Fees are Calculated Correctly During Pool Initialization
+
+1. Fund deposits 4000 USDT to the pool.
+2. Manager exchanges 2000 USDT to ETH.
+3. The exchange rate of ETH bumps by 100%.
+4. 1 min passed.
+5. The pool calculates fees as:
+   1. Management Fee = Total cost after changing rate \* Management Commission \* Fee Period
+   2. Protocol Fee = Total cost after changing rate \* Protocol Commission \* Fee Period
+   3. Performance Fee = Profit \* Performance commission rate
+
+## Test Case: Total Fee is Distributed Correctly Between the Fund and the UFarm
+
+1. Bob deposits 2000 USDT to the pool.
+2. Manager exchanges 1000 USDT to ETH.
+3. The exchange rate of ETH bumps by 1/3, 30 days passed.
+4. The pool calculates the total fees as:
+   1. Protocol Fee = Fee Period \* Protocol Commission \* Assets Under Management
+   2. Management Fee = Fee Period \* Management Commission \* Assets Under Management
+   3. Performance Fee = Management Commission \* Profit Above HWM
+5. UFarm Fee should be equal to the sum of the Protocol Fee and 20% of the sum of the Management Fee and Performance Fee:
+   1. Total UFarm Fee = Protocol Fee + 20% \* (Management Fee + Performance Fee)
+6. Fund Fee should be equal to 80% of the sum of the Management Fee and Performance Fee:
+   1. Total Fund Fee = 80% \* (Management Fee + Performance Fee)
+
+## Test Case: Performance Fee is Not Calculated When There is No Profit
+
+1. Bob deposits 10000 USDT to the pool.
+2. Manager exchanges 5000 USDT to ETH.
+3. The exchange rate of ETH dumps to 1/2.
+4. Alice deposits 2500 USDT to the pool and no performance fee is calculated.
+
+## Test Case: Protocol Fee and Management Fee are Calculated When There is No Change in the Pool Exchange Rate
+
+1. Bob deposits 1000 USDT to the pool.
+2. The exchange rate of ETH does not change. 180 days passed.
+3. The pool calculates the protocol fee as:
+   1. Protocol Fee = Fee Period \* Protocol Commission \* Assets Under Management
+   2. 180/365 \* 0.03 \* 1000 ~= 14.79 USDT
+4. The pool calculates the management fee as:
+   1. Management Fee = Fee Period \* Management Commission \* Assets Under Management
+   2. 180/365 \* 0.02 \* 1000 ~= 10.96 USDT
+
+## Test Case: Management and Protocol Fees Can't Be More Than Pool Balance
+
+1. Bob deposits 1000 USDT to the pool.
+2. Manager exchanges 500 USDT to ETH.
+3. The exchange rate of ETH changes to x10.
+4. Protocol fee is always 0.3% of the pool balance per year. Management fee is 4.7% of the pool balance per year. Performance fee is 10% of the profit.
+5. 21 years passed. Total annual rate is 5%, so it is 100% for 20 years.
+   1. Total cost ~= 500 + 500 \* 10 = 5500 USDT
+   2. Performance fee ~= 5500 \* 10% = 550 USDT
+6. The pool calculates the management fee as:
+   1. Management Fee = Fee Period _ Management Commission _ Assets Under Management
+   2. 21 _ 0.047 _ 5500 = 5428.5 USDT
+7. The pool calculates the protocol fee as:
+   1. Protocol Fee = Fee Period _ Protocol Commission _ Assets Under Management
+   2. 21 _ 0.003 _ 5500 = 346.5 USDT
+
+## Test Case: Full Withdrawal After 1 Year of Pool's Existence
+
+1. Bob deposits 1000 USDT to the pool.
+2. Manager exchanges 500 USDT to ETH.
+3. 1 year passed.
+4. Bob withdraws all his funds. Fees are calculated as:
+   1. Protocol Fee = Fee Period _ Protocol Commission _ Assets Under Management
+   2. Management Fee = Fee Period _ Management Commission _ Assets Under Management
+   3. Performance Fee = Management Commission \* Profit Above HWM
+   4. Total UFarm Fee = Protocol Fee + 20% \* (Management Fee + Performance Fee)
+   5. Total Fund Fee = 80% \* (Management Fee + Performance Fee)
+   6. Total Fee = Total UFarm Fee + Total Fund Fee
+   7. Bob receives 1000 - feesValue USDT
+
+## Test Case: Performance Fee is Calculated Correctly During Deposit
+
+1. Bob deposits 1000 USDT to the pool that splits 50% to ETH and 50% to USDT.
+2. Manager exchanges 500 USDT to ETH.
+3. The exchange rate of ETH bumps by 1/3.
+4. The pool calculates the performance fee as:
+   1. Performance fee = Profit \* Performance commission rate
+   2. (1300 - 1000) \* 10% = 30 USDT at the time of deposit.

package/test/UFarmCore.test.ts

@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { ethers } from 'hardhat'
+import { expect } from 'chai'
+import { anyValue } from '@nomicfoundation/hardhat-chai-matchers/withArgs'
+import { time, loadFixture, takeSnapshot } from '@nomicfoundation/hardhat-network-helpers'
+import { UFarmFund } from '../typechain-types/'
+
+import { UFarmCoreFixture } from './_fixtures'
+
+import {
+	protocolToBytes32,
+	constants,
+	getEventFromTx,
+	AssetWithPriceFeed,
+	FeedWithDecimal,
+} from './_helpers'
+import { bitsToBigNumber } from './_helpers'
+
+describe('UFarmCore test', function () {
+	describe('Basic tests', function () {
+		it('Should create fund', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			const firstFundId = 0
+			const applicationId = ethers.utils.randomBytes(32)
+
+			expect(await UFarmCore_instance.connect(deployer).createFund(deployer.address, applicationId))
+				.to.emit(UFarmCore_instance, 'FundCreated')
+				.withArgs(applicationId, firstFundId, anyValue)
+
+			const address_UFarmFund = await UFarmCore_instance.getFund(firstFundId)
+
+			const UFarmFund_instance: UFarmFund = await ethers.getContractAt(
+				'UFarmFund',
+				address_UFarmFund,
+				alice,
+			)
+
+			expect(await UFarmFund_instance.name()).to.equal('UFarmFund')
+		})
+
+		it('Should create the same fund with same applicationId', async function () {
+			const { UFarmCore_instance, FundFactory_instance, deployer, alice, bob } = await loadFixture(
+				UFarmCoreFixture,
+			)
+
+			const applications = [
+				{
+					id: ethers.utils.randomBytes(32),
+					admin: alice.address,
+				},
+				{
+					id: ethers.utils.randomBytes(32),
+					admin: deployer.address,
+				},
+				{
+					id: ethers.utils.randomBytes(32),
+					admin: bob.address,
+				},
+			]
+			const reversedApplications = applications.reverse()
+			
+			const cleanSnapshot = await takeSnapshot()
+
+			const funds1 = []
+
+			for (const application of applications) {
+				const fundAddr = await FundFactory_instance.getFundBySalt(application.admin, application.id)
+
+				expect(
+					await UFarmCore_instance.connect(deployer).createFund(application.admin, application.id),
+				)
+					.to.emit(UFarmCore_instance, 'FundCreated')
+					.withArgs(application.id, anyValue, fundAddr)
+
+				funds1.push(fundAddr)
+			}
+
+			await cleanSnapshot.restore()
+
+			const funds2 = []
+			
+			for (const application of reversedApplications) {
+				const fundAddr = await FundFactory_instance.getFundBySalt(application.admin, application.id)
+
+				expect(
+					await UFarmCore_instance.connect(deployer).createFund(application.admin, application.id),
+				)
+					.to.emit(UFarmCore_instance, 'FundCreated')
+					.withArgs(application.id, anyValue, fundAddr)
+
+				funds2.push(fundAddr)
+			}
+			expect(funds1).to.deep.equal(funds2, 'Funds are not the same')
+		})
+	})
+	describe('UFarm Permission tests', function () {
+		it('Should deploy contract and grant permissions to the admin', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			for (const [key, value] of Object.entries(constants.UFarm.Permissions)) {
+				expect(await UFarmCore_instance.hasPermission(deployer.address, value)).to.equal(
+					true,
+					`Deployer doesn't have permission ${key}`,
+				)
+			}
+		})
+		it('Should grant UFarm owner', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			expect(await UFarmCore_instance.hasPermission(alice.address, 2)).to.equal(
+				false,
+				'Alice is already UFarm owner',
+			)
+
+			const ownerMask = bitsToBigNumber([constants.UFarm.Permissions.Owner])
+
+			await expect(UFarmCore_instance.connect(deployer).updatePermissions(alice.address, ownerMask))
+				.to.emit(UFarmCore_instance, 'PermissionsUpdated')
+				.withArgs(alice.address, ownerMask)
+
+			expect(
+				await UFarmCore_instance.hasPermission(alice.address, constants.UFarm.Permissions.Owner),
+			).to.equal(true, 'Alice is not UFarm owner')
+		})
+		it('Should grant and remove UFarm permission', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			expect(
+				await UFarmCore_instance.hasPermission(alice.address, constants.UFarm.Permissions.Member),
+			).to.equal(false, 'Alice is already UFarm member')
+			expect(
+				await UFarmCore_instance.hasPermission(
+					alice.address,
+					constants.UFarm.Permissions.UpdatePermissions,
+				),
+			).to.equal(false, 'Alice already has UpdatePermissions permission')
+
+			const memberBlockFundMask = bitsToBigNumber([
+				constants.UFarm.Permissions.Member,
+				constants.UFarm.Permissions.BlockFund,
+			])
+
+			await expect(
+				UFarmCore_instance.connect(deployer).updatePermissions(alice.address, memberBlockFundMask),
+			)
+				.to.emit(UFarmCore_instance, 'PermissionsUpdated')
+				.withArgs(alice.address, memberBlockFundMask)
+
+			expect(
+				await UFarmCore_instance.hasPermission(alice.address, constants.UFarm.Permissions.Member),
+			).to.equal(true, 'Alice is not UFarm member')
+			expect(
+				await UFarmCore_instance.hasPermission(
+					alice.address,
+					constants.UFarm.Permissions.BlockFund,
+				),
+			).to.equal(true, 'Alice does not have BlockFund permission')
+
+			const multiMask = bitsToBigNumber([
+				constants.UFarm.Permissions.Member,
+				constants.UFarm.Permissions.UpdateUFarmMember,
+				constants.UFarm.Permissions.TurnPauseOn,
+			])
+
+			await expect(UFarmCore_instance.connect(deployer).updatePermissions(alice.address, multiMask))
+				.to.emit(UFarmCore_instance, 'PermissionsUpdated')
+				.withArgs(alice.address, multiMask)
+
+			expect(
+				await UFarmCore_instance.hasPermission(alice.address, constants.UFarm.Permissions.Member),
+			).to.equal(true)
+			expect(
+				await UFarmCore_instance.hasPermission(
+					alice.address,
+					constants.UFarm.Permissions.BlockFund,
+				),
+			).to.equal(false)
+			expect(
+				await UFarmCore_instance.hasPermission(
+					alice.address,
+					constants.UFarm.Permissions.TurnPauseOn,
+				),
+			).to.equal(true)
+		})
+		it('Should deploy with one owner', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			expect(
+				await UFarmCore_instance.hasPermission(deployer.address, constants.UFarm.Permissions.Owner),
+			).to.equal(true)
+			expect(
+				await UFarmCore_instance.hasPermission(bob.address, constants.UFarm.Permissions.Owner),
+			).to.equal(false)
+		})
+		it('Only owner can grant ownership', async function () {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			// Bob is not member
+			expect(
+				await UFarmCore_instance.hasPermission(bob.address, constants.UFarm.Permissions.Owner),
+			).to.equal(false, 'Bob is not UFarm owner')
+
+			// Bob can't grant ownership to anyone
+			const ownerMask = bitsToBigNumber([constants.UFarm.Permissions.Owner])
+
+			await expect(
+				UFarmCore_instance.connect(bob).updatePermissions(alice.address, ownerMask),
+			).to.be.revertedWithCustomError(UFarmCore_instance, 'NonAuthorized')
+			await expect(
+				UFarmCore_instance.connect(bob).updatePermissions(bob.address, ownerMask),
+			).to.be.revertedWithCustomError(UFarmCore_instance, 'NonAuthorized')
+
+			// Grant member role to Bob
+			await UFarmCore_instance.updatePermissions(
+				bob.address,
+				bitsToBigNumber([constants.UFarm.Permissions.Member]),
+			)
+
+			// Bob is member
+			await expect(
+				UFarmCore_instance.connect(bob).updatePermissions(alice.address, ownerMask),
+			).to.be.revertedWithCustomError(UFarmCore_instance, 'NonAuthorized')
+			await expect(
+				UFarmCore_instance.connect(bob).updatePermissions(bob.address, ownerMask),
+			).to.be.revertedWithCustomError(UFarmCore_instance, 'NonAuthorized')
+
+			// Grant owner role to Bob
+			await UFarmCore_instance.updatePermissions(bob.address, ownerMask)
+
+			await expect(UFarmCore_instance.connect(bob).updatePermissions(alice.address, ownerMask)).to
+				.be.not.reverted
+		})
+	})
+
+	describe('Token whitelist tests', function () {
+		function convertToEventLogFormat(
+			asset: AssetWithPriceFeed,
+		): (string | number | FeedWithDecimal)[] & { assetInfo: AssetWithPriceFeed } {
+			// Construct the priceFeed array with both indexed and named properties
+			const priceFeedArray = [asset.priceFeed.feedAddr, asset.priceFeed.feedDec] as (
+				| string
+				| number
+			)[] &
+				FeedWithDecimal
+			priceFeedArray.feedAddr = asset.priceFeed.feedAddr
+			priceFeedArray.feedDec = asset.priceFeed.feedDec
+
+			// Construct the result array with both indexed and named properties
+			const resultArray = [asset.assetAddr, asset.assetDec, priceFeedArray] as (
+				| string
+				| number
+				| typeof priceFeedArray
+			)[] &
+				AssetWithPriceFeed
+			resultArray.assetAddr = asset.assetAddr
+			resultArray.assetDec = asset.assetDec
+			resultArray.priceFeed = priceFeedArray
+
+			const finalOutput = [resultArray] as unknown as (string | number | FeedWithDecimal)[] & {
+				assetInfo: AssetWithPriceFeed
+			}
+			finalOutput.assetInfo = resultArray
+
+			return finalOutput
+		}
+
+		it('Should add tokens to whitelist with event', async function () {
+			const { UFarmCore_instance, tokenFeeds } = await loadFixture(UFarmCoreFixture)
+
+			const feed0 = tokenFeeds[0]
+			const feed1 = tokenFeeds[1]
+			const feed2 = tokenFeeds[2]
+
+			const thisBlock = await ethers.provider.getBlock('latest')
+
+			await UFarmCore_instance.whitelistTokens([feed0])
+			await UFarmCore_instance.whitelistTokens([feed1, feed2])
+
+			const tokenAddedFilter = UFarmCore_instance.filters.TokenAdded()
+			const events = await UFarmCore_instance.queryFilter(tokenAddedFilter, thisBlock.number)
+
+			for (let i = 0; i < events.length; i++) {
+				expect(events[i].args).to.deep.equal(convertToEventLogFormat(tokenFeeds[i]))
+			}
+		})
+		it('Should remove token from whitelist', async function () {
+			const { UFarmCore_instance, tokenFeeds } = await loadFixture(UFarmCoreFixture)
+
+			const feed0 = tokenFeeds[0]
+
+			await UFarmCore_instance.whitelistTokens([feed0])
+
+			await expect(UFarmCore_instance.blacklistTokens([feed0.assetAddr]))
+				.to.emit(UFarmCore_instance, 'TokenRemoved')
+				.withArgs(feed0.assetAddr)
+		})
+	})
+	describe('Protocol Whitelist tests', () => {
+		it('Should add protocol to whitelist', async () => {
+			const { UFarmCore_instance, deployer, alice, bob } = await loadFixture(UFarmCoreFixture)
+
+			const protocolName = protocolToBytes32('protocolName')
+
+			expect(await UFarmCore_instance.isProtocolWhitelisted(protocolName)).to.equal(false)
+
+			await expect(
+				UFarmCore_instance.whitelistProtocolsWithControllers([protocolName], [deployer.address]),
+			)
+				.to.emit(UFarmCore_instance, 'ProtocolAdded')
+				.withArgs(protocolName, deployer.address)
+
+			expect(await UFarmCore_instance.isProtocolWhitelisted(protocolName)).to.equal(true)
+		})
+	})
+
+	describe("Parameters' tests", function () {
+		it('Should change minimumFundDeposit', async function () {
+			const { UFarmCore_instance } = await loadFixture(UFarmCoreFixture)
+
+			expect(await UFarmCore_instance.minimumFundDeposit()).to.equal(0)
+
+			await expect(UFarmCore_instance.setMinimumFundDeposit(100))
+				.to.emit(UFarmCore_instance, 'MinimumFundDepositChanged')
+				.withArgs(100)
+
+			expect(await UFarmCore_instance.minimumFundDeposit()).to.equal(100)
+		})
+	})
+})