// Calculate monthly emission for current year
function getMonthlyEmission(year) {
  const yearlyEmissions = {
    1: 200_000_000,
    2: 250_000_000,
    3: 200_000_000,
    4: 150_000_000,
    5: 100_000_000
  };

  const yearlyTotal = yearlyEmissions[year] || 0;
  const monthlyEmission = yearlyTotal / 12;

  return monthlyEmission;
}

// Example: Year 2 monthly emission
console.log(`Month: ${getMonthlyEmission(2).toLocaleString()} NZT`);
// Output: Month: 20,833,333 NZT

# Calculate expected daily emission
def calculate_daily_emission(year):
    yearly_caps = {
        1: 200_000_000,
        2: 250_000_000,
        3: 200_000_000,
        4: 150_000_000,
        5: 100_000_000
    }

    yearly_emission = yearly_caps.get(year, 0)
    daily_emission = yearly_emission / 365

    return daily_emission

# Example: Year 1 daily emission
print(f"Daily: {calculate_daily_emission(1):,.2f} NZT")
# Output: Daily: 547,945.21 NZT

// Calculate current inflation rate
function getCurrentInflationRate() public view returns (uint256) {
    uint256 currentSupply = nztToken.totalSupply();
    uint256 yearlyEmission = getYearlyEmissionCap();

    // Inflation = (New Supply / Current Supply) * 100
    uint256 inflationRate = (yearlyEmission * 10000) / currentSupply;

    return inflationRate; // Returns basis points (10000 = 100%)
}

// Example: Year 2
// Current supply: 300M
// Yearly emission: 250M
// Inflation: (250M / 300M) * 100 = 83.33%

// 35% of all gas fees are burned
function calculateAnnualBurn(dailyTransactions, avgGasPrice) {
  const avgGasPerTx = 100_000; // Average gas per transaction
  const dailyGas = dailyTransactions * avgGasPerTx;
  const dailyFees = dailyGas * avgGasPrice; // In NZT

  const baseFeeShare = dailyFees * 0.70; // 70% is base fee
  const burnShare = baseFeeShare * 0.50; // 50% of base fee burned

  const annualBurn = burnShare * 365;
  return annualBurn;
}

// Example: 1M daily transactions at 1 gwei
const burn = calculateAnnualBurn(1_000_000, 1e-9 * 2000); // Assume 1 gwei = 2000 NZT
console.log(`Annual burn: ${burn.toLocaleString()} NZT`);
// Output: Annual burn: 25,550,000 NZT (2.56% of supply)

// 40% of slashed tokens go to treasury (effectively removed from circulation)
function slashAgent(address agent, uint256 amount) external {
    uint256 treasuryShare = (amount * 40) / 100; // 40% to treasury
    uint256 insuranceShare = (amount * 30) / 100; // 30% to insurance
    uint256 rewardShare = (amount * 30) / 100;    // 30% to stakers

    nztToken.transferFrom(agent, treasury, treasuryShare);
    nztToken.transferFrom(agent, insurance, insuranceShare);
    nztToken.transferFrom(agent, rewardPool, rewardShare);
}

// Estimated annual slashing: 5M NZT (0.5% of supply)

// Tokens locked in staking reduce circulating supply
function estimateLockedSupply(totalSupply, stakingRatio) {
  const lockedTokens = totalSupply * stakingRatio;
  const circulatingSupply = totalSupply - lockedTokens;

  return {
    locked: lockedTokens,
    circulating: circulatingSupply,
    effectiveInflation: 1 / stakingRatio
  };
}

// Example: Year 3 with 40% staking ratio
const result = estimateLockedSupply(750_000_000, 0.40);
console.log(`Locked: ${result.locked.toLocaleString()} NZT`);
console.log(`Circulating: ${result.circulating.toLocaleString()} NZT`);
// Output: Locked: 300,000,000 NZT
//         Circulating: 450,000,000 NZT

contract MintManager {
    bool public paused;

    function pauseEmissions() external onlyRole(GOVERNANCE_ROLE) {
        paused = true;
        emit EmissionsPaused(block.timestamp);
    }

    function unpauseEmissions() external onlyRole(GOVERNANCE_ROLE) {
        paused = false;
        emit EmissionsUnpaused(block.timestamp);
    }

    modifier whenNotPaused() {
        require(!paused, "Emissions paused");
        _;
    }
}

function proposeEmissionChange(
    uint256 year,
    uint256 newEmissionAmount
) external onlyRole(GOVERNANCE_ROLE) {
    require(year > getCurrentYear(), "Cannot modify past years");
    require(newEmissionAmount <= MAX_SUPPLY - totalEmitted, "Exceeds max supply");

    // Create governance proposal
    uint256 proposalId = governance.propose(
        "Modify Year X Emission Schedule",
        address(this),
        abi.encodeWithSignature(
            "updateYearlyEmission(uint256,uint256)",
            year,
            newEmissionAmount
        )
    );

    emit EmissionChangeProposed(proposalId, year, newEmissionAmount);
}

// Calculate post-emission staking APY
function calculatePostEmissionAPY(
  dailyTransactions,
  avgTaskReward,
  annualSlashing,
  totalStaked
) {
  // Annual fee revenue
  const dailyFees = dailyTransactions * 100_000 * 1e-9 * 2000; // NZT
  const annualFees = dailyFees * 365 * 0.35; // 35% to stakers

  // Annual task rewards
  const dailyTasks = dailyTransactions * 0.1; // 10% of txs are task-related
  const annualTaskRewards = dailyTasks * 365 * avgTaskReward * 0.1;

  // Slashing distribution
  const slashingToStakers = annualSlashing * 0.3;

  // Total annual rewards
  const totalRewards = annualFees + annualTaskRewards + slashingToStakers;

  // Calculate APY
  const apy = (totalRewards / totalStaked) * 100;

  return {
    totalRewards,
    apy,
    breakdown: {
      fees: annualFees,
      tasks: annualTaskRewards,
      slashing: slashingToStakers
    }
  };
}

// Example: Year 6+ with mature network
const result = calculatePostEmissionAPY(
  5_000_000,    // 5M daily transactions
  100,          // 100 NZT avg task reward
  10_000_000,   // 10M NZT slashed annually
  400_000_000   // 400M NZT staked (40%)
);

console.log(`Post-emission APY: ${result.apy.toFixed(2)}%`);
console.log(`From fees: ${result.breakdown.fees.toLocaleString()} NZT`);
console.log(`From tasks: ${result.breakdown.tasks.toLocaleString()} NZT`);
console.log(`From slashing: ${result.breakdown.slashing.toLocaleString()} NZT`);

// Output:
// Post-emission APY: 12.84%
// From fees: 44,695,000 NZT
// From tasks: 1,825,000 NZT
// From slashing: 3,000,000 NZT

Equilibrium Point:
- Daily emissions: 0 (max supply reached)
- Daily burns: ~0.3% of circulating supply annually
- Staking locks: 40% of total supply
- Result: Deflationary circulating supply with healthy staking yields

const mintManager = new ethers.Contract(
  mintManagerAddress,
  mintManagerAbi,
  provider
);

// Get total emitted to date
const totalEmitted = await mintManager.totalEmitted();
console.log(`Total emitted: ${ethers.formatEther(totalEmitted)} NZT`);

// Get current year
const currentYear = await mintManager.getCurrentYear();
console.log(`Current year: ${currentYear}`);

// Get available emission
const available = await mintManager.getAvailableEmission();
console.log(`Available: ${ethers.formatEther(available)} NZT`);

// Get yearly cap
const yearlyCap = await mintManager.getYearlyEmissionCap();
console.log(`Yearly cap: ${ethers.formatEther(yearlyCap)} NZT`);