@oldzeppelin/contract 1.1.1

package/deploy/43_deploy_fund_beacon.ts

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { getDeployerSigner, deployBeaconContract, _deployTags } from '../scripts/_deploy_helpers'
+
+const deployFund: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying UFarmFund...')
+
+	await deployBeaconContract(hre, 'UFarmFund', deployerSigner)
+
+	console.log('\n UFarmFund deployed!')
+}
+
+export default deployFund
+deployFund.dependencies = []
+deployFund.tags = _deployTags(['UFarmFund'])

package/deploy/4_deploy_tokens.ts

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { ArtifactData, DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	getPrefixedTokens,
+	deployContract,
+	isTestnet,
+	isPublicTestnet,
+	getDeployerSigner,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+
+const deployTokens: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)) {
+		console.log(`Skipping tokens deployment`)
+		return
+	}
+	const prefixedTokens = await getPrefixedTokens(hre)
+
+	console.log('Deploying tokens...')
+
+	const deployerSigner = await getDeployerSigner(hre)
+	const deployer = deployerSigner.address
+
+	for (const token of prefixedTokens) {
+		let args: any[] | undefined = undefined
+		let contract: string | ArtifactData | undefined = undefined
+
+		switch (token.rawName) {
+			case 'WETH':
+				contract = 'MockedWETH9'
+				break
+			case 'STETH':
+				if (isPublicTestnet(hre.network)) {
+					contract = 'StableCoin'
+					args = [token.name, token.symbol, token.decimals]
+				} else {
+					const steth_deployment = await hre.deployments.getOrNull('STETH')
+					if (!steth_deployment) throw new Error(`STETH deployment not found`)
+				}
+				break
+			case 'WSTETH':
+				if (isPublicTestnet(hre.network)) {
+					contract = 'StableCoin'
+					args = [token.name, token.symbol, token.decimals]
+				} else {
+					const wsteth_deployment = await hre.deployments.getOrNull('WSTETH')
+					if (!wsteth_deployment) throw new Error(`WSTETH deployment not found`)
+				}
+				break
+			default:
+				contract = 'StableCoin'
+				args = [token.name, token.symbol, token.decimals]
+				break
+		}
+
+		if (contract)
+			await deployContract(hre, {
+				deploymentName: token.rawName,
+				from: deployer,
+				args: args,
+				log: true,
+				contract: contract,
+				skipIfAlreadyDeployed: true,
+			})
+	}
+
+	console.log('Tokens deployed!')
+}
+
+
+
+export default deployTokens
+deployTokens.dependencies = _deployTags(['Lido'])
+deployTokens.tags = _deployTags(['Tokens'])

package/deploy/50_deploy_poolFactory.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	getDeployerSigner,
+	deployContract,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+
+const deployPoolFactory: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const ufarmCore_deployment = await hre.deployments.get('UFarmCore')
+	const pool_beacon_deployment = await hre.deployments.get('UFarmPool')
+	const poolAdmin_beacon_deployment = await hre.deployments.get('PoolAdmin')
+
+	console.log('\nDeploying PoolFactory...')
+
+	await deployContract(hre, {
+		deploymentName: 'PoolFactory',
+		from: deployerSigner.address,
+		args: [ufarmCore_deployment.address, pool_beacon_deployment.address, poolAdmin_beacon_deployment.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'PoolFactory',
+	})
+
+	console.log('\n PoolFactory deployed!')
+}
+
+export default deployPoolFactory
+deployPoolFactory.dependencies = _deployTags(['UFarmCore', 'UFarmPool', 'PoolAdmin'])
+deployPoolFactory.tags = _deployTags(['PoolFactory'])

package/deploy/51_deploy_fundFactory.ts

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { isTestnet, getDeployerSigner, deployContract, _deployTags } from '../scripts/_deploy_helpers'
+
+const deployFundFactory: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const ufarmCore_deployment = await hre.deployments.get('UFarmCore')
+	const ufarmFund_deployments = await hre.deployments.get('UFarmFund')
+
+	console.log('\nDeploying FundFactory...')
+
+	await deployContract(hre, {
+		deploymentName: 'FundFactory',
+		from: deployerSigner.address,
+		args: [ufarmCore_deployment.address, ufarmFund_deployments.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'FundFactory',
+	})
+
+	console.log('\n FundFactory deployed!')
+}
+
+export default deployFundFactory
+deployFundFactory.dependencies = _deployTags(['UFarmCore', 'UFarmPool', 'PoolAdmin','UFarmFund'])
+deployFundFactory.tags = _deployTags(['FundFactory'])

package/deploy/60_init_contracts.ts

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	isTestnet,
+	getDeployerSigner,
+	getInstanceFromDeployment,
+	retryOperation,
+	getPriceOracleContract,
+	_deployTags,
+	getNetworkType,
+} from '../scripts/_deploy_helpers'
+import { FundFactory, PoolFactory, PriceOracle, UFarmCore } from '../typechain-types'
+
+const initContracts: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const priceOracle_instance = (
+		getInstanceFromDeployment<PriceOracle>(hre, await hre.deployments.get('PriceOracle'))
+	).connect(deployerSigner)
+
+	const ufarmCore_instance = (
+		getInstanceFromDeployment<UFarmCore>(hre, await hre.deployments.get('UFarmCore'))
+	).connect(deployerSigner)
+
+	const fundFactory_instance = (
+		getInstanceFromDeployment<FundFactory>(hre, await hre.deployments.get('FundFactory'))
+	).connect(deployerSigner)
+
+	const poolFactory_instance = (
+		getInstanceFromDeployment<PoolFactory>(hre, await hre.deployments.get('PoolFactory'))
+	).connect(deployerSigner)
+
+	console.log('\nInitializing contracts...')
+
+	if ((await ufarmCore_instance.priceOracle()) !== priceOracle_instance.address) {
+		console.log('Initializing PriceOracle...')
+
+		const thisNetworkPriceOracle = getPriceOracleContract(hre.network)
+		
+		const args = [ufarmCore_instance.address].concat(
+			thisNetworkPriceOracle.args.map((arg) => Object.values(arg)[0]),
+		)
+		console.log('args:', args)
+
+		await retryOperation(async () => {
+			await hre.deployments.execute(
+				'PriceOracle',
+				{
+					from: deployerSigner.address,
+					log: true,
+				},
+				thisNetworkPriceOracle.initFunc,
+				...args,
+			)
+		}, 3)
+
+		console.log('PriceOracle initialized!')
+	} else {
+		console.log('PriceOracle already initialized!')
+	}
+
+	const [fundAddr, poolAddr, priceOracleAddr] = await Promise.all([
+		ufarmCore_instance.fundFactory(),
+		ufarmCore_instance.poolFactory(),
+		ufarmCore_instance.priceOracle(),
+	])
+
+	const AddressZero = hre.ethers.constants.AddressZero
+
+	// if any of that addresses is not set, we need to initialize UFarmCore
+	if (fundAddr === AddressZero || poolAddr === AddressZero || priceOracleAddr === AddressZero) {
+		console.log('Initializing UFarmCore...')
+
+		await retryOperation(async () => {
+			await hre.deployments.execute(
+				'UFarmCore',
+				{
+					from: deployerSigner.address,
+					log: true,
+				},
+				'__init__UFarmCore',
+				deployerSigner.address,
+				fundFactory_instance.address,
+				poolFactory_instance.address,
+				priceOracle_instance.address,
+			)
+		}, 3)
+
+		console.log('UFarmCore initialized!')
+	} else {
+		console.log('UFarmCore already initialized!')
+	}
+
+	console.log('\nAll contracts initialized!')
+}
+
+export default initContracts
+initContracts.dependencies = ['PriceOracle', 'UFarmCore', 'FundFactory', 'PoolFactory']
+initContracts.tags = _deployTags(['InitializeUFarm'])

package/deploy/61_whitelist_tokens.ts

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { _deployTags, whitelistTokensWithAggregator, isMainnet } from '../scripts/_deploy_helpers'
+import { AggregatorV2V3Interface, UFarmMockV3Aggregator } from '../typechain-types'
+
+const whitelistTokens: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (isMainnet(hre.network)) {
+		await whitelistTokensWithAggregator<AggregatorV2V3Interface>(hre)
+	} else {
+		await whitelistTokensWithAggregator<UFarmMockV3Aggregator>(hre)
+	}
+}
+
+export default whitelistTokens
+whitelistTokens.dependencies = _deployTags(['InitializeUFarm', 'MockedAggregators', 'WstETHOracle'])
+whitelistTokens.tags = _deployTags(['WhiteListTokens'])

package/deploy/70_deploy_uniV2Controller.ts

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	isTestnet,
+	getDeployerSigner,
+	getInstanceFromDeployment,
+	deployContract,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+import { UniswapV2Pair__factory } from '../typechain-types'
+import { getInitCodeHash } from '../test/_helpers'
+import { getInitCodeUniV2 } from '../scripts/_deploy_network_options'
+
+const deployUniV2Controller: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const uniV2Router_deployment = await hre.deployments.get('UniswapV2Router02')
+	const uniV2Factory_deployment = await hre.deployments.get('UniswapV2Factory')
+	const priceOracle_deployment = await hre.deployments.get('PriceOracle')
+
+	if (isTestnet(hre.network)) {
+		const init_code_hash = await getInitCodeHash(UniswapV2Pair__factory.bytecode)
+
+		console.log('\nDeploying UnoswapV2Controller...')
+
+		await deployContract(hre, {
+			deploymentName: 'UniV2Controller',
+			from: deployerSigner.address,
+			args: [
+				uniV2Factory_deployment.address,
+				uniV2Router_deployment.address,
+				priceOracle_deployment.address,
+				init_code_hash,
+			],
+			log: true,
+			skipIfAlreadyDeployed: true,
+			contract: 'UniswapV2ControllerUFarm', // only for testnet
+		})
+
+		console.log('UnoswapV2Controller deployed!')
+	} else {
+		console.log('\nDeploying UniswapV2Controller...')
+
+		const thisInitOptionV2 = getInitCodeUniV2(hre.network)
+
+		if (!thisInitOptionV2) {
+			throw new Error(`Init code not found for network: ${hre.network.name}`)
+		}
+
+		await deployContract(hre, {
+			deploymentName: 'UniV2Controller',
+			from: deployerSigner.address,
+			args: [
+				uniV2Factory_deployment.address,
+				uniV2Router_deployment.address,
+				priceOracle_deployment.address,
+				thisInitOptionV2.codeHash,
+			],
+			log: true,
+			skipIfAlreadyDeployed: true,
+			contract: thisInitOptionV2.controller,
+		})
+	}
+}
+
+export default deployUniV2Controller
+deployUniV2Controller.dependencies = _deployTags(['PrepareEnvARB', 'UniV2', 'PriceOracle', 'Tokens'])
+deployUniV2Controller.tags = _deployTags(['UniV2Controller'])

package/deploy/71_deploy_uniV3Controller.ts

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { isTestnet, getDeployerSigner, deployUpgradedContract, _deployTags } from '../scripts/_deploy_helpers'
+import { getInitCodeHash } from '../test/_helpers'
+import { UniswapV3Pool__factory } from '../typechain-types'
+import { getInitCodeUniV3 } from '../scripts/_deploy_network_options'
+
+const deployUniV3Controller: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const priceOracle_deployment = await hre.deployments.get('PriceOracle')
+	const uniV3Factory_deployment = await hre.deployments.get('UniswapV3Factory')
+	const swapRouter_deployment = await hre.deployments.get('SwapRouter')
+	const nfpm_deployment = await hre.deployments.get('NonfungiblePositionManager')
+
+	if (isTestnet(hre.network)) {
+		console.log('\nDeploying UnoswapV3Controller...')
+
+		await deployUpgradedContract(hre, {
+			deploymentName: 'UniV3Controller',
+			from: deployerSigner.address,
+			args: [
+				swapRouter_deployment.address,
+				uniV3Factory_deployment.address,
+				nfpm_deployment.address,
+				priceOracle_deployment.address,
+				await getInitCodeHash(UniswapV3Pool__factory.bytecode)
+			],
+			log: true,
+			skipIfAlreadyDeployed: true,
+			contract: 'UniswapV3ControllerUFarm', // only for testnet
+		})
+		console.log('UnoswapV3Controller deployed!')
+	} else {
+		console.log('\nDeploying UniswapV3Controller...')
+
+
+		const thisInitOptionV3 = getInitCodeUniV3(hre.network)
+
+		if (!thisInitOptionV3) {
+			throw new Error(`UniswapV3Controller deployment not supported on ${hre.network.name}`)
+		}
+
+		await deployUpgradedContract(hre, {
+			deploymentName: 'UniV3Controller',
+			from: deployerSigner.address,
+			args: [
+				swapRouter_deployment.address,
+				uniV3Factory_deployment.address,
+				nfpm_deployment.address,
+				priceOracle_deployment.address,
+				thisInitOptionV3.codeHash,
+			],
+			log: true,
+			skipIfAlreadyDeployed: true,
+			contract: thisInitOptionV3.controller,
+		})
+
+		console.log(`${thisInitOptionV3.controller} deployed!`)
+	}
+}
+
+export default deployUniV3Controller
+deployUniV3Controller.dependencies = _deployTags(['UniV3', 'PriceOracle'])
+deployUniV3Controller.tags = _deployTags(['UniV3Controller'])

package/deploy/72_deploy_oneInchController.ts

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { getDeployerSigner, _deployTags, deployUpgradedContract } from '../scripts/_deploy_helpers'
+
+const deployOneInchController: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const oneInchDeployment = await hre.deployments.get('AggregationRouterV5')
+
+	await deployUpgradedContract(hre, {
+		deploymentName: 'OneInchV5Controller',
+		from: deployerSigner.address,
+		args: [oneInchDeployment.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'OneInchV5Controller',
+		estimateGasExtra: 100000,
+	})
+}
+
+export default deployOneInchController
+deployOneInchController.dependencies = _deployTags(['OneInch'])
+deployOneInchController.tags = _deployTags(['OneInchV5Controller'])

package/deploy/79_whitelist_controllers.ts

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	_deployTags,
+	getDeployerSigner,
+	getInstanceFromDeployment,
+	getNewContractName,
+	retryOperation,
+} from '../scripts/_deploy_helpers'
+import { IController, UFarmCore } from '../typechain-types'
+
+const whitelistControllers: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const uniV2Controller_deployment = await hre.deployments.get('UniV2Controller')
+	const uniV3Controller_deployment = await hre.deployments.get('UniV3Controller')
+	const oneInchController_deployment = await hre.deployments.get('OneInchV5Controller')
+
+	const ufarmCore_deployment = await hre.deployments.get('UFarmCore')
+	const ufarmCore_instance = getInstanceFromDeployment<UFarmCore>(hre, ufarmCore_deployment)
+
+	console.log('\nWhitelisting controllers...')
+
+	const controllersToWhitelist: Record<string, { address: string; controllerName: string }> = {}
+	const controllersToUpdate: Record<string, { address: string; oldControllerName: string }> = {}
+
+	const whitelistedProtocols = await ufarmCore_instance.getWhitelistedProtocols()
+
+	for (const [controller, deployment] of Object.entries({
+		UniV2Controller: uniV2Controller_deployment,
+		UniV3Controller: uniV3Controller_deployment,
+		OneInchV5Controller: oneInchController_deployment,
+	})) {
+		const controllerInstance = getInstanceFromDeployment<IController>(hre, deployment)
+		const protocolName = await controllerInstance.PROTOCOL()
+
+		if (!whitelistedProtocols.includes(protocolName)) {
+			console.log(`Whitelisting ${controller} of protocol ${protocolName} ...`)
+			controllersToWhitelist[protocolName] = {
+				address: deployment.address,
+				controllerName: controller,
+			}
+		} else {
+			const newlyDeployedController = await hre.deployments.getOrNull(
+				getNewContractName(controller),
+			)
+			if (newlyDeployedController) {
+				console.log(
+					`Updating controller ${controller} of protocol ${protocolName} to newly deployed ${newlyDeployedController.address} ...`,
+				)
+				controllersToUpdate[protocolName] = {
+					address: newlyDeployedController.address,
+					oldControllerName: controller,
+				}
+			} else
+				console.log(
+					`Controller ${controller} of protocol ${protocolName} already whitelisted, no need to update`,
+				)
+		}
+	}
+
+	if (Object.keys(controllersToWhitelist).length === 0) {
+		console.log(`All controllers already whitelisted!`)
+	} else {
+		console.log(`Whitelisting controllers ...`)
+		await retryOperation(async () => {
+			await hre.deployments.execute(
+				'UFarmCore',
+				{
+					from: deployerSigner.address,
+					log: true,
+				},
+				'whitelistProtocolsWithControllers',
+
+				Array.from(Object.keys(controllersToWhitelist)),
+				Array.from(Object.values(controllersToWhitelist)).map((controller) => controller.address),
+			)
+		}, 3)
+	}
+
+	if (Object.keys(controllersToUpdate).length === 0) {
+		console.log(`All controllers already updated!`)
+	} else {
+		console.log(`Updating controllers ...`)
+		await retryOperation(async () => {
+			await hre.deployments.execute(
+				'UFarmCore',
+				{
+					from: deployerSigner.address,
+					log: true,
+				},
+				'updateProtocolsControllers',
+
+				Array.from(Object.keys(controllersToUpdate)),
+				Array.from(Object.values(controllersToUpdate)).map((controller) => controller.address),
+			)
+		}, 3)
+
+		// update new controller names
+		for (const [protocolName, controller] of Object.entries(controllersToUpdate)) {
+			const newControllerName = getNewContractName(controller.oldControllerName)
+			const newControllerDeployment = await hre.deployments.get(newControllerName)
+			await hre.deployments.delete(controller.oldControllerName)
+			await hre.deployments.save(controller.oldControllerName, newControllerDeployment)
+			await hre.deployments.delete(newControllerName)
+
+			console.log(
+				`Replaced controller deployment of ${controller.oldControllerName} for protocol ${protocolName} to newly deployed ${newControllerDeployment.address} ...`,
+			)
+		}
+
+		console.log('Controllers updated!')
+	}
+}
+
+export default whitelistControllers
+whitelistControllers.dependencies = _deployTags([
+	'InitializeUFarm',
+	'UniV2Controller',
+	'UniV3Controller',
+	'OneInchV5Controller',
+])
+whitelistControllers.tags = _deployTags(['WhitelistControllers'])

package/deploy/ufarm/arbitrum/1_prepare_env.ts

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { ArtifactData, DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	isTestnet,
+	getDeployerSigner,
+	getStaticConfig,
+	trySaveDeployment,
+	mockedAggregatorName,
+	_deployTags,
+} from '../../../scripts/_deploy_helpers'
+
+const prepareEnv: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (isTestnet(hre.network)) {
+		console.log('Skipping tokens parsing on testnet')
+		return
+	}
+	const deployerSigner = await getDeployerSigner(hre)
+
+	// prepare tokens
+
+	const staticConfig = await getStaticConfig()
+
+	const pendingTokens = staticConfig.tokens
+
+	for (const token of pendingTokens) {
+		const tokenRawName = token.ticker.toUpperCase()
+
+		await trySaveDeployment(
+			tokenRawName,
+			{
+				from: deployerSigner.address,
+				address: token.address_chain_42161,
+				contract: '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol:IERC20Metadata',
+				deploymentName: tokenRawName,
+			},
+			hre,
+		)
+	}
+
+	const pendingAggregators = staticConfig.oracles
+
+	for (const oracle of pendingAggregators) {
+		const oracleRawName = mockedAggregatorName(oracle.ticker, hre.network)
+
+		await trySaveDeployment(
+			oracleRawName,
+			{
+				from: deployerSigner.address,
+				address: oracle.address_chain_42161,
+				contract: 'AggregatorV2V3Interface',
+				deploymentName: oracleRawName,
+			},
+			hre,
+		)
+	}
+	
+	const pendingProtocols = staticConfig.protocols
+
+	for (const protocol of pendingProtocols) {
+		const protocolRawName = protocol.name
+
+		await trySaveDeployment(
+			protocolRawName,
+			{
+				from: deployerSigner.address,
+				address: protocol.address_chain_42161,
+				contract: protocol.abi,
+				deploymentName: protocolRawName,
+			},
+			hre,
+		)
+	}
+}
+
+// export default prepareEnv
+prepareEnv.dependencies = _deployTags([])
+prepareEnv.tags = _deployTags(['PrepareEnvARB'])
+export default prepareEnv
+
+