Polygon zkEVM Yield Farming: Complete Tutorial for Maximum DeFi Yields

// Network configuration for MetaMask
const polygonzkEVMConfig = {
  chainId: '0x44D', // 1101 in decimal
  chainName: 'Polygon zkEVM',
  nativeCurrency: {
    name: 'Ether',
    symbol: 'ETH',
    decimals: 18
  },
  rpcUrls: ['https://zkevm-rpc.com'],
  blockExplorerUrls: ['https://zkevm.polygonscan.com/']
};

// Add network to MetaMask
await ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [polygonzkEVMConfig]
});

// QuickSwap LP token staking contract
contract QuickswapFarm {
    function deposit(uint256 _pid, uint256 _amount) external {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        
        updatePool(_pid);
        
        if (user.amount > 0) {
            uint256 pending = user.amount * pool.accRewardPerShare / 1e12 - user.rewardDebt;
            if(pending > 0) {
                safeRewardTransfer(msg.sender, pending);
            }
        }
        
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount += _amount;
        }
        
        user.rewardDebt = user.amount * pool.accRewardPerShare / 1e12;
        emit Deposit(msg.sender, _pid, _amount);
    }
}

// Calculate optimal liquidity amounts
function calculateLiquidity(ethAmount, usdcAmount, currentPrice) {
  const ethValue = ethAmount * currentPrice;
  const usdcValue = usdcAmount;
  
  // Balance amounts for 50/50 pool
  if (ethValue > usdcValue) {
    return {
      eth: usdcAmount / currentPrice,
      usdc: usdcAmount
    };
  } else {
    return {
      eth: ethAmount,
      usdc: ethAmount * currentPrice
    };
  }
}

// Example: Add $1000 liquidity
const liquidity = calculateLiquidity(0.3, 500, 1667); // ETH price $1667
console.log(`Add ${liquidity.eth} ETH and ${liquidity.usdc} USDC`);

// Staking transaction
async function stakeLPTokens(farmContract, lpTokenAmount) {
  try {
    // Approve LP tokens for staking
    const approveTx = await lpToken.approve(farmContract.address, lpTokenAmount);
    await approveTx.wait();
    
    // Stake LP tokens
    const stakeTx = await farmContract.deposit(0, lpTokenAmount); // Pool ID 0 for ETH/USDC
    await stakeTx.wait();
    
    console.log('LP tokens staked successfully');
    return stakeTx.hash;
  } catch (error) {
    console.error('Staking failed:', error);
  }
}

function calculateOptimalCompounding(
  principal,
  dailyAPY,
  gasCost,
  compoundingDays
) {
  const dailyReturn = principal * (dailyAPY / 365);
  const netDailyReturn = dailyReturn - gasCost;
  
  if (netDailyReturn <= 0) {
    return "Compounding not profitable";
  }
  
  // Calculate when to compound
  const optimalDays = Math.ceil(gasCost / dailyReturn);
  
  return {
    optimalFrequency: `Every ${optimalDays} days`,
    netAPY: ((netDailyReturn * 365) / principal) * 100
  };
}

// Example: $1000 principal, 20% APY, $0.02 gas
const strategy = calculateOptimalCompounding(1000, 0.20, 0.02, 7);
console.log(strategy);
// Output: {optimalFrequency: "Every 1 days", netAPY: 19.27}

contract zkEVMArbitrage {
    function executeArbitrage(
        address tokenA,
        address tokenB,
        uint256 amount,
        address[] memory exchanges
    ) external {
        // 1. Flash loan from Aave
        IFlashLoanReceiver.flashLoan(tokenA, amount);
        
        // 2. Buy tokenB on Exchange 1
        uint256 tokenBAmount = swapExactTokensForTokens(
            amount,
            0,
            getPath(tokenA, tokenB),
            exchanges[0]
        );
        
        // 3. Sell tokenB on Exchange 2  
        uint256 tokenAAmount = swapExactTokensForTokens(
            tokenBAmount,
            0,
            getPath(tokenB, tokenA),
            exchanges[1]
        );
        
        // 4. Repay flash loan + profit
        require(tokenAAmount > amount, "Arbitrage not profitable");
        repayFlashLoan(amount);
        
        // 5. Keep profit
        uint256 profit = tokenAAmount - amount;
        IERC20(tokenA).transfer(msg.sender, profit);
    }
}

contract AutoFarmer {
    mapping(address => UserStrategy) public strategies;
    
    struct UserStrategy {
        uint256 targetAPY;
        uint256 maxSlippage;
        address[] preferredPools;
        bool autoCompound;
    }
    
    function autoRebalance(address user) external {
        UserStrategy memory strategy = strategies[user];
        
        // Check current positions
        uint256 currentAPY = calculateCurrentAPY(user);
        
        if (currentAPY < strategy.targetAPY) {
            // Find better opportunities
            address bestPool = findBestPool(strategy.preferredPools);
            migrateFunds(user, bestPool);
        }
        
        if (strategy.autoCompound) {
            compoundRewards(user);
        }
    }
}

function calculateImpermanentLoss(priceChange) {
  // Formula: IL = 2 * sqrt(priceRatio) / (1 + priceRatio) - 1
  const priceRatio = 1 + priceChange;
  const impermanentLoss = (2 * Math.sqrt(priceRatio)) / (1 + priceRatio) - 1;
  
  return impermanentLoss * 100; // Convert to percentage
}

// Examples
console.log(`25% price increase: ${calculateImpermanentLoss(0.25).toFixed(2)}% IL`);
console.log(`50% price increase: ${calculateImpermanentLoss(0.50).toFixed(2)}% IL`);
console.log(`100% price increase: ${calculateImpermanentLoss(1.0).toFixed(2)}% IL`);

// Output:
// 25% price increase: -0.62% IL
// 50% price increase: -2.02% IL  
// 100% price increase: -5.72% IL

// Portfolio tracker
class zkEVMFarmTracker {
  constructor() {
    this.positions = [];
    this.totalValue = 0;
  }
  
  addPosition(protocol, pool, amount, apy) {
    this.positions.push({
      protocol,
      pool,
      amount,
      apy,
      entryDate: new Date(),
      dailyRewards: (amount * apy) / 365
    });
    this.updateTotalValue();
  }
  
  calculateDailyRewards() {
    return this.positions.reduce((total, pos) => total + pos.dailyRewards, 0);
  }
  
  getPortfolioAPY() {
    const weightedAPY = this.positions.reduce((total, pos) => {
      return total + (pos.apy * pos.amount / this.totalValue);
    }, 0);
    return weightedAPY;
  }
}

// Usage example
const tracker = new zkEVMFarmTracker();
tracker.addPosition("QuickSwap", "ETH/USDC", 1000, 0.20);
tracker.addPosition("Gamma", "ETH/USDT", 500, 0.25);

console.log(`Daily rewards: $${tracker.calculateDailyRewards().toFixed(2)}`);
console.log(`Portfolio APY: ${tracker.getPortfolioAPY().toFixed(2)}%`);

// Reset and approve tokens
async function resetApproval(tokenContract, spenderAddress, newAmount) {
  // Reset to 0 first
  await tokenContract.approve(spenderAddress, 0);
  
  // Set new approval
  await tokenContract.approve(spenderAddress, newAmount);
}