@oldzeppelin/contract 1.1.1

package/scripts/post-deploy.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [ -z "$1" ]
+then
+  echo "Error: no path to the directory for copying artifacts was specified."
+  exit 1
+fi
+
+OZ_SOURCE_DIR="./.openzeppelin" 
+ARTIFACTS_SOURCE_DIR="./artifacts"
+DEPLOYMENTS_SOURCE_DIR="./deployments"
+DEST_PATH="$1"
+
+mkdir -p $DEST_PATH
+
+# Copy the entire folders into the deployment-artifacts
+cp -r ./.openzeppelin "$DEST_PATH"
+cp -r ./artifacts "$DEST_PATH"
+cp -r ./deployments "$DEST_PATH"
+
+# Copy all deployments*.json files from the current directory into the combined_folder
+cp deployments*.json "$DEST_PATH"
+
+echo "Folders copied successfully into $DEST_PATH"

package/scripts/setUniV2Rate.ts

@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { ethers } from 'hardhat'
+import * as dotenv from 'dotenv'
+import hre from 'hardhat'
+import fs from 'fs'
+import { MintableToken, setExchangeRate } from '../test/_helpers'
+import { UniswapV2Factory } from '../typechain-types'
+import { BigNumber, BigNumberish } from 'ethers'
+import { customSetTimeout, getInstanceFromDeployment } from './_deploy_helpers'
+
+dotenv.config()
+
+type ContractInfo = {
+	address: string
+	abi: any[]
+}
+
+type Deployments = {
+	name: string
+	chainId: string
+	contracts: {
+		[contractName in RequiredContracts]: ContractInfo
+	}
+}
+
+const StableCoins = [`USDT`, `USDC`, `DAI`]
+const EthersCoins = [`WETH`, `STETH`, `WSTETH`]
+const IgnoringCoins: string[] = []
+const CommonCoins = [`WBTC`, `MKR`]
+const AllCoins = [...StableCoins, ...EthersCoins, ...IgnoringCoins, ...CommonCoins]
+
+type RequiredContracts = (typeof AllCoins)[number] | 'UFarmCore' | 'TestFund' | 'UniswapV2Factory'
+
+type Rate = {
+	rawName0: (typeof AllCoins)[number]
+	rawName1: (typeof AllCoins)[number]
+	amount0: BigNumberish
+	amount1: BigNumberish
+}
+
+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%
+}
+
+const interval = 50 * 60 // 50 minutes in seconds
+const day = 24 * 60 * 60 // 24 hours in seconds
+
+async function main() {
+	async function getCurrentPrice(
+		tokenA: MintableToken,
+		tokenB: MintableToken,
+		factory: UniswapV2Factory,
+	) {
+		const pairAddress = await factory.getPair(tokenA.address, tokenB.address)
+		const pair = await ethers.getContractAt('UniswapV2Pair', pairAddress, deployer)
+		const [reserve0, reserve1] = await pair.getReserves()
+		return reserve0
+			.mul(10n ** BigInt(await tokenB.decimals()))
+			.div(reserve1)
+			.mul(997)
+			.div(1000)
+	}
+	function addSinMultiplier(rate: BigNumber, iteration: number): BigNumber {
+		let toAdd = rate.mul(interval).div(day).div(10) // 10% of daily rate
+		const sinMultiplier = Math.floor(Math.sin(iteration) * 100) + 30
+		return rate.add(toAdd.mul(sinMultiplier).div(10))
+	}
+
+	console.log('Starting pool data script...')
+	const [deployer] = await ethers.getSigners()
+
+	const deploymentsConfig: Deployments = JSON.parse(
+		fs.readFileSync(hre.deploymentsJsonPath, 'utf8'),
+	)
+	const deployConfigRates = hre.testnetDeployConfig.initialRates as Rate[]
+
+	const deployedContracts = deploymentsConfig.contracts
+
+	const [uniV2factory_instance] = await Promise.all([
+		ethers.getContractAt('UniswapV2Factory', deployedContracts.UniswapV2Factory.address, deployer),
+	])
+
+	for (let iteration = 0; iteration < 15000000; iteration++) {
+		// let thisIterationETHUSDprice = BigNumber.from(0)
+		// let thisIterationUSDdecimals = 0
+
+		for (let i = 0; i < deployConfigRates.length; i++) {
+			const thisRateConfig = deployConfigRates[i]
+			let newRate = BigNumber.from(0)
+
+			let [amount0, amount1] = [
+				BigNumber.from(thisRateConfig.amount0),
+				BigNumber.from(thisRateConfig.amount1),
+			]
+			const pairName = `${thisRateConfig.rawName0}/${thisRateConfig.rawName1}`
+
+			let [token0, token1] = [
+				await getInstanceFromDeployment<MintableToken>(
+					hre,
+					deploymentsConfig.contracts[thisRateConfig.rawName0],
+				),
+				await getInstanceFromDeployment<MintableToken>(
+					hre,
+					deploymentsConfig.contracts[thisRateConfig.rawName1],
+				),
+			]
+
+			if (!token0 || !token1) {
+				throw new Error('Unknown token in pair: ' + pairName)
+			}
+
+			const isExist = await isUniswapV2PairExist(
+				uniV2factory_instance,
+				token0.address,
+				token1.address,
+			)
+			if (!isExist) {
+				console.log(`Pair ${pairName} not exist, skipping...`)
+				continue
+			}
+
+			const uniV2pool_addr = await uniV2factory_instance.getPair(token0.address, token1.address)
+			let [decimals0, decimals1] = [await token0.decimals(), await token1.decimals()]
+
+			{
+				const isStable = {
+					a: StableCoins.includes(thisRateConfig.rawName0),
+					b: StableCoins.includes(thisRateConfig.rawName1),
+				}
+
+				if (isStable.a && isStable.b) {
+					console.log(
+						`Ignoring pair ${thisRateConfig.rawName0}/${thisRateConfig.rawName1} because of stable coins`,
+					)
+					continue
+				}
+
+				const isEthers = {
+					a: EthersCoins.includes(thisRateConfig.rawName0),
+					b: EthersCoins.includes(thisRateConfig.rawName1),
+				}
+
+				if (isEthers.a && isEthers.b) {
+					console.log(
+						`Ignoring pair ${thisRateConfig.rawName0}/${thisRateConfig.rawName1} because of ethers coins`,
+					)
+					continue
+				}
+
+				if ((isEthers.a && isStable.b) || (isEthers.b && isStable.a)) {
+					const stableA_etherB = isEthers.a && isStable.b
+				}
+
+				const isCommon = {
+					a: CommonCoins.includes(thisRateConfig.rawName0),
+					b: CommonCoins.includes(thisRateConfig.rawName1),
+				}
+
+				const isIgnoring = {
+					a: IgnoringCoins.includes(thisRateConfig.rawName0),
+					b: IgnoringCoins.includes(thisRateConfig.rawName1),
+				}
+
+				if (isIgnoring.a || isIgnoring.b) {
+					console.log(
+						`Ignoring pair ${thisRateConfig.rawName0}/${
+							thisRateConfig.rawName1
+						} because of ignoring coin (${
+							isIgnoring.a ? thisRateConfig.rawName0 : thisRateConfig.rawName1
+						})`,
+					)
+					continue
+				}
+			}
+
+			console.log(`\n\nRate: ${JSON.stringify(thisRateConfig)}`)
+
+			const uniV2pool_instance = await ethers.getContractAt(
+				'UniswapV2Pair',
+				uniV2pool_addr,
+				deployer,
+			)
+
+			const pairToken0 = await uniV2pool_instance.token0()
+			const isReveresed = pairToken0 === token1.address
+
+			let [reserve0, reserve1] = await uniV2pool_instance.getReserves()
+			if (isReveresed) {
+				;[reserve0, reserve1] = [reserve1, reserve0]
+			}
+
+			let originalRate = amount1.mul(10n ** BigInt(decimals0)).div(amount0)
+			let actualRate = reserve1.mul(10n ** BigInt(decimals0)).div(reserve0)
+			let reversedRate = reserve0.mul(10n ** BigInt(decimals1)).div(reserve1)
+
+			console.log(
+				`Original rate: ${originalRate.toString()}\nActual rate: ${actualRate.toString()}\nReversed actual rate: ${reversedRate.toString()}`,
+			)
+
+			if (newRate.isZero()) {
+				newRate = addSinMultiplier(actualRate, iteration)
+			}
+			let newRateRevesed = BigNumber.from(10n ** BigInt(decimals0 + decimals1) / newRate.toBigInt())
+
+			console.log(`New rate: ${newRate.toString()}, reversed: ${newRateRevesed}`)
+
+			await customSetTimeout(3)
+
+			console.log(
+				`token0: ${token0.address}\ntoken1: ${
+					token1.address
+				}\nnewRate: ${newRate.toString()}\ndeployer: ${deployer.address}\nuniV2factory_instance: ${
+					uniV2factory_instance.address
+				}`,
+			)
+
+			await setExchangeRate(token0, token1, newRateRevesed, deployer, uniV2factory_instance)
+			await customSetTimeout(3)
+
+			const rateAfterChanging = await getCurrentPrice(token0, token1, uniV2factory_instance)
+
+			console.log(`Rate after changing: ${rateAfterChanging.toString()}\n`)
+		}
+
+		console.log(`Iteration ${iteration} finished!\n\n\n`)
+		await customSetTimeout(1) // 50 minutes
+	}
+
+	console.log('Pool data script done!')
+
+	process.exit(0)
+}
+
+main().catch((error) => {
+	console.error(error)
+	process.exitCode = 1
+})

package/scripts/swapOneInchV5.ts

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumber } from 'ethers'
+import { UFarmPool, StableCoin } from '../typechain-types'
+import {
+	ISwapResponse,
+	constants,
+	encodePoolOneInchSwap,
+	oneInchCustomUnoswapTo,
+} from '../test/_helpers'
+import { oneinchETHConstants } from '../test/_oneInchTestData'
+
+async function main() {
+	const {
+		pool,
+		tokenin,
+		tokenout,
+		amountin,
+		amountoutmin,
+		deadline,
+		oneInchAddr,
+		uniswapV2Router,
+		uniswapV2Factory,
+	} = {
+		pool: '0x7f9B0a701882Dc9c904517533e27772905275112',
+		tokenin: '0xd71fe004d84b10FbD161838F87A94f2327A315a1',
+		tokenout: '0xeF8DF16e4BAe9582393Fd96099ed670526F09a8D',
+		amountin: '1000000',
+		amountoutmin: '1',
+		deadline: Math.floor(Date.now() / 100 + 100).toString(),
+		oneInchAddr: '0x001C073d1ed78a0aADc31f2D320300aE30D1a085', // Double check this address
+		uniswapV2Router: '0xA37Fc726C2acc26a5807F32a40f7D2Fe7540F4cb',
+		uniswapV2Factory: '0x2a973622751ce6Ae37b3567c328a78BC3A59A050',
+	}
+	console.log(deadline)
+
+	const Pool = (await hre.ethers.getContractAt('UFarmPool', pool)) as UFarmPool
+
+	const [tokenInstanceIn, tokenInstanceOut] = [
+		(await hre.ethers.getContractAt('StableCoin', tokenin)) as StableCoin,
+		(await hre.ethers.getContractAt('StableCoin', tokenout)) as StableCoin,
+	]
+
+	const [balanceInBefore, balanceOutBefore] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(`Swapping ${amountin} ${tokenin} for at least ${amountoutmin} ${tokenout} on ${pool}`)
+
+	const OneInchResponse = oneinchETHConstants.swap.usdt100_weth.response
+
+	const injectedOneInchResponse = await oneInchCustomUnoswapTo(
+		// OneInchResponse.request as ISwapRequest,
+		OneInchResponse as ISwapResponse,
+		oneInchAddr,
+		amountin,
+		Pool.address,
+		[tokenInstanceIn.address, tokenInstanceOut.address],
+		uniswapV2Router,
+		uniswapV2Factory,
+	)
+
+	const oneInchSwapTxData = encodePoolOneInchSwap(injectedOneInchResponse.tx.data)
+
+	const tx = await Pool.protocolAction(
+		constants.UFarm.prtocols.OneInchProtocolString,
+		oneInchSwapTxData,
+	)
+	const receipt = await tx.wait()
+
+	const [balanceInAfter, balanceOutAfter] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(
+		`Swapped with tx hash: ${receipt.transactionHash}\nSpent ${balanceInBefore.sub(
+			balanceInAfter,
+		)} ${await tokenInstanceIn.symbol()} and received ${balanceOutAfter.sub(
+			balanceOutBefore,
+		)} ${await tokenInstanceOut.symbol()}`,
+	)
+
+	console.log('Swap operation complete.')
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})

package/scripts/swapUniswapV2.ts

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumber } from 'ethers'
+import { UFarmPool, StableCoin } from '../typechain-types'
+import { constants, encodePoolSwapDataUniswapV2 } from '../test/_helpers'
+
+async function main() {
+	const { pool, tokenin, tokenout, amountin, amountoutmin, deadline } = {
+		pool: '0x7f9B0a701882Dc9c904517533e27772905275112',
+		tokenin: '0xd71fe004d84b10FbD161838F87A94f2327A315a1',
+		tokenout: '0xeF8DF16e4BAe9582393Fd96099ed670526F09a8D',
+		amountin: '1000000',
+		amountoutmin: '1',
+		deadline: Math.floor(Date.now() / 100 + 100).toString(),
+	}
+	console.log(deadline)
+
+	const [amountInB, amountOutMinB] = [BigNumber.from(amountin), BigNumber.from(amountoutmin)]
+
+	const Pool = (await hre.ethers.getContractAt('UFarmPool', pool)) as UFarmPool
+
+	const [tokenInstanceIn, tokenInstanceOut] = [
+		(await hre.ethers.getContractAt('StableCoin', tokenin)) as StableCoin,
+		(await hre.ethers.getContractAt('StableCoin', tokenout)) as StableCoin,
+	]
+
+	const [balanceInBefore, balanceOutBefore] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(`Swapping ${amountin} ${tokenin} for at least ${amountoutmin} ${tokenout} on ${pool}`)
+
+	const tx = await Pool.protocolAction(
+		constants.UFarm.prtocols.UniswapV2ProtocolString,
+		encodePoolSwapDataUniswapV2(amountInB, amountOutMinB, deadline, [
+			tokenInstanceIn.address,
+			tokenInstanceOut.address,
+		]),
+	)
+	const receipt = await tx.wait()
+
+	const [balanceInAfter, balanceOutAfter] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(
+		`Swapped with tx hash: ${receipt.transactionHash}\nSpent ${balanceInBefore.sub(
+			balanceInAfter,
+		)} ${await tokenInstanceIn.symbol()} and received ${balanceOutAfter.sub(
+			balanceOutBefore,
+		)} ${await tokenInstanceOut.symbol()}`,
+	)
+
+	console.log('Swap operation complete.')
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})

package/scripts/swapUniswapV3.ts

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import hre from 'hardhat'
+import { BigNumber } from 'ethers'
+import { UFarmPool, StableCoin } from '../typechain-types'
+import { constants, encodePoolSwapUniV3SingleHopExactInput } from '../test/_helpers'
+
+async function main() {
+	const { pool, tokenin, tokenout, amountin, amountoutmin, deadline } = {
+		pool: '0x7f9B0a701882Dc9c904517533e27772905275112',
+		tokenin: '0xd71fe004d84b10FbD161838F87A94f2327A315a1',
+		tokenout: '0xeF8DF16e4BAe9582393Fd96099ed670526F09a8D',
+		amountin: '1000000',
+		amountoutmin: '1',
+		deadline: Math.floor(Date.now() / 100 + 100).toString(),
+	}
+	console.log(deadline)
+
+	const [amountInB, amountOutMinB] = [BigNumber.from(amountin), BigNumber.from(amountoutmin)]
+
+	const Pool = (await hre.ethers.getContractAt('UFarmPool', pool)) as UFarmPool
+
+	const [tokenInstanceIn, tokenInstanceOut] = [
+		(await hre.ethers.getContractAt('StableCoin', tokenin)) as StableCoin,
+		(await hre.ethers.getContractAt('StableCoin', tokenout)) as StableCoin,
+	]
+
+	const [balanceInBefore, balanceOutBefore] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(`Swapping ${amountin} ${tokenin} for at least ${amountoutmin} ${tokenout} on ${pool}`)
+
+	const tx = await Pool.protocolAction(
+		constants.UFarm.prtocols.UniswapV3ProtocolString,
+		encodePoolSwapUniV3SingleHopExactInput(
+            tokenInstanceIn.address,
+            tokenInstanceOut.address,
+            3000,
+            Pool.address,
+            deadline,
+            amountInB,
+            amountOutMinB,
+            constants.UniV3.MIN_SQRT_RATIO
+        )
+	)
+	const receipt = await tx.wait()
+
+	const [balanceInAfter, balanceOutAfter] = await Promise.all([
+		tokenInstanceIn.balanceOf(Pool.address),
+		tokenInstanceOut.balanceOf(Pool.address),
+	])
+
+	console.log(
+		`Swapped with tx hash: ${receipt.transactionHash}\nSpent ${balanceInBefore.sub(
+			balanceInAfter,
+		)} ${await tokenInstanceIn.symbol()} and received ${balanceOutAfter.sub(
+			balanceOutBefore,
+		)} ${await tokenInstanceOut.symbol()}`,
+	)
+
+	console.log('Swap operation complete.')
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})

package/scripts/test.ts

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { ethers } from 'hardhat'
+import hre from 'hardhat'
+import {
+	MintableToken,
+	_prepareInvite,
+	_signWithdrawRequest,
+	bitsToBigNumber,
+	constants,
+	encodePoolAddLiqudityDataAsIsUniswapV2,
+	encodePoolAddLiqudityDataUniswapV2,
+	encodePoolSwapDataUniswapV2,
+	get1InchResult,
+	getBlockchainTimestamp,
+	getEventFromTx,
+	mintAndCreatePairUniV2,
+	mintAndDeposit,
+	prepareWithdrawRequest,
+} from '../test/_helpers'
+import {
+	IERC20,
+	IERC20Metadata,
+	PoolAdmin,
+	PriceOracle,
+	StableCoin,
+	UFarmCore,
+	UFarmFund,
+	UFarmPool,
+	UniswapV2Factory,
+	UniswapV2Factory__factory,
+	UniswapV2Pair,
+	UniswapV2Pair__factory,
+	UniswapV2Router02,
+	UnoswapV2Controller,
+} from '../typechain-types'
+
+import { BigNumber, BigNumberish, Contract } from 'ethers'
+import { customSetTimeout, getInstanceFromDeployment, retryOperation } from './_deploy_helpers'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
+
+async function main() {
+	console.log('Starting')
+	const { deployer, fundOwner } = await hre.getNamedAccounts()
+
+	const USDCaddr = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'
+	const USDTaddr = '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9'
+	const DOLAaddr = '0x6a7661795c374c0bfc635934efaddff3a7ee23b6'
+
+	const response = await get1InchResult(USDTaddr, DOLAaddr, BigNumber.from(10).pow(6))
+
+	console.log(`1inch response: ${JSON.stringify(response, null, 2)}`)
+
+	console.log('END OF SCRIPT')
+	process.exit(0)
+}
+
+main().catch((error) => {
+	console.error(error)
+	process.exitCode = 1
+})

package/scripts/typings-copy-artifacts.ts

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import fs from 'fs'
+import path from 'path'
+
+const sourceDirectories = [
+	'./artifacts/contracts/main/contracts',
+	'./artifacts/contracts/test/UniswapV3/@uniswap/v3-core/contracts/UniswapV3Pool.sol',
+    './artifacts/contracts/test/UniswapV3/@uniswap/v3-periphery/contracts/SwapRouter.sol',
+    './artifacts/contracts/test/UniswapV3/@uniswap/v3-periphery/contracts/NonfungiblePositionManager.sol',
+    './artifacts/contracts/test/UniswapV3/@uniswap/v3-periphery/contracts/lens/QuoterV2.sol',
+    './artifacts/contracts/test/UniswapV3/@uniswap/v3-core/contracts/UniswapV3Factory.sol',
+]
+const targetDirectory = './ufarm-evm-typings/build/artifacts'
+
+// Ensure target directory exists or create it
+if (!fs.existsSync(targetDirectory)) {
+	fs.mkdirSync(targetDirectory, { recursive: true })
+}
+
+// Read all subdirectories inside the source directory
+for (const sourceDirectory of sourceDirectories) {
+	if (!fs.existsSync(sourceDirectory)) {
+		console.warn(`Skipping source directory ${sourceDirectory}`)
+		continue
+	}
+
+	const solDirs = getAllSolFolders(sourceDirectory)
+
+	solDirs.forEach((contractDir) => {
+		const contractName = contractDir.split('.sol')[0].split('/').pop()
+
+		if (contractName) {
+			const rootContractDir = contractDir.split('.sol')[0].slice(0, -contractName.length)
+
+			const sourceFile = path.join(contractDir, contractName + '.json')
+
+			const isInterface = contractName[0] == 'I' && contractName[1] == contractName[1].toUpperCase()
+			if (isInterface) {
+				const nonInterfaceSourceDir = path.join(
+					rootContractDir,
+					contractName.slice(1) + '.sol',
+				)
+
+                if (fs.existsSync(nonInterfaceSourceDir) && solDirs.includes(nonInterfaceSourceDir)) {
+                    console.log(`Skipping interface of ${contractName} in favor of ${nonInterfaceSourceDir}`)
+                    return
+                }
+			}
+
+			// Skip if file doesn't exist
+			if (!fs.existsSync(sourceFile)) {
+				console.warn(`Skipping ${sourceFile}`)
+				return
+			}
+			const targetFile = path.join(targetDirectory, '/', contractName + '.json')
+			console.log(`Copying ${sourceFile} to ${targetFile}`)
+			fs.copyFileSync(sourceFile, targetFile)
+		}
+	})
+}
+function getAllSolFolders(dir: string, solFolders: string[] = []): string[] {
+	if (dir.endsWith('.sol')) {
+		solFolders.push(dir)
+	}
+	const files = fs.readdirSync(dir)
+
+	for (const file of files) {
+		const filePath = path.join(dir, file)
+		const stat = fs.statSync(filePath)
+
+		if (stat.isDirectory()) {
+			getAllSolFolders(filePath, solFolders)
+		} else if (file.endsWith('.sol')) {
+			const folder = path.dirname(filePath)
+			if (!solFolders.includes(folder)) {
+				solFolders.push(folder)
+			}
+		}
+	}
+
+	return solFolders
+}

package/tasks/boostPool.ts

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { task } from 'hardhat/config'
+import { types } from 'hardhat/config'
+
+task('boostPool', 'Increases exchange rate of pool in testnet')
+	.addParam('pool', 'address of the pool', '0xPool', types.string)
+	.setAction(async function (taskArgs, hre) {
+		if (!hre.ethers.utils.isAddress(taskArgs.pool)) {
+			if ((taskArgs.pool as string) === '0xPool') {
+				console.log(
+					`Default manager address was not set, manager will be a caller with address: ${taskArgs.pool}`,
+				)
+			} else {
+				throw new Error(`Manager (${taskArgs.pool}) is not a proper EVM address.`)
+			}
+		}
+		const [signer] = await hre.ethers.getSigners()
+		console.log(
+			`Signer addr:\n${await signer.getAddress()}\n`,
+			`Signer balance:\n${await signer.getBalance()}\n`,
+		)
+
+		const pool_instance = await hre.ethers.getContractAt('UFarmPool', taskArgs.pool)
+		const valueToken = await pool_instance.valueToken()
+		const token_instance = await hre.ethers.getContractAt('StableCoin', valueToken)
+
+		console.log(`Increasing pool rate(${pool_instance.address})`)
+
+        const initialTotalCost = await pool_instance.getTotalCost()
+        const initialRate = await pool_instance.getExchangeRate()
+
+        const ONE_HUNDRED_BUCKS = hre.ethers.utils.parseUnits('100', 6)
+        const depositAmount = initialTotalCost.gt(ONE_HUNDRED_BUCKS) ? initialTotalCost.div(5) : ONE_HUNDRED_BUCKS
+		await (await token_instance.mint(pool_instance.address, depositAmount)).wait()
+		const rateAfterDeposit = await pool_instance.getExchangeRate()
+
+		console.log(`Initial rate: ${initialRate} | Rate after deposit: ${rateAfterDeposit}`)
+	})