@oldzeppelin/contract 1.1.1

package/scripts/_deploy_network_options.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { Network } from 'hardhat/types'
+import { getNetworkType } from './_deploy_helpers'
+
+export const initOptsUniV2: Record<
+	string,
+	{
+		codeHash: string
+		controller: string
+	}
+> = {
+	arbitrum: {
+		codeHash: '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+		controller: 'UniswapV2ControllerArbitrum',
+	},
+}
+
+export const initOptsUniV3: Record<
+	string,
+	{
+		codeHash: string
+		controller: string
+	}
+> = {
+	arbitrum: {
+		codeHash: '0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54',
+		controller: 'UniswapV3ControllerArbitrum',
+	},
+}
+
+export const getInitCodeUniV2 = (network: Network) => {
+	const networkType = getNetworkType(network)
+	if (networkType === 'arbitrum') {
+		return initOptsUniV2.arbitrum
+	} else {
+		throw new Error(`Init code not found for network: ${network.name} with tags: ${network.tags}`)
+	}
+}
+
+export const getInitCodeUniV3 = (network: Network) => {
+	const networkType = getNetworkType(network)
+
+	if (networkType === 'arbitrum') {
+		return initOptsUniV3.arbitrum
+	} else {
+		throw new Error(`Init code not found for network: ${network.name} with tags: ${network.tags}`)
+	}
+}

package/scripts/activatePool.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumberish } from 'ethers'
+import { UFarmPool, StableCoin, UFarmFund, PoolAdmin, UFarmCore } from '../typechain-types'
+import { PoolCreationStruct, constants, getEventFromTx } from '../test/_helpers'
+
+async function main() {
+	const { pool } = {
+		pool: '0x2240ce642A77f4B7ea926035181DEC1f4e968AA4',
+	}
+
+	const pool_instance = (await hre.ethers.getContractAt('UFarmPool', pool)) as UFarmPool
+	const pool_admin = await pool_instance.poolAdmin()
+	console.log('Pool admin contract:', pool_admin)
+
+    const pool_admin_instance = (await hre.ethers.getContractAt('PoolAdmin', pool_admin)) as PoolAdmin
+
+    const core = await pool_instance.ufarmCore()
+    const core_instance = (await hre.ethers.getContractAt('UFarmCore', core)) as UFarmCore
+    const minFundDeposit = await core_instance.minimumFundDeposit()
+
+    const fund = await pool_instance.ufarmFund()
+    const fund_instance = (await hre.ethers.getContractAt('UFarmFund', fund)) as UFarmFund
+
+
+    if (minFundDeposit.gt(0)) {
+        console.log('Minimum fund deposit is not zero, depositing...')
+        await(await fund_instance.depositToPool(pool, minFundDeposit)).wait()
+        console.log('Deposit done')
+    }
+
+	const event = await getEventFromTx(
+		pool_admin_instance.changePoolStatus(constants.Pool.State.Active),
+		pool_instance,
+		'PoolStatusChanged',
+	)
+
+	if (!event) {
+		throw new Error('Pool activation failed')
+	} else {
+		console.log('Pool activated')
+	}
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})

package/scripts/createPool.ts

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumberish } from 'ethers'
+import { UFarmPool, StableCoin, UFarmFund } from '../typechain-types'
+import {
+	PoolCreationStruct,
+	getEventFromTx,
+} from '../test/_helpers'
+
+async function main() {
+	const {
+        fund,
+        usdt,
+	} = {
+        fund: '0x8D30D3D813694415d4e44B1604F24a53236b6726',
+        usdt: '0xd71fe004d84b10FbD161838F87A94f2327A315a1',
+	}
+	const poolArgs: PoolCreationStruct = {
+		minInvestment: 1 as BigNumberish,
+		maxInvestment: hre.ethers.utils.parseUnits('1000000', 6),
+		managementCommission: 200 as BigNumberish,
+		performanceCommission: 3000 as BigNumberish,
+		depositLockupPeriod: 0 as BigNumberish, // will be removed
+		withdrawalLockupPeriod: 0 as BigNumberish,
+		valueToken: usdt,
+		staff: [
+            // Example staff member:
+			// {
+			// 	addr: bob.address,
+			// 	permissionsMask: bitsToBigNumber([
+			// 		constants.Pool.Permissions.Member,
+			// 		constants.Pool.Permissions.UpdateLockupPeriods,
+			// 	]),
+			// },
+			// {
+			// 	addr: alice.address,
+			// 	permissionsMask: bitsToBigNumber(Array.from(Object.values(constants.Pool.Permissions))),
+			// },
+		],
+		name: 'UFarmPool',
+		symbol: 'Pool symbol',
+	}
+
+    const fund_instance = (await hre.ethers.getContractAt('UFarmFund', fund)) as UFarmFund
+
+    const event = await getEventFromTx(fund_instance.createPool(poolArgs),fund_instance,'PoolCreated')
+
+    if (!event) {
+        throw new Error('Pool creation failed')
+    }
+
+    console.log('Pool created at', event.args.pool)
+
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})

package/scripts/deploy_1inch_proxy.ts

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumberish } from 'ethers'
+import { UFarmPool, StableCoin, UFarmFund, OneInchV5Controller__factory } from '../typechain-types'
+import { PoolCreationStruct, constants, encodePoolOneInchSwap, getEventFromTx } from '../test/_helpers'
+import { IERC20Metadata } from '../typechain-types/@openzeppelin/contracts/token/ERC20/extensions'
+
+
+// args:                    (0xe6e40dcfe2607f89f8642ab4a065a8e8605a1a57c2cc8d316950366809a262fc, 0x4c9ddf69000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c80502b1c5000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000098214f00000000000000000000000000000000000000000000000000000000009627d20000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000180000000000000003b6d03403041cbd36888becc7bbcbc0045e3b1f144466f5f8b1ccac8000000000000000000000000000000000000000000000000)
+
+async function main() {
+	const [deployer] = await hre.ethers.getSigners()
+    console.log(`Deplyer address: ${deployer.address}`)
+
+	const aggregationRouterV5_orig = '0x1111111254eeb25477b68fb85ed929f73a960582'
+    const usdcAddress = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'
+    const usdtAddress = '0xdac17f958d2ee523a2206206994597c13d831ec7'
+    const usdtHolderAddr = '0xDFd5293D8e347dFe59E90eFd55b2956a1343963d'
+    const oneInchTx = `0x4c9ddf69000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c80502b1c5000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000000000000000000000000000000000000005f19b4a0000000000000000000000000000000000000000000000000000000005dfb5bd0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000180000000000000003b6d03403041cbd36888becc7bbcbc0045e3b1f144466f5f8b1ccac8000000000000000000000000000000000000000000000000`
+// 0x4c9ddf69000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e4f78dc253000000000000000000000000cd8fc37291cb0e7ea855b58377adc7bccdad46f900000000000000000000000010c12d979b9e48f208f530ec5f3ea67837a4f8220000000000000000000000000000000000000000000000000000000002faf08000000000000000000000000000000000000000000000000000626340c0ec97ed00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000100000000000000003b6d034070831b48335d931e07b64ab0c7d28d5e0aec101c00000000000000000000000000000000000000000000000000000000
+// 0x4c9ddf69000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c8
+// 0502b1c5000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000098214f00000000000000000000000000000000000000000000000000000000009627d20000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000180000000000000003b6d03403041cbd36888becc7bbcbc0045e3b1f144466f5f8b1ccac8000000000000000000000000000000000000000000000000`
+    // const oneInchTx = '0xf91abd17000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000007aadfda890440000000000000000000000000000000000000000000000000000018e86d4a84500000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000002000000000000000000000000bec08b12212b461e207ac0b5d6106d9dfe01282e00000000000000000000000026569e2199c92f8b7c3deb52f9b33aee257f9c76'
+
+    // impersonate usdt holder
+    const provider = new hre.ethers.providers.JsonRpcProvider(
+        "http://localhost:8545"
+      );
+    await provider.send("hardhat_impersonateAccount", [usdtHolderAddr]);
+
+    // hre.e
+    // const account = provider.getSigner(usdtHolderAddr);
+
+    // await hre.network.provider.request({
+    //     method: 'hardhat_impersonateAccount',
+    //     params: [usdtHolderAddr],
+    // })
+    const usdtHolder = await provider.getSigner(usdtHolderAddr)
+    // console.log(`Impersonated usdt holder: ${usdtHolder.address}`)
+
+    const usdtInstance = await hre.ethers.getContractAt('@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol:IERC20Metadata', usdtAddress) as IERC20Metadata
+    const usdcInstance = await hre.ethers.getContractAt('@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol:IERC20Metadata', usdcAddress) as IERC20Metadata
+
+	const oneInchControllerFactory = await hre.ethers.getContractFactory('InchSwapTestController')
+    const testProxyFactory = await hre.ethers.getContractFactory('InchSwapTestProxy')
+
+    const aggregationRouterV5Factory = await hre.ethers.getContractFactory('AggregationRouterV5')
+    const aggregationRouterV5 = await aggregationRouterV5Factory.deploy('0xDFd5293D8e347dFe59E90eFd55b2956a1343963d')    
+    console.log(`AggregationRouterV5 deployed at: ${aggregationRouterV5.address}`)
+
+	const testController = await oneInchControllerFactory.deploy(aggregationRouterV5.address)
+    console.log(`test controller deployed at: ${testController.address}`)
+
+    const testProxy = await testProxyFactory.deploy()
+    console.log(`TestProxy deployed at: ${testProxy.address}`)
+
+    const usdtInitialBalance = await usdtInstance.balanceOf(testProxy.address)
+    const usdcInitialBalance = await usdcInstance.balanceOf(testProxy.address)
+
+    console.log(`usdt initial balance: ${usdtInitialBalance.toString()}`)
+    console.log(`usdc initial balance: ${usdcInitialBalance.toString()}`)
+
+    
+    await testProxy.addController(constants.UFarm.prtocols.OneInchProtocolString, testController.address)
+    console.log(`OneInchController added to TestProxy`)
+
+    const usdtAmountOut = constants.ONE_HUNDRED_BUCKS.mul(2)
+    if ((await usdtInstance.balanceOf(usdtHolderAddr)).lt(usdtAmountOut)) {
+        throw new Error('usdtAmountOut is greater than balance of holder')
+    }
+
+    await (await usdtInstance.connect(usdtHolder).transfer(testProxy.address, usdtAmountOut)).wait()
+    console.log(`Transferred ${usdtAmountOut} USDT to TestProxy`)
+
+    // make approve from proxyContract
+    // const encodedApproveToAggRouter = usdtInstance.interface.encodeFunctionData('approve', [aggregationRouterV5, hre.ethers.constants.MaxUint256])
+
+    // await testProxy.executeAny(usdtAddress, encodedApproveToAggRouter)
+    // console.log(`Approved ${usdtAmountOut} USDT to AggregationRouter from TestProxy`)
+
+    // const originalControllerFactory = await hre.ethers.getContractFactory('InchSwapTestController')
+    // const oneInchSwapCalldata = originalControllerFactory.interface.encodeFunctionData('delegated1InchSwap',[oneInchTx])
+    console.log(`oneInchSwapCalldata: ${oneInchTx}`)
+    // const oneInchSwapCalldata = encodePoolOneInchSwap(oneInchTx)
+    await testProxy.protocolAction(constants.UFarm.prtocols.OneInchProtocolString, oneInchTx)
+    console.log(`1inch swap executed`)
+
+    const newUsdtBalance = await usdtInstance.balanceOf(usdtHolderAddr)
+    const newUsdcBalance = await usdcInstance.balanceOf(testProxy.address)
+    console.log(`usdt balance after swap: ${newUsdtBalance.toString()}`)
+    console.log(`usdc balance after swap: ${newUsdcBalance.toString()}`)
+
+}
+main().catch((error) => {
+	console.error(error)
+	process.exitCode = 1
+})

package/scripts/pool-data.ts

@@ -0,0 +1,420 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { ethers } from 'hardhat'
+import * as dotenv from 'dotenv'
+import hre from 'hardhat'
+import fs from 'fs'
+import {
+	PoolCreationStruct,
+	constants,
+	deployPool,
+	encodePoolSwapDataUniswapV2,
+	encodePoolAddLiqudityDataUniswapV2,
+	getEventFromTx,
+	mintAndDeposit,
+	getBlockchainTimestamp,
+	mintAndCreatePairUniV2,
+	mintAndCreatePairUniV2WithEth,
+	logChangeBalanceWrapper,
+	packPerformanceCommission,
+} from '../test/_helpers'
+import {
+	IERC20,
+	IERC20Metadata__factory,
+	PoolAdmin,
+	PriceOracle,
+	UFarmCore,
+	UFarmPool,
+	UniswapV2Factory,
+} from '../typechain-types'
+import { BigNumber } from 'ethers'
+import { customSetTimeout, retryOperation } from './_deploy_helpers'
+
+dotenv.config()
+
+type ContractInfo = {
+	address: string
+	abi: any[]
+}
+
+type RequiredContracts = 'UFarmCore' | 'TestFund' | 'USDT' | 'USDC' | 'WETH'
+
+type Deployments = {
+	name: string
+	chainId: string
+	contracts: {
+		[contractName in RequiredContracts]: ContractInfo
+	}
+}
+
+async function isUniswapV2PairExist(
+	factoryContract: UniswapV2Factory,
+	token0Address: string,
+	token1Address: string,
+): Promise<boolean> {
+	try {
+		const pairAddress = await factoryContract.getPair(token0Address, token1Address)
+		return (await hre.ethers.provider.getCode(pairAddress)) !== '0x'
+	} catch (error) {
+		console.error('Error checking pair existence:', error)
+		return false
+	}
+}
+
+const increaseGasLimit = (estimatedGasLimit: BigNumber) => {
+	return estimatedGasLimit.mul(130).div(100) // increase by 30%
+}
+
+async function main(iterations: number = 150_000, pool1_addr?: string, pool2_addr?: string) {
+	console.log('Starting pool data script...')
+
+	const [deployer, alice, bob, carol, david, emma] = await ethers.getSigners()
+
+	const deployConfig: Deployments = JSON.parse(fs.readFileSync(hre.deploymentsJsonPath, 'utf8'))
+
+	const [core_addr, fund_addr, usdt_addr, usdc_addr, weth_addr] = [
+		deployConfig.contracts.UFarmCore.address,
+		deployConfig.contracts.TestFund.address,
+		deployConfig.contracts.USDT.address,
+		deployConfig.contracts.USDC.address,
+		deployConfig.contracts.WETH.address,
+	]
+
+	const [core_instance, fund_instance, usdt_instance, usdc_instance, weth_instance] = [
+		await ethers.getContractAt('UFarmCore', core_addr, deployer),
+		await ethers.getContractAt('UFarmFund', fund_addr, deployer),
+		await ethers.getContractAt('StableCoin', usdt_addr, deployer),
+		await ethers.getContractAt('StableCoin', usdc_addr, deployer),
+		await ethers.getContractAt('WETH9', weth_addr, deployer),
+	]
+
+	// Create 2 new pools
+
+	const getPools = async (pool1_addr?: string, pool2_addr?: string) => {
+		if (pool1_addr && pool2_addr) {
+			return [
+				await ethers.getContractAt('UFarmPool', pool1_addr, david),
+				await ethers.getContractAt('UFarmPool', pool2_addr, emma),
+			]
+		}
+
+		const emptyPoolArgs: PoolCreationStruct = {
+			minInvestment: 0,
+			maxInvestment: hre.ethers.constants.MaxUint256,
+			managementCommission: hre.ethers.constants.One.div(101),
+			packedPerformanceCommission: packPerformanceCommission([{
+				step: 0,
+				commission: Math.floor(constants.Pool.Commission.MAX_PERFORMANCE_COMMISION / 80)
+			}]),
+			withdrawalLockupPeriod: 0,
+			valueToken: usdt_addr,
+			staff: [],
+			name: 'name',
+			symbol: 'symbol',
+		}
+
+		const pool1 = (
+			await retryOperation(async () => {
+				return await deployPool(
+					{ ...emptyPoolArgs, name: 'Data-Pool-1', symbol: 'dp-1' },
+					fund_instance,
+				)
+			}, 5)
+		).pool.connect(david)
+
+		const pool2 = (
+			await retryOperation(async () => {
+				return await deployPool(
+					{ ...emptyPoolArgs, name: 'Data-Pool-2', symbol: 'dp-2' },
+					fund_instance,
+				)
+			}, 5)
+		).pool.connect(emma)
+
+		console.log(`Pools:\n${pool1.address}\n${pool2.address}`)
+
+		// Deposit 10k USDT into each pool
+		const tenThousandBucks = BigNumber.from(10_000).mul(1e6)
+		await usdt_instance.mint(fund_addr, tenThousandBucks.mul(2))
+		console.log('Minted 20k USDT to fund contract')
+
+		await retryOperation(async () => {
+			await fund_instance.depositToPool(pool1.address, tenThousandBucks)
+		}, 5)
+		console.log('Deposited 10k USDT into pool 1')
+
+		await retryOperation(async () => {
+			await fund_instance.depositToPool(pool2.address, tenThousandBucks)
+		}, 5)
+		console.log('Deposited 10k USDT into pool 2')
+
+		// Buy USDC and WETH with USDT on UniswapV2 for each pool
+		const buyUSDCdata = async () => {
+			return encodePoolSwapDataUniswapV2(
+				tenThousandBucks.div(2),
+				BigNumber.from(1000),
+				(await getBlockchainTimestamp(hre.ethers.provider)) + 200,
+				[usdt_addr, usdc_addr],
+			)
+		}
+
+		const buyWETHdata = async () => {
+			return encodePoolSwapDataUniswapV2(
+				tenThousandBucks.div(2),
+				BigNumber.from(1000),
+				(await getBlockchainTimestamp(hre.ethers.provider)) + 200,
+				[usdt_addr, weth_addr],
+			)
+		}
+
+		await retryOperation(async () => {
+			await (
+				await pool1.protocolAction(
+					constants.UFarm.prtocols.UniswapV2ProtocolString,
+					await buyUSDCdata(),
+				)
+			).wait()
+		}, 5)
+		console.log(`Bought ${await usdc_instance.balanceOf(pool1.address)} USDC with USDT on pool 1`)
+
+		await retryOperation(async () => {
+			await (
+				await pool2.protocolAction(
+					constants.UFarm.prtocols.UniswapV2ProtocolString,
+					await buyUSDCdata(),
+				)
+			).wait()
+		}, 5)
+		console.log(`Bought ${await usdc_instance.balanceOf(pool2.address)} USDC with USDT on pool 2`)
+
+		await retryOperation(async () => {
+			await (
+				await pool1.protocolAction(
+					constants.UFarm.prtocols.UniswapV2ProtocolString,
+					await buyWETHdata(),
+				)
+			).wait()
+		}, 5)
+		console.log(`Bought ${await weth_instance.balanceOf(pool1.address)} WETH with USDT on pool 1`)
+
+		await retryOperation(async () => {
+			await (
+				await pool2.protocolAction(
+					constants.UFarm.prtocols.UniswapV2ProtocolString,
+					await buyWETHdata(),
+				)
+			).wait()
+		}, 5)
+		console.log(`Bought ${await weth_instance.balanceOf(pool2.address)} WETH with USDT on pool 2`)
+
+		// Become liquidity provider of USDC/WETH pair
+		const addLiquidityData = async (pool: UFarmPool) => {
+			const [usdcBalance, wethBalance] = await Promise.all([
+				usdc_instance.balanceOf(pool.address),
+				weth_instance.balanceOf(pool.address),
+			])
+
+			const UniV2Controller_addr = await core_instance.controllers(
+				constants.UFarm.prtocols.UniswapV2ProtocolString,
+			)
+
+			const UniV2Controller_instance = await ethers.getContractAt(
+				'UnoswapV2Controller',
+				UniV2Controller_addr,
+				deployer,
+			)
+
+			const getQuotedAmounts = async (): ReturnType<
+				typeof UniV2Controller_instance.quoteExactLiquidityAmounts
+			> => {
+				try {
+					const quotedAmounts = await UniV2Controller_instance.quoteExactLiquidityAmounts(
+						usdc_addr,
+						weth_addr,
+						usdcBalance,
+						wethBalance,
+						1000,
+						1000,
+						(await getBlockchainTimestamp(hre.ethers.provider)) + 200,
+					)
+
+					console.log(
+						`Quoted amounts: ${quotedAmounts[0].toString()}, ${quotedAmounts[1].toString()}`,
+					)
+
+					return quotedAmounts
+				} catch (error) {
+					console.log('Checking for pair existence...')
+					const [factory_addr, router_addr] = await Promise.all([
+						UniV2Controller_instance.factory(),
+						UniV2Controller_instance.router(),
+					])
+					const factory_instance = await ethers.getContractAt(
+						'UniswapV2Factory',
+						factory_addr,
+						deployer,
+					)
+					const router_instance = await ethers.getContractAt(
+						'UniswapV2Router02',
+						router_addr,
+						deployer,
+					)
+					if (await isUniswapV2PairExist(factory_instance, usdc_addr, weth_addr)) {
+						console.log('Pair already exists')
+					} else {
+						await mintAndCreatePairUniV2WithEth(
+							usdc_instance,
+							BigNumber.from(10).pow(6).mul(2000),
+							constants.ONE,
+							deployer,
+							router_instance,
+						)
+						console.log('Pair created!')
+					}
+					// retry
+					return await getQuotedAmounts()
+				}
+
+			}
+
+			await getQuotedAmounts()
+
+			return encodePoolAddLiqudityDataUniswapV2(
+				usdc_addr,
+				weth_addr,
+				usdcBalance.div(2),
+				wethBalance.div(2),
+				1000,
+				1000,
+				(await getBlockchainTimestamp(hre.ethers.provider)) + 200,
+			)
+		}
+
+		const poolAddLiquidity = async (pool: UFarmPool) => {
+			const addLiqData = await addLiquidityData(pool)
+			const estimateAddLiquidty = await pool.estimateGas.protocolAction(
+				constants.UFarm.prtocols.UniswapV2ProtocolString,
+				addLiqData,
+			)
+
+			const receiptAddLiq = await (
+				await pool.protocolAction(constants.UFarm.prtocols.UniswapV2ProtocolString, addLiqData, {
+					gasLimit: increaseGasLimit(estimateAddLiquidty),
+				})
+			).wait()
+
+			console.log(`Added liquidity to pool ${pool.address} in block ${receiptAddLiq.blockNumber}`)
+		}
+
+		await poolAddLiquidity(pool1)
+		await poolAddLiquidity(pool2)
+
+		console.log('Preparation done!')
+
+		return [pool1, pool2]
+	}
+
+	const [pool1, pool2] = await getPools(pool1_addr, pool2_addr)
+
+	const ufarmCore_addr = await pool1.ufarmCore()
+	const ufarmCore_instance = await ethers.getContractAt('UFarmCore', ufarmCore_addr, deployer)
+
+	const UnoswapV2Controller_addr = await ufarmCore_instance.controllers(
+		constants.UFarm.prtocols.UniswapV2ProtocolString,
+	)
+
+	const UnoswapV2Controller_instance = await ethers.getContractAt(
+		'UnoswapV2Controller',
+		UnoswapV2Controller_addr,
+		deployer,
+	)
+
+	const encodeSwapOfHalf = async (pool: UFarmPool, swapTo: string, swapFrom: string) => {
+		const swapFrom_instance = IERC20Metadata__factory.connect(swapFrom, deployer)
+		const swapTo_instance = IERC20Metadata__factory.connect(swapTo, deployer)
+
+		const [symbol1, symbol2] = await Promise.all([
+			swapFrom_instance.symbol(),
+			swapTo_instance.symbol(),
+		])
+
+		const amountToSwap = (await swapFrom_instance.balanceOf(pool.address)).div(2)
+		const timestamp = (await getBlockchainTimestamp(hre.ethers.provider)) + 200
+		const amountOut = await UnoswapV2Controller_instance.getAmountOut(amountToSwap, [
+			swapFrom,
+			swapTo,
+		])
+
+		console.log(
+			`Going to swap ${amountToSwap.toString()} ${symbol1} to ${amountOut.toString()} ${symbol2}`,
+		)
+
+		return encodePoolSwapDataUniswapV2(amountToSwap, BigNumber.from(10000), timestamp, [
+			swapFrom,
+			swapTo,
+		])
+	}
+
+	async function threeRetries<T>(fn: () => Promise<T>): Promise<T> {
+		return await retryOperation(async () => {
+			return fn()
+		}, 3)
+	}
+
+	async function logBalanceSwapRetry<T>(pool: UFarmPool, token1: string, token2: string) {
+		return await logChangeBalanceWrapper(
+			async () => {
+				return await threeRetries(async () => {
+					const encodedSwap1 = await encodeSwapOfHalf(pool, token1, token2)
+
+					const estimatedGasLimit = await pool.estimateGas.protocolAction(
+						constants.UFarm.prtocols.UniswapV2ProtocolString,
+						encodedSwap1,
+					)
+
+					return await (
+						await pool.protocolAction(
+							constants.UFarm.prtocols.UniswapV2ProtocolString,
+							encodedSwap1,
+							{
+								gasLimit: increaseGasLimit(estimatedGasLimit),
+							},
+						)
+					).wait()
+				})
+			},
+			pool.address,
+			token1,
+			token2,
+		)
+	}
+
+	const swapToAndFrom = async (pool: UFarmPool, swapTo: string, swapFrom: string) => {
+		const receiptTo = await logBalanceSwapRetry(pool, swapTo, swapFrom)
+		console.log(`Block: ${receiptTo.blockNumber}`)
+
+		await customSetTimeout(15)
+
+		const receiptFrom = await logBalanceSwapRetry(pool, swapFrom, swapTo)
+		console.log(`Block: ${receiptFrom.blockNumber}`)
+		await customSetTimeout(15)
+
+	}
+
+	for (let i = 0; i < iterations; i++) {
+		console.log(`Iteration ${i + 1} from ${iterations}`)
+
+		await swapToAndFrom(pool1, usdc_addr, weth_addr)
+		console.log('Swapped USDC <=> WETH on pool 1')
+
+		await swapToAndFrom(pool2, usdc_addr, weth_addr)
+		console.log('Swapped USDC <=> WETH on pool 2\n')
+	}
+
+	// TODO: sell liquidity and buy it again
+}
+
+main().catch((error) => {
+	console.error(error)
+	process.exitCode = 1
+})