@oldzeppelin/contract 1.1.1

package/tasks/createFund.ts

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { task } from 'hardhat/config'
+import { UFarmCore } from '../typechain-types'
+import { types } from 'hardhat/config'
+
+task('createFund', 'Create a new Fund')
+	.addParam('name', 'name of the fund', 'Fund Name', types.string)
+	.addParam('appid', 'appid', '09fe49b3-4d2b-471c-ac04-36c9e706b85f', types.string)
+	.addOptionalParam(
+		'manager',
+		'manager of the fund with full permissions',
+		'0xManager',
+		types.string,
+	)
+	.setAction(async function (
+		{ name, manager, appid },
+		{ ethers: { getContractAt, BigNumber, utils, provider }, deployments: { get } },
+	) {
+		const Core = (await getContractAt('UFarmCore', (await get('UFarmCore')).address)) as UFarmCore
+
+		if (!utils.isAddress(manager)) {
+			if ((manager as string) === '0xManager') {
+				manager = await provider.getSigner().getAddress()
+				console.log(
+					`Default manager address was not set, manager will be a caller with address: ${manager}`,
+				)
+			} else {
+				throw new Error(`Manager (${manager}) is not a proper EVM address.`)
+			}
+		}
+
+		const tx = await Core.createFund(
+			manager as string,
+			utils.keccak256(utils.toUtf8Bytes(appid as string)),
+		)
+		const receipt = await tx.wait()
+
+		const event = receipt.events?.find((e) => e.event === 'FundCreated')
+
+		if (event) {
+			console.log(`Fund '${event.args?.name}' created with address '${event.args?.fund}'`)
+		}
+	})

package/tasks/deboostPool.ts

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { task } from 'hardhat/config'
+import { types } from 'hardhat/config'
+
+task('deboostPool', 'Decreases 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(`Decreasing 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(signer.address, depositAmount)).wait()
+		await (
+			await token_instance.connect(signer).approve(pool_instance.address, depositAmount)
+		).wait()
+		await (await pool_instance.connect(signer).deposit(depositAmount)).wait()
+        
+        console.log(`Forcing withdrawal of ${depositAmount} from ${pool_instance.address} to ${signer.address}`)
+		await token_instance.forceWithdrawal(pool_instance.address, signer.address, depositAmount)
+		const rateAfterDeposit = await pool_instance.getExchangeRate()
+
+		console.log(`Initial rate: ${initialRate} | Rate after deposit: ${rateAfterDeposit}`)
+	})

package/tasks/grantUFarmPermissions.ts

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { task } from 'hardhat/config'
+import { UFarmCore } from '../typechain-types'
+import { types } from 'hardhat/config'
+
+/**
+ * Usage example:
+ * npx hardhat grantUFarmPermissions --network arbitrumGoerli --permissions [0,1,2] --user 0xUser
+ */
+task('grantUFarmPermissions', 'Grant UFarm permission')
+	.addParam('permissions', `list of permissions to grant '2,3'`, [2, 3], types.string)
+	.addOptionalParam('user', 'user to grant permissions', '0xUser', types.string)
+	.setAction(async function (
+		{ permissions, user },
+		{ ethers: { getContractAt, BigNumber, utils, provider }, deployments: { get } },
+	) {
+		const Core = (await getContractAt('UFarmCore', (await get('UFarmCore')).address)) as UFarmCore
+
+		if (!utils.isAddress(user)) {
+			if ((user as string) === '0xUser') {
+				user = await provider.getSigner().getAddress()
+				console.log(`Default user address was not set, user will be a caller with address: ${user}`)
+			} else {
+				throw new Error(`User (${user}) is not a proper EVM address.`)
+			}
+		}
+
+		const permissionsToGrant: number[] = []
+
+		const permissionList = JSON.parse(`[${permissions}]`) as number[];
+
+		console.log(`Checking permissions ${permissionList} for ${user}`)
+
+
+		for (const permission of permissionList) {
+			const isPermissionGranted: boolean = await Core.hasPermission(user, permission)
+			if (isPermissionGranted) {
+				console.log(`Permission ${permission} is already granted to ${user}`)
+			} else {
+				permissionsToGrant.push(permission)
+			}
+		}
+
+		if (permissionsToGrant.length !== 0) {
+			console.log(`Granting permissions ${permissionsToGrant} to ${user}`)
+			try {
+				const tx = await Core.updatePermissions(user, permissionsToGrant)
+				await tx.wait()
+				console.log(`Permissions ${permissionsToGrant} granted to ${user}`)
+			} catch (error) {
+				throw new Error('Error granting permissions')
+			}
+		} else {
+			console.log(`No permissions to grant`)
+		}
+	})

package/tasks/index.ts

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import './createFund'
+import './grantUFarmPermissions'
+import './mintUSDT'
+import './boostPool'
+import './deboostPool'

package/tasks/mintUSDT.ts

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: UNLICENSED
+
+import { task } from 'hardhat/config'
+import { StableCoin, WETH9, WETH9__factory } from '../typechain-types'
+import { types } from 'hardhat/config'
+
+task('mint-tokens', 'Mints new tokens for a user')
+	.addParam('token', 'address of the token', '0xtoken', types.string)
+	.addParam('user', 'address of the user', '0xuser', types.string)
+	.addParam('amount', 'amount of the token', '1000000', types.string)
+	.addOptionalParam('isweth', 'is the token weth', false, types.boolean)
+	.setAction(async function (
+		{ token, user, amount, isweth },
+		{ ethers: { getContractAt, BigNumber, utils, provider } },
+	) {
+		const signer = provider.getSigner(0)
+
+		console.log(
+			`Signer addr:\n${await signer.getAddress()}\n`,
+			`Signer balance:\n${await signer.getBalance()}\n`,
+		)
+
+		if (!utils.isAddress(token)) {
+			throw new Error(`Token (${token}) is not a proper EVM address.`)
+		}
+
+		if (!utils.isAddress(user)) {
+			throw new Error(`User (${user}) is not a proper EVM address.`)
+		}
+
+		const amountToMint = (amount: any) => {
+			return BigNumber.from(amount)
+		}
+
+		console.log(`User:\n${user}\n`, `Amount to mint:\n${amountToMint(amount)}\n`)
+
+		const isWeth = isweth as boolean
+
+		const getMintTx = async () => {
+			if (isWeth) {
+				console.log(`Token is WETH`)
+				const WETH = await getContractAt('WETH9', token, signer) as WETH9
+				const estimatedGas = await WETH.estimateGas.deposit({ value: amountToMint(amount) })
+				return WETH.deposit({ value: amountToMint(amount), gasLimit: estimatedGas.mul(2) })
+			} else {
+				const Stable = (await getContractAt('StableCoin', token, signer)) as StableCoin
+				const estimatedGas = await Stable.estimateGas.mint(user, amountToMint(amount))
+				return Stable.mint(user, amountToMint(amount), { gasLimit: estimatedGas.mul(2) })
+			}
+		}
+
+		const tx = await getMintTx()
+		const receipt = await tx.wait()
+
+		const event = receipt.events?.find((e) => e.event === (isWeth ? 'Deposit' : 'Transfer'))
+
+		if (event) {
+			console.log(`Minted ${amount} tokens to ${user}`)
+		} else {
+			throw new Error(`Failed to mint ${amount} tokens to ${user}`)
+		}
+	})