CODE- EthereansOS farm Component breakdown

Note this is the entire component broken down by function. We want to mirror the logic related to Univ3 pools for our farm starter kit.

How to Help: Help by using a function as the input for chatgpt4 and asking it to explain it for you. Paste the input as CHATGPT ANALYSIS under a new subtitle (Use ## for the subtitle heading)

HTMLRender

 return (<>
            <div className={style.ActionInfoSection}>
                {content && <div className={style.FarmingAsideInfoLP}>{content}</div>}
                <a className={style.ActionInfoSectionSettings} onClick={() => setSettings(!settings)}>
                    <figure>
                        <img src={`${process.env.PUBLIC_URL}/img/settings.svg`}/>
                    </figure>
                </a>
            </div>
            {settings && <div className={style.SettingFB}>
                {renderSlippage && <div>
                    <label className={style.SettingBLabPerch}>
                        <p>Slippage: {slippage}%</p>
                        <input type="range" min="0" max="99" step="0.05" value={slippage} onChange={e => setSlippage(parseFloat(e.currentTarget.value))}/>
                    </label>
                </div>}
                {renderFeeType && <div className={style.FarmProtocolFees}>
                    <p>Protocol Fees:</p>
                    <label className={style.FarmProtocolFee}>
                        <span><b>🧮  Transaction</b></span>
                        {setupTokens && manageStatus && manageStatus.additionalFees && feeData && feeData.feePercentageForTransacted && <span>{calculateTransactedFee(feeData.feePercentageForTransacted, element.generation === 'gen1' ? manageStatus.tokenAmounts[0] : manageStatus.additionalFees[0], setupTokens[0])} {setupTokens[0].symbol} - {calculateTransactedFee(feeData.feePercentageForTransacted, element.generation === 'gen1' ? manageStatus.tokenAmounts[1] : manageStatus.additionalFees[1], setupTokens[1])}  {setupTokens[1].symbol}</span>}
                        <input type="radio" name={"feeType" + postfix} checked={feeType === 'percentage'} onClick={() => setFeeType("percentage")}/>
                    </label>
                    {!dualChainId && contracts.indexOf(web3Utils.toChecksumAddress(element.address)) === -1 && <label className={style.FarmProtocolFee}>
                        <span><b>🔥 Burn</b></span>
                        {feeData && feeData.tokenToTransferOrBurnInApplication && feeData.transferOrBurnAmountInApplication && <span>{formatMoney(fromDecimals(feeData.transferOrBurnAmountInApplication, feeData.tokenToTransferOrBurnInApplication.decimals, true), 6)} {feeData.tokenToTransferOrBurnInApplication.symbol}</span>}
                        <input type="radio" name={"feeType" + postfix} checked={feeType === 'burn'} onClick={() => setFeeType("burn")}/>
                    </label>}
                </div>}
                {renderAddress && <div>
                    <label className={style.SettingBLabRegular}>
                        <p>Receiver:</p>
                        <input type="text" value={receiver} onChange={e => setReceiver(e.currentTarget.value)}/>
                    </label>
                </div>}
            </div>}
        </>)
    }

    const getManageAdvanced = () => {
        const RemoveButton = <ActionAWeb3Button onSuccess={reloadData} onClick={removeLiquidity}>Remove</ActionAWeb3Button>
        if (withdrawOpen && currentPosition && setupInfo.free) {
            return (
                <div>
                    {(!setupInfo || setupInfo.minStakeable === '0') && <div className={style.RemoveLiquiditytools}>
                        <input type="range" value={removalAmount} onChange={(e) => setRemovalAmount(parseInt(e.target.value))} id="formControlRange" />
                        <a className={style.RegularButtonDuo} onClick={() => setRemovalAmount(100)} >MAX</a>
                        {renderSettings(true, true)}
                        <p><b>{removalAmount}%</b></p> <p>{manageStatus.tokens.map((token, i) => <span key={token.address}> {formatMoneyUniV3(fromDecimals(parseInt(manageStatus.tokenAmounts[i].full || manageStatus.tokenAmounts[i]) * removalAmount / 100, token.decimals, true), 4)} {token.symbol} </span>)}</p>
                    </div>}
                    <div className={style.LiqiudityAffairs}>
                        {setupInfo && setupInfo.minStakeable === '0' && RemoveButton}
                        {setupInfo && setupInfo.minStakeable !== '0' && renderSettings(true, true, undefined, RemoveButton)}
                    </div>
                </div>
            )
        }

        return (
            <div className={style.FarmingDynamics}>
                {setupTokens.map((setupToken, i) => {
                    return <div className={style.FarmToken} key={setupToken.address}>
                        {(i === 1 ? tickData.cursorNumber !== 100 : tickData.cursorNumber !== 0) && <TokenInputRegular selected={setupToken} tokens={[setupToken]} onElement={(t, _, value) => onUpdateTokenAmount(fromDecimals(value, t.decimals, true), i) } outputValue={tokenAmounts[i].value || fromDecimals(tokenAmounts[i].full || tokenAmounts[i], setupToken.decimals, true)}/>}
                    </div>
                })}
                {minimumStakingError && <div>
                    <p>{minimumStakingError}</p>
                </div>}
                {renderSettings(true, false, !currentPosition, (setupInfo.free && rewardTokenInfo && lpTokenAmount !== undefined && lpTokenAmount !== null && lpTokenAmount !== '' && lpTokenAmount !== '0' && (!lpTokenAmount.full || lpTokenAmount.full !== '0')) && <div>
                    <p>
                        Estimated reward per day:
                        <br/>
                        <b>{formatMoneyUniV3(freeEstimatedReward, rewardTokenInfo.decimals)} {rewardTokenInfo.symbol}</b>
                    </p>
                </div>)}
                <div className={style.timeToFarm}>
                    {tokensApprovals.some(value => !value) && approveButton}
                    <ActionAWeb3Button onSuccess={reloadData} onClick={addLiquidity} disabled={tokensApprovals.some(value => !value) || tokenAmounts.some(value => value === 0)}>Add Liquidity</ActionAWeb3Button>
                </div>
            </div>
        )
    }

    if (!setupTokens || setupTokens.length === 0 || !setup) {
        return <OurCircularProgress/>
    }

    return (
        <div className={style.FarmSetupV3}>
            <div className={style.FarmSetupMain}>
                <div className={style.SetupFarmingInstructions}>
                    <div className={style.SetupFarmingInstructionsV3}>
                        {setupTokens.map((token, i) => <div key={token.address} className={style.TokenFarmV3InfoBox}>{token.address !== VOID_ETHEREUM_ADDRESS ? <a target="_blank" href={`${getNetworkElement({ context, chainId }, "etherscanURL")}token/${token.address}`}><LogoRenderer input={token} /></a> : <LogoRenderer input={token} />}<span> {tickData && `${formatMoneyUniV3(i === 0 ? tickData.cursorNumber : 100 - tickData.cursorNumber, 2)}%`} <span>{token.symbol}</span></span> </div>)}
                        {!endBlockReached &&
                            <p className={style.BlockInfoV3B}>
                            {setup.active && parseInt(setup.endBlock) > currentBlock && <span className={style.V3FarmStatusYEP}>Active</span>}
                                {!delayedBlock && <> {(!setup.active && canActivateSetup) ? <span>{setupReady ? "new" : "Soon"}</span> : (!setup.active) ? <span>Inactive</span> : <></>} {(parseInt(setup.endBlock) <= currentBlock && parseInt(setup.endBlock) !== 0) && <span>Ended</span>}</>}{delayedBlock !== 0 && <span>Soon</span>}
                                {!isNaN(apy) && <> <b>APR</b>: {apy === 0 ? 0 : formatMoneyUniV3(apy, 3)}%</>}
                            </p>
                        }
                        {rewardTokenInfo && <p className={style.BlockInfoV3}><b>Daily Rate</b>: {formatMoneyUniV3(fromDecimals(parseInt(setup.rewardPerBlock) * 6400, rewardTokenInfo.decimals, true), 4)} {rewardTokenInfo.symbol}</p>}
                        {mainTokenInfo && setupInfo && setupInfo.minStakeable !== '0' && <p className={style.BlockInfoV3}><b>Minimum Staking</b>: {formatMoneyUniV3(fromDecimals(setupInfo.minStakeable, mainTokenInfo.decimals, true), 6)} {mainTokenInfo.symbol}</p>}
                        {parseInt(setup.endBlock) > 0 ? <p className={style.BlockInfoV3}><b>End</b>: <a target="_blank" href={`${getNetworkElement({ context, chainId : dualChainId || chainId }, "etherscanURL")}block/${setup.endBlock}`}>{setup.endBlock}</a></p> : <p className={style.BlockInfoV3}><b>Duration</b>: {getPeriodFromDuration(setupInfo.blockDuration)}</p>}
                        {setupMustBeToggled && <ActionAWeb3Button onSuccess={refresh} onClick={toggleSetup}>Toggle</ActionAWeb3Button>}
                        {!currentPosition && (!open && parseInt(setup.endBlock) > parseInt(currentBlock)) && <a className={style.RegularButtonDuo} onClick={() => void(setOpen(true), setWithdrawOpen(false), setEdit(false))}>Farm</a>}
                        {!currentPosition && open && <RegularButtonDuo className={style.RegularButtonDuoBack} onClick={() => void(setOpen(false), setWithdrawOpen(false), setEdit(false))}>Close</RegularButtonDuo>}
                        {
                            !delayedBlock && canActivateSetup && <>
                                {
                                    !open && setupReady && <>
                                        {
                                            activateLoading ? <OurCircularProgress/> : <>
                                                <RegularButtonDuo onClick={() => void(setOpen(true), setWithdrawOpen(false), setEdit(false))}>Farm</RegularButtonDuo>
                                                <p className={style.FarmDisclamerGas}>You're the first farmer on this setup, you'll spend more gas, but all of the initial currentBlock rewards are yours! </p>
                                            </>
                                        }
                                    </>
                                }
                                {!setupReady && <p>Not ready to be activated, come back at another time</p>}
                            </>
                        }
                        {delayedBlock !== 0 && <div>
                            <p><b>Start Block: <a href={`${getNetworkElement({ context, chainId : dualChainId || chainId }, "etherscanURL")}block/${delayedBlock}`} target="_blank">#{delayedBlock}</a></b></p>
                        </div>}
                        {/*<a Web3ActionBTN" onClick={async () => {
                            var updatedSetups = [{
                                add: false,
                                disable: true,
                                index: 0,
                                info: {
                                    blockDuration: 0,
                                    startBlock: "1000000000000000000",
                                    originalRewardPerBlock: 0,
                                    minStakeable: 0,
                                    renewTimes: 0,
                                    liquidityPoolTokenAddress: VOID_ETHEREUM_ADDRESS,
                                    mainTokenAddress: VOID_ETHEREUM_ADDRESS,
                                    involvingETH: false,
                                    setupsCount: 0,
                                    lastSetupIndex: 0,
                                    tickLower: 0,
                                    tickUpper: 320000
                                }
                            }]
                            try {
                                var data = {from : account}
                                var method = extensionContract.methods.setFarmingSetups(updatedSetups)
                                data.gas = await method.estimateGas(data)
                                var transaction = await method.send(data)
                            } catch(e) {
                                console.log('ALE LEGGI DA QUA')
                                console.log(e)
                            }
                        }}>Terminate Setup</a> @todo remove */}
                    </div>
                    <div className={style.farmInfoCurve}>
                        <p className={style.farmInfoCurveL}>
                            <p className={style.MAinTokensel}>
                                <a onClick={() => setsecondTokenIndex(1 - (secondTokenIndex || 0))}><img src={`${process.env.PUBLIC_URL}/img/switch.png`}/></a> {setupTokens[secondTokenIndex].symbol} per {setupTokens[1 - secondTokenIndex].symbol}
                            </p>
                        </p>
                        {element.generation === 'gen1' && lpTokenInfo && <p className={style.farmInfoCurveR}>
                            <p className={style.PriceRangeInfoFarm}>
                                <a target="_blank" href={`${getNetworkElement({ context, chainId }, 'etherscanURL')}address/${lpTokenInfo.contract.options.address}`}><span className={style.VersionFarm}>{lpTokenInfo.amm.name}</span></a>
                            </p>
                        </p>}
                        {element.generation === 'gen2' && <p className={style.farmInfoCurveR}>
                            <p className={style.PriceRangeInfoFarm}>
                                <a className={style.ExtLinkButton} target="_blank" href={context.uniswapV3PoolURLTemplate.split('{0}').join(dualChainId ? 'optimism/' : '').split('{1}').join(setupInfo.liquidityPoolTokenAddress)}>{formatMoneyUniV3(numberToString(parseInt(lpTokenInfo.fee) / 10000), '2')}%</a>
                                {((currentPosition?.tokenId && currentPosition?.tokenId !== '0') || (setup.objectId && setup.objectId !== '0')) && <a className={style.ExtLinkButton} href={context.uniswapV3NFTURLTemplate.split('{0}').join(dualChainId ? 'optimism/' : '').split('{1}').join(currentPosition?.tokenId || setup.objectId)} target="_blank">NFT</a>}
                            </p>
                        </p>}
                        {!tickData ? <OurCircularProgress/> : <div className={style.UniV3CurveView}>
                            <div className={style.UniV3CurveViewCurv}>
                                <span className={style.CircleLeftV3Curve}></span>
                                <span className={style.CircleLeftV3CurvePrice}>
                                    {tickData.diluted ? element.generation === 'gen2' ? "Diluted" : <>&#8734;</> :
                                        tickData.tickLowerUSDPrice ?
                                        ("$" + formatMoneyUniV3(tickData.tickLowerUSDPrice)) :
                                        `${formatMoneyUniV3(tickData.minPrice)} ${setupTokens[secondTokenIndex].symbol}`
                                    }
                                </span>
                                <span className={style.CircleRightV3Curve}></span>
                                <span className={style.CircleRightV3CurvePrice}>
                                    {tickData.diluted ? element.generation === 'gen2' ? "Diluted" : <>&#8734;</> :
                                        tickData.tickUpperUSDPrice ?
                                        ("$" + formatMoneyUniV3(tickData.tickUpperUSDPrice)) :
                                        `${formatMoneyUniV3(tickData.maxPrice)} ${setupTokens[secondTokenIndex].symbol}`
                                    }
                                </span>
                                <div className={style.CircleActualPriceV3} style={{left : `${tickData.cursor}%`}}>
                                    <span className={style.CircleRightV3Actual}>
                                        <img src={`${process.env.PUBLIC_URL}/img/arrow.png`}/>
                                        <span className={style.CircleRightV3ActualPrice}>
                                            {tickData.tickCurrentUSDPrice ?
                                                ("$" + formatMoneyUniV3(tickData.tickCurrentUSDPrice)) :
                                                `${formatMoneyUniV3(tickData.currentPrice)}`
                                            }
                                        </span>
                                    </span>
                                </div>
                            </div>
                        </div>}
                        <span className={style.UniV3TVLFIV}>
                            <b>TVL</b>: {setupTokens.map((token, index) => <span key={token.address}>{formatMoneyUniV3(fromDecimals(token.liquidity, token.decimals, true), 4)} {token.symbol}{index !== setupTokens.length - 1 ? ' - ' : ''}</span>)}
                        </span>
                    </div>
                </div>
            </div>
            {
                currentPosition &&
                <div className={style.YourFarmingPositionsFarmingFarmingFarmingChiFarmaViveComeUnPAsha}>
                    <div className={style.FarmYou}>
                        {manageStatus && <p><b>Your Deposit</b>:<br></br> {manageStatus.tokens.map((token, i) => <span key={token.address}> {formatMoneyUniV3(fromDecimals(manageStatus.tokenAmounts[i], token.decimals, true), 3)} {token.symbol} </span>)}</p>}
                        {!endBlockReached && <p><b>Daily Earnings</b>:<br></br> {calculateDailyEarnings()} {rewardTokenInfo.symbol}</p>}
                        {(!manageStatus?.withdrawOnly && !open && parseInt(setup.endBlock) > parseInt(currentBlock)) && <RegularButtonDuo onClick={() => void(setOpen(true), setWithdrawOpen(false), setEdit(false))}>Increase</RegularButtonDuo>}
                        {open && <RegularButtonDuo onClick={() => void(setOpen(false), setWithdrawOpen(false), setEdit(false))}>Close</RegularButtonDuo>}
                        {!manageStatus?.withdrawOnly && !withdrawOpen && <RegularButtonDuo onClick={() => void(setOpen(false), setWithdrawOpen(true), setEdit(false))}>Decrease</RegularButtonDuo>}
                        {withdrawOpen && <RegularButtonDuo onClick={() => void(setOpen(false), setWithdrawOpen(false), setEdit(false))}>Close</RegularButtonDuo>}
                        {manageStatus?.withdrawOnly && <>
                            {!open && !withdrawOpen && renderSettings(true, true, undefined, <ActionAWeb3Button onSuccess={reloadData} onClick={withdrawAll}>Withdraw All</ActionAWeb3Button>)}
                        </>}
                    </div>
                    <div className={style.farmed}>
                        <p><b>Available</b>: <br></br>{formatMoneyUniV3(fromDecimals(freeAvailableRewards, rewardTokenInfo.decimals, true), 4)} {rewardTokenInfo.symbol}</p>
                        {element.generation === 'gen2' && manageStatus && <p><b>Fees Earned</b>: <br></br>{formatMoneyUniV3(fromDecimals(manageStatus.additionalFees[0], setupTokens[0].decimals, true), 4)} {setupTokens[0].symbol} - {formatMoneyUniV3(fromDecimals(manageStatus.additionalFees[1], setupTokens[1].decimals, true), 4)} {setupTokens[1].symbol}</p>}
                        {!manageStatus?.withdrawOnly && <>
                            {approveFeeButton}
                            {element.generation === 'gen2' && !open && !withdrawOpen && renderSettings(false, true)}
                        </>}
                    </div>
                </div>
            }
            {((open || withdrawOpen) && !edit) && <><hr/>{getAdvanced()}</>}
            {(edit && !open && !withdrawOpen) && getEdit()}
        </div>
    )
}

Helper Functions

const calculateLockedFixedValue = () => {
    const { rewardPerBlock } = setup
    const { maxStakeable } = setupInfo
    const normalizedRewardPerBlock = parseInt(rewardPerBlock) * 10 ** (18 - rewardTokenInfo.decimals)
    const normalizedMaxStakeable = parseInt(maxStakeable) * 10 ** (18 - mainTokenInfo.decimals)
    const amount = normalizedRewardPerBlock * (1 / normalizedMaxStakeable)
    return (canActivateSetup) ? formatMoneyUniV3(amount * parseInt(setupInfo.blockDuration), 6) : parseInt(currentBlock) >= parseInt(setup.endBlock) ? 0 : formatMoneyUniV3(amount * (parseInt(setup.endBlock) - parseInt(currentBlock)), 6)
}

function onSlippageChange(e) {
    var value = parseFloat(e.currentTarget.value)
    var min = parseFloat(e.currentTarget.min)
    var max = parseFloat(e.currentTarget.max)
    value = isNaN(value) ? 0 : value
    if(value < min) {
        value = min
    }
    if(value > max) {
        value = max
    }
    setSlippage(value)
}

const getAdvanced = () => {
    return !edit ? getManageAdvanced() : getEdit()
}

const getEdit = () => {
    return

    {/* @locked For upcoming release
    <div pb-4 px-4">
        <hr />
        <div row mt-2 align-items-center justify-content-start">
            {
                setupInfo.free &&
                <div col-12 mb-md-2">
                    <Input value={dfoCore.toDecimals(updatedRewardPerBlock)} min={0} onChange={(e) => setUpdatedRewardPerBlock(dfoCore.toFixed(dfoCore.fromDecimals(e.target.value), rewardTokenInfo.decimals))} label={"Reward per currentBlock"} />
                </div>
            }
            <div col-12 mb-md-2">
                <Input value={updatedRenewTimes} min={0} onChange={(e) => setUpdatedRenewTimes(e.target.value)} label={"Renew times"} />
            </div>
            <div col-12">
                <button onClick={() => updateSetup()} btn btn-secondary">Update</button>
                {setup.active && <button onClick={() => disableSetup()} btn btn-primary">Disable</button>}
            </div>
        </div>
    </div>*/}
}

function calculateDailyEarnings() {
    if(!manageStatus) {
        return 0
    }
    var rewardPerBlock = formatNumber(fromDecimals(setup.rewardPerBlock, rewardTokenInfo.decimals, true))
    var liquidityPoolAmount = formatNumber(fromDecimals(manageStatus.liquidityPoolAmount, rewardTokenInfo.decimals, true))
    var totalSupply = formatNumber(fromDecimals(setup.totalSupply, rewardTokenInfo.decimals, true))
    var dailyEarnings = (rewardPerBlock * 6400 * liquidityPoolAmount) / totalSupply
    dailyEarnings = numberToString(dailyEarnings)
    dailyEarnings = formatMoneyUniV3(dailyEarnings, 4)
    return dailyEarnings
    //fromDecimals((parseInt(setup.rewardPerBlock) * 6400 * parseInt(manageStatus.liquidityPoolAmount) / parseInt(setup.totalSupply)).toString().split('.')[0], rewardTokenInfo.decimals, true)
}

function calculateTransactedFee(percentage, amount, setupToken) {

    amount = numberToString(parseFloat(fromDecimals(percentage, 18, true)) * parseInt(amount)).split('.')[0]

    return formatMoney(fromDecimals(amount, setupToken.decimals, true), 6)
}

function renderSettings(renderSlippage, renderFeeType, renderAddress, content) {
    const postfix = "_" + numberToString(new Date() * Math.random()).split('.').join('')

UpdateEthAmount

const updateEthAmount = async amount => {
        try {
            setLoadingPrestoData(true)
            setPrestoData(null)
            setEthAmount(amount || "0")
            if (!parseFloat(amount)) {
                return setLoadingPrestoData(false)
            }
            var value = toDecimals(numberToString(amount), 18)

            var halfValue = web3Utils.toBN(value).div(web3Utils.toBN(2)).toString()
            var ammEthereumAddress = (await blockchainCall(ammContract.methods.data))[0]

            var info = setupInfo

            var liquidityPool = info.liquidityPoolTokenAddress

            var tokens = await blockchainCall(ammContract.methods.byLiquidityPool, liquidityPool)
            var token0 = newContract(context.ERC20ABI, tokens[2][0])
            var token1 = newContract(context.ERC20ABI, tokens[2][1])
            var token0decimals = tokens[2][0] === VOID_ETHEREUM_ADDRESS ? 18 : await blockchainCall(token0.methods.decimals)
            var token1decimals = tokens[2][1] === VOID_ETHEREUM_ADDRESS ? 18 : await blockchainCall(token1.methods.decimals)

            var lpDecimals = await blockchainCall(newContract(context.ERC20ABI, liquidityPool).methods.decimals)

            var mainTokenIndex = tokens[2].indexOf(info.mainTokenAddress)

            var amm = ammContract//amms[selectedAmmIndex].contract

            var ethereumAddress = (await blockchainCall(amm.methods.data))[0]

            async function calculateBestLP(firstToken, secondToken, firstDecimals, secondDecimals, hf) {

                var data = await blockchainCall(amm.methods.byTokens, [ethereumAddress, firstToken])

                var liquidityPoolAddress = data[2]

                if (liquidityPoolAddress === VOID_ETHEREUM_ADDRESS) {
                    return {}
                }

                var mainTokenIndex = data[3].indexOf(firstToken)
                var middleTokenIndex = data[3].indexOf(ethereumAddress)

                var mainAmount = formatNumber(normalizeValue(data[1][mainTokenIndex], firstDecimals))
                var middleTokenAmount = formatNumber(normalizeValue(data[1][middleTokenIndex], 18))

                var constant = mainAmount * middleTokenAmount

                var newMiddleTokenAmount = middleTokenAmount + formatNumber(normalizeValue(halfValue, 18))

                var newMainAmount = constant / newMiddleTokenAmount

                var mainReceived = mainAmount - newMainAmount

                var firstTokenEthLiquidityPoolAddress = liquidityPoolAddress
                var token0Value = (await blockchainCall(amm.methods.getSwapOutput, ethereumAddress, hf || halfValue, [liquidityPoolAddress], [firstToken]))[1]

                var ratio = newMainAmount / mainAmount

                if (!hf) {
                    return await calculateBestLP(firstToken, secondToken, firstDecimals, secondDecimals, halfValue = numberToString(formatNumber(halfValue) * ratio).split('.')[0])
                }

                var token1Value = (await blockchainCall(ammContract.methods.byTokenAmount, liquidityPool, firstToken, token0Value))
                var lpAmount = token1Value[0]
                token1Value = token1Value[1][token1Value[2].indexOf(secondToken)]

                lpAmount = numberToString(parseInt(lpAmount) / ratio).split('.')[0]
                token1Value = numberToString(parseInt(token1Value) / ratio).split('.')[0]

                const updatedFirstTokenAmount = formatNumber(normalizeValue(token0Value, firstDecimals))
                const updatedSecondTokenAmount = formatNumber(normalizeValue(token1Value, secondDecimals))

                liquidityPoolAddress = (await blockchainCall(amm.methods.byTokens, [ethereumAddress, secondToken]))[2]
                var secondTokenEthLiquidityPoolAddress = liquidityPoolAddress
                var token1ValueETH = "0"
                if (secondTokenEthLiquidityPoolAddress !== VOID_ETHEREUM_ADDRESS) {
                    token1ValueETH = (await blockchainCall(amm.methods.getSwapOutput, secondToken, token1Value, [liquidityPoolAddress], [ethereumAddress]))[1]
                }

                return { lpAmount, updatedFirstTokenAmount, updatedSecondTokenAmount, token0Value, token1Value, token1ValueETH, firstTokenEthLiquidityPoolAddress, secondTokenEthLiquidityPoolAddress }
            }

            var bestLP = await calculateBestLP(token0.options.address, token1.options.address, token0decimals, token1decimals)

            var lpAmount = bestLP.lpAmount
            var firstTokenAmount = bestLP.token0Value
            var secondTokenAmount = bestLP.token1Value
            var firstTokenETH = halfValue
            var secondTokenETH = bestLP.token1ValueETH
            var token0EthLiquidityPoolAddress = bestLP.firstTokenEthLiquidityPoolAddress
            var token1EthLiquidityPoolAddress = bestLP.secondTokenEthLiquidityPoolAddress

            if (token0.options.address === ammEthereumAddress || !lpAmount || (bestLP.updatedSecondTokenAmount > bestLP.updatedFirstTokenAmount)) {
                bestLP = await calculateBestLP(token1.options.address, token0.options.address, token1decimals, token0decimals)

                lpAmount = bestLP.lpAmount
                firstTokenAmount = bestLP.token1Value
                secondTokenAmount = bestLP.token0Value
                firstTokenETH = bestLP.token1ValueETH
                secondTokenETH = halfValue
                token0EthLiquidityPoolAddress = bestLP.secondTokenEthLiquidityPoolAddress
                token1EthLiquidityPoolAddress = bestLP.firstTokenEthLiquidityPoolAddress
            }

            var operations = []

            token0EthLiquidityPoolAddress !== VOID_ETHEREUM_ADDRESS && operations.push({
                inputTokenAddress: ethereumAddress,
                inputTokenAmount: firstTokenETH,
                ammPlugin: amm.options.address,
                liquidityPoolAddresses: [token0EthLiquidityPoolAddress],
                swapPath: [token0.options.address],
                enterInETH: true,
                exitInETH: false,
                receivers: [farmingPresto.options.address],
                receiversPercentages: []
            })

            token1EthLiquidityPoolAddress !== VOID_ETHEREUM_ADDRESS && operations.push({
                inputTokenAddress: ethereumAddress,
                inputTokenAmount: secondTokenETH,
                ammPlugin: amm.options.address,
                liquidityPoolAddresses: [token1EthLiquidityPoolAddress],
                swapPath: [token1.options.address],
                enterInETH: true,
                exitInETH: false,
                receivers: [farmingPresto.options.address],
                receiversPercentages: []
            })

            var ethValue = 0
            token0EthLiquidityPoolAddress !== VOID_ETHEREUM_ADDRESS && (ethValue = web3Utils.toBN(ethValue).add(web3Utils.toBN(firstTokenETH)).toString())
            token1EthLiquidityPoolAddress !== VOID_ETHEREUM_ADDRESS && (ethValue = web3Utils.toBN(ethValue).add(web3Utils.toBN(secondTokenETH)).toString())
            info.involvingETH && token0.options.address === ammEthereumAddress && (ethValue = web3Utils.toBN(ethValue).add(web3Utils.toBN(firstTokenAmount)).toString())
            info.involvingETH && token1.options.address === ammEthereumAddress && (ethValue = web3Utils.toBN(ethValue).add(web3Utils.toBN(secondTokenAmount)).toString())

            var request = {
                setupIndex : setup.setupIndex,
                amount: mainTokenIndex === 0 ? firstTokenAmount : secondTokenAmount,
                amountIsLiquidityPool: false,
                positionOwner: isEthereumAddress(receiver) ? receiver : account
            }

            if (!setupInfo.free) {
                const reward = await blockchainCall(element.contract.methods.calculateLockedFarmingReward, setup.setupIndex, mainTokenIndex === 0 ? firstTokenAmount : secondTokenAmount, false, 0)
                setLockedEstimatedReward(fromDecimals(parseInt(reward.relativeRewardPerBlock) * (parseInt(setup.endBlock) - currentBlock), rewardTokenInfo.decimals))
            } else {
                const val = parseInt(lpAmount) * 6400 * parseInt(setup.rewardPerBlock) / (parseInt(setup.totalSupply) + parseInt(lpAmount))
                if (!isNaN(val)) {
                    setFreeEstimatedReward(fromDecimals(val, rewardTokenInfo.decimals))
                }
            }

            setPrestoData({
                ethValue: value,
                transaction: farmingPresto.methods.openPosition(
                    getNetworkElement({ context, chainId }, "prestoAddress"),
                    operations,
                    element.address,
                    request
                ),
                firstTokenAmount,
                secondTokenAmount,
                token0decimals,
                token1decimals,
                token0Address: token0.options.address,
                token1Address: token1.options.address,
                token0Symbol: info.involvingETH && token0.options.address === ammEthereumAddress ? "ETH" : await blockchainCall(token0.methods.symbol),
                token1Symbol: info.involvingETH && token1.options.address === ammEthereumAddress ? "ETH" : await blockchainCall(token1.methods.symbol)
            })

            setLpTokenAmount({ full: lpAmount, value: fromDecimals(lpAmount, lpDecimals) })
        } catch (error) {
            console.log(error)
        }
        setLoadingPrestoData(false)
    }

ApproveButton, onInputTypeChange

 const ApproveButton = ({ contract, text, onApproval, spender, value }) => {

        const approve = useCallback(async () => {
            setApproveLoading(true)
            try {
                await blockchainCall(contract.methods.approve, spender, value || MAX_UINT256)
            } catch(e) {
                setApproveLoading(false)
                throw e
            }
        }, [contract.options.address])

        return approveLoading ? <OurCircularProgress/> : <ActionAWeb3Button onClick={approve} onSuccess={() => void(setApproveLoading(), onApproval())}>{text}</ActionAWeb3Button>
    }

    const approveButton = useMemo(() => {
        const notApprovedIndex = tokensApprovals.findIndex(value => !value)
        if (notApprovedIndex !== -1) {
            if(!tickData || tickData.cursorNumber === 0 || tickData.cursorNumber === 100) {
                var index = tickData?.cursorNumber === 100 ? 0 : 1
                return notApprovedIndex === index && <ApproveButton contract={setupTokens[index].contract} spender={element.address} onApproval={() => onTokenApproval(index, false)} text={`Approve ${setupTokens[index].symbol}`} />
            }
            return <ApproveButton contract={setupTokens[notApprovedIndex].contract} spender={element.address} onApproval={() => onTokenApproval(notApprovedIndex, false)} text={`Approve ${setupTokens[notApprovedIndex].symbol}`} />
        } else {
            return <></>
        }
    }, [tokensApprovals, lpTokenInfo, setupTokens, tickData, approveLoading])

    const approveFeeButton = useMemo(() => {
        if(!burnFeeAllowance) {
            return <ActionAWeb3Button onSuccess={reloadData} onClick={withdrawReward}>Claim</ActionAWeb3Button>
        }
        return <ApproveButton contract={feeData.tokenToTransferOrBurnInApplication.contract} spender={feeData.operator} onApproval={setBurnFeeAllowance} text={`Approve ${feeData.tokenToTransferOrBurnInApplication.symbol} to transfer/burn fees`} value={feeData && feeData.transferOrBurnAmountInApplication}/>
    }, [feeData, burnFeeAllowance, currentPosition])

    const onInputTypeChange = async (e) => {
        setInputType(e.target.value)
        const ethBalance = await web3.eth.getBalance(account)
        setEthBalanceOf(ethBalance)
        setPrestoData(null)
        setShowPrestoError(false)
        setEthAmount(0)
        if (e.target.value === 'add-eth') {
            setLpTokenAmount(0)
            setTokenAmounts(new Array(setupTokens.length).fill(0))
            setFreeEstimatedReward("0")
            setLockedEstimatedReward("0")
        }
    }

    const onOutputTypeChange = e => {
        setOutputType(e.target.value)
    }

Remove Liquidity, Claim, widthrdraw $ fee calc

 async function percentageFeeOrBurn() {
        var burnData = "0x"
        if(feeType === "burn") {
            burnData = abi.encode(["bool", "bytes"], [true, "0x"])
        }
        return burnData
    }


    const removeLiquidity = async () => {
        if (setupInfo.free && (!removalAmount || removalAmount === 0) && setupInfo.minStakeable === '0') return
        const removedLiquidity = removalAmount === 100 || setupInfo.minStakeable !== '0' ? manageStatus.liquidityPoolAmount : numberToString(parseInt(manageStatus.liquidityPoolAmount) * removalAmount / 100).split('.')[0]
        var amMin = await calculateSlippageAmounts(slippage, removedLiquidity, 'burn')
        var burnData = await percentageFeeOrBurn()
        if(element.generation === 'gen1') {
            return await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, 0, removedLiquidity, amMin[0].full || amMin[0], amMin[1].full || amMin[1], burnData)
        }
        try {
            await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, removedLiquidity, amMin[0].full || amMin[0], amMin[1].full || amMin[1], burnData)
        } catch(e) {
            console.error(e.message)
            const message = (e.message || e).toLowerCase()
            if(message.indexOf('user denied') === -1 && message.indexOf('price slippage') === -1) {
                await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, removedLiquidity, burnData)
            } else {
                throw e
            }
        }
    }

    async function withdrawAll() {
        var amMin = await calculateSlippageAmounts(slippage, manageStatus.liquidityPoolAmount, 'burn')
        var burnData = await percentageFeeOrBurn()
        if(element.generation === 'gen1') {
            return await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, 0, manageStatus.liquidityPoolAmount, amMin[0].full || amMin[0], amMin[1].full || amMin[1], burnData)
        }
        try {
            await element.contract.methods.withdrawLiquidity(currentPosition.positionId, manageStatus.liquidityPoolAmount, amMin[0].full || amMin[0], amMin[1].full || amMin[1], burnData).call({from : account})
        } catch(e) {
            console.error(e.message)
        }
        try {
            await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, manageStatus.liquidityPoolAmount, amMin[0].full || amMin[0], amMin[1].full || amMin[1], burnData)
        } catch(e) {
            console.error(e.message)
            const message = (e.message || e).toLowerCase()
            if(message.indexOf('user denied') === -1 && message.indexOf('price slippage') === -1) {
                await blockchainCall(element.contract.methods.withdrawLiquidity, currentPosition.positionId, manageStatus.liquidityPoolAmount, burnData)
            } else {
                throw e
            }
        }
    }

    async function withdrawReward() {
        var burnData = await percentageFeeOrBurn()
        try {
            await blockchainCall(element.contract.methods["withdrawReward(uint256,bytes)"], currentPosition.positionId, burnData)
        } catch(e) {
            var msg = (e.message || e).toLowerCase()
            if(msg.indexOf('user denied') === -1 && msg.indexOf("allowance") === -1) {
                await blockchainCall(element.contract.methods["withdrawReward(uint256)"], currentPosition.positionId)
            } else {
                throw e
            }
        }
    }

    const transferPosition = async (positionId, index) => {
        if (!positionId) return
        if (setupInfo.free) {
            setTransferLoading(true)
            try {
                //const gasLimit = await element.contract.methods.transferPosition(freeTransferAddress, positionId).estimateGas({ from: account })
                await blockchainCall(element.contract.methods.transferPosition, account, positionId)
                await reloadData()
            } catch (error) {
                console.log(error)
            } finally {
                setTransferLoading(false)
            }
        }
    }

AddLiquidity

async function addLiquidity(data) {
        if(element.generation === 'gen2') {
            return await addLiquidityGen2({setup, lpTokenAmount, receiver, setupTokens, inputType, setupInfo, ethereumAddress, tokenAmounts, element, currentPosition, prestoData, amountsMin, context, ...web3Data, ...data })
        }

        const stake = {
            setupIndex : setup.setupIndex,
            amount: 0,
            amountIsLiquidityPool: inputType === 'add-lp' ? true : false,
            positionOwner: receiver || VOID_ETHEREUM_ADDRESS,
            amount0Min : amountsMin[0],
            amount1Min : amountsMin[1]
        }

        var ethTokenIndex = null
        var ethTokenValue = 0
        var mainTokenIndex = 0
        var ethereumAddress = lpTokenInfo?.amm?.ethereumAddress
        await Promise.all(setupTokens.map(async (token, i) => {
            if (setupInfo.involvingETH && token.address === VOID_ETHEREUM_ADDRESS) {
                ethTokenIndex = i
            }
            if (token.address === setupInfo.mainTokenAddress || setupInfo.involvingETH && token.address === VOID_ETHEREUM_ADDRESS && setupInfo.mainTokenAddress === ethereumAddress) {
                mainTokenIndex = i
            }
        }))
        var lpAmount = numberToString((lpTokenAmount && lpTokenAmount.full) || lpTokenAmount)
        stake.amount = numberToString(stake.amountIsLiquidityPool ? lpAmount : tokenAmounts[mainTokenIndex].full || tokenAmounts[mainTokenIndex])
        ethTokenValue = ethTokenIndex === undefined || ethTokenIndex === null ? "0" : numberToString(tokenAmounts[ethTokenIndex].full || tokenAmounts[ethTokenIndex])
        var value = setupInfo.involvingETH && !stake.amountIsLiquidityPool ? ethTokenValue : "0"

        if (!currentPosition || receiver) {
            await blockchainCall(element.contract.methods.openPosition, stake, { value })
        } else if (currentPosition) {
            await blockchainCall(element.contract.methods.addLiquidity, currentPosition.positionId, stake, { value })
        }
    }

onUpdateTokenAmount

function onUpdateTokenAmount(value, index, isFull) {
if(value === undefined || value === null || !value) {
    value = '0'
}
var tks = tokenAmounts.map(it => it)
if(value.indexOf('.') !== -1 && value.split('.')[1].length > 18) {
    value = value.split('.')
    value[1] = value[1].substring(0, 18)
    value = value.join('.')
}
const fullValue = isFull ? value : toDecimals(value, setupTokens[index].decimals)
tks[index] = {
    value : isFull ? fromDecimals(value, setupTokens[index].decimals, true) : value,
    full : fullValue
}
//isFull && setTokenAmounts(tks.map(it => it))
if(fromDecimals(fullValue, setupTokens[index].decimals, true) === numberToString(tokenAmounts[index].value || 0)) {
    return
}
setLpTokenAmount(null)
updateAmountTimeout.current && clearTimeout(updateAmountTimeout.current)
if (!value) {
    setLockedEstimatedReward(0)
    setFreeEstimatedReward(0)
    //setTokenAmounts(tokenAmounts.map(() => 0))
    return
}
updateAmountTimeout.current = setTimeout(async function () {
    var liquidityPoolAmount
    var surplus = 0
    async function elaborateValue() {
        var currentIndex = parseInt(index)
        var val = fullValue
        if(arguments.length === 2) {
            val = tks[currentIndex = 1 - currentIndex].full
        }
        var tokenAddress = setupTokens[currentIndex].address
        if(element.generation === 'gen1') {
            tokenAddress = lpTokenInfo.originalTokenAddresses[currentIndex]
            const ammContract = lpTokenInfo.amm.contract
            var result = await blockchainCall(ammContract.methods.byTokenAmount, setupInfo.liquidityPoolTokenAddress, tokenAddress, val.ethereansosAdd(surplus))
            liquidityPoolAmount = result.liquidityPoolAmount
            result = await blockchainCall(ammContract.methods.byLiquidityPoolAmount, setupInfo.liquidityPoolTokenAddress, liquidityPoolAmount)
            var ams = result.tokensAmounts
            if(fullValue !== ams[index] && setupTokens[index].decimals !== '18') {
                result = await blockchainCall(ammContract.methods.byTokenAmount, setupInfo.liquidityPoolTokenAddress, tokenAddress, ams[index])
                liquidityPoolAmount = result.liquidityPoolAmount
                ams = result.tokensAmounts
            }
            tks[0] = {
                value : index === 0 && !isFull ? value : fromDecimals(ams[0], setupTokens[0].decimals, true),
                full : ams[0]
            }
            tks[1] = {
                value : index === 1 && !isFull ? value : fromDecimals(ams[1], setupTokens[1].decimals, true),
                full : ams[1]
            }
        } else {
            tokenAddress = tokenAddress === VOID_ETHEREUM_ADDRESS ? ethereumAddress : tokenAddress
            var pool = await createPool()
            var fromAmountData = {pool, tickLower : parseInt(setupInfo.tickLower), tickUpper : parseInt(setupInfo.tickUpper), useFullPrecision : false}
            fromAmountData[`amount${currentIndex}`] = formatNumber(val) + surplus
            var pos = Position[`fromAmount${currentIndex}`](fromAmountData)
            liquidityPoolAmount = pos.liquidity.toString()

            if(setup.objectId && setup.objectId !== '0') {
                var amount0 = pos.amount0.toSignificant(18)
                amount0 === '0' && tickData.cursorNumber !== 0 && tickData.cursorNumber !== 100 && (amount0 = fromDecimals('1', setupTokens[0].decimals, true))

                var amount1 = pos.amount1.toSignificant(18)
                amount1 === '0' && tickData.cursorNumber !== 0 && tickData.cursorNumber !== 100 && (amount1 = fromDecimals('1', setupTokens[1].decimals, true))
                tks[0] = {
                    value : index === 0 && !isFull ? value : numberToString(amount0),
                    full : toDecimals(numberToString(amount0), setupTokens[0].decimals)
                }
                tks[1] = {
                    value : index === 1 && !isFull ? value : numberToString(amount1),
                    full : toDecimals(numberToString(amount1), setupTokens[1].decimals)
                }
            } else {
                pos = pos.mintAmounts
                tks[0] = {
                    value : index === 0 && !isFull ? value : fromDecimals(pos.amount0.toString(), setupTokens[0].decimals, true),
                    full : pos.amount0.toString()
                }
                tks[1] = {
                    value : index === 1 && !isFull ? value : fromDecimals(pos.amount1.toString(), setupTokens[1].decimals, true),
                    full : pos.amount1.toString()
                }
            }
        }
    }
    await elaborateValue()
    while(web3Utils.toBN(tks[index].full).lt(web3Utils.toBN(fullValue))) {
        await elaborateValue(surplus += 999999)
    }
    const balance = setupTokens[index].address === VOID_ETHEREUM_ADDRESS ? await web3.eth.getBalance(account) : await blockchainCall(setupTokens[index].contract.methods.balanceOf, account)
    if(parseInt(fullValue) === parseInt(balance)) {
        tks[index].full = balance
    }
    const mainTokenIndex = setupTokens.indexOf(setupTokens.filter(it => web3Utils.toChecksumAddress(it.address) === web3Utils.toChecksumAddress(isWeth(setupInfo, setupInfo.mainTokenAddress) ? VOID_ETHEREUM_ADDRESS : setupInfo.mainTokenAddress))[0])
    while(element.generation === 'gen2' && setupInfo.minStakeable !== '0' && index === mainTokenIndex && parseInt(tks[index].full) >= parseInt(setupInfo.minStakeable) && !await addLiquidity({test : true, tokenAmounts : tks, lpTokenAmount : liquidityPoolAmount})) {
        console.log("value0", tks[0].full)
        console.log("value1", tks[1].full)
        await elaborateValue(surplus += 999999, true)
    }
    console.log("Liquidity", liquidityPoolAmount)
    console.log("totalSupply", setup.totalSupply)
    console.log("value0", tks[0].full)
    console.log("value1", tks[1].full)
    tickData && tickData.cursorNumber === 0 && (tks[0] = {
        value : '0',
        full : '0'
    })
    tickData && tickData.cursorNumber === 100 && (tks[1] = {
        value : '0',
        full : '0'
    })
    setTokenAmounts(tks.map(it => it))
    setLpTokenAmount(liquidityPoolAmount)
    if (parseInt(setup.totalSupply) + parseInt(liquidityPoolAmount) > 0) {
        var val = parseInt(liquidityPoolAmount) * 6400 * parseInt(setup.rewardPerBlock) / (parseInt(setup.totalSupply) + parseInt(liquidityPoolAmount))
        val = numberToString(val).split('.')[0]
        if (!isNaN(val)) {
            setFreeEstimatedReward(fromDecimals(val, rewardTokenInfo.decimals))
        }
    }
}, 300)

CreatePool

async function createPool(liquidity) {
    liquidity = liquidity || 0
    var slot0 = await blockchainCall(lpTokenInfo.contract.methods.slot0)
    var tick = nearestUsableTick(parseInt(slot0.tick), TICK_SPACINGS[lpTokenInfo.fee])
    var sqrtPriceX96 = TickMath.getSqrtRatioAtTick(tick).toString()
    var pool
    try {
        pool = new Pool(lpTokenInfo.uniswapTokens[0], lpTokenInfo.uniswapTokens[1], parseInt(lpTokenInfo.fee), parseInt(sqrtPriceX96), liquidity, tick)
    } catch(e) {
        try {
            pool = new Pool(lpTokenInfo.uniswapTokens[0], lpTokenInfo.uniswapTokens[1], parseInt(lpTokenInfo.fee), parseInt(slot0.sqrtPriceX96), liquidity, parseInt(slot0.tick))
        } catch(e) {
        }
    }
    return pool
}

CalculateSlippageAmmounts

async function calculateSlippageAmounts(slippage, liquidity, type) {
    slippage = cleanSlippage(slippage)
    if(slippage == 0) {
        return ['0', '0']
    }
    if(element.generation === 'gen1') {
        const amm = (await ammAggregatorPromise).amms.filter(it => web3Utils.toChecksumAddress(it.address) === web3Utils.toChecksumAddress(setupInfo.ammPlugin))[0]
        const result = [...(await blockchainCall(amm.contract.methods.byLiquidityPoolAmount, setupInfo.liquidityPoolTokenAddress, liquidity))[0]]
        result[0] = numberToString(parseInt(result[0]) * (1 - (slippage / 100))).split('.')[0]
        result[1] = numberToString(parseInt(result[1]) * (1 - (slippage / 100))).split('.')[0]
        return result
    }
    try {
        var toler = new Percent(slippage, 100)
        const partialPosition = new Position({
            pool: await createPool(liquidity),
            liquidity,
            tickLower: parseInt(setupInfo.tickLower),
            tickUpper: parseInt(setupInfo.tickUpper)
        })
        var { amount0: amount0Min, amount1: amount1Min } = partialPosition[`${type || 'mint'}AmountsWithSlippage`](toler)
        amount0Min = amount0Min.toString().split('.')[0]
        amount1Min = amount1Min.toString().split('.')[0]
        return [{
            full : amount0Min,
            value : fromDecimals(amount0Min, setupTokens[0].decimals, true)
        }, {
            full : amount1Min,
            value : fromDecimals(amount1Min, setupTokens[1].decimals, true)
        }]
    } catch(e) {
        return ['0', '0']
    }
}

Calculate APY, IsWeth, Calculate SLippage

const calculateApy = async (setup, setupInfo, rewardTokenAddress, rewardTokenDecimals, setupTokens) => {
    if (parseInt(setup.totalSupply) === 0) return -1
    const yearlyBlocks = 2304000
    try {
        const ethPrice = await getEthereumPrice({ context })
        const wusdAddress = getNetworkElement({ context, chainId }, "WUSDAddress") || ""
        const realRewardTokenAddress = await resolveToken({ context, ...web3Data }, rewardTokenAddress)
        const realSetupTokens = await Promise.all(setupTokens.map(it => resolveToken({ context, ...web3Data }, {...it})))
        if (setupInfo.free) {
            const searchTokens = [realRewardTokenAddress, ...realSetupTokens.map(it => it.address || it)].filter(it => it).map(web3Utils.toChecksumAddress).filter((it, i, arr) => arr.indexOf(it) === i)
            const res = await getTokenPricesInDollarsOnCoingecko({ context, web3Data }, searchTokens, { tickToPrice, Token, Pool, Position, nearestUsableTick, TICK_SPACINGS, TickMath, maxLiquidityForAmounts })
            const { data } = res
            const rewardTokenPriceUsd = realRewardTokenAddress !== VOID_ETHEREUM_ADDRESS ? realRewardTokenAddress.toLowerCase() === wusdAddress.toLowerCase() ? 1 : data[realRewardTokenAddress.toLowerCase()].usd : ethPrice
            var den = 0
            await Promise.all(realSetupTokens.map(async (token) => {
                if (token && token.address) {
                    const tokenPrice = token.address !== VOID_ETHEREUM_ADDRESS ? token.address.toLowerCase() === wusdAddress.toLowerCase() ? 1 : data[token.address.toLowerCase()].usd : ethPrice
                    den += (tokenPrice * token.liquidity * 10 ** (18 - token.decimals))
                }
            }))
            const num = (parseInt(setup.rewardPerBlock) * 10 ** (18 - rewardTokenDecimals) * yearlyBlocks) * rewardTokenPriceUsd
            return (num * 100 / den)
        } else {
            const { mainTokenAddress } = setupInfo
            const mainTokenContract = mainTokenAddress !== VOID_ETHEREUM_ADDRESS ? newContract(context.ERC20ABI, mainTokenAddress) : null
            const decimals = mainTokenAddress !== VOID_ETHEREUM_ADDRESS ? await blockchainCall(mainTokenContract.methods.decimals) : 18
            const searchTokens = `${rewardTokenAddress},${mainTokenAddress}`
            const res = await getTokenPricesInDollarsOnCoingecko({ context, web3Data }, searchTokens)
            const { data } = res
            const rewardTokenPriceUsd = rewardTokenAddress !== VOID_ETHEREUM_ADDRESS ? rewardTokenAddress.toLowerCase() === wusdAddress.toLowerCase() ? 1 : data[rewardTokenAddress.toLowerCase()].usd : ethPrice
            const mainTokenPriceUsd = mainTokenAddress !== VOID_ETHEREUM_ADDRESS ? mainTokenAddress.toLowerCase() === wusdAddress.toLowerCase() ? 1 : data[mainTokenAddress.toLowerCase()].usd : ethPrice
            const num = (parseInt(setup.rewardPerBlock) * 10 ** (18 - rewardTokenDecimals) * yearlyBlocks) * rewardTokenPriceUsd * 100
            const den = (parseInt(setupInfo.maxStakeable) * 10 ** (18 - decimals) * mainTokenPriceUsd) * 2
            return num / den
        }
    } catch (error) {
        return 0
    }
}

const isWeth = (setupInfo, address) => {
    return address.toLowerCase() === ethereumAddress.toLowerCase() && setupInfo.involvingETH
}

const getPeriodFromDuration = (duration) => {
    const blockIntervals = context.blockIntervals
    const inv = Object.entries(blockIntervals).reduce((ret, entry) => {
        const [key, value] = entry
        ret[value] = key
        return ret
    }, {})
    return inv[duration]
}

const activateSetup = async () => {
    if (!setupReady) return
    setActivateLoading(true)
    try {
        await blockchainCall(element.contract.methods.activateSetup, setup.infoIndex)
        await reloadData()
    } catch (error) {
        console.log(error)
    } finally {
        setActivateLoading(false)
    }
}

const onTokenApproval = (index, isLp) => {
    if (isLp) {
        setLpTokenInfo({ ...lpTokenInfo, approval: true })
        return
    }
    setTokensApprovals(tokensApprovals.map((val, i) => i === index ? true : val))
    try {
        if(setupInfo.minStakeable !== '0') {
            const index = setupTokens.indexOf(setupTokens.filter(it => web3Utils.toChecksumAddress(it.address) === web3Utils.toChecksumAddress(isWeth(setupInfo, setupInfo.mainTokenAddress) ? VOID_ETHEREUM_ADDRESS : setupInfo.mainTokenAddress))[0])
            onUpdateTokenAmount(fromDecimals(setupInfo.minStakeable, setupTokens[index].decimals, true), index)
        }
    } catch(e) {
    }
}

function cleanSlippage(slippage) {
    slippage = numberToString(parseFloat(slippage || 0))
    if(slippage === '0') {
        return 0
    }
    var arr = slippage.split('.')
    if(arr.length > 1) {
        var n = parseFloat('0.' + arr[1])
        slippage = numberToString(parseInt(arr[0]) + (n >= 0.5 ? 1 : 0))
    }
    return parseInt(slippage)
}

ActivateSetup

function toggleSetup() {
        return blockchainCall(element.contract.methods.toggleSetup, setup.infoIndex)
    }

    const loadData = useCallback(async (farmSetup, farmSetupInfo, reset, loop) => {
        var position = null
        var lockPositions = []
        reset && setLockedEstimatedReward(0)
        setUpdatedRenewTimes(farmSetupInfo.renewTimes)
        setUpdatedRewardPerBlock(farmSetup.rewardPerBlock)
        var positions = element.positions || []
        var positionIds = positions.map(it => it.positionId)
        if(positions.length === 0) {
            const events = await getLogs(web3.currentProvider, 'eth_getLogs', {
                address: element.address,
                topics: [
                    web3.utils.sha3("Transfer(uint256,address,address)"),
                    [],
                    [],
                    abi.encode(["address"], [account])
                ],
                fromBlock: web3Utils.toHex(getNetworkElement({ context, chainId }, 'deploySearchStart')) || "0x0",
                toBlock: 'latest',
            })
            positionIds = events.map(it => abi.decode(["uint256"], it.topics[1])[0].toString())
        }
        for (const positionId of positionIds) {
            var pos = positions.filter(it => it.positionId === positionId)[0] || await loadFarmingPosition({ ...web3Data, context }, element.contract, positionId)
            if(!positions.filter(it => it.positionId === positionId)[0]) {
                var {'0': loadedSetup, '1': loadedSetupInfo} = await loadFarmingSetup({...web3Data, context}, element.contract, pos.setupIndex)
                loadedSetupInfo = {...loadedSetupInfo}
                loadedSetup = {...loadedSetup, setupIndex : pos.setupIndex, setupInfo : {...loadedSetupInfo}}
                pos = { ...pos, positionId, setup : {...loadedSetup} }
            }
            if (isValidPosition({ ...web3Data, context }, pos) && parseInt(pos.setup.setupIndex) === parseInt(setup.setupIndex)) {
                if (farmSetupInfo.free) {
                    position = { ...pos, positionId }
                } else if (!positionIds.includes(positionId)) {
                    lockPositions.push({ ...pos, positionId })
                }
            }
        }
        setSetupMustBeToggled(farmSetup.active && parseInt(currentBlock) > parseInt(farmSetup.endBlock) && (parseInt(farmSetup.totalSupply) === 0 || position === undefined || position === null) && parseInt(farmSetupInfo.renewTimes) > 0)
        setCurrentPosition(position)
        setLockedPositions(lockPositions)
        if (!position && reset) {
            setOpen(false)
            setWithdrawOpen(false)
        }
        !extensionContract && setExtensionContract(element.extensionContract)
        const rewardToken = rewardTokenInfo || await loadTokenFromAddress({ context, ...web3Data, seaport }, await blockchainCall(element.contract.methods._rewardTokenAddress))
        const rewardTokenApproval = await blockchainCall(rewardToken.contract.methods.allowance, account, element.address)
        setRewardTokenInfo(oldValue => ({ ...oldValue, ...rewardToken, approval: parseInt(rewardTokenApproval) !== 0 && parseInt(rewardTokenApproval) >= parseInt(rewardToken.balance) }))

        const tokenAddress = farmSetupInfo.liquidityPoolTokenAddress
        const lpToken = newContract(context.UniswapV3PoolABI, tokenAddress)

        if(!loop) {
            if(element.generation === 'gen1') {
                const lpToken = newContract(context.ERC20ABI, farmSetupInfo.liquidityPoolTokenAddress)
                const lpTokenSymbol = await lpToken.methods.symbol().call()
                const lpTokenDecimals = await lpToken.methods.decimals().call()
                const lpTokenBalance = await lpToken.methods.balanceOf(account).call()
                const lpTokenApproval = await lpToken.methods.allowance(account, element.contract.options.address).call()

                const info = await blockchainCall((await ammAggregatorPromise).ammAggregator.methods.findByLiquidityPool, tokenAddress)

                const ammAggregatorAddress = web3Utils.toChecksumAddress(info[3])
                const amms = (await ammAggregatorPromise).amms
                const amm = amms.filter(it => it.address === ammAggregatorAddress)[0]

                const originalTokenAddresses = info[2].map(web3Utils.toChecksumAddress)
                const tokenAddresses = originalTokenAddresses.map(it => farmSetupInfo.involvingETH && it === amm.ethereumAddress ? VOID_ETHEREUM_ADDRESS : it)
                const tokens = await Promise.all(tokenAddresses.map(it => loadTokenFromAddress({ context, ...web3Data, seaport }, it)))

                const tokenValues = (await blockchainCall(amm.contract.methods.byLiquidityPoolAmount, farmSetupInfo.liquidityPoolTokenAddress, farmSetup.totalSupply))[0]

                setLpTokenInfo({ originalTokenAddresses, tokenAddresses, tokens, tokenValues, amm, contract: lpToken, symbol: lpTokenSymbol, decimals: lpTokenDecimals, balance: lpTokenBalance, approval: parseInt(lpTokenApproval) !== 0 && parseInt(lpTokenApproval) >= parseInt(lpTokenBalance) })
            } else {
                const lpTokenSymbol = "UniV3"
                const lpTokenDecimals = "18"
                const lpTokenBalance = "0"
                const lpTokenApproval = "0"
                const fee = await blockchainCall(lpToken.methods.fee)
                const slot = await blockchainCall(lpToken.methods.slot0)
                var uniswapTokens = await Promise.all([
                    await blockchainCall(lpToken.methods.token0),
                    await blockchainCall(lpToken.methods.token1)
                ].map(async tkAddress => {
                    const currentToken = await loadTokenFromAddress({ context, ...web3Data, seaport }, tkAddress)
                    return new Token(chainId, tkAddress, parseInt(currentToken.decimals), currentToken.symbol, currentToken.name)
                }))
                console.log("Slot", farmSetup.infoIndex, {
                    tick: slot.tick,
                    sqrtPriceX96: slot.sqrtPriceX96,
                    tickLower : farmSetupInfo.tickLower,
                    tickUpper : farmSetupInfo.tickUpper,
                    fee,
                    inRange : parseInt(farmSetupInfo.tickLower) >= parseInt(slot.tick) && parseInt(slot.tick) <= parseInt(farmSetupInfo.tickUpper)
                })
                setLpTokenInfo({ uniswapTokens, fee, contract: lpToken, symbol: lpTokenSymbol, decimals: lpTokenDecimals, balance: lpTokenBalance, approval: parseInt(lpTokenApproval) !== 0 && parseInt(lpTokenApproval) >= parseInt(lpTokenBalance) })
            }
        }
        const activateSetup = parseInt(farmSetupInfo.renewTimes) > 0 && !farmSetup.active && parseInt(farmSetupInfo.lastSetupIndex) === parseInt(setup.setupIndex)
        setCanActivateSetup(activateSetup)
        var startBlock = formatNumber(farmSetupInfo.startBlock || 0)
        setDelayedBlock(currentBlock > startBlock ? 0 : startBlock)

        setEndBlockReached(currentBlock > formatNumber(farmSetup.endBlock))

        if(!loop) {
            const extensionBalance = await blockchainCall(rewardToken.contract.methods.balanceOf, element.extensionAddress)
            var extB = web3Utils.toBN(extensionBalance)
            var rwPB = web3Utils.toBN(farmSetup.rewardPerBlock)
            var bD = web3Utils.toBN(farmSetupInfo.blockDuration)
            var mul = rwPB.mul(bD)
            var ready = extB.gte(mul)
            ready = element.byMint || ready
            setSetupReady(ready)
        }

        var balances = ['0', '0']
        var fees = ['0', '0']
        if(element.generation === 'gen2') {
            try {
                ({balances, fees} = await simulateDecreaseLiquidityAndCollect(farmSetup.objectId, element.address))
            } catch(e) {
                if(farmSetup.totalSupply !== '0') {
                    try {
                        const lpTokenEthers = new ethers.Contract(tokenAddress, context.UniswapV3PoolABI, ethersProvider)
                        var data = await lpTokenEthers.callStatic.burn(farmSetupInfo.tickLower, farmSetupInfo.tickUpper, farmSetup.totalSupply, {
                            from : getNetworkElement({ context, chainId }, "uniswapV3NonfungiblePositionManagerAddress")
                        })
                        balances = [data.amount0.toString(), data.amount1.toString()]
                    } catch(e) {
                        console.log(e)
                    }
                }
            }
        }
        if(element.generation === 'gen1' && lpTokenInfo) {
            balances = lpTokenInfo.tokenValues
        }
        const tokens = [...setupTokens]
        if(tokens.length === 0) {
            const liquidityPoolTokens = element.generation === 'gen2' ? await Promise.all([
                blockchainCall(lpToken.methods.token0),
                blockchainCall(lpToken.methods.token1)
            ]) : (await blockchainCall((await ammAggregatorPromise).ammAggregator.methods.findByLiquidityPool, tokenAddress))[2]
            for (var i in liquidityPoolTokens) {
                const address = liquidityPoolTokens[i]
                const token = await loadTokenFromAddress({context, ...web3Data, seaport}, isWeth(farmSetupInfo, address) ? VOID_ETHEREUM_ADDRESS : address)
                tokens.push(token)
            }
            setSetupTokens(oldValue => (oldValue && oldValue.length > 0 && oldValue) || tokens)
        }

        const approvals = []
        for(const i in tokens) {
            const token = tokens[i]
            token.balance = await blockchainCall(token.contract.methods.balanceOf, account)
            token.liquidity = balances[i]
            const approval = await blockchainCall(token.contract.methods.allowance, account, element.address)
            approvals.push(parseInt(approval) !== 0 && (parseInt(approval) >= parseInt(token.balance) || !token))
            if (web3Utils.toChecksumAddress(token.address) === web3Utils.toChecksumAddress(farmSetupInfo.mainTokenAddress) || (web3Utils.toChecksumAddress(token.address) === VOID_ETHEREUM_ADDRESS && web3Utils.toChecksumAddress(farmSetupInfo.mainTokenAddress) === web3Utils.toChecksumAddress(farmSetupInfo.ethereumAddress))) {
                setMainTokenInfo(oldValue => ({...oldValue, ...token, approval: parseInt(approval) !== 0 && (parseInt(approval) >= parseInt(token.balance) || !token)}))
            }
        }

        setTokensApprovals(approvals)

        reset && setLpTokenAmount(null)
        reset && setTokenAmounts(new Array(tokens.length).fill(0))

        // retrieve the manage data using the position
        if (position) {
            const free = position['free']
            const creationBlock = position['creationBlock']
            const positionSetupIndex = position['setupIndex']
            const liquidityPoolTokenAmount = position['liquidityPoolTokenAmount']
            const amounts = {
                tokenAmounts : [0, 0]
            }
            var additionalFees = ['0', '0']
            try {
                var simulation = await simulateDecreaseLiquidityAndCollect(position.tokenId || farmSetup.objectId, element.address, position.liquidityPoolTokenAmount)
                amounts.tokenAmounts = simulation.liquidity
                additionalFees = simulation.fees
            } catch(e) {
            }
            if(element.generation === 'gen1') {
                const amm = (await ammAggregatorPromise).amms.filter(it => web3Utils.toChecksumAddress(it.address) === web3Utils.toChecksumAddress(setupInfo.ammPlugin))[0]
                const result = await blockchainCall(amm.contract.methods.byLiquidityPoolAmount, setupInfo.liquidityPoolTokenAddress, position.liquidityPoolTokenAmount)
                amounts.tokenAmounts = result[0]
            }
            console.log(position.positionId)
            const availableReward = await blockchainCall(element.contract.methods.calculateFreeFarmingReward, position.positionId, true)
            var freeReward = parseInt(availableReward)
            if (currentBlock < parseInt(farmSetup.endBlock)) {
                freeReward += (parseInt(farmSetup.rewardPerBlock) * (parseInt(position.liquidityPoolTokenAmount) / parseInt(farmSetup.totalSupply)))
            }
            freeReward = numberToString(freeReward).split('.')[0]
            setFreeAvailableRewards(freeReward)
            try {
                var result = await blockchainCall(element.contract.methods.calculateTradingFees, position.positionId, freeReward, fees[0], fees[1])
                additionalFees = [
                    result[0],
                    result[1]
                ]
            } catch(e) {}
            var withdrawOnly = !farmSetup.active || currentBlock > parseInt(farmSetup.endBlock)
            setManageStatus({ withdrawOnly, additionalFees, free, creationBlock, positionSetupIndex, liquidityPoolAmount: liquidityPoolTokenAmount, tokenAmounts: amounts['tokenAmounts'], tokens })
        }
        // calculate APY
        setApy(await calculateApy(farmSetup, farmSetupInfo, rewardToken.address, rewardToken.decimals, tokens))
    }, [setupTokens, account, currentBlock])

    const reloadData = useCallback(async (noReset, loop) => {
        try {
            var { '0': farmSetup, '1': farmSetupInfo } = await loadFarmingSetup({ ...web3Data, context }, element.contract, setup.setupIndex)
            farmSetupInfo = {... farmSetupInfo, free : true, ethereumAddress : getNetworkElement({ context, chainId }, 'wethTokenAddress')}
            farmSetup = {... farmSetup, togglable : farmSetup.active && currentBlock > parseInt(farmSetup.endBlock)}
            farmSetup.setupIndex = setup.setupIndex
            farmSetup.setupInfo = farmSetupInfo
            setSetup(farmSetup)
            setSetupInfo(farmSetupInfo)
            setShowPrestoError(false)
            await loadData(farmSetup, farmSetupInfo, !noReset, loop)
        } catch (e) {
            console.log(e)
        }
    }, [element.address, setup && setup.setupIndex, loadData])

    useEffect(() => {
        dequeue(intervalId)
        if(noInternalRefetch || !setupTokens || setupTokens.length === 0) {
            return
        }
        enqueue(intervalId, () => reloadData(true, true))
        return () => dequeue(intervalId)
    }, [noInternalRefetch, reloadData, setupTokens])

    async function simulateDecreaseLiquidityAndCollect(objectId, lmContractAddress, amount) {
        var nftPosMan = newContract(context.UniswapV3NonfungiblePositionManagerABI, getNetworkElement({ context, chainId }, "uniswapV3NonfungiblePositionManagerAddress"))
        var bytes = [
            nftPosMan.methods.decreaseLiquidity({
                tokenId : objectId,
                liquidity : amount || (await blockchainCall(nftPosMan.methods.positions, objectId)).liquidity,
                amount0Min : 0,
                amount1Min : 0,
                deadline: new Date().getTime() + 10000
            }).encodeABI(),
            nftPosMan.methods.collect({
                tokenId : objectId,
                recipient: lmContractAddress,
                amount0Max: MAX_UINT128,
                amount1Max: MAX_UINT128
            }).encodeABI()
        ]
        var result = await nftPosMan.methods.multicall(bytes).call({
            from : lmContractAddress
        })
        var liquidity = web3.eth.abi.decodeParameters(["uint128", "uint128"], result[0])
        var balances = web3.eth.abi.decodeParameters(["uint128", "uint128"], result[1])
        var fees = [
            web3Utils.toBN(balances[0]).sub(web3Utils.toBN(liquidity[0])).toString(),
            web3Utils.toBN(balances[1]).sub(web3Utils.toBN(liquidity[1])).toString(),
        ]
        return {
            liquidity,
            balances,
            fees
        }
    }

Recalculate Fee Allowance

 const recalculateFeeAllowance = useCallback(() => {
        setupTokens && setupTokens.length > 0 && feeData && (feeData.tokenToTransferOrBurnInApplication || feeData.tokenToTransferOrBurnInCreation) && setTimeout(async () => {
            setFeeData(oldValue => ({...oldValue, transferOrBurnAllowanceInCreation : undefined, transferOrBurnAllowanceInApplication : undefined}))
            async function allowed(token, operator, account, amount) {
                if(!token || token.address === VOID_ETHEREUM_ADDRESS || amount === '0') {
                    return true
                }
                return parseInt(amount) <= parseInt(await blockchainCall(token.contract.methods.allowance, operator, account))
            }
            feeData.transferOrBurnAllowanceInCreation = await allowed(feeData.tokenToTransferOrBurnInCreation, feeData.operator, account, feeData.transferOrBurnAmountInCreation)
            feeData.transferOrBurnAllowanceInApplication = await allowed(feeData.tokenToTransferOrBurnInCreation, feeData.operator, account, feeData.transferOrBurnAmountInApplication)
            var { data } = await getTokenPricesInDollarsOnCoingecko({ context, web3Data }, feeData.tokenToTransferOrBurnAddressInApplication)
            data = data[feeData.tokenToTransferOrBurnAddressInApplication.toLowerCase()].usd
            data *= parseFloat(fromDecimals(feeData.transferOrBurnAmountInApplication, feeData.tokenToTransferOrBurnInApplication.decimals, true))
            const burnFeePrice = data
            if(feeData.feePercentageForTransacted === '0') {
                return setFeeType("burn")
            }
            const events = await getLogs(web3.currentProvider, 'eth_getLogs', {
                address: element.address,
                topics: [
                    web3.utils.sha3("Transfer(uint256,address,address)"),
                    [],
                    [],
                    abi.encode(["address"], [account])
                ],
                fromBlock: web3Utils.toHex(getNetworkElement({ context, chainId }, 'deploySearchStart')) || "0x0",
                toBlock: 'latest',
            })
            var positionId = events.map(it => abi.decode(["uint256"], it.topics[1])[0].toString())
            try {
                positionId = positionId[positionId.length - 1]
                if(!positionId) {
                    return
                }
                const position = await loadFarmingPosition({ ...web3Data, context }, element.contract, positionId)
                const simulation = await simulateDecreaseLiquidityAndCollect(position.tokenId, element.address, position.liquidityPoolTokenAmount)
                console.log({simulation})
                var { data } = await getTokenPricesInDollarsOnCoingecko({ context, web3Data }, setupTokens.map(it => it.address))
                data = setupTokens.map(it => data[it.address.toLowerCase()].usd || data[it.address.toLowerCase()] || 0)
                data = data.map((it, i) => it * parseFloat(fromDecimals(simulation.fees[i], setupTokens[i].decimals, true)))
                data = data.reduce((acc, i) => acc + i, 0)
                if(data <= burnFeePrice) {
                    return setFeeType("percentage")
                }
            } catch(e) {
            }

        })
    }, [feeData && feeData.transferOrBurnTypeInApplication, setupTokens, account])

    useEffect(recalculateFeeAllowance, [recalculateFeeAllowance])

UseEffects

    useEffect(() => blockchainCall(element.contract.methods.initializer).then(factoryAddress => blockchainCall(newContract(context.EthereansFactoryABI, factoryAddress).methods.feeInfo)).then(result => void(setFeeData(result), reloadData())), [])

useEffect(() => {
    updateEthAmount(ethAmount)
}, [receiver, selectedAmmIndex])

useEffect(() => element.generation === 'gen2' && calculateSlippageAmounts(slippage, lpTokenAmount).then(setAmountsMin), [element.generation, slippage, lpTokenAmount])
useEffect(() => {
    if(element.generation !== 'gen1' || !tokenAmounts || tokenAmounts.length === 0) {
        return setAmountsMin(['0', '0'])
    }
    const arr = [
        numberToString(parseInt(tokenAmounts[0].full || tokenAmounts[0]) * (100 - parseFloat(slippage)) / 100).split('.')[0],
        numberToString(parseInt(tokenAmounts[1].full || tokenAmounts[1]) * (100 - parseFloat(slippage)) / 100).split('.')[0]
    ]
    setAmountsMin(arr)
}, [element.generation, tokenAmounts, slippage])

useEffect(() => setTimeout(async () => {
    if(element.generation === 'gen1') {
        try {
            var tickData = {
                diluted : true,
                maxPrice : 0,
                minPrice : 9999999,
                currentPrice : 0,
                cursorNumber : 50,
                outOfRangeLower : 0,
                outOfRangeUpper : 99999999,
                tickLowerUSDPrice : 0,
                tickUpperUSDPrice : 0,
                tickCurrentUSDPrice : 0
            }
            const tokenIndex = secondTokenIndex
            const value = formatNumber(fromDecimals(lpTokenInfo.tokenValues[tokenIndex], lpTokenInfo.tokens[tokenIndex].decimals, true))
            const price = Object.values((await getTokenPricesInDollarsOnCoingecko({context, web3Data}, lpTokenInfo.tokenAddresses[tokenIndex])).data)[0]
            const usdPrice = price
            tickData.tickCurrentUSDPrice = usdPrice
            setTickData(tickData)
        } catch(e) {
        }
    }
    if(element.generation === 'gen2') {
        try {
            var slot = await blockchainCall(lpTokenInfo.contract.methods.slot0)
            var a = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[0], lpTokenInfo.uniswapTokens[1], parseInt(setupInfo.tickLower)).toSignificant(15))
            var b = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[0], lpTokenInfo.uniswapTokens[1], parseInt(setupInfo.tickUpper)).toSignificant(15))
            var c = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[0], lpTokenInfo.uniswapTokens[1], parseInt(slot.tick)).toSignificant(15))
            var diluted = Math.abs(parseInt(setupInfo.tickUpper) - parseInt(setupInfo.tickLower)) >= 180000
            var tickData = {
                diluted,
                maxPrice : tickToPrice(lpTokenInfo.uniswapTokens[1 - secondTokenIndex], lpTokenInfo.uniswapTokens[secondTokenIndex], parseInt(setupInfo.tickLower)).toSignificant(4),
                minPrice : tickToPrice(lpTokenInfo.uniswapTokens[1 - secondTokenIndex], lpTokenInfo.uniswapTokens[secondTokenIndex], parseInt(setupInfo.tickUpper)).toSignificant(4),
                currentPrice : tickToPrice(lpTokenInfo.uniswapTokens[1 - secondTokenIndex], lpTokenInfo.uniswapTokens[secondTokenIndex], parseInt(slot.tick)).toSignificant(4),
                cursorNumber : !(c > a) ? 100 : !(c < b) ? 0 : null,
                outOfRangeLower : parseInt(slot.tick) <= parseInt(setupInfo.tickLower),
                outOfRangeUpper : parseInt(slot.tick) >= parseInt(setupInfo.tickUpper),
                tickLowerUSDPrice : 0,
                tickUpperUSDPrice : 0,
                tickCurrentUSDPrice : 0
            }
            if(secondTokenIndex === 1) {
                var maxPrice = tickData.maxPrice
                tickData.maxPrice = tickData.minPrice
                tickData.minPrice = maxPrice
            }
            if(tickData.cursorNumber !== 0 && tickData.cursorNumber !== 100) {
                tickData.cursorNumber = (1 / ((Math.sqrt(a * b) - Math.sqrt(b * c)) / (c - Math.sqrt(b * c)) + 1)) * 100
            }
            tickData.cursor = formatMoneyUniV3(secondTokenIndex === 1 ? 100 - tickData.cursorNumber : tickData.cursorNumber, 2)

            var tokensForPrice = lpTokenInfo.uniswapTokens.map(it => it.address === ethereumAddress ? VOID_ETHEREUM_ADDRESS : it.address)
            var ethIndex = tokensForPrice.indexOf(VOID_ETHEREUM_ADDRESS)
            if(ethIndex !== -1) {
                var ethPrice = await getEthereumPrice({ context })
                tickData.tickLowerUSDPrice = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[1 - ethIndex], lpTokenInfo.uniswapTokens[ethIndex], parseInt(setupInfo.tickLower)).toSignificant(15)) * ethPrice
                tickData.tickUpperUSDPrice = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[1 - ethIndex], lpTokenInfo.uniswapTokens[ethIndex], parseInt(setupInfo.tickUpper)).toSignificant(15)) * ethPrice
                tickData.tickCurrentUSDPrice = formatNumber(tickToPrice(lpTokenInfo.uniswapTokens[1 - ethIndex], lpTokenInfo.uniswapTokens[ethIndex], parseInt(slot.tick)).toSignificant(15)) * ethPrice
                tickData.cursor = formatMoneyUniV3(ethIndex === 1 ? 100 - tickData.cursorNumber : tickData.cursorNumber, 2)
            }
            setTickData(tickData)
        } catch(e) {
        }
    }
}), [lpTokenInfo, secondTokenIndex, setupInfo])

useEffect(() => {
    setReceiver()
    setMinimumStakingError()
}, [open])

useEffect(() => {
    if(!open || !setupInfo || setupInfo.minStakeable === '0' || !setupTokens || setupTokens.length === 0 || !tokenAmounts || tokenAmounts.length === 0 || (tokenAmounts.filter(it => parseInt(it.full || it) === 0).length === 2 && minimumStakingError !== undefined && minimumStakingError !== null)) {
        return
    }
    const index = setupTokens.indexOf(setupTokens.filter(it => web3Utils.toChecksumAddress(it.address) === web3Utils.toChecksumAddress(isWeth(setupInfo, setupInfo.mainTokenAddress) ? VOID_ETHEREUM_ADDRESS : setupInfo.mainTokenAddress))[0])

    const value = parseInt(tokenAmounts[index].full || tokenAmounts[index])

    if(value < parseInt(setupInfo.minStakeable)) {
        if(minimumStakingError !== undefined  && minimumStakingError !== null) {
            minimumStakingErrorTimeout.current && clearTimeout(minimumStakingErrorTimeout.current)
            setMinimumStakingError(`${setupTokens[index].symbol} value has been reset to the minimum amount of ${fromDecimals(setupInfo.minStakeable, setupTokens[index].decimals)}`)
            minimumStakingErrorTimeout.current = setTimeout(() => setMinimumStakingError(""), 2500)
        } else {
            setMinimumStakingError("")
        }
        return onUpdateTokenAmount(fromDecimals(setupInfo.minStakeable, setupTokens[index].decimals, true), index)
    }
}, [setupTokens, setupInfo, tokenAmounts, open, minimumStakingError])

useEffect(() => {
    feeData && !feeData.transferOrBurnTypeInApplication && !feeData.transferOrBurnTypeInCreation && setTimeout(async () => {
        const tokenToTransferOrBurnInApplication = feeData.tokenToTransferOrBurnAddressInApplication !== VOID_ETHEREUM_ADDRESS && await loadTokenFromAddress({context, ...web3Data, seaport}, feeData.tokenToTransferOrBurnAddressInApplication)
        const tokenToTransferOrBurnInCreation = feeData.tokenToTransferOrBurnAddressInCreation !== VOID_ETHEREUM_ADDRESS && await loadTokenFromAddress({context, ...web3Data, seaport}, feeData.tokenToTransferOrBurnAddressInCreation)
        const transferOrBurnTypeInApplication = feeData.transferOrBurnReceiverInApplication === VOID_ETHEREUM_ADDRESS ? 'burn' : 'transfer'
        const transferOrBurnTypeInCreation = feeData.transferOrBurnReceiverInCreation === VOID_ETHEREUM_ADDRESS ? 'burn' : 'transfer'
        setFeeData(oldValue => ({...oldValue, tokenToTransferOrBurnInApplication, tokenToTransferOrBurnInCreation, transferOrBurnTypeInApplication, transferOrBurnTypeInCreation}))
    })
}, [feeData])

useEffect(() => {
    feeData && console.log("Fee data", feeData)
    feeType !== 'burn' && setBurnFeeAllowance()
    feeData && (feeData.transferOrBurnTypeInApplication || feeData.transferOrBurnTypeInCreation) && feeData.tokenToTransferOrBurnAddressInApplication !== VOID_ETHEREUM_ADDRESS && feeType === 'burn' && setTimeout(async () => {
        setBurnFeeAllowance(parseInt(await blockchainCall(feeData.tokenToTransferOrBurnInApplication.contract.methods.allowance, account, feeData.operator)) < parseInt(feeData.transferOrBurnAmountInApplication))
    })
}, [feeData, feeType, account])

useEffect(setSettings, [open, edit, withdrawOpen])

AMM aggregator promise & getFarmingPrestoAddress

const ammAggregatorPromise = useMemo(() => new Promise(async ok => {
    var amms = []
        const ammAggregator = newContract(context.AMMAggregatorABI, getNetworkElement({ context, chainId }, 'ammAggregatorAddress'))
        const ammAddresses = (await ammAggregator.methods.amms().call()).map(web3Utils.toChecksumAddress)
        for (var address of ammAddresses) {
            const ammContract = newContract(context.AMMABI, address)
            const amm = {
                address,
                contract: ammContract,
                info: await ammContract.methods.info().call(),
                data: await ammContract.methods.data().call()
            }
            amm.name = amm.info[0]
            amm.ethereumAddress = web3Utils.toChecksumAddress(amm.data[0])
            amm.data[2] && amms.push(amm)
        }
        setSelectedAmmIndex(0)
        const uniswap = amms.filter(it => it.info[0] === 'UniswapV2')[0]
        const index = amms.indexOf(uniswap)
        amms.splice(index, 1)
        amms.unshift(uniswap)
        ok({
            ammAggregator,
            amms
        })
}), [chainId])

function getFarmingPrestoAddress() {
    var prestoAddress = getNetworkElement({ context, chainId }, "farmingPrestoAddress")
    var oldPrestoAddress = getNetworkElement({ context, chainId }, "farmingPrestoAddressOld")
    var oldFarmingPrestoContracts = getNetworkElement({ context, chainId }, "oldFarmingPrestoContracts").map(it => web3Utils.toChecksumAddress(it))
    var lmContractAddress = web3Utils.toChecksumAddress(element.address)
    return oldFarmingPrestoContracts.indexOf(lmContractAddress) === -1 ? prestoAddress : oldPrestoAddress
}

const farmingPresto = useMemo(() => newContract(context.FarmingPrestoABI, getFarmingPrestoAddress()), [chainId])

Imports and State definitions

import React, { useRef, useEffect, useState, useMemo, useCallback } from 'react'

import { tickToPrice, Pool, Position, nearestUsableTick, TICK_SPACINGS, TickMath, maxLiquidityForAmounts } from '@uniswap/v3-sdk/dist/'
import { Token, Percent } from "@uniswap/sdk-core/dist"

import OurCircularProgress from '../../Global/OurCircularProgress'
import LogoRenderer from '../../Global/LogoRenderer'
import ActionAWeb3Button from '../../Global/ActionAWeb3Button'
import TokenInputRegular from '../../Global/TokenInputRegular'
import RegularButtonDuo from '../../Global/RegularButtonDuo'

import { formatMoney, blockchainCall, getTokenPricesInDollarsOnCoingecko, ethers, sendAsync, isEthereumAddress, getEthereumPrice, normalizeValue, formatMoneyUniV3, useWeb3, useEthosContext, getNetworkElement, web3Utils, abi, VOID_ETHEREUM_ADDRESS, toDecimals, fromDecimals, numberToString, formatNumber, getTokenPriceInDollarsOnUniswap } from '@ethereansos/interfaces-core'

import { loadFarmingSetup, loadFarmingPosition, isValidPosition, addLiquidityGen2 } from '../../../logic/farming'
import { loadTokenFromAddress } from '../../../logic/erc20'
import { getLogs } from '../../../logic/logger'
import { enqueue, dequeue } from '../../../logic/interval'

import style from '../../../all.module.css'
import { resolveToken } from '../../../logic/dualChain'
import { useOpenSea } from '../../../logic/uiUtilities'

const MAX_UINT128 = '0x' + web3Utils.toBN(2).pow(web3Utils.toBN(128)).sub(web3Utils.toBN(1)).toString('hex')
const MAX_UINT256 = '0x' + web3Utils.toBN(2).pow(web3Utils.toBN(256)).sub(web3Utils.toBN(1)).toString('hex')

const contracts = [
"0x3889ABE350A054701e8ea55055CcD960cB4cB91a",
"0x679780Ea3133C388E3c7efeb22e98a68Ccf99aFf"
].map(web3Utils.toChecksumAddress)

export default props => {

const { element, setupInput, refresh, noInternalRefetch } = props

const context = useEthosContext()

const seaport = useOpenSea()

const web3Data = useWeb3()

const { web3, account, chainId, newContract, block, dualChainId, dualBlock } = web3Data

const currentBlock = useMemo(() => parseInt(dualBlock || block), [block, dualBlock])

const ethersProvider = useMemo(() => new ethers.providers.Web3Provider(web3.currentProvider), [web3])

// general info and setup data
const [setup, setSetup] = useState(setupInput)
const [setupInfo, setSetupInfo] = useState(setupInput.setupInfo)
const [activateLoading, setActivateLoading] = useState(false)
const [transferLoading, setTransferLoading] = useState(false)
const [approveLoading, setApproveLoading] = useState()
// panel status
const [open, setOpen] = useState(false)
const [edit, setEdit] = useState(false)
const [withdrawOpen, setWithdrawOpen] = useState(false)
const [showFreeTransfer, setShowFreeTransfer] = useState(false)
const [canActivateSetup, setCanActivateSetup] = useState(false)
const [setupReady, setSetupReady] = useState(false)
const [showPrestoError, setShowPrestoError] = useState(false)
// amm data
const [AMM, setAMM] = useState({ name: "", version: "" })
const [ammContract, setAmmContract] = useState(null)

const [freeTransferAddress, setFreeTransferAddress] = useState("")
const [extensionContract, setExtensionContract] = useState(null)
const [farmTokenDecimals, setFarmTokenDecimals] = useState(18)
const [farmTokenERC20Address, setFarmTokenERC20Address] = useState("")
const [farmTokenSymbol, setFarmTokenSymbol] = useState("")
const [farmTokenBalance, setFarmTokenBalance] = useState("0")
const [farmTokenRes, setFarmTokenRes] = useState([])
const [setupTokens, setSetupTokens] = useState([])
const [tokenAmounts, setTokenAmounts] = useState([])
const [tokensApprovals, setTokensApprovals] = useState([])
const [lpTokenAmount, setLpTokenAmount] = useState(null)
const [lockedEstimatedReward, setLockedEstimatedReward] = useState(0)
const [freeEstimatedReward, setFreeEstimatedReward] = useState(0)
const [lpTokenInfo, setLpTokenInfo] = useState(null)
const [mainTokenInfo, setMainTokenInfo] = useState(null)
const [rewardTokenInfo, setRewardTokenInfo] = useState(null)
const [removalAmount, setRemovalAmount] = useState(0)
const [currentPosition, setCurrentPosition] = useState(null)
const [manageStatus, setManageStatus] = useState(null)
const [freeAvailableRewards, setFreeAvailableRewards] = useState(0)
const [lockedPositions, setLockedPositions] = useState([])
const [lockedPositionStatuses, setLockedPositionStatuses] = useState([])
const [lockedPositionRewards, setLockedPositionRewards] = useState([])
const [updatedRewardPerBlock, setUpdatedRewardPerBlock] = useState(0)
const [updatedRenewTimes, setUpdatedRenewTimes] = useState(0)
const [receiver, setReceiver] = useState()
const [apy, setApy] = useState(0)
const [inputType, setInputType] = useState("add-pair")
const [outputType, setOutputType] = useState("to-pair")
const [ethAmount, setEthAmount] = useState(0)
const [ethBalanceOf, setEthBalanceOf] = useState("0")
const intervalId = useMemo(() => new Date().getTime() + '_' + (new Date().getTime() * Math.random()), [])
const updateAmountTimeout = useRef(null)
const minimumStakingErrorTimeout = useRef(null)
const [prestoData, setPrestoData] = useState(null)
const [selectedAmmIndex, setSelectedAmmIndex] = useState(0)
const [amms, setAmms] = useState(0)
const [loadingPrestoData, setLoadingPrestoData] = useState(false)
const [delayedBlock, setDelayedBlock] = useState(0)
const [endBlockReached, setEndBlockReached] = useState(false)
const [secondTokenIndex, setsecondTokenIndex] = useState(0)
const [tickData, setTickData] = useState({cursorNumber : 50})

const ethereumAddress = getNetworkElement({ context, chainId }, "wethTokenAddress")

const [settings, setSettings] = useState(false)
const [slippage, setSlippage] = useState(3)
const [amountsMin, setAmountsMin] = useState(['0', '0'])

const [minimumStakingError, setMinimumStakingError] = useState()

const [feeType, setFeeType] = useState("percentage")

const [feeData, setFeeData] = useState()

const [burnFeeAllowance, setBurnFeeAllowance] = useState()

const [setupMustBeToggled, setSetupMustBeToggled] = useState()