@neuraiproject/neurai-assets 1.2.5 → 1.3.1

package/README.md

@@ -651,3 +651,50 @@ console.log('Transaction ID:', txid);
 For AuthScript wallets, derive addresses externally with `neurai-key`, then initialize
 `NeuraiAssets` with those `nq1...` / `tnq1...` addresses. The recommended network labels
 are `xna` and `xna-test`; `xna-pq` and `xna-pq-test` remain available as compatibility aliases.
+
+## Fee estimation (PQ-aware)
+
+Asset transactions are usually built with one or two XNA inputs plus, depending on the operation, an owner-token or qualifier UTXO. The library estimates the fee twice per build: a rough pre-estimate to size the initial XNA selection, and a final estimate once the actual UTXOs are known.
+
+Both estimates share a single `estimatesmartfee` lookup. The fee rate is stable for the lifetime of one build, so it is fetched on the first `estimateFee` call and cached on the builder instance for the second — half as many RPC round trips as before `1.3.1`.
+
+Both estimates use the helpers in [`src/utils/feeSizing.js`](src/utils/feeSizing.js) and distinguish PQ AuthScript inputs/outputs from legacy P2PKH ones. PQ inputs spend ~977 vbytes vs ~148 for legacy — without this distinction, transactions built from PQ addresses fall under the node's `min relay fee` and are rejected with `code -26: min relay fee not met`.
+
+You should not need to call these helpers directly; they are wired into every builder. They are documented here so you can audit the fee math or use the same constants if you compose transactions outside the standard builder flow.
+
+```js
+const {
+  VBYTES,
+  estimateInputVbytes,
+  estimateOutputBytes,
+  estimateTransactionVbytes,
+  isPQAddress,
+  isPQScript,
+} = require('@neuraiproject/neurai-assets/src/utils/feeSizing');
+
+VBYTES.legacyInputVbytes; // 148
+VBYTES.pqInputVbytes;     // 977
+VBYTES.legacyOutputBytes; // 34
+VBYTES.pqOutputBytes;     // 43
+
+estimateInputVbytes({ script: '5120…' });        // 977
+estimateInputVbytes({ address: 'nq1…' });        // 977
+estimateInputVbytes({ address: 'mgRYHdMq…' });   // 148
+estimateOutputBytes('tnq1…');                    // 43
+
+const vbytes = estimateTransactionVbytes(
+  [{ script: '5120…' }, { address: 'mgRYHdMq…' }],   // 1 PQ + 1 legacy input
+  ['nq1qchange…', 'mgRYHdMqburn…'],                  // 1 PQ + 1 legacy output
+);
+```
+
+The constants mirror those exported from `@neuraiproject/neurai-sign-transaction` (`VBYTES`). They are inlined here on purpose: depending on the full signer would pull `bitcoinjs-lib` and `@noble/post-quantum` into the IIFE / browser bundles, far more weight than these constants need. The signer remains the source of truth — if it ever bumps a vbytes value, this file must follow.
+
+### Limitations
+
+The estimator assumes the most common spend layout for every input:
+
+- legacy inputs → P2PKH `scriptSig` worst case (DER signature + compressed pubkey)
+- PQ inputs → AuthScript v1 with the **default** `OP_TRUE` `witnessScript` and **no** `functionalArgs`
+
+That covers all standard asset operations. If you build transactions whose PQ inputs use covenant `witnessScript`s, NoAuth (`authType=0x00`) or Legacy AuthScript (`authType=0x02`) witnesses, compute the witness size yourself and add it to the result of `estimateTransactionVbytes` (or use `estimateVirtualSize` from `@neuraiproject/neurai-sign-transaction` after building the raw transaction, which fills dummy witnesses of the worst-case size and returns the exact post-signing vsize).

package/dist/NeuraiAssets.global.js

@@ -2725,6 +2725,118 @@ var NeuraiAssetsBundle = (function (exports) {
 		return OwnerTokenManager_1;
 	}
 
+	/**
+	 * Fee / size helpers for Neurai transactions.
+	 *
+	 * These constants and classifiers are the same ones exposed by
+	 * `@neuraiproject/neurai-sign-transaction` (`VBYTES`, `isPQAddress`,
+	 * `isPQScript`, `estimateInputVbytes`, `estimateOutputBytes`,
+	 * `estimateTransactionVbytes`). They are inlined here to keep the assets
+	 * package light: depending on the full signer would pull `bitcoinjs-lib`
+	 * and `@noble/post-quantum` into the IIFE / browser bundles, which is far
+	 * more weight than the few constants we actually need for fee estimation.
+	 *
+	 * SOURCE OF TRUTH: `@neuraiproject/neurai-sign-transaction` `src/estimate.ts`.
+	 * Keep these values in sync with the signer's `VBYTES`. Mismatches surface
+	 * immediately as `min relay fee not met` failures from the node.
+	 */
+
+	var feeSizing;
+	var hasRequiredFeeSizing;
+
+	function requireFeeSizing () {
+		if (hasRequiredFeeSizing) return feeSizing;
+		hasRequiredFeeSizing = 1;
+		/** Per-component byte sizes used across the Neurai stack for fee estimation. */
+		const VBYTES = Object.freeze({
+		  /** Raw transaction overhead: version (4) + in-count varint (1) + out-count varint (1) + locktime (4). */
+		  baseTxOverheadBytes: 10,
+		  /** Extra weight contributed by the segwit marker + flag bytes when any input is PQ. */
+		  segwitMarkerVbytes: 1,
+		  /** vbytes for a typical legacy P2PKH input (worst-case scriptSig). */
+		  legacyInputVbytes: 148,
+		  /** vbytes for a typical PQ AuthScript input with the default OP_TRUE witnessScript. */
+		  pqInputVbytes: 977,
+		  /** Bytes of a legacy P2PKH output (8-byte value + 1-byte script length + 25-byte scriptPubKey). */
+		  legacyOutputBytes: 34,
+		  /** Bytes of an AuthScript-v1 output (8-byte value + 1-byte script length + 34-byte scriptPubKey). */
+		  pqOutputBytes: 43,
+		});
+
+		/** True for Neurai PQ AuthScript bech32 destinations (`nq1…` mainnet, `tnq1…` testnet). */
+		function isPQAddress(address) {
+		  return (
+		    typeof address === 'string' &&
+		    (address.startsWith('nq1') || address.startsWith('tnq1'))
+		  );
+		}
+
+		/** True for AuthScript-v1 scriptPubKey hex (witness v1, 32-byte program — `5120…`). */
+		function isPQScript(scriptHex) {
+		  if (typeof scriptHex !== 'string' || scriptHex.length < 4) return false;
+		  return scriptHex.toLowerCase().startsWith('5120');
+		}
+
+		/**
+		 * Estimate the vbytes contributed by spending one UTXO. Uses the UTXO's
+		 * `script` if available, otherwise falls back to its `address`. Unknown
+		 * prevouts are treated as legacy.
+		 */
+		function estimateInputVbytes(utxo) {
+		  const script = utxo && utxo.script;
+		  if (typeof script === 'string' && script.length > 0) {
+		    return isPQScript(script) ? VBYTES.pqInputVbytes : VBYTES.legacyInputVbytes;
+		  }
+		  const address = utxo && utxo.address;
+		  if (typeof address === 'string' && isPQAddress(address)) {
+		    return VBYTES.pqInputVbytes;
+		  }
+		  return VBYTES.legacyInputVbytes;
+		}
+
+		/** Estimate the bytes contributed by an output (address string or `{address}`). */
+		function estimateOutputBytes(target) {
+		  const address =
+		    typeof target === 'string' ? target : (target && target.address) || '';
+		  return isPQAddress(address) ? VBYTES.pqOutputBytes : VBYTES.legacyOutputBytes;
+		}
+
+		/**
+		 * Sum the per-input/per-output contributions, plus base overhead and segwit
+		 * marker (added once when any input is PQ). Inputs may be partial UTXO-like
+		 * objects with `script` and/or `address`. Outputs may be address strings or
+		 * `{ address }` descriptors.
+		 */
+		function estimateTransactionVbytes(inputs, outputs) {
+		  let vbytes = VBYTES.baseTxOverheadBytes;
+		  let hasPQInput = false;
+
+		  for (const inp of inputs) {
+		    const v = estimateInputVbytes(inp);
+		    vbytes += v;
+		    if (v === VBYTES.pqInputVbytes) hasPQInput = true;
+		  }
+
+		  for (const out of outputs) {
+		    vbytes += estimateOutputBytes(out);
+		  }
+
+		  if (hasPQInput) vbytes += VBYTES.segwitMarkerVbytes;
+
+		  return vbytes;
+		}
+
+		feeSizing = {
+		  VBYTES,
+		  isPQAddress,
+		  isPQScript,
+		  estimateInputVbytes,
+		  estimateOutputBytes,
+		  estimateTransactionVbytes,
+		};
+		return feeSizing;
+	}
+
 	/**
 	 * UTXO Selector
 	 * Selects appropriate UTXOs for asset transactions
@@ -2742,6 +2854,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		if (hasRequiredUTXOSelector) return UTXOSelector_1;
 		hasRequiredUTXOSelector = 1;
 		const { InsufficientFundsError } = requireErrors();
+		const { estimateTransactionVbytes } = requireFeeSizing();
 
 		class UTXOSelector {
 		  /**
@@ -2980,35 +3093,44 @@ var NeuraiAssetsBundle = (function (exports) {
 		  }
 
 		  /**
-		   * Estimate transaction size in bytes
-		   * Used for fee calculation
+		   * Estimate transaction size in vbytes for fee calculation.
+		   *
+		   * Both arguments accept either a count (legacy callers) or an array of
+		   * descriptors that allow the estimator to distinguish PQ AuthScript
+		   * inputs/outputs from legacy P2PKH ones — PQ inputs are roughly six
+		   * times larger than legacy inputs and would otherwise underflow the
+		   * node's `min relay fee`.
 		   *
-		   * @param {number} inputCount - Number of inputs
-		   * @param {number} outputCount - Number of outputs
-		   * @returns {number} Estimated size in bytes
+		   * Input descriptors may be UTXO-like objects with `script` and/or
+		   * `address`. Output descriptors may be address strings or `{ address }`.
+		   * When a count is provided instead of an array, every input/output is
+		   * treated as legacy.
+		   *
+		   * @param {number|Array} inputs - Input count or array of UTXO-like descriptors
+		   * @param {number|Array} outputs - Output count or array of address-like descriptors
+		   * @returns {number} Estimated vbytes
 		   */
-		  estimateTransactionSize(inputCount, outputCount) {
-		    // Rough estimation:
-		    // - Each input: ~180 bytes
-		    // - Each output: ~34 bytes
-		    // - Transaction overhead: ~10 bytes
-		    const inputSize = inputCount * 180;
-		    const outputSize = outputCount * 34;
-		    const overhead = 10;
-
-		    return inputSize + outputSize + overhead;
+		  estimateTransactionSize(inputs, outputs) {
+		    const inputDescriptors = Array.isArray(inputs)
+		      ? inputs
+		      : new Array(inputs).fill({});
+		    const outputDescriptors = Array.isArray(outputs)
+		      ? outputs
+		      : new Array(outputs).fill({});
+		    return estimateTransactionVbytes(inputDescriptors, outputDescriptors);
 		  }
 
 		  /**
-		   * Estimate fee for a transaction
-		   * @param {number} inputCount - Number of inputs
-		   * @param {number} outputCount - Number of outputs
+		   * Estimate fee for a transaction.
+		   *
+		   * @param {number|Array} inputs - Input count or array of UTXO-like descriptors
+		   * @param {number|Array} outputs - Output count or array of address-like descriptors
 		   * @param {number} feeRate - Fee rate in XNA per KB (default: 0.015)
 		   * @returns {number} Estimated fee in XNA
 		   */
-		  estimateFee(inputCount, outputCount, feeRate = 0.015) {
-		    const sizeBytes = this.estimateTransactionSize(inputCount, outputCount);
-		    const sizeKB = sizeBytes / 1000;
+		  estimateFee(inputs, outputs, feeRate = 0.015) {
+		    const sizeVbytes = this.estimateTransactionSize(inputs, outputs);
+		    const sizeKB = sizeVbytes / 1000;
 		    const fee = sizeKB * feeRate;
 
 		    // Round up to 8 decimals
@@ -4296,6 +4418,11 @@ var NeuraiAssetsBundle = (function (exports) {
 		    this.ownerTokenManager = new OwnerTokenManager(rpc);
 		    this.utxoSelector = new UTXOSelector(rpc);
 		    this.outputOrderer = new OutputOrderer();
+
+		    // `estimatesmartfee` is called twice per build (pre-selection guess and
+		    // post-selection recompute). The fee rate is stable for the duration of
+		    // a single build, so cache the first lookup and reuse it.
+		    this._feeRatePromise = null;
 		  }
 
 		  /**
@@ -4330,14 +4457,23 @@ var NeuraiAssetsBundle = (function (exports) {
 		  }
 
 		  /**
-		   * Estimate transaction fee
-		   * @param {number} inputCount - Number of inputs
-		   * @param {number} outputCount - Number of outputs
+		   * Estimate transaction fee.
+		   *
+		   * Both arguments accept either a count (legacy) or an array of descriptors
+		   * that lets the underlying estimator distinguish PQ AuthScript inputs/outputs
+		   * from legacy P2PKH ones. Pass arrays whenever you have actual UTXOs and
+		   * output addresses on hand — counts produce a legacy-only estimate.
+		   *
+		   * @param {number|Array} inputs - Input count or array of UTXO-like descriptors
+		   * @param {number|Array} outputs - Output count or array of address-like descriptors
 		   * @returns {Promise<number>} Estimated fee in XNA
 		   */
-		  async estimateFee(inputCount, outputCount) {
-		    const feeRate = await this.utxoSelector.getFeeRate();
-		    return this.utxoSelector.estimateFee(inputCount, outputCount, feeRate);
+		  async estimateFee(inputs, outputs) {
+		    if (!this._feeRatePromise) {
+		      this._feeRatePromise = this.utxoSelector.getFeeRate();
+		    }
+		    const feeRate = await this._feeRatePromise;
+		    return this.utxoSelector.estimateFee(inputs, outputs, feeRate);
 		  }
 
 		  /**
@@ -4799,7 +4935,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const changeAddress = await this.getChangeAddress();
 
 		    // 5. Estimate fee (rough estimate for initial UTXO selection)
-		    const estimatedFee = await this.estimateFee(1, 3);
+		    const outputAddresses = [burnInfo.address, changeAddress, toAddress];
+		    const estimatedFee = await this.estimateFee(1, outputAddresses);
 
 		    // 6. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -4809,8 +4946,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 8. Recalculate fee with actual input count
-		    const actualFee = await this.estimateFee(baseCurrencyUTXOs.length, 3);
+		    // 8. Recalculate fee with actual inputs (PQ-aware)
+		    const actualFee = await this.estimateFee(baseCurrencyUTXOs, outputAddresses);
 
 		    // 9. Verify we still have enough after fee recalculation
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -5034,7 +5171,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		    // 8. Estimate fee
 		    // Inputs: XNA UTXOs + owner token UTXO
 		    // Outputs: burn + change + owner token return + issue operation
-		    const estimatedFee = await this.estimateFee(2, 4);
+		    const outputAddresses = [
+		      burnInfo.address,
+		      changeAddress,
+		      changeAddress, // owner token return goes to change address
+		      toAddress,
+		    ];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 9. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -5044,9 +5187,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 11. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + 1; // +1 for owner token
-		    const actualFee = await this.estimateFee(actualInputCount, 4);
+		    // 11. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 12. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -5248,14 +5391,15 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const toAddress = await this.getToAddress();
 		    const changeAddress = await this.getChangeAddress();
 
-		    const estimatedFee = await this.estimateFee(1, 3);
+		    const outputAddresses = [burnInfo.address, changeAddress, toAddress];
+		    const estimatedFee = await this.estimateFee(1, outputAddresses);
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
 
 		    const utxoSelection = await this.selectUTXOs(totalXNANeeded, null, 0);
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    const actualFee = await this.estimateFee(baseCurrencyUTXOs.length, 3);
+		    const actualFee = await this.estimateFee(baseCurrencyUTXOs, outputAddresses);
 		    const totalRequired = burnInfo.amount + actualFee;
 
 		    if (totalXNAInput < totalRequired) {
@@ -5470,9 +5614,14 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		    // 8. Estimate fee
 		    // Inputs: XNA UTXOs + owner token UTXO
-		    // Outputs: burn + change + reissue operation
-		    // (node auto-generates owner token return from the reissue entry, total = 4 physical outputs)
-		    const estimatedFee = await this.estimateFee(2, 4);
+		    // Outputs: burn + change + owner token return + reissue operation
+		    const outputAddresses = [
+		      burnInfo.address,
+		      changeAddress,
+		      changeAddress, // owner token return goes to change address
+		      toAddress,
+		    ];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 9. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -5482,9 +5631,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 11. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + 1; // +1 for owner token
-		    const actualFee = await this.estimateFee(actualInputCount, 4);
+		    // 11. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 12. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -5745,7 +5894,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		    // 7. Estimate fee
 		    // Inputs: XNA UTXOs + owner token UTXO
 		    // Outputs: burn + change + owner token return + issue_unique operation
-		    const estimatedFee = await this.estimateFee(2, 4);
+		    const outputAddresses = [
+		      burnInfo.address,
+		      changeAddress,
+		      changeAddress, // owner token return goes to change address
+		      toAddress,
+		    ];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 8. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -5755,9 +5910,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 10. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + 1; // +1 for owner token
-		    const actualFee = await this.estimateFee(actualInputCount, 4);
+		    // 10. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 11. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -6005,8 +6160,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const changeAddress = await this.getChangeAddress();
 
 		    // 7. Estimate fee
-		    const outputCount = 3;
-		    const estimatedFee = await this.estimateFee(2, outputCount);
+		    const outputAddresses = [burnInfo.address, changeAddress, toAddress];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 8. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -6016,9 +6171,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 10. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + parentQualifierUTXOs.length;
-		    const actualFee = await this.estimateFee(actualInputCount, outputCount);
+		    // 10. Recalculate fee with actual inputs (PQ-aware), including parent qualifier UTXOs
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ...parentQualifierUTXOs];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 11. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -6257,7 +6412,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		    }
 
 		    // 7. Estimate fee (+1 for owner token input)
-		    const estimatedFee = await this.estimateFee(2, 4);
+		    const outputAddresses = [
+		      burnInfo.address,
+		      changeAddress,
+		      changeAddress, // owner token return goes to change address
+		      toAddress,
+		    ];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 8. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -6267,8 +6428,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 10. Recalculate fee with actual input count (+1 for owner token)
-		    const actualFee = await this.estimateFee(baseCurrencyUTXOs.length + 1, 4);
+		    // 10. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 11. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -6525,7 +6687,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const burnInfo = this.burnManager.getReissueBurn();
 
 		    // 8. Estimate fee
-		    const estimatedFee = await this.estimateFee(2, 4);
+		    const outputAddresses = [
+		      burnInfo.address,
+		      changeAddress,
+		      changeAddress, // owner token return goes to change address
+		      toAddress,
+		    ];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 9. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -6535,9 +6703,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 11. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + 1; // +1 for owner token
-		    const actualFee = await this.estimateFee(actualInputCount, 4);
+		    // 11. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 12. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -6772,7 +6940,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		      : this.burnManager.getTagAddressBurn(addressCount);
 
 		    // 6. Estimate fee
-		    const estimatedFee = await this.estimateFee(2, 3);
+		    // Outputs: burn + XNA change + tag/untag operation (sent to changeAddress)
+		    const outputAddresses = [burnInfo.address, changeAddress, changeAddress];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 7. Calculate total XNA needed
 		    const totalXNANeeded = burnInfo.amount + estimatedFee;
@@ -6782,9 +6952,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 9. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + qualifierUTXOs.length;
-		    const actualFee = await this.estimateFee(actualInputCount, 3);
+		    // 9. Recalculate fee with actual inputs (PQ-aware), including qualifier UTXOs
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ...qualifierUTXOs];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 10. Verify we have enough XNA
 		    const totalRequired = burnInfo.amount + actualFee;
@@ -7019,16 +7189,18 @@ var NeuraiAssetsBundle = (function (exports) {
 		    const burnAmount = 0;
 
 		    // 6. Estimate fee
-		    const estimatedFee = await this.estimateFee(2, 3);
+		    // Outputs: XNA change + freeze/unfreeze operation (sent to changeAddress)
+		    const outputAddresses = [changeAddress, changeAddress];
+		    const estimatedFee = await this.estimateFee(2, outputAddresses);
 
 		    // 7. Select XNA UTXOs (only for fee, no burn)
 		    const utxoSelection = await this.selectUTXOs(estimatedFee, null, 0);
 		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
 		    const totalXNAInput = utxoSelection.totalXNA;
 
-		    // 8. Recalculate fee with actual input count
-		    const actualInputCount = baseCurrencyUTXOs.length + 1; // +1 for owner token
-		    const actualFee = await this.estimateFee(actualInputCount, 3);
+		    // 8. Recalculate fee with actual inputs (PQ-aware), including owner token UTXO
+		    const actualFeeInputs = [...baseCurrencyUTXOs, ownerTokenUTXO];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
 
 		    // 9. Verify we have enough XNA for fee
 		    if (totalXNAInput < actualFee) {