import * as MaxPriorityFeePerGas from './primitives/MaxPriorityFeePerGas/index.js';

// Set tip for miners
const tip = MaxPriorityFeePerGas.fromGwei(2n); // 2 Gwei tip
console.log(MaxPriorityFeePerGas.toWei(tip)); // 2000000000n

// From hex (RPC format)
const fee = MaxPriorityFeePerGas.from("0x77359400");
console.log(MaxPriorityFeePerGas.toGwei(fee)); // 2n

type MaxPriorityFeePerGasType = bigint & { readonly [brand]: "MaxPriorityFeePerGas" };

const fee1 = MaxPriorityFeePerGas.from(2000000000n);
const fee2 = MaxPriorityFeePerGas.from("0x77359400");
const fee3 = MaxPriorityFeePerGas.from(2000000000);

const fee = MaxPriorityFeePerGas.fromGwei(2n); // 2000000000n Wei

const fee = MaxPriorityFeePerGas.fromWei(2000000000n);

const fee = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.toGwei(fee); // 2n

MaxPriorityFeePerGas.toWei(fee); // 2000000000n

MaxPriorityFeePerGas.toNumber(fee); // 2000000000

MaxPriorityFeePerGas.toBigInt(fee); // 2000000000n

const fee1 = MaxPriorityFeePerGas.from(2000000000n);
const fee2 = MaxPriorityFeePerGas.from(2000000000n);
MaxPriorityFeePerGas.equals(fee1, fee2); // true

const fee1 = MaxPriorityFeePerGas.from(2000000000n);
const fee2 = MaxPriorityFeePerGas.from(5000000000n);
MaxPriorityFeePerGas.compare(fee1, fee2); // -1

const priorityFee = MaxPriorityFeePerGas.fromGwei(2n);
const gasUsed = 21000n;

// Miner receives
const minerRevenue = priorityFee * gasUsed; // 42000000000000n Wei (0.000042 ETH)

const baseFee = BaseFeePerGas.fromGwei(25n);
const maxFee = MaxFeePerGas.fromGwei(30n);
const maxPriorityFee = MaxPriorityFeePerGas.fromGwei(10n);

// Available for tip: maxFee - baseFee = 5 Gwei
const availableForTip = maxFee - baseFee; // 5000000000n

// Effective priority fee = min(maxPriorityFee, availableForTip)
const effectiveTip = availableForTip < maxPriorityFee
  ? availableForTip
  : maxPriorityFee; // 5 Gwei (capped)

const priority = {
  // No rush, lowest cost
  low: MaxPriorityFeePerGas.fromGwei(1n),

  // Normal inclusion speed
  normal: MaxPriorityFeePerGas.fromGwei(2n),

  // Faster inclusion
  high: MaxPriorityFeePerGas.fromGwei(5n),

  // Next block priority
  urgent: MaxPriorityFeePerGas.fromGwei(10n),
};

const noTip = MaxPriorityFeePerGas.from(0n);
// Transaction still valid, but low priority

// Standard transfer - normal priority
const normalTx = {
  to: '0x...',
  value: parseEther('1.0'),
  maxPriorityFeePerGas: MaxPriorityFeePerGas.fromGwei(2n),
};

// Contract interaction - higher priority
const contractTx = {
  to: '0x...',
  data: '0x...',
  maxPriorityFeePerGas: MaxPriorityFeePerGas.fromGwei(5n),
};

// Time-sensitive trade - urgent
const tradeTx = {
  to: '0x...',
  data: '0x...',
  maxPriorityFeePerGas: MaxPriorityFeePerGas.fromGwei(10n),
};

// Adjust priority based on mempool congestion
async function getRecommendedPriorityFee(
  urgency: 'low' | 'normal' | 'high'
): Promise<bigint> {
  // Query mempool or fee estimation service
  const mempoolStats = await fetchMempoolStats();

  const percentiles = {
    low: mempoolStats.p25,    // 25th percentile
    normal: mempoolStats.p50,  // 50th percentile
    high: mempoolStats.p75,    // 75th percentile
  };

  return MaxPriorityFeePerGas.fromGwei(
    BigInt(percentiles[urgency])
  );
}

// Sandwich attack protection
const mevProtectionTip = MaxPriorityFeePerGas.fromGwei(50n);

// Front-run prevention
const privateTx = {
  to: '0x...',
  data: '0x...',
  maxPriorityFeePerGas: mevProtectionTip,
  // Consider using Flashbots or private relay
};

async function estimatePriorityFee(
  provider,
  blocks = 20,
  percentile = 50
): Promise<bigint> {
  const fees: bigint[] = [];

  for (let i = 0; i < blocks; i++) {
    const block = await provider.getBlock(-i);

    // Collect priority fees from block transactions
    for (const tx of block.transactions) {
      if (tx.maxPriorityFeePerGas) {
        fees.push(MaxPriorityFeePerGas.from(tx.maxPriorityFeePerGas));
      }
    }
  }

  fees.sort((a, b) => Number(a - b));
  const index = Math.floor((fees.length * percentile) / 100);

  return fees[index];
}

// Mainnet typical
const mainnet = MaxPriorityFeePerGas.fromGwei(2n);

// L2s (cheaper)
const arbitrum = MaxPriorityFeePerGas.fromGwei(1n);
const optimism = MaxPriorityFeePerGas.fromGwei(1n);

// Polygon (very cheap)
const polygon = MaxPriorityFeePerGas.fromGwei(30n); // 30 Gwei common

// Initial submission
let priorityFee = MaxPriorityFeePerGas.fromGwei(2n);
const txHash = await sendTransaction({ maxPriorityFeePerGas: priorityFee });

// If stuck, increase tip
setTimeout(async () => {
  const receipt = await provider.getTransactionReceipt(txHash);
  if (!receipt) {
    // Increase by 20%
    const newPriority = MaxPriorityFeePerGas.fromGwei(
      (MaxPriorityFeePerGas.toGwei(priorityFee) * 120n) / 100n
    );

    // Replace transaction with same nonce
    await sendTransaction({
      nonce: originalNonce,
      maxPriorityFeePerGas: newPriority,
    });
  }
}, 30000); // Check after 30s

// Calculate optimal tip within budget
function calculateTip(
  baseFee: bigint,
  maxFee: bigint,
  desiredTip: bigint
): bigint {
  const available = maxFee - baseFee;

  return MaxPriorityFeePerGas.from(
    available < desiredTip ? available : desiredTip
  );
}

const baseFee = BaseFeePerGas.fromGwei(25n);
const maxFee = MaxFeePerGas.fromGwei(35n);
const desiredTip = MaxPriorityFeePerGas.fromGwei(15n);

const actualTip = calculateTip(baseFee, maxFee, desiredTip);
// Returns 10 Gwei (capped by available budget)

const priorityFee = MaxPriorityFeePerGas.fromGwei(2n);
const gasUsed = 21000n; // Standard transfer

// Cost in Wei
const tipCost = priorityFee * gasUsed; // 42000000000000n

// Cost in ETH (using Denomination)
const ethCost = Number(tipCost) / 1e18; // 0.000042 ETH