payment_queryFeeDetails - Neuroweb RPC Method

import { ApiPromise, WsProvider } from '@polkadot/api';

async function analyzeFeeComponents(api, tx) {
  const feeDetails = await api.rpc.payment.queryFeeDetails(tx.toHex());

  if (feeDetails.inclusionFee.isNone) {
    return { feeless: true };
  }

  const fee = feeDetails.inclusionFee.unwrap();
  const base = BigInt(fee.baseFee.toString());
  const len = BigInt(fee.lenFee.toString());
  const weight = BigInt(fee.adjustedWeightFee.toString());
  const total = base + len + weight;

  const analysis = {
    baseFee: { value: base, percentage: Number((base * 10000n) / total) / 100 },
    lenFee: { value: len, percentage: Number((len * 10000n) / total) / 100 },
    weightFee: { value: weight, percentage: Number((weight * 10000n) / total) / 100 },
    total
  };

  // Suggest optimization based on dominant component
  if (analysis.lenFee.percentage > 50) {
    analysis.suggestion = 'Length fee dominates -- reduce call data size or batch smaller calls';
  } else if (analysis.weightFee.percentage > 50) {
    analysis.suggestion = 'Weight fee dominates -- choose lighter runtime operations';
  } else {
    analysis.suggestion = 'Fees are balanced -- batch calls to amortize base fee';
  }

  return analysis;
}

async function compareBatchVsIndividual(api, calls) {
  // Individual fee total
  let individualTotal = 0n;
  for (const call of calls) {
    const tx = api.tx(call);
    const details = await api.rpc.payment.queryFeeDetails(tx.toHex());
    if (details.inclusionFee.isSome) {
      const fee = details.inclusionFee.unwrap();
      individualTotal += BigInt(fee.baseFee.toString())
        + BigInt(fee.lenFee.toString())
        + BigInt(fee.adjustedWeightFee.toString());
    }
  }

  // Batched fee
  const batchTx = api.tx.utility.batchAll(calls);
  const batchDetails = await api.rpc.payment.queryFeeDetails(batchTx.toHex());
  let batchTotal = 0n;
  if (batchDetails.inclusionFee.isSome) {
    const fee = batchDetails.inclusionFee.unwrap();
    batchTotal = BigInt(fee.baseFee.toString())
      + BigInt(fee.lenFee.toString())
      + BigInt(fee.adjustedWeightFee.toString());
  }

  const savings = individualTotal - batchTotal;
  console.log(`Individual total: ${individualTotal} planck`);
  console.log(`Batch total:      ${batchTotal} planck`);
  console.log(`Savings:          ${savings} planck (${Number((savings * 10000n) / individualTotal) / 100}%)`);

  return { individualTotal, batchTotal, savings };
}

async function compareFeesBetweenBlocks(api, extrinsicHex, blockHashBefore, blockHashAfter) {
  const [before, after] = await Promise.all([
    api.rpc.payment.queryFeeDetails(extrinsicHex, blockHashBefore),
    api.rpc.payment.queryFeeDetails(extrinsicHex, blockHashAfter)
  ]);

  function extractFees(details) {
    if (details.inclusionFee.isNone) return null;
    const fee = details.inclusionFee.unwrap();
    return {
      base: BigInt(fee.baseFee.toString()),
      len: BigInt(fee.lenFee.toString()),
      weight: BigInt(fee.adjustedWeightFee.toString())
    };
  }

  const feesBefore = extractFees(before);
  const feesAfter = extractFees(after);

  if (feesBefore && feesAfter) {
    console.log('Fee comparison:');
    console.log(`  Base fee:   ${feesBefore.base} -> ${feesAfter.base}`);
    console.log(`  Length fee: ${feesBefore.len} -> ${feesAfter.len}`);
    console.log(`  Weight fee: ${feesBefore.weight} -> ${feesAfter.weight}`);
  }
}