Total Fee = (Base Fee + Priority Fee) × Gas Used

function calculateL1Cost(
  batchSize,        // Bytes in batch
  baseL2GasPrice,   // Base L2 gas price (wei)
  calldataGas       // 16 gas per non-zero byte
) {
  // L1 gas = calldata cost
  const l1Gas = batchSize * calldataGas;

  // L1 cost in Base L2 native token (ETH)
  const l1CostETH = l1Gas * baseL2GasPrice;

  // Convert to NZT equivalent
  const ethToNztRate = 2000; // 1 ETH = 2000 NZT
  const l1CostNZT = l1CostETH * ethToNztRate;

  return {
    l1Gas,
    l1CostETH,
    l1CostNZT,
    costPerTx: l1CostNZT / (batchSize / 200) // Assume 200 bytes per tx
  };
}

// Example: 100 KB batch at 1 gwei Base L2 gas price
const result = calculateL1Cost(
  100_000,   // 100 KB
  1e9,       // 1 gwei
  16         // Calldata gas per byte
);

console.log(`L1 Gas: ${result.l1Gas.toLocaleString()}`);
console.log(`L1 Cost: ${result.l1CostETH} ETH`);
console.log(`L1 Cost: ${result.l1CostNZT.toLocaleString()} NZT`);
console.log(`Cost per tx: ${result.costPerTx.toFixed(6)} NZT`);

// Output:
// L1 Gas: 1,600,000
// L1 Cost: 0.0016 ETH
// L1 Cost: 3,200 NZT
// Cost per tx: 6.4 NZT

# Optimize batch size for cost efficiency
def optimize_batch(tx_count, avg_tx_size, base_l2_gas_price):
    """
    Calculate optimal batch size considering:
    - Calldata costs on Base L2
    - Batch submission overhead
    - Transaction inclusion delay
    """
    batch_size = tx_count * avg_tx_size
    calldata_cost = batch_size * 16 * base_l2_gas_price

    # Add overhead for batch header, proof, etc.
    overhead = 500 * base_l2_gas_price

    total_cost = calldata_cost + overhead
    cost_per_tx = total_cost / tx_count

    return {
        'batch_size_bytes': batch_size,
        'total_l1_cost': total_cost,
        'cost_per_tx': cost_per_tx,
        'efficiency': tx_count / (batch_size / 1000)  # txs per KB
    }

# Example: Optimize for 1000 transactions
result = optimize_batch(
    tx_count=1000,
    avg_tx_size=200,
    base_l2_gas_price=1e9  # 1 gwei
)

print(f"Batch size: {result['batch_size_bytes']:,} bytes")
print(f"Total L1 cost: {result['total_l1_cost']:.6f} ETH")
print(f"Cost per tx: {result['cost_per_tx']:.9f} ETH")
print(f"Efficiency: {result['efficiency']:.2f} txs/KB")

class GasCostCalculator {
  constructor(baseFee, priorityFee, nztToUSD) {
    this.baseFee = baseFee;        // in gwei
    this.priorityFee = priorityFee; // in gwei
    this.nztToUSD = nztToUSD;      // NZT price in USD
  }

  calculateCost(gasUsed) {
    const totalGwei = gasUsed * (this.baseFee + this.priorityFee);
    const totalNZT = totalGwei / 1e9;
    const totalUSD = totalNZT * this.nztToUSD;

    return {
      gas: gasUsed,
      gwei: totalGwei,
      nzt: totalNZT,
      usd: totalUSD
    };
  }

  compareOperations(operations) {
    return operations.map(op => ({
      operation: op.name,
      ...this.calculateCost(op.gas)
    }));
  }
}

// Example usage
const calculator = new GasCostCalculator(
  1,     // 1 gwei base fee
  0.5,   // 0.5 gwei priority fee
  0.05   // $0.05 per NZT
);

const operations = [
  { name: 'Register Agent', gas: 250_000 },
  { name: 'Submit Proof', gas: 150_000 },
  { name: 'Stake Tokens', gas: 120_000 }
];

const costs = calculator.compareOperations(operations);
console.table(costs);

// Output:
// ┌─────────────────────┬──────────┬──────────┬──────────┬─────────┐
// │     operation       │   gas    │   gwei   │   nzt    │   usd   │
// ├─────────────────────┼──────────┼──────────┼──────────┼─────────┤
// │  Register Agent     │  250000  │  375000  │ 0.000375 │ 0.00002 │
// │  Submit Proof       │  150000  │  225000  │ 0.000225 │ 0.00001 │
// │  Stake Tokens       │  120000  │  180000  │ 0.000180 │ 0.00001 │
// └─────────────────────┴──────────┴──────────┴──────────┴─────────┘

function estimateMonthlyCost(
  dailyTaskClaims,
  dailyProofSubmissions,
  dailyStakingOps,
  avgGasPrice
) {
  const gasCosts = {
    claimTask: 90_000,
    submitProof: 150_000,
    stakingOp: 120_000
  };

  const dailyCost =
    (dailyTaskClaims * gasCosts.claimTask +
     dailyProofSubmissions * gasCosts.submitProof +
     dailyStakingOps * gasCosts.stakingOp) *
    avgGasPrice / 1e9; // Convert to NZT

  const monthlyCost = dailyCost * 30;

  return {
    dailyGas: dailyCost / avgGasPrice * 1e9,
    dailyCostNZT: dailyCost,
    monthlyCostNZT: monthlyCost,
    monthlyCostUSD: monthlyCost * 0.05 // Assume $0.05 per NZT
  };
}

// Example: Active agent
const activeCost = estimateMonthlyCost(
  10,    // 10 task claims per day
  10,    // 10 proof submissions per day
  2,     // 2 staking operations per day
  1e-9   // 1 gwei
);

console.log(`Daily gas: ${activeCost.dailyGas.toLocaleString()}`);
console.log(`Monthly cost: ${activeCost.monthlyCostNZT.toFixed(6)} NZT`);
console.log(`Monthly cost: $${activeCost.monthlyCostUSD.toFixed(4)}`);

// Output:
// Daily gas: 1,140,000
// Monthly cost: 0.034200 NZT
// Monthly cost: $0.0017

// Compare to Ethereum L1
const l1MonthlyCost = activeCost.monthlyCostUSD * 30000;
console.log(`Same operations on L1: $${l1MonthlyCost.toFixed(2)}`);
// Output: Same operations on L1: $51.00

const dailyFees = 100_000; // NZT

const distribution = {
  baseFee: dailyFees * 0.70,      // 70,000 NZT
  sequencerFee: dailyFees * 0.20, // 20,000 NZT
  l1Fee: dailyFees * 0.10         // 10,000 NZT
};

const baseFeeDistribution = {
  burned: distribution.baseFee * 0.50,  // 35,000 NZT
  stakers: distribution.baseFee * 0.50  // 35,000 NZT
};

console.log('Daily Fee Distribution:');
console.log(`Total Fees: ${dailyFees.toLocaleString()} NZT`);
console.log(`\nBase Fee (70%): ${distribution.baseFee.toLocaleString()} NZT`);
console.log(`  - Burned: ${baseFeeDistribution.burned.toLocaleString()} NZT`);
console.log(`  - Stakers: ${baseFeeDistribution.stakers.toLocaleString()} NZT`);
console.log(`\nSequencer (20%): ${distribution.sequencerFee.toLocaleString()} NZT`);
console.log(`L1 Costs (10%): ${distribution.l1Fee.toLocaleString()} NZT`);

// Annual impact
const annualBurn = baseFeeDistribution.burned * 365;
const annualStaking = baseFeeDistribution.stakers * 365;

console.log(`\nAnnual Burn: ${annualBurn.toLocaleString()} NZT (1.28% of supply)`);
console.log(`Annual Staking: ${annualStaking.toLocaleString()} NZT (1.28% of supply)`);

contract FeeGovernance {
    // Adjustable parameters
    uint256 public minBaseFee = 1 gwei;
    uint256 public maxBaseFee = 100 gwei;
    uint256 public baseFeePercentage = 70;    // 70%
    uint256 public sequencerPercentage = 20;  // 20%
    uint256 public l1Percentage = 10;         // 10%

    /// @notice Update fee split (governance only)
    function updateFeeSplit(
        uint256 _baseFee,
        uint256 _sequencer,
        uint256 _l1
    ) external onlyGovernance {
        require(_baseFee + _sequencer + _l1 == 100, "Must equal 100%");

        baseFeePercentage = _baseFee;
        sequencerPercentage = _sequencer;
        l1Percentage = _l1;

        emit FeeSplitUpdated(_baseFee, _sequencer, _l1);
    }

    /// @notice Update min/max base fee (governance only)
    function updateBaseFeeRange(
        uint256 _min,
        uint256 _max
    ) external onlyGovernance {
        require(_min < _max, "Invalid range");
        minBaseFee = _min;
        maxBaseFee = _max;

        emit BaseFeeRangeUpdated(_min, _max);
    }
}