@neuraiproject/neurai-assets 1.2.3 → 1.3.0

package/dist/NeuraiAssets.global.js

@@ -1091,45 +1091,45 @@ var NeuraiAssetsBundle = (function (exports) {
 		};
 
 		/**
-		 * Asset naming rules (same for all networks)
+		 * Asset naming helpers.
+		 * Network-specific maximum lengths are enforced in AssetNameValidator.
 		 */
 		const ASSET_NAME_RULES = {
 		  ROOT: {
 		    minLength: 3,
-		    maxLength: 30,
+		    maxLength: 31,
 		    pattern: /^[A-Z0-9_.]+$/,
-		    cannotStartWith: ['.', 'A', 'Z'],
-		    reserved: ['XNA', 'NEURAI']
+		    reserved: ['XNA', 'NEURAI', 'NEURAICOIN']
 		  },
 		  SUB: {
 		    minLength: 1,
-		    maxLength: 30,
+		    maxLength: 31,
 		    pattern: /^[A-Z0-9_.]+$/,
 		    separator: '/',
-		    maxDepth: 1  // Only one level of sub-assets
+		    maxDepth: null
 		  },
 		  UNIQUE: {
 		    minLength: 1,
-		    maxLength: 30,
-		    pattern: /^[A-Z0-9_.]+$/,
+		    maxLength: 32,
+		    pattern: /^[-A-Za-z0-9@$%&*()[\]{}_.?:]+$/,
 		    separator: '#'
 		  },
 		  QUALIFIER: {
 		    minLength: 3,
-		    maxLength: 30,
-		    pattern: /^[A-Z0-9_]+$/,
+		    maxLength: 32,
+		    pattern: /^[A-Z0-9_.]+$/,
 		    prefix: '#',
 		    separator: '/'
 		  },
 		  RESTRICTED: {
 		    minLength: 3,
-		    maxLength: 30,
+		    maxLength: 32,
 		    pattern: /^[A-Z0-9_.]+$/,
 		    prefix: '$'
 		  },
 		  DEPIN: {
 		    minLength: 3,
-		    maxLength: 120,
+		    maxLength: 121,
 		    pattern: /^[A-Z0-9_.]+$/,
 		    prefix: '&',
 		    separator: '/'
@@ -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
@@ -3370,52 +3492,164 @@ var NeuraiAssetsBundle = (function (exports) {
 		const { ASSET_NAME_RULES } = requireConstants();
 		const { InvalidAssetNameError } = requireErrors();
 
+		const MIN_ASSET_LENGTH = 3;
+		const MAINNET_MAX_NAME_LENGTH = 32;
+		const TESTNET_MAX_NAME_LENGTH = 121;
+
+		const ROOT_NAME_CHARACTERS = /^[A-Z0-9._]{3,}$/;
+		const SUB_NAME_CHARACTERS = /^[A-Z0-9._]+$/;
+		const UNIQUE_TAG_CHARACTERS = /^[-A-Za-z0-9@$%&*()[\]{}_.?:]+$/;
+		const QUALIFIER_NAME_CHARACTERS = /^#[A-Z0-9._]{3,}$/;
+		const SUB_QUALIFIER_NAME_CHARACTERS = /^#[A-Z0-9._]+$/;
+		const RESTRICTED_NAME_CHARACTERS = /^\$[A-Z0-9._]{3,}$/;
+		const DEPIN_NAME_CHARACTERS = /^&[A-Z0-9._]{3,}$/;
+		const SUB_DEPIN_NAME_CHARACTERS = /^&[A-Z0-9._]+\/[A-Z0-9._/]+$/;
+		const DOUBLE_PUNCTUATION = /^.*[._]{2,}.*$/;
+		const LEADING_PUNCTUATION = /^[._].*$/;
+		const TRAILING_PUNCTUATION = /^.*[._]$/;
+		const QUALIFIER_LEADING_PUNCTUATION = /^[#$][._].*$/;
+		const NEURAI_NAMES = /^XNA$|^NEURAI$|^NEURAICOIN$|^#XNA$|^#NEURAI$|^#NEURAICOIN$/;
+
+		function isTestnet(network) {
+		  return typeof network === 'string' && network.toLowerCase().includes('test');
+		}
+
+		function getMaxAssetNameLength(network) {
+		  return isTestnet(network) ? TESTNET_MAX_NAME_LENGTH : MAINNET_MAX_NAME_LENGTH;
+		}
+
+		function getRootOrSubMaxLength(network) {
+		  return getMaxAssetNameLength(network) - 1;
+		}
+
+		function ensureName(name, label) {
+		  if (!name || typeof name !== 'string') {
+		    throw new InvalidAssetNameError(`${label} must be a non-empty string`, name);
+		  }
+		}
+
+		function ensureMaxLength(name, maxLength, label) {
+		  if (name.length > maxLength) {
+		    throw new InvalidAssetNameError(`${label} cannot exceed ${maxLength} characters`, name);
+		  }
+		}
+
+		function ensureUppercase(name, message) {
+		  if (name !== name.toUpperCase()) {
+		    throw new InvalidAssetNameError(message, name);
+		  }
+		}
+
+		function isRootNameValid(name) {
+		  return ROOT_NAME_CHARACTERS.test(name)
+		    && !DOUBLE_PUNCTUATION.test(name)
+		    && !LEADING_PUNCTUATION.test(name)
+		    && !TRAILING_PUNCTUATION.test(name)
+		    && !NEURAI_NAMES.test(name);
+		}
+
+		function isSubNameValid(name) {
+		  return SUB_NAME_CHARACTERS.test(name)
+		    && !DOUBLE_PUNCTUATION.test(name)
+		    && !LEADING_PUNCTUATION.test(name)
+		    && !TRAILING_PUNCTUATION.test(name);
+		}
+
+		function isQualifierNameValid(name) {
+		  return QUALIFIER_NAME_CHARACTERS.test(name)
+		    && !DOUBLE_PUNCTUATION.test(name)
+		    && !QUALIFIER_LEADING_PUNCTUATION.test(name)
+		    && !TRAILING_PUNCTUATION.test(name)
+		    && !NEURAI_NAMES.test(name);
+		}
+
+		function isSubQualifierNameValid(name) {
+		  return SUB_QUALIFIER_NAME_CHARACTERS.test(name)
+		    && !DOUBLE_PUNCTUATION.test(name)
+		    && !LEADING_PUNCTUATION.test(name)
+		    && !TRAILING_PUNCTUATION.test(name);
+		}
+
+		function isRestrictedNameValid(name) {
+		  return RESTRICTED_NAME_CHARACTERS.test(name)
+		    && !DOUBLE_PUNCTUATION.test(name)
+		    && !LEADING_PUNCTUATION.test(name)
+		    && !TRAILING_PUNCTUATION.test(name)
+		    && !NEURAI_NAMES.test(name);
+		}
+
+		function isNameValidBeforeTag(name) {
+		  const parts = name.split('/');
+
+		  if (!isRootNameValid(parts[0])) {
+		    return false;
+		  }
+
+		  for (let index = 1; index < parts.length; index += 1) {
+		    if (!isSubNameValid(parts[index])) {
+		      return false;
+		    }
+		  }
+
+		  return true;
+		}
+
+		function isQualifierNameValidBeforeTag(name) {
+		  const parts = name.split('/');
+
+		  if (!isQualifierNameValid(parts[0])) {
+		    return false;
+		  }
+
+		  if (parts.length > 2) {
+		    return false;
+		  }
+
+		  for (let index = 1; index < parts.length; index += 1) {
+		    if (!isSubQualifierNameValid(parts[index])) {
+		      return false;
+		    }
+		  }
+
+		  return true;
+		}
+
+		function isDepinIndicator(name) {
+		  return DEPIN_NAME_CHARACTERS.test(name) || SUB_DEPIN_NAME_CHARACTERS.test(name);
+		}
+
 		class AssetNameValidator {
 		  /**
 		   * Validate ROOT asset name
-		   * Rules: 3-30 uppercase characters, A-Z, 0-9, underscore, period
-		   * Cannot start with period, A, or Z
+		   * Rules: 3-31 visible characters on mainnet, A-Z, 0-9, underscore, period
+		   * Cannot start or end with period/underscore, cannot use repeated punctuation
 		   * Cannot be reserved names
 		   */
-		  static validateRoot(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('Asset name must be a non-empty string', name);
-		    }
+		  static validateRoot(name, network = 'xna') {
+		    ensureName(name, 'Asset name');
 
-		    // Length check
-		    if (name.length < ASSET_NAME_RULES.ROOT.minLength || name.length > ASSET_NAME_RULES.ROOT.maxLength) {
+		    const maxLength = getRootOrSubMaxLength(network);
+
+		    if (name.length < MIN_ASSET_LENGTH || name.length > maxLength) {
 		      throw new InvalidAssetNameError(
-		        `ROOT asset name must be ${ASSET_NAME_RULES.ROOT.minLength}-${ASSET_NAME_RULES.ROOT.maxLength} characters`,
+		        `ROOT asset name must be ${MIN_ASSET_LENGTH}-${maxLength} characters`,
 		        name
 		      );
 		    }
 
-		    // Uppercase check
-		    if (name !== name.toUpperCase()) {
-		      throw new InvalidAssetNameError('Asset name must be uppercase', name);
-		    }
+		    ensureUppercase(name, 'Asset name must be uppercase');
 
-		    // Starting character check
-		    if (ASSET_NAME_RULES.ROOT.cannotStartWith.some(char => name.startsWith(char))) {
-		      throw new InvalidAssetNameError(
-		        `Asset name cannot start with: ${ASSET_NAME_RULES.ROOT.cannotStartWith.join(', ')}`,
-		        name
-		      );
+		    if (NEURAI_NAMES.test(name)) {
+		      throw new InvalidAssetNameError(`${name} is a reserved asset name`, name);
 		    }
 
-		    // Pattern check
-		    if (!ASSET_NAME_RULES.ROOT.pattern.test(name)) {
+		    if (!isRootNameValid(name)) {
 		      throw new InvalidAssetNameError(
-		        'Asset name can only contain A-Z, 0-9, underscore, and period',
+		        'Name contains invalid characters (Valid characters are: A-Z 0-9 _ .) (special characters can\'t be the first or last characters)',
 		        name
 		      );
 		    }
 
-		    // Reserved names check
-		    if (ASSET_NAME_RULES.ROOT.reserved.includes(name)) {
-		      throw new InvalidAssetNameError(`${name} is a reserved asset name`, name);
-		    }
-
 		    return true;
 		  }
 
@@ -3423,39 +3657,25 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate SUB asset name
 		   * Format: ROOT/SUBNAME
 		   */
-		  static validateSub(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('SUB asset name must be a non-empty string', name);
-		    }
+		  static validateSub(name, network = 'xna') {
+		    ensureName(name, 'SUB asset name');
 
-		    const parts = name.split(ASSET_NAME_RULES.SUB.separator);
-		    if (parts.length !== 2) {
+		    if (!name.includes(ASSET_NAME_RULES.SUB.separator)) {
 		      throw new InvalidAssetNameError(
 		        `SUB asset must be in ${ASSET_NAME_RULES.SUB.separator} format (ROOT/SUBNAME)`,
 		        name
 		      );
 		    }
 
-		    const [rootName, subName] = parts;
-
-		    // Validate root part
-		    this.validateRoot(rootName);
-
-		    // Validate sub part
-		    if (subName.length < ASSET_NAME_RULES.SUB.minLength || subName.length > ASSET_NAME_RULES.SUB.maxLength) {
-		      throw new InvalidAssetNameError(
-		        `SUB asset name must be ${ASSET_NAME_RULES.SUB.minLength}-${ASSET_NAME_RULES.SUB.maxLength} characters`,
-		        name
-		      );
-		    }
+		    ensureMaxLength(name, getRootOrSubMaxLength(network), 'SUB asset name');
 
-		    if (subName !== subName.toUpperCase()) {
+		    if (name !== name.toUpperCase()) {
 		      throw new InvalidAssetNameError('SUB asset name must be uppercase', name);
 		    }
 
-		    if (!ASSET_NAME_RULES.SUB.pattern.test(subName)) {
+		    if (!isNameValidBeforeTag(name)) {
 		      throw new InvalidAssetNameError(
-		        'SUB asset name can only contain A-Z, 0-9, underscore, and period',
+		        'Name contains invalid characters (Valid characters are: A-Z 0-9 _ .) (special characters can\'t be the first or last characters)',
 		        name
 		      );
 		    }
@@ -3467,10 +3687,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate UNIQUE asset name
 		   * Format: ROOT#TAG
 		   */
-		  static validateUnique(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('UNIQUE asset name must be a non-empty string', name);
-		    }
+		  static validateUnique(name, network = 'xna') {
+		    ensureName(name, 'UNIQUE asset name');
+
+		    ensureMaxLength(name, getMaxAssetNameLength(network), 'UNIQUE asset name');
 
 		    const parts = name.split(ASSET_NAME_RULES.UNIQUE.separator);
 		    if (parts.length !== 2) {
@@ -3482,24 +3702,9 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		    const [rootName, tag] = parts;
 
-		    // Validate root part
-		    this.validateRoot(rootName);
-
-		    // Validate tag
-		    if (tag.length < ASSET_NAME_RULES.UNIQUE.minLength || tag.length > ASSET_NAME_RULES.UNIQUE.maxLength) {
-		      throw new InvalidAssetNameError(
-		        `UNIQUE tag must be ${ASSET_NAME_RULES.UNIQUE.minLength}-${ASSET_NAME_RULES.UNIQUE.maxLength} characters`,
-		        name
-		      );
-		    }
-
-		    if (tag !== tag.toUpperCase()) {
-		      throw new InvalidAssetNameError('UNIQUE tag must be uppercase', name);
-		    }
-
-		    if (!ASSET_NAME_RULES.UNIQUE.pattern.test(tag)) {
+		    if (!isNameValidBeforeTag(rootName) || !UNIQUE_TAG_CHARACTERS.test(tag)) {
 		      throw new InvalidAssetNameError(
-		        'UNIQUE tag can only contain A-Z, 0-9, underscore, and period',
+		        'Unique name contains invalid characters (Valid characters are: A-Z a-z 0-9 @ $ % & * ( ) [ ] { } _ . ? : -)',
 		        name
 		      );
 		    }
@@ -3511,10 +3716,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate QUALIFIER asset name
 		   * Format: #NAME or #ROOT/SUB
 		   */
-		  static validateQualifier(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('QUALIFIER asset name must be a non-empty string', name);
-		    }
+		  static validateQualifier(name, network = 'xna') {
+		    ensureName(name, 'QUALIFIER asset name');
 
 		    if (!name.startsWith(ASSET_NAME_RULES.QUALIFIER.prefix)) {
 		      throw new InvalidAssetNameError(
@@ -3523,58 +3726,17 @@ var NeuraiAssetsBundle = (function (exports) {
 		      );
 		    }
 
-		    const withoutPrefix = name.substring(1);
-
-		    if (withoutPrefix.includes(ASSET_NAME_RULES.QUALIFIER.separator)) {
-		      // Sub-qualifier: #ROOT/SUB
-		      const parts = withoutPrefix.split(ASSET_NAME_RULES.QUALIFIER.separator);
-		      if (parts.length !== 2) {
-		        throw new InvalidAssetNameError(
-		          'SUB_QUALIFIER must be in #ROOT/SUB format',
-		          name
-		        );
-		      }
-
-		      // Validate each part as a qualifier name (without the #)
-		      parts.forEach(part => {
-		        if (part.length < ASSET_NAME_RULES.QUALIFIER.minLength || part.length > ASSET_NAME_RULES.QUALIFIER.maxLength) {
-		          throw new InvalidAssetNameError(
-		            `QUALIFIER name must be ${ASSET_NAME_RULES.QUALIFIER.minLength}-${ASSET_NAME_RULES.QUALIFIER.maxLength} characters`,
-		            name
-		          );
-		        }
+		    ensureMaxLength(name, getMaxAssetNameLength(network), 'QUALIFIER asset name');
 
-		        if (part !== part.toUpperCase()) {
-		          throw new InvalidAssetNameError('QUALIFIER name must be uppercase', name);
-		        }
-
-		        if (!ASSET_NAME_RULES.QUALIFIER.pattern.test(part)) {
-		          throw new InvalidAssetNameError(
-		            'QUALIFIER name can only contain A-Z, 0-9, and underscore',
-		            name
-		          );
-		        }
-		      });
-		    } else {
-		      // Root qualifier: #NAME
-		      if (withoutPrefix.length < ASSET_NAME_RULES.QUALIFIER.minLength ||
-		          withoutPrefix.length > ASSET_NAME_RULES.QUALIFIER.maxLength) {
-		        throw new InvalidAssetNameError(
-		          `QUALIFIER name must be ${ASSET_NAME_RULES.QUALIFIER.minLength}-${ASSET_NAME_RULES.QUALIFIER.maxLength} characters`,
-		          name
-		        );
-		      }
-
-		      if (withoutPrefix !== withoutPrefix.toUpperCase()) {
-		        throw new InvalidAssetNameError('QUALIFIER name must be uppercase', name);
-		      }
+		    if (name !== name.toUpperCase()) {
+		      throw new InvalidAssetNameError('QUALIFIER name must be uppercase', name);
+		    }
 
-		      if (!ASSET_NAME_RULES.QUALIFIER.pattern.test(withoutPrefix)) {
-		        throw new InvalidAssetNameError(
-		          'QUALIFIER name can only contain A-Z, 0-9, and underscore',
-		          name
-		        );
-		      }
+		    if (!isQualifierNameValidBeforeTag(name)) {
+		      throw new InvalidAssetNameError(
+		        'Qualifier name contains invalid characters (Valid characters are: A-Z 0-9 _ .) (# must be the first character, _ . special characters can\'t be the first or last characters)',
+		        name
+		      );
 		    }
 
 		    return true;
@@ -3584,10 +3746,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate RESTRICTED asset name
 		   * Format: $NAME
 		   */
-		  static validateRestricted(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('RESTRICTED asset name must be a non-empty string', name);
-		    }
+		  static validateRestricted(name, network = 'xna') {
+		    ensureName(name, 'RESTRICTED asset name');
 
 		    if (!name.startsWith(ASSET_NAME_RULES.RESTRICTED.prefix)) {
 		      throw new InvalidAssetNameError(
@@ -3596,10 +3756,18 @@ var NeuraiAssetsBundle = (function (exports) {
 		      );
 		    }
 
-		    const withoutPrefix = name.substring(1);
+		    ensureMaxLength(name, getMaxAssetNameLength(network), 'RESTRICTED asset name');
+
+		    if (name !== name.toUpperCase()) {
+		      throw new InvalidAssetNameError('RESTRICTED asset name must be uppercase', name);
+		    }
 
-		    // Validate the part after $ as a ROOT asset name
-		    this.validateRoot(withoutPrefix);
+		    if (!isRestrictedNameValid(name)) {
+		      throw new InvalidAssetNameError(
+		        'Restricted name contains invalid characters (Valid characters are: A-Z 0-9 _ .) ($ must be the first character, _ . special characters can\'t be the first or last characters)',
+		        name
+		      );
+		    }
 
 		    return true;
 		  }
@@ -3608,10 +3776,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate DEPIN asset name
 		   * Format: &NAME or &NAME/SUB[/...]
 		   */
-		  static validateDepin(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('DEPIN asset name must be a non-empty string', name);
-		    }
+		  static validateDepin(name, network) {
+		    ensureName(name, 'DEPIN asset name');
 
 		    if (!name.startsWith(ASSET_NAME_RULES.DEPIN.prefix)) {
 		      throw new InvalidAssetNameError(
@@ -3620,58 +3786,41 @@ var NeuraiAssetsBundle = (function (exports) {
 		      );
 		    }
 
-		    if (name.length > ASSET_NAME_RULES.DEPIN.maxLength) {
-		      throw new InvalidAssetNameError(
-		        `DEPIN asset name cannot exceed ${ASSET_NAME_RULES.DEPIN.maxLength} characters`,
-		        name
-		      );
+		    if (network && !isTestnet(network)) {
+		      throw new InvalidAssetNameError('DEPIN assets are only available in testnet', name);
 		    }
 
-		    const parts = name.split(ASSET_NAME_RULES.DEPIN.separator);
-		    if (parts.length === 0) {
-		      throw new InvalidAssetNameError('DEPIN asset name is invalid', name);
+		    ensureMaxLength(name, getMaxAssetNameLength(network || 'xna-test'), 'DEPIN asset name');
+
+		    if (name !== name.toUpperCase()) {
+		      throw new InvalidAssetNameError('DEPIN asset name must be uppercase', name);
 		    }
 
-		    const rootPart = parts[0].substring(1);
-		    if (rootPart.length < ASSET_NAME_RULES.DEPIN.minLength) {
+		    if (!isDepinIndicator(name)) {
 		      throw new InvalidAssetNameError(
-		        `DEPIN root name must be at least ${ASSET_NAME_RULES.DEPIN.minLength} characters`,
+		        'DEPIN asset name can only contain A-Z, 0-9, underscore, period, and separator /',
 		        name
 		      );
 		    }
 
-		    if (rootPart !== rootPart.toUpperCase()) {
-		      throw new InvalidAssetNameError('DEPIN asset name must be uppercase', name);
-		    }
+		    const parts = name.split(ASSET_NAME_RULES.DEPIN.separator);
 
-		    if (!ASSET_NAME_RULES.DEPIN.pattern.test(rootPart)) {
+		    if (parts.length > 1) {
+		      parts.forEach(part => {
+		        if (part.length < MIN_ASSET_LENGTH) {
+		          throw new InvalidAssetNameError(
+		            `Each DEPIN sub-part must be at least ${MIN_ASSET_LENGTH} characters`,
+		            name
+		          );
+		        }
+		      });
+		    } else if (name.length < MIN_ASSET_LENGTH + 1) {
 		      throw new InvalidAssetNameError(
-		        'DEPIN asset name can only contain A-Z, 0-9, underscore, and period',
+		        `DEPIN name must be at least ${MIN_ASSET_LENGTH} characters (excluding &)`,
 		        name
 		      );
 		    }
 
-		    const subParts = parts.slice(1);
-		    subParts.forEach(part => {
-		      if (part.length < ASSET_NAME_RULES.DEPIN.minLength) {
-		        throw new InvalidAssetNameError(
-		          `Each DEPIN sub-part must be at least ${ASSET_NAME_RULES.DEPIN.minLength} characters`,
-		          name
-		        );
-		      }
-
-		      if (part !== part.toUpperCase()) {
-		        throw new InvalidAssetNameError('DEPIN asset name must be uppercase', name);
-		      }
-
-		      if (!ASSET_NAME_RULES.DEPIN.pattern.test(part)) {
-		        throw new InvalidAssetNameError(
-		          'DEPIN asset name can only contain A-Z, 0-9, underscore, and period',
-		          name
-		        );
-		      }
-		    });
-
 		    return true;
 		  }
 
@@ -3679,24 +3828,31 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * Validate owner token name
 		   * Format: ASSETNAME!
 		   */
-		  static validateOwnerToken(name) {
-		    if (!name || typeof name !== 'string') {
-		      throw new InvalidAssetNameError('Owner token name must be a non-empty string', name);
-		    }
+		  static validateOwnerToken(name, network) {
+		    ensureName(name, 'Owner token name');
+
+		    ensureMaxLength(name, getMaxAssetNameLength(network), 'Owner token name');
 
 		    if (!name.endsWith('!')) {
 		      throw new InvalidAssetNameError('Owner token must end with !', name);
 		    }
 
 		    const assetName = name.substring(0, name.length - 1);
+		    const validBaseName = isNameValidBeforeTag(assetName)
+		      || (assetName.startsWith('&') && (() => {
+		        try {
+		          this.validateDepin(assetName, network);
+		          return true;
+		        } catch (error) {
+		          return false;
+		        }
+		      })());
 
-		    // Validate the asset name part (could be ROOT, RESTRICTED, or DEPIN)
-		    if (assetName.startsWith('$')) {
-		      this.validateRestricted(assetName);
-		    } else if (assetName.startsWith('&')) {
-		      this.validateDepin(assetName);
-		    } else {
-		      this.validateRoot(assetName);
+		    if (!validBaseName) {
+		        throw new InvalidAssetNameError(
+		          'Owner name contains invalid characters (Valid characters are: A-Z 0-9 _ .) (special characters can\'t be the first or last characters)',
+		          name
+		        );
 		    }
 
 		    return true;
@@ -3707,27 +3863,27 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * @param {string} name - Asset name
 		   * @returns {string} Asset type ('ROOT', 'SUB', 'UNIQUE', 'QUALIFIER', 'RESTRICTED', 'DEPIN', 'OWNER')
 		   */
-		  static validateAndDetectType(name) {
+		  static validateAndDetectType(name, network) {
 		    if (name.endsWith('!')) {
-		      this.validateOwnerToken(name);
+		      this.validateOwnerToken(name, network);
 		      return 'OWNER';
 		    } else if (name.startsWith('#')) {
-		      this.validateQualifier(name);
+		      this.validateQualifier(name, network);
 		      return name.includes('/') ? 'SUB_QUALIFIER' : 'QUALIFIER';
 		    } else if (name.startsWith('$')) {
-		      this.validateRestricted(name);
+		      this.validateRestricted(name, network);
 		      return 'RESTRICTED';
 		    } else if (name.startsWith('&')) {
-		      this.validateDepin(name);
+		      this.validateDepin(name, network);
 		      return 'DEPIN';
 		    } else if (name.includes('#')) {
-		      this.validateUnique(name);
+		      this.validateUnique(name, network);
 		      return 'UNIQUE';
 		    } else if (name.includes('/')) {
-		      this.validateSub(name);
+		      this.validateSub(name, network);
 		      return 'SUB';
 		    } else {
-		      this.validateRoot(name);
+		      this.validateRoot(name, network);
 		      return 'ROOT';
 		    }
 		  }
@@ -4296,14 +4452,20 @@ 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) {
+		  async estimateFee(inputs, outputs) {
 		    const feeRate = await this.utxoSelector.getFeeRate();
-		    return this.utxoSelector.estimateFee(inputCount, outputCount, feeRate);
+		    return this.utxoSelector.estimateFee(inputs, outputs, feeRate);
 		  }
 
 		  /**
@@ -4404,22 +4566,22 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		    switch (type) {
 		      case 'ROOT':
-		        AssetNameValidator.validateRoot(assetName);
+		        AssetNameValidator.validateRoot(assetName, this.network);
 		        break;
 		      case 'SUB':
-		        AssetNameValidator.validateSub(assetName);
+		        AssetNameValidator.validateSub(assetName, this.network);
 		        break;
 		      case 'UNIQUE':
-		        AssetNameValidator.validateUnique(assetName);
+		        AssetNameValidator.validateUnique(assetName, this.network);
 		        break;
 		      case 'QUALIFIER':
-		        AssetNameValidator.validateQualifier(assetName);
+		        AssetNameValidator.validateQualifier(assetName, this.network);
 		        break;
 		      case 'RESTRICTED':
-		        AssetNameValidator.validateRestricted(assetName);
+		        AssetNameValidator.validateRestricted(assetName, this.network);
 		        break;
 		      case 'DEPIN':
-		        AssetNameValidator.validateDepin(assetName);
+		        AssetNameValidator.validateDepin(assetName, this.network);
 		        break;
 		      default:
 		        throw new Error(`Unknown asset type: ${type}`);
@@ -4765,7 +4927,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;
@@ -4775,8 +4938,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;
@@ -5000,7 +5163,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;
@@ -5010,9 +5179,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;
@@ -5214,14 +5383,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) {
@@ -5436,9 +5606,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;
@@ -5448,9 +5623,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;
@@ -5711,7 +5886,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;
@@ -5721,9 +5902,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;
@@ -5840,7 +6021,7 @@ var NeuraiAssetsBundle = (function (exports) {
 	 *
 	 * QUALIFIER assets:
 	 * - KYC/compliance tags (e.g., #KYC_VERIFIED, #ACCREDITED)
-	 * - Format: #NAME or #ROOT/SUB
+	 * - Format: #NAME or #ROOT/#SUB
 	 * - Cost: 2000 XNA (root) or 200 XNA (sub-qualifier)
 	 * - Quantity: 1-10 units only
 	 * - Units: Always 0 (non-divisible)
@@ -5971,8 +6152,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;
@@ -5982,9 +6163,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;
@@ -6223,7 +6404,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;
@@ -6233,8 +6420,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;
@@ -6491,7 +6679,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;
@@ -6501,9 +6695,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;
@@ -6738,7 +6932,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;
@@ -6748,9 +6944,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;
@@ -6985,16 +7181,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) {
@@ -7305,7 +7503,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		  /**
 		   * Create a ROOT asset
 		   * @param {object} params - Asset creation parameters
-		   * @param {string} params.assetName - Asset name (3-30 chars, A-Z 0-9 _ .)
+		    * @param {string} params.assetName - Asset name (3-31 visible chars on mainnet, A-Z 0-9 _ .)
 		   * @param {number} params.quantity - Total supply
 		   * @param {number} [params.units=0] - Decimal places (0-8)
 		   * @param {boolean} [params.reissuable=true] - Can mint more later