import * as Gwei from 'tevm/Gwei'
import * as Wei from 'tevm/Wei'
import * as Uint from 'tevm/Uint'

const gasPrice = Gwei(50n)      // 50 Gwei
const gasUsed = 21_000n              // Standard transfer

const gasPriceWei = Gwei.toWei(gasPrice)
const costWei = Uint.times(gasPriceWei, Uint(gasUsed))

console.log(`Cost: ${costWei} Wei`)    // 1,050,000,000,000,000 Wei
console.log(`Cost: 1,050,000 Gwei`)    // 1,050,000 Gwei
console.log(`Cost: 0.00105 ETH`)       // ~0.00105 ETH

import * as Gwei from 'tevm/Gwei'
import * as Wei from 'tevm/Wei'
import * as Uint from 'tevm/Uint'

const gasPrice = Gwei(200n)     // 200 Gwei (urgent)
const gasUsed = 21_000n              // Standard transfer

const gasPriceWei = Gwei.toWei(gasPrice)
const costWei = Uint.times(gasPriceWei, Uint(gasUsed))

console.log(`Cost: ${costWei} Wei`)    // 4,200,000,000,000,000 Wei
console.log(`Cost: 4,200,000 Gwei`)    // 4,200,000 Gwei
console.log(`Cost: 0.0042 ETH`)        // ~0.0042 ETH

import * as Gwei from 'tevm/Gwei'
import * as Wei from 'tevm/Wei'
import * as Uint from 'tevm/Uint'

interface EIP1559Cost {
  minCost: { wei: bigint; gwei: bigint; ether: number }
  maxCost: { wei: bigint; gwei: bigint; ether: number }
  estimatedCost: { wei: bigint; gwei: bigint; ether: number }
}

function calculateEIP1559(
  baseFeePerGas: Gwei.Type,
  maxPriorityFeePerGas: Gwei.Type,
  maxFeePerGas: Gwei.Type,
  gasLimit: bigint
): EIP1559Cost {
  // Minimum cost (base fee only)
  const baseFeeWei = Gwei.toWei(baseFeePerGas)
  const minCostWei = Uint.times(baseFeeWei, Uint(gasLimit))

  // Maximum cost (max fee)
  const maxFeeWei = Gwei.toWei(maxFeePerGas)
  const maxCostWei = Uint.times(maxFeeWei, Uint(gasLimit))

  // Estimated cost (base + priority)
  const priorityFeeWei = Gwei.toWei(maxPriorityFeePerGas)
  const effectiveFeeWei = Uint.plus(baseFeeWei, priorityFeeWei)
  const estimatedCostWei = Uint.times(effectiveFeeWei, Uint(gasLimit))

  return {
    minCost: {
      wei: minCostWei,
      gwei: Uint.dividedBy(minCostWei, Uint(1_000_000_000n)),
      ether: Number(minCostWei) / 1e18
    },
    maxCost: {
      wei: maxCostWei,
      gwei: Uint.dividedBy(maxCostWei, Uint(1_000_000_000n)),
      ether: Number(maxCostWei) / 1e18
    },
    estimatedCost: {
      wei: estimatedCostWei,
      gwei: Uint.dividedBy(estimatedCostWei, Uint(1_000_000_000n)),
      ether: Number(estimatedCostWei) / 1e18
    }
  }
}

// Example: Normal Ethereum conditions
const cost = calculateEIP1559(
  Gwei(30n),  // baseFee
  Gwei(2n),   // priorityFee
  Gwei(50n),  // maxFee
  21_000n          // gasLimit
)

console.log('Min (base only):', cost.minCost)           // 630,000 Gwei
console.log('Estimated (base + priority):', cost.estimatedCost)  // 672,000 Gwei
console.log('Max (worst case):', cost.maxCost)          // 1,050,000 Gwei

import * as Gwei from 'tevm/Gwei'
import * as Wei from 'tevm/Wei'
import * as Uint from 'tevm/Uint'

interface TransactionCost {
  wei: bigint
  gwei: bigint
  ether: string
  usd: string
}

function analyzeCost(
  gasPriceGwei: Gwei.Type,
  gasUsed: bigint,
  ethPriceUsd: number
): TransactionCost {
  const gasPriceWei = Gwei.toWei(gasPriceGwei)
  const costWei = Uint.times(gasPriceWei, Uint(gasUsed))
  const costGwei = Uint.dividedBy(costWei, Uint(1_000_000_000n))
  const costEth = Number(costWei) / 1e18
  const costUsd = costEth * ethPriceUsd

  return {
    wei: costWei,
    gwei: costGwei,
    ether: `${costEth.toFixed(6)} ETH`,
    usd: `$${costUsd.toFixed(2)} USD`
  }
}

// Compare costs across different conditions
const scenarios = [
  { price: 20, desc: 'Slow' },
  { price: 50, desc: 'Standard' },
  { price: 100, desc: 'Fast' },
  { price: 200, desc: 'Urgent' }
]

const ethPrice = 2000  // $2000 per ETH

console.log('Transfer costs (21,000 gas):')
scenarios.forEach(({ price, desc }) => {
  const cost = analyzeCost(Gwei(BigInt(price)), 21_000n, ethPrice)
  console.log(`${desc}: ${cost.gwei} Gwei = ${cost.ether} = ${cost.usd}`)
})

import * as Gwei from 'tevm/Gwei'
import * as Wei from 'tevm/Wei'
import * as Uint from 'tevm/Uint'

function costMatrix(
  gasPrices: bigint[],
  ethPrices: number[],
  gasUsed: bigint = 21_000n
): Map<string, number> {
  const costs = new Map<string, number>()

  for (const gwei of gasPrices) {
    for (const eth of ethPrices) {
      const gasPriceWei = Gwei.toWei(Gwei(gwei))
      const costWei = Uint.times(gasPriceWei, Uint(gasUsed))
      const costUsd = (Number(costWei) / 1e18) * eth

      costs.set(`${gwei}gwei_${eth}usd`, costUsd)
    }
  }

  return costs
}

// Create matrix: gas prices vs ETH prices
const gasPrices = [20n, 50n, 100n, 200n]
const ethPrices = [1000, 2000, 3000, 5000]
const costs = costMatrix(gasPrices, ethPrices)

// Show cost ranges
console.table(Array(costs.entries()).map(([key, value]) => ({
  scenario: key,
  cost: `$${value.toFixed(2)}`
})))