@oldzeppelin/contract 1.1.1

package/deploy/22_deploy_mocked_aggregators.ts

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction, Deployment } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	deployContract,
+	isTestnet,
+	getTokenDeployments,
+	getInstanceFromDeployment,
+	mockedAggregatorName,
+	getDeployerSigner,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+import { StableCoin, UniswapV2Router02 } from '../typechain-types'
+
+const deployMockedAggregators: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)) {
+		console.log(`Skipping Mocked Aggregators deployment`)
+		return
+	}
+
+	const tokenDeployments = await getTokenDeployments(hre)
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const usdt_instance = getInstanceFromDeployment<StableCoin>(hre, tokenDeployments.USDT)
+
+	const uniswapV2Router_deployment = await hre.deployments.get('UniswapV2Router02')
+	const uniswapV2Router_instance = getInstanceFromDeployment<UniswapV2Router02>(
+		hre,
+		uniswapV2Router_deployment,
+	)
+
+	console.log('\nDeploying Mocked ChainLink Aggregators...')
+
+	async function deployMockedAggregator(
+		token: string,
+		tokenDeployment: Deployment,
+		args: any[] = [
+			8,
+			uniswapV2Router_instance.address,
+			tokenDeployment.address,
+			usdt_instance.address,
+		],
+	) {
+		const mockedAggregator = mockedAggregatorName(token, hre.network)
+		console.log(`Deploying ${mockedAggregator} ...`)
+		return await deployContract(hre, {
+			deploymentName: mockedAggregator,
+			from: deployerSigner.address,
+			args: args,
+			log: true,
+			skipIfAlreadyDeployed: true,
+			contract: 'UFarmMockV3Aggregator',
+		})
+	}
+
+	async function getStETHOracleOrDeploy(): Promise<{
+		stETHUSD: Deployment
+		wstETHstETH: Deployment
+	}> {
+		const steth_oracle_deployment = await hre.deployments.getOrNull(
+			mockedAggregatorName('STETH', hre.network),
+		)
+		const lido_oracle_deployment = await hre.deployments.getOrNull(
+			'LidoRateOracle'
+		)
+
+		if (!steth_oracle_deployment || !lido_oracle_deployment) {
+			const steth_deployment = tokenDeployments.STETH
+			const wsteth_deployment = tokenDeployments.WSTETH
+
+			const stETHUSD = await deployMockedAggregator('STETH', steth_deployment, [
+				18,
+				uniswapV2Router_instance.address,
+				steth_deployment.address,
+				usdt_instance.address,
+			])
+			const wstETHstETH = await deployContract(hre, {
+				deploymentName: 'LidoRateOracle',
+				from: deployerSigner.address,
+				args: [wsteth_deployment.address],
+				log: true,
+				skipIfAlreadyDeployed: true,
+				contract: 'MockV3wstETHstETHAgg',
+			})
+			return {
+				stETHUSD,
+				wstETHstETH,
+			}
+		} else {
+			return {
+				stETHUSD: steth_oracle_deployment,
+				wstETHstETH: lido_oracle_deployment,
+			}
+		}
+	}
+
+	console.log(`AllTokens: ${Object.keys(tokenDeployments)}`)
+
+	for (const [token, deployment] of Object.entries(tokenDeployments)) {
+		if (token === 'STETH') {
+			console.log('Skipping STETH Aggregator')
+			continue
+		}
+
+		const aggregatorName = mockedAggregatorName(token, hre.network)
+
+		console.log(`Deploying ${aggregatorName} ...`)
+
+		if (token === 'WSTETH') {
+			// Check for STETH oracle
+			const steth_oracle_deployment = await getStETHOracleOrDeploy()
+		} else {
+			await deployMockedAggregator(token, deployment)
+		}
+	}
+
+	console.log('\nMocked ChainLink Aggregators deployed!')
+}
+
+export default deployMockedAggregators
+deployMockedAggregators.dependencies = _deployTags(['UniV2Pairs','Lido'])
+deployMockedAggregators.tags = _deployTags(['MockedAggregators'])

package/deploy/22_deploy_wsteth_oracle.ts

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	getDeployerSigner,
+	mockedAggregatorName,
+	_deployTags,
+	deployUpgradedContract,
+	retryOperation,
+	replaceUpdatedContract,
+} from '../scripts/_deploy_helpers'
+
+const deployWstETHOracle: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying WstETHOracle...')
+
+	const wsteth_deployment = await hre.deployments.get('WSTETH')
+	const stethUSD_oracle_deployment = await hre.deployments.get(
+		mockedAggregatorName('STETH', hre.network),
+	)
+	const LidoRateOracle = await hre.deployments.get('LidoRateOracle')
+
+	const wstethOracleDeployments = await deployUpgradedContract(hre, {
+		deploymentName: 'WSTETHOracle',
+		from: deployerSigner.address,
+		args: [wsteth_deployment.address, stethUSD_oracle_deployment.address, LidoRateOracle.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'WstETHOracle',
+	})
+
+	const ufarmCore_deployment = await hre.deployments.getOrNull('UFarmCore')
+
+	if (ufarmCore_deployment) {
+		if (wstethOracleDeployments.newDeployment) {
+			const ufarmCore_instance = await hre.ethers.getContractAt(
+				'UFarmCore',
+				ufarmCore_deployment.address,
+				deployerSigner,
+			)
+			const existingWstETHOracle = await ufarmCore_instance.tokenInfo(wsteth_deployment.address)
+			// if new oracle is deployed, update it in UFarmCore
+			if (
+				existingWstETHOracle.priceFeed.feedAddr !== wstethOracleDeployments.newDeployment.address
+			) {
+				if (existingWstETHOracle.priceFeed.feedAddr !== hre.ethers.constants.AddressZero) {
+					console.log(`Removing WstETHOracle from UFarmCore...`)
+					await retryOperation(async () => {
+						await ufarmCore_instance.blacklistTokens([wsteth_deployment.address])
+					}, 3)
+					console.log(`WstETH blacklisted in UFarmCore.`)
+					await replaceUpdatedContract(hre, 'WSTETHOracle')
+				} else {
+					console.log('WstETH is not whitelisted in UFarmCore yet.')
+				}
+			}
+		}
+	}
+}
+
+export default deployWstETHOracle
+deployWstETHOracle.dependencies = _deployTags(['MockedAggregators'])
+deployWstETHOracle.tags = _deployTags(['WstETHOracle'])

package/deploy/23_deploy_uniV3.ts

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	deployContract,
+	isTestnet,
+	getTokenDeployments,
+	getDeployerSigner,
+	getInstanceFromDeployment,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+import { ethers } from 'hardhat'
+import { UniswapV3Factory } from '../typechain-types'
+
+const deployUniV3: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)){
+		console.log(`Skipping Uniswap V3 deployment`)
+		return
+	}
+
+	const tokenDeployments = await getTokenDeployments(hre)
+	const weth_deployment = tokenDeployments.WETH
+
+	console.log('\nDeploying UniswapV3...')
+
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const uniswapV3Factory_deployment = await deployContract(hre, {
+		deploymentName: 'UniswapV3Factory',
+		from: deployerSigner.address,
+		args: [],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'UniswapV3Factory',
+	})
+
+	const uniswapV3Factory_instance = await getInstanceFromDeployment<UniswapV3Factory>(
+		hre,
+		uniswapV3Factory_deployment,
+	)
+	if ((await uniswapV3Factory_instance.feeAmountTickSpacing(100)) == 0)
+		await (await uniswapV3Factory_instance.connect(deployerSigner).enableFeeAmount(100, 1)).wait()
+
+	const uniswapV3_SwapRouter_deployment = await deployContract(hre, {
+		deploymentName: 'SwapRouter',
+		from: deployerSigner.address,
+		args: [uniswapV3Factory_deployment.address, weth_deployment.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'SwapRouter',
+	})
+
+	const uniswapV3_NonfungiblePositionManager_deployment = await deployContract(hre, {
+		deploymentName: 'NonfungiblePositionManager',
+		from: deployerSigner.address,
+		args: [
+			uniswapV3Factory_deployment.address,
+			weth_deployment.address,
+			ethers.constants.AddressZero,
+		],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'NonfungiblePositionManager',
+	})
+
+	const uniswapV3_Quoter_deployment = await deployContract(hre, {
+		deploymentName: 'QuoterV2',
+		from: deployerSigner.address,
+		args: [uniswapV3Factory_deployment.address, weth_deployment.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'QuoterV2',
+	})
+	console.log('\nUniswapV3 deployed!')
+}
+
+export default deployUniV3
+deployUniV3.dependencies = _deployTags(['Tokens'])
+deployUniV3.tags = _deployTags(['UniV3'])

package/deploy/24_create_pairs_uniV3.ts

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
+import {
+	isTestnet,
+	getTokenDeployments,
+	retryOperation,
+	getInstanceFromDeployment,
+	getDeployerSigner,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+import { BigNumberish } from 'ethers'
+import { NonfungiblePositionManager, StableCoin, UniswapV3Factory, WETH9 } from '../typechain-types'
+import {
+	MintableToken,
+	addLiquidityUniswapV3,
+} from '../test/_helpers'
+
+const createUniV3Pairs: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	async function isUniswapV3PairExist(
+		factoryContract: UniswapV3Factory,
+		token0Address: string,
+		token1Address: string,
+		fee: number,
+	): Promise<boolean> {
+		try {
+			const pairAddress = await factoryContract.getPool(token0Address, token1Address, fee)
+			return pairAddress !== hre.ethers.constants.AddressZero
+		} catch (error) {
+			console.error('Error checking pair existence:', error)
+			return false
+		}
+	}
+
+	async function checkAndCreateUniV3Pair(
+		token0Contract: MintableToken,
+		token1Contract: MintableToken,
+		amount0: BigNumberish,
+		amount1: BigNumberish,
+		fee: number,
+		signer: SignerWithAddress,
+		factoryContract: UniswapV3Factory,
+		positionManager: NonfungiblePositionManager,
+		maxRetries: number,
+	): Promise<void> {
+		const token0Address = token0Contract.address
+		const token1Address = token1Contract.address
+
+		const [token0Symbol, token1Symbol] = await Promise.all([
+			token0Contract.symbol(),
+			token1Contract.symbol(),
+		])
+
+		const pairName = `${token0Symbol}/${token1Symbol}`
+
+		if (await isUniswapV3PairExist(factoryContract, token0Address, token1Address, fee)) {
+			console.log(`${pairName} pair already exists!`)
+		} else {
+			console.log(`Creating ${pairName} pair...`)
+
+			await retryOperation(async () => {
+				await addLiquidityUniswapV3(
+					token0Contract,
+					token1Contract,
+					amount0,
+					amount1,
+					factoryContract,
+					positionManager,
+					signer,
+					fee,
+				)
+			}, maxRetries)
+			console.log(`${pairName} pair created!`)
+		}
+	}
+
+	if (!isTestnet(hre.network)){
+		console.log(`Skipping Uniswap V3 pairs creation`)
+		return
+	}
+
+	const tokenDeployments = await getTokenDeployments(hre)
+	const deployerSigner = await getDeployerSigner(hre)
+
+	const uniV3Factory_deployment = await hre.deployments.get('UniswapV3Factory')
+	const nfpm_deployment = await hre.deployments.get('NonfungiblePositionManager')
+
+	const uniV3Factory_instance = getInstanceFromDeployment<UniswapV3Factory>(
+		hre,
+		uniV3Factory_deployment,
+	)
+	const nfpm_instance = getInstanceFromDeployment<NonfungiblePositionManager>(
+		hre,
+		nfpm_deployment,
+	)
+
+	const allPairs = hre.testnetDeployConfig.initialRates
+
+	async function createV3PairForTokens(rate: typeof allPairs[0]) {
+		const [token0Name, token1Name] = [rate.rawName0, rate.rawName1]
+		const [token0_instance, token1_instance] = [
+			getInstanceFromDeployment<MintableToken>(hre, tokenDeployments[token0Name]),
+			getInstanceFromDeployment<MintableToken>(hre, tokenDeployments[token1Name]),
+		]
+
+		const [decimals0, decimals1] = await Promise.all([
+			token0_instance.decimals(),
+			token1_instance.decimals(),
+		])
+
+		console.log(`decimals0: ${decimals0}, decimals1: ${decimals1}`)
+
+		await checkAndCreateUniV3Pair(
+			token0_instance,
+			token1_instance,
+			rate.amount0,
+			rate.amount1,
+			3000,
+			deployerSigner,
+			uniV3Factory_instance,
+			nfpm_instance,
+			3,
+		)
+	
+	}
+
+	console.log('\nCreating UniswapV3 pairs...')
+
+	for (const rate of allPairs) {
+		await createV3PairForTokens(rate)
+	}
+
+	console.log('\nUniswapV3 pairs created!')
+}
+
+export default createUniV3Pairs
+createUniV3Pairs.dependencies = _deployTags(['UniV3', 'Tokens'])
+createUniV3Pairs.tags = _deployTags(['UniV3Pairs'])

package/deploy/25_deploy_oneInch.ts

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	isTestnet,
+	deployContract,
+	getInstanceFromDeployment,
+	getDeployerSigner,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+
+const deployOneInch: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)){
+		console.log(`Skipping OneInch deployment`)
+		return
+	}
+
+	const deployerSigner = await getDeployerSigner(hre)
+	const weth_deployment = await hre.deployments.get('WETH')
+
+	console.log('\nDeploying OneInch...')
+
+	const oneInchV5Aggregator_deployment = await deployContract(hre, {
+		deploymentName: 'AggregationRouterV5',
+		from: deployerSigner.address,
+		args: [weth_deployment.address],
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'AggregationRouterV5',
+	})
+
+	console.log('\n OneInch deployed!')
+}
+
+export default deployOneInch
+deployOneInch.dependencies = _deployTags(['Tokens'])
+deployOneInch.tags = _deployTags(['OneInch'])

package/deploy/2_deploy_multicall.ts

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { isTestnet, deployContract, getDeployerSigner, _deployTags } from '../scripts/_deploy_helpers'
+
+const deployMulticall: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)){
+        console.log(`Skipping Multicall3 deployment`)
+        return
+    }
+
+	const deployerSigner = await getDeployerSigner(hre)
+
+    const deployerAddr = deployerSigner.address
+    const deployerBalance = await deployerSigner.getBalance()
+    console.log(`Deployer address: ${deployerAddr}\nDeployer balance: ${deployerBalance.toString()}`)
+
+	console.log('\nDeploying Multicall3...')
+
+    const multicallDeployment = await deployContract(hre, {
+        deploymentName: 'Multicall3',
+        from: deployerSigner.address,
+        log: true,
+        skipIfAlreadyDeployed: true,
+        contract: 'Multicall3',
+    })
+
+	console.log('\n Multicall3 deployed!')
+}
+
+export default deployMulticall
+deployMulticall.dependencies = []
+deployMulticall.tags = _deployTags(['Multicall3'])

package/deploy/30_deploy_price_oracle.ts

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	deployProxyContract,
+	getDeployerSigner,
+	getPriceOracleContract,
+	_deployTags,
+} from '../scripts/_deploy_helpers'
+
+const deployPriceOracle: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying PriceOracle...')
+	const priceOracleContract = getPriceOracleContract(hre.network)
+	await deployProxyContract(
+		hre,
+		priceOracleContract.contract,
+		deployerSigner,
+		undefined,
+		{
+			kind: 'uups',
+		},
+		'PriceOracle',
+	)
+
+	console.log(`\n ${priceOracleContract.contract} deployed!`)
+}
+
+export default deployPriceOracle
+deployPriceOracle.dependencies = _deployTags([])
+deployPriceOracle.tags = _deployTags(['PriceOracle'])

package/deploy/3_deploy_lido.ts

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import { DeployFunction } from 'hardhat-deploy/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import {
+	isTestnet,
+	deployContract,
+	getDeployerSigner,
+	_deployTags,
+	getNetworkType,
+	isMainnet,
+} from '../scripts/_deploy_helpers'
+
+const deployLido: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	if (!isTestnet(hre.network)) {
+		console.log(`Skipping Lido deployment`)
+		return
+	}
+
+	if (getNetworkType(hre.network) === 'arbitrumSepolia' || isMainnet(hre.network)) {
+		console.log('Skipping Lido deployment')
+		return
+	}
+
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying Lido...')
+
+	const lido_deposit = await deployContract(hre, {
+		deploymentName: 'DepositContractMock',
+		from: deployerSigner.address,
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'DepositContractMock',
+	})
+
+	const lido_registry = await deployContract(hre, {
+		deploymentName: 'NodeOperatorsRegistry',
+		from: deployerSigner.address,
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'NodeOperatorsRegistry',
+	})
+
+	const steth = await deployContract(hre, {
+		deploymentName: 'STETH',
+		from: deployerSigner.address,
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'Lido',
+		args: [
+			lido_deposit.address,
+			deployerSigner.address,
+			lido_registry.address,
+			deployerSigner.address,
+			deployerSigner.address,
+		],
+	})
+
+	const wsteth = await deployContract(hre, {
+		deploymentName: 'WSTETH',
+		from: deployerSigner.address,
+		log: true,
+		skipIfAlreadyDeployed: true,
+		contract: 'WstETH',
+		args: [steth.address],
+	})
+
+	console.log('\n Lido contracts deployed!')
+
+	const randomBytes = hre.ethers.utils.randomBytes(32)
+	const withdrawalCredentials = hre.ethers.utils.hexlify(randomBytes)
+	const withdrawalCredentialsSet: boolean =
+		(await hre.deployments.read('STETH', 'getWithdrawalCredentials')) ===
+		hre.ethers.constants.HashZero
+
+	if (!withdrawalCredentialsSet) {
+		await hre.deployments.execute(
+			'NodeOperatorsRegistry',
+			{ from: deployerSigner.address, log: true },
+			'setLido',
+			steth.address,
+		)
+		await hre.deployments.execute(
+			'STETH',
+			{ from: deployerSigner.address, log: true },
+			'setWithdrawalCredentials',
+			withdrawalCredentials,
+		)
+	}
+
+	const currentOracle = (await hre.deployments.read('STETH', 'getOracle')) as string
+	if (currentOracle !== deployerSigner.address)
+		await hre.deployments.execute(
+			'STETH',
+			{ from: deployerSigner.address, log: true },
+			'setOracle',
+			deployerSigner.address,
+		)
+
+	const currentFee = (await hre.deployments.read('STETH', 'getFee')) as string
+	if (parseInt(currentFee) !== 0)
+		await hre.deployments.execute('STETH', { from: deployerSigner.address, log: true }, 'setFee', 0)
+
+	const isLidoStopped = (await hre.deployments.read('STETH', 'isStopped')) as boolean
+	if (isLidoStopped)
+		await hre.deployments.execute('STETH', { from: deployerSigner.address, log: true }, 'resume')
+
+	console.log('\n Lido contracts activated!\n')
+}
+
+export default deployLido
+deployLido.dependencies = []
+deployLido.tags = _deployTags(['Lido'])

package/deploy/40_deploy_pool_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 deployPool: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying UFarmPool...')
+
+	await deployBeaconContract(hre, 'UFarmPool', deployerSigner)
+
+	console.log('\n UFarmPool deployed!')
+}
+
+export default deployPool
+deployPool.dependencies = []
+deployPool.tags = _deployTags(['UFarmPool'])

package/deploy/41_deploy_poolAdmin_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 deployPoolAdmin: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying PoolAdmin...')
+
+	await deployBeaconContract(hre, 'PoolAdmin', deployerSigner)
+
+	console.log('\n PoolAdmin deployed!')
+}
+
+export default deployPoolAdmin
+deployPoolAdmin.dependencies = []
+deployPoolAdmin.tags = _deployTags(['PoolAdmin'])

package/deploy/42_deploy_ufarmcore.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, deployProxyContract, _deployTags } from '../scripts/_deploy_helpers'
+
+const deployUFarmCore: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+	const deployerSigner = await getDeployerSigner(hre)
+
+	console.log('\nDeploying UFarmCore...')
+
+	const currentUFarmCoreDeployment = await hre.deployments.getOrNull('UFarmCore')
+
+	if (currentUFarmCoreDeployment) {
+		console.log(`Already deployed at: ${currentUFarmCoreDeployment.address}`)
+	} else {
+		const res = await deployProxyContract(hre, 'UFarmCore', deployerSigner, undefined, {
+			kind: 'uups',
+		})
+
+		console.log(`UFarmCore deployed at: ${res.address}`)
+	}
+
+	console.log('\n UFarmCore deployed!')
+}
+
+export default deployUFarmCore
+deployUFarmCore.dependencies = []
+deployUFarmCore.tags = _deployTags(['UFarmCore'])