@neuraiproject/neurai-assets 1.2.2 → 1.2.5

package/dist/NeuraiAssets.global.js

@@ -1040,11 +1040,15 @@ var NeuraiAssetsBundle = (function (exports) {
 	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,
@@ -1055,6 +1059,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    name: 'xna-test',
 		    displayName: 'Neurai Testnet',
 		    addressPrefix: 't',
+		    authScriptAddressPrefix: 'tnq1',
 		    pqAddressPrefix: 'tnq1',
 		    assetNameMaxLength: 32,  // Same as mainnet
 		    defaultRPCPort: 19101,
@@ -1063,8 +1068,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		  },
 		  MAINNET_PQ: {
 		    name: 'xna-pq',
-		    displayName: 'Neurai Mainnet PQ',
+		    displayName: 'Neurai Mainnet AuthScript',
 		    addressPrefix: 'N',
+		    authScriptAddressPrefix: 'nq1',
 		    pqAddressPrefix: 'nq1',
 		    assetNameMaxLength: 32,
 		    defaultRPCPort: 19001,
@@ -1073,8 +1079,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		  },
 		  TESTNET_PQ: {
 		    name: 'xna-pq-test',
-		    displayName: 'Neurai Testnet PQ',
+		    displayName: 'Neurai Testnet AuthScript',
 		    addressPrefix: 't',
+		    authScriptAddressPrefix: 'tnq1',
 		    pqAddressPrefix: 'tnq1',
 		    assetNameMaxLength: 32,
 		    defaultRPCPort: 19101,
@@ -1084,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: '/'
@@ -1144,32 +1151,68 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		/**
 		 * 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';
@@ -1182,9 +1225,13 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		networks = {
 		  NETWORKS,
+		  MAINNET_NETWORKS,
+		  TESTNET_NETWORKS,
 		  ASSET_NAME_RULES,
 		  ASSET_LIMITS,
 		  getNetworkConfig,
+		  resolveAddressNetworkFamily,
+		  areAddressNetworksCompatible,
 		  detectNetworkFromAddress
 		};
 		return networks;
@@ -1212,9 +1259,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		} = requireBurnAddresses();
 		const {
 		  NETWORKS,
+		  MAINNET_NETWORKS,
+		  TESTNET_NETWORKS,
 		  ASSET_NAME_RULES,
 		  ASSET_LIMITS,
 		  getNetworkConfig,
+		  resolveAddressNetworkFamily,
+		  areAddressNetworksCompatible,
 		  detectNetworkFromAddress
 		} = requireNetworks();
 
@@ -1237,9 +1288,13 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		  // Networks
 		  NETWORKS,
+		  MAINNET_NETWORKS,
+		  TESTNET_NETWORKS,
 		  ASSET_NAME_RULES,
 		  ASSET_LIMITS,
 		  getNetworkConfig,
+		  resolveAddressNetworkFamily,
+		  areAddressNetworksCompatible,
 		  detectNetworkFromAddress
 		};
 		return constants$1;
@@ -1856,7 +1911,11 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireNetworkDetector () {
 		if (hasRequiredNetworkDetector) return networkDetector;
 		hasRequiredNetworkDetector = 1;
-		const { NETWORKS } = requireConstants();
+		const {
+		  NETWORKS,
+		  areAddressNetworksCompatible,
+		  resolveAddressNetworkFamily
+		} = requireConstants();
 
 		class NetworkDetector {
 		  /**
@@ -1893,18 +1952,18 @@ var NeuraiAssetsBundle = (function (exports) {
 		  /**
 		   * 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';
 		    }
 
@@ -1924,31 +1983,32 @@ var NeuraiAssetsBundle = (function (exports) {
 		  /**
 		   * 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) {
@@ -1958,7 +2018,7 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		    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}`
 		        );
@@ -3310,52 +3370,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;
 		  }
 
@@ -3363,39 +3535,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);
+		    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
 		      );
 		    }
@@ -3407,10 +3565,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) {
@@ -3422,24 +3580,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
 		      );
 		    }
@@ -3451,10 +3594,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(
@@ -3463,58 +3604,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
-		          );
-		        }
-
-		        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;
@@ -3524,10 +3624,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(
@@ -3536,10 +3634,18 @@ var NeuraiAssetsBundle = (function (exports) {
 		      );
 		    }
 
-		    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;
 		  }
@@ -3548,10 +3654,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(
@@ -3560,58 +3664,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;
 		  }
 
@@ -3619,24 +3706,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;
@@ -3647,27 +3741,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';
 		    }
 		  }
@@ -4344,22 +4438,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}`);
@@ -5780,7 +5874,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)
@@ -7245,7 +7339,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