@neuraiproject/neurai-assets 1.2.2 → 1.2.5

package/dist/index.js

@@ -1037,11 +1037,15 @@ var hasRequiredNetworks;
 function requireNetworks () {
 	if (hasRequiredNetworks) return networks;
 	hasRequiredNetworks = 1;
+	const MAINNET_NETWORKS = ['xna', 'mainnet', 'xna-pq', 'mainnet-pq'];
+	const TESTNET_NETWORKS = ['xna-test', 'testnet', 'regtest', 'xna-pq-test', 'testnet-pq'];
+
 	const NETWORKS = {
 	  MAINNET: {
 	    name: 'xna',
 	    displayName: 'Neurai Mainnet',
 	    addressPrefix: 'N',
+	    authScriptAddressPrefix: 'nq1',
 	    pqAddressPrefix: 'nq1',
 	    assetNameMaxLength: 32,
 	    defaultRPCPort: 19001,
@@ -1052,6 +1056,7 @@ function requireNetworks () {
 	    name: 'xna-test',
 	    displayName: 'Neurai Testnet',
 	    addressPrefix: 't',
+	    authScriptAddressPrefix: 'tnq1',
 	    pqAddressPrefix: 'tnq1',
 	    assetNameMaxLength: 32,  // Same as mainnet
 	    defaultRPCPort: 19101,
@@ -1060,8 +1065,9 @@ function requireNetworks () {
 	  },
 	  MAINNET_PQ: {
 	    name: 'xna-pq',
-	    displayName: 'Neurai Mainnet PQ',
+	    displayName: 'Neurai Mainnet AuthScript',
 	    addressPrefix: 'N',
+	    authScriptAddressPrefix: 'nq1',
 	    pqAddressPrefix: 'nq1',
 	    assetNameMaxLength: 32,
 	    defaultRPCPort: 19001,
@@ -1070,8 +1076,9 @@ function requireNetworks () {
 	  },
 	  TESTNET_PQ: {
 	    name: 'xna-pq-test',
-	    displayName: 'Neurai Testnet PQ',
+	    displayName: 'Neurai Testnet AuthScript',
 	    addressPrefix: 't',
+	    authScriptAddressPrefix: 'tnq1',
 	    pqAddressPrefix: 'tnq1',
 	    assetNameMaxLength: 32,
 	    defaultRPCPort: 19101,
@@ -1081,45 +1088,45 @@ function requireNetworks () {
 	};
 
 	/**
-	 * 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: '/'
@@ -1141,32 +1148,68 @@ function requireNetworks () {
 
 	/**
 	 * Get network configuration
+	 * `xna-pq` / `xna-pq-test` are preserved as compatibility aliases for
+	 * AuthScript address flows on the same mainnet/testnet families.
+	 *
 	 * @param {string} networkName - Network name ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
 	 * @returns {object} Network configuration
 	 */
 	function getNetworkConfig(networkName) {
-	  if (networkName === 'xna' || networkName === 'mainnet') {
-	    return NETWORKS.MAINNET;
-	  } else if (networkName === 'xna-test' || networkName === 'testnet') {
-	    return NETWORKS.TESTNET;
-	  } else if (networkName === 'xna-pq' || networkName === 'mainnet-pq') {
-	    return NETWORKS.MAINNET_PQ;
-	  } else if (networkName === 'xna-pq-test' || networkName === 'testnet-pq') {
-	    return NETWORKS.TESTNET_PQ;
+	  if (MAINNET_NETWORKS.includes(networkName)) {
+	    return networkName === 'xna-pq' || networkName === 'mainnet-pq'
+	      ? NETWORKS.MAINNET_PQ
+	      : NETWORKS.MAINNET;
+	  } else if (TESTNET_NETWORKS.includes(networkName)) {
+	    return networkName === 'xna-pq-test' || networkName === 'testnet-pq'
+	      ? NETWORKS.TESTNET_PQ
+	      : NETWORKS.TESTNET;
 	  } else {
 	    throw new Error(`Unknown network: ${networkName}`);
 	  }
 	}
 
 	/**
-	 * Detect network from address prefix
+	 * Resolve a network name to its chain family.
+	 * AuthScript aliases share the same family as legacy addresses.
+	 *
+	 * @param {string} networkName - Network name
+	 * @returns {'mainnet'|'testnet'} Network family
+	 */
+	function resolveAddressNetworkFamily(networkName) {
+	  if (MAINNET_NETWORKS.includes(networkName)) {
+	    return 'mainnet';
+	  }
+
+	  if (TESTNET_NETWORKS.includes(networkName)) {
+	    return 'testnet';
+	  }
+
+	  throw new Error(`Unknown network: ${networkName}`);
+	}
+
+	/**
+	 * Determine whether two network labels are compatible for address use.
+	 * This treats legacy and AuthScript labels on the same chain as compatible.
+	 *
+	 * @param {string} left - First network name
+	 * @param {string} right - Second network name
+	 * @returns {boolean} True if both belong to the same chain family
+	 */
+	function areAddressNetworksCompatible(left, right) {
+	  return resolveAddressNetworkFamily(left) === resolveAddressNetworkFamily(right);
+	}
+
+	/**
+	 * Detect network from address prefix.
+	 * `nq1...` / `tnq1...` are AuthScript witness-v1 destinations.
+	 *
 	 * @param {string} address - Neurai address
 	 * @returns {string} Network name ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
 	 */
 	function detectNetworkFromAddress(address) {
-	  if (address.startsWith(NETWORKS.MAINNET_PQ.pqAddressPrefix)) {
+	  if (address.startsWith(NETWORKS.MAINNET_PQ.authScriptAddressPrefix)) {
 	    return 'xna-pq';
-	  } else if (address.startsWith(NETWORKS.TESTNET_PQ.pqAddressPrefix)) {
+	  } else if (address.startsWith(NETWORKS.TESTNET_PQ.authScriptAddressPrefix)) {
 	    return 'xna-pq-test';
 	  } else if (address.startsWith('N')) {
 	    return 'xna';
@@ -1179,9 +1222,13 @@ function requireNetworks () {
 
 	networks = {
 	  NETWORKS,
+	  MAINNET_NETWORKS,
+	  TESTNET_NETWORKS,
 	  ASSET_NAME_RULES,
 	  ASSET_LIMITS,
 	  getNetworkConfig,
+	  resolveAddressNetworkFamily,
+	  areAddressNetworksCompatible,
 	  detectNetworkFromAddress
 	};
 	return networks;
@@ -1209,9 +1256,13 @@ function requireConstants () {
 	} = requireBurnAddresses();
 	const {
 	  NETWORKS,
+	  MAINNET_NETWORKS,
+	  TESTNET_NETWORKS,
 	  ASSET_NAME_RULES,
 	  ASSET_LIMITS,
 	  getNetworkConfig,
+	  resolveAddressNetworkFamily,
+	  areAddressNetworksCompatible,
 	  detectNetworkFromAddress
 	} = requireNetworks();
 
@@ -1234,9 +1285,13 @@ function requireConstants () {
 
 	  // Networks
 	  NETWORKS,
+	  MAINNET_NETWORKS,
+	  TESTNET_NETWORKS,
 	  ASSET_NAME_RULES,
 	  ASSET_LIMITS,
 	  getNetworkConfig,
+	  resolveAddressNetworkFamily,
+	  areAddressNetworksCompatible,
 	  detectNetworkFromAddress
 	};
 	return constants$1;
@@ -1853,7 +1908,11 @@ var hasRequiredNetworkDetector;
 function requireNetworkDetector () {
 	if (hasRequiredNetworkDetector) return networkDetector;
 	hasRequiredNetworkDetector = 1;
-	const { NETWORKS } = requireConstants();
+	const {
+	  NETWORKS,
+	  areAddressNetworksCompatible,
+	  resolveAddressNetworkFamily
+	} = requireConstants();
 
 	class NetworkDetector {
 	  /**
@@ -1890,18 +1949,18 @@ function requireNetworkDetector () {
 	  /**
 	   * Detect network from address
 	   * @param {string} address - Neurai address
-	   * @returns {string} Network name ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
+	   * @returns {string} Network label ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
 	   */
 	  static detectFromAddress(address) {
 	    if (!address || typeof address !== 'string') {
 	      throw new Error('Address must be a non-empty string');
 	    }
 
-	    if (address.startsWith(NETWORKS.MAINNET_PQ.pqAddressPrefix)) {
+	    if (address.startsWith(NETWORKS.MAINNET_PQ.authScriptAddressPrefix)) {
 	      return 'xna-pq';
 	    }
 
-	    if (address.startsWith(NETWORKS.TESTNET_PQ.pqAddressPrefix)) {
+	    if (address.startsWith(NETWORKS.TESTNET_PQ.authScriptAddressPrefix)) {
 	      return 'xna-pq-test';
 	    }
 
@@ -1921,31 +1980,32 @@ function requireNetworkDetector () {
 	  /**
 	   * Detect network from multiple addresses
 	   * @param {string[]} addresses - Array of addresses
-	   * @returns {string} Network name ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
+	   * @returns {string} Network label. Mixed legacy/AuthScript addresses on the same
+	   * chain are normalized to the chain family label (`xna` or `xna-test`).
 	   */
 	  static detectFromAddresses(addresses) {
 	    if (!Array.isArray(addresses) || addresses.length === 0) {
 	      throw new Error('Addresses must be a non-empty array');
 	    }
 
-	    // Detect from first address
-	    const network = this.detectFromAddress(addresses[0]);
+	    const firstNetwork = this.detectFromAddress(addresses[0]);
+	    const family = resolveAddressNetworkFamily(firstNetwork);
 
 	    // Verify all addresses are from the same network
 	    for (let i = 1; i < addresses.length; i++) {
 	      const otherNetwork = this.detectFromAddress(addresses[i]);
-	      if (otherNetwork !== network) {
-	        throw new Error(`Mixed network addresses detected: ${network} and ${otherNetwork}`);
+	      if (!areAddressNetworksCompatible(firstNetwork, otherNetwork)) {
+	        throw new Error(`Mixed network addresses detected: ${firstNetwork} and ${otherNetwork}`);
 	      }
 	    }
 
-	    return network;
+	    return family === 'mainnet' ? 'xna' : 'xna-test';
 	  }
 
 	  /**
 	   * Validate that addresses match expected network
 	   * @param {string[]} addresses - Array of addresses
-	   * @param {string} expectedNetwork - Expected network ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
+	   * @param {string} expectedNetwork - Expected network label
 	   * @returns {boolean} True if all addresses match network
 	   */
 	  static validateAddressesNetwork(addresses, expectedNetwork) {
@@ -1955,7 +2015,7 @@ function requireNetworkDetector () {
 
 	    for (const address of addresses) {
 	      const network = this.detectFromAddress(address);
-	      if (network !== expectedNetwork) {
+	      if (!areAddressNetworksCompatible(network, expectedNetwork)) {
 	        throw new Error(
 	          `Address ${address} is from ${network} but expected ${expectedNetwork}`
 	        );
@@ -3307,52 +3367,164 @@ function requireAssetNameValidator () {
 	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;
 	  }
 
@@ -3360,39 +3532,25 @@ function requireAssetNameValidator () {
 	   * 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);
+	    ensureMaxLength(name, getRootOrSubMaxLength(network), 'SUB asset name');
 
-	    // 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
-	      );
-	    }
-
-	    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
 	      );
 	    }
@@ -3404,10 +3562,10 @@ function requireAssetNameValidator () {
 	   * 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) {
@@ -3419,24 +3577,9 @@ function requireAssetNameValidator () {
 
 	    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
 	      );
 	    }
@@ -3448,10 +3591,8 @@ function requireAssetNameValidator () {
 	   * 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(
@@ -3460,58 +3601,17 @@ function requireAssetNameValidator () {
 	      );
 	    }
 
-	    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
-	          );
-	        }
-
-	        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
-	        );
-	      }
+	    ensureMaxLength(name, getMaxAssetNameLength(network), 'QUALIFIER asset 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;
@@ -3521,10 +3621,8 @@ function requireAssetNameValidator () {
 	   * 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(
@@ -3533,10 +3631,18 @@ function requireAssetNameValidator () {
 	      );
 	    }
 
-	    const withoutPrefix = name.substring(1);
+	    ensureMaxLength(name, getMaxAssetNameLength(network), 'RESTRICTED asset name');
 
-	    // Validate the part after $ as a ROOT asset name
-	    this.validateRoot(withoutPrefix);
+	    if (name !== name.toUpperCase()) {
+	      throw new InvalidAssetNameError('RESTRICTED asset name must be uppercase', name);
+	    }
+
+	    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;
 	  }
@@ -3545,10 +3651,8 @@ function requireAssetNameValidator () {
 	   * 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(
@@ -3557,58 +3661,41 @@ function requireAssetNameValidator () {
 	      );
 	    }
 
-	    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;
 	  }
 
@@ -3616,24 +3703,31 @@ function requireAssetNameValidator () {
 	   * 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;
@@ -3644,27 +3738,27 @@ function requireAssetNameValidator () {
 	   * @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';
 	    }
 	  }
@@ -4341,22 +4435,22 @@ function requireBaseAssetTransactionBuilder () {
 
 	    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}`);
@@ -5777,7 +5871,7 @@ function requireIssueUniqueBuilder () {
  *
  * 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)
@@ -7242,7 +7336,7 @@ function requireNeuraiAssets () {
 	  /**
 	   * 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