@neuraiproject/neurai-assets 1.0.0

package/src/utils/assetNameParser.js

@@ -0,0 +1,203 @@
+/**
+ * Asset Name Parser
+ * Parses and analyzes asset names
+ */
+
+const { AssetType } = require('../constants');
+
+class AssetNameParser {
+  /**
+   * Parse asset name and extract information
+   * @param {string} name - Asset name
+   * @returns {object} Parsed information
+   */
+  static parse(name) {
+    const isOwner = name.endsWith('!');
+    const isRestricted = name.startsWith('$');
+    const isQualifier = name.startsWith('#');
+    const cleanName = isOwner ? name.slice(0, -1) : name;
+
+    let type;
+    let parent = null;
+    let subName = null;
+    let tag = null;
+    let prefix = null;
+
+    if (isQualifier) {
+      // QUALIFIER or SUB_QUALIFIER: #NAME or #ROOT/SUB
+      if (cleanName.includes('/')) {
+        type = AssetType.SUB_QUALIFIER;
+        const withoutHash = cleanName.substring(1);
+        const parts = withoutHash.split('/');
+        parent = '#' + parts[0];
+        subName = parts[1];
+        prefix = '#';
+      } else {
+        type = AssetType.QUALIFIER;
+        prefix = '#';
+      }
+    } else if (isRestricted) {
+      // RESTRICTED: $NAME
+      type = AssetType.RESTRICTED;
+      prefix = '$';
+    } else if (cleanName.includes('#')) {
+      // UNIQUE: ROOT#TAG
+      type = AssetType.UNIQUE;
+      const parts = cleanName.split('#');
+      parent = parts[0];
+      tag = parts[1];
+    } else if (cleanName.includes('/')) {
+      // SUB: ROOT/SUB
+      type = AssetType.SUB;
+      const parts = cleanName.split('/');
+      parent = parts[0];
+      subName = parts[1];
+    } else {
+      // ROOT
+      type = AssetType.ROOT;
+    }
+
+    // Override type if owner token
+    if (isOwner) {
+      const baseType = type;
+      type = AssetType.OWNER;
+      return {
+        type,
+        baseType,
+        parent,
+        name: cleanName,
+        subName,
+        tag,
+        prefix,
+        isOwner: true,
+        isRestricted: cleanName.startsWith('$'),
+        isQualifier: false,
+        fullName: name,
+        baseName: cleanName
+      };
+    }
+
+    return {
+      type,
+      parent,
+      name: cleanName,
+      subName,
+      tag,
+      prefix,
+      isOwner,
+      isRestricted,
+      isQualifier,
+      fullName: name,
+      baseName: cleanName
+    };
+  }
+
+  /**
+   * Get asset type from name
+   * @param {string} name - Asset name
+   * @returns {number} AssetType enum value
+   */
+  static getType(name) {
+    return this.parse(name).type;
+  }
+
+  /**
+   * Get parent asset name
+   * @param {string} name - Asset name
+   * @returns {string|null} Parent asset name or null
+   */
+  static getParent(name) {
+    return this.parse(name).parent;
+  }
+
+  /**
+   * Check if asset is an owner token
+   * @param {string} name - Asset name
+   * @returns {boolean} True if owner token
+   */
+  static isOwnerToken(name) {
+    return name.endsWith('!');
+  }
+
+  /**
+   * Get owner token name for an asset
+   * @param {string} assetName - Asset name
+   * @returns {string} Owner token name (assetName + '!')
+   */
+  static getOwnerTokenName(assetName) {
+    if (this.isOwnerToken(assetName)) {
+      return assetName;
+    }
+    return assetName + '!';
+  }
+
+  /**
+   * Get base asset name from owner token
+   * @param {string} ownerTokenName - Owner token name (with !)
+   * @returns {string} Base asset name (without !)
+   */
+  static getBaseAssetName(ownerTokenName) {
+    if (this.isOwnerToken(ownerTokenName)) {
+      return ownerTokenName.slice(0, -1);
+    }
+    return ownerTokenName;
+  }
+
+  /**
+   * Check if asset is restricted
+   * @param {string} name - Asset name
+   * @returns {boolean} True if restricted
+   */
+  static isRestricted(name) {
+    return name.startsWith('$');
+  }
+
+  /**
+   * Check if asset is a qualifier
+   * @param {string} name - Asset name
+   * @returns {boolean} True if qualifier
+   */
+  static isQualifier(name) {
+    return name.startsWith('#');
+  }
+
+  /**
+   * Check if asset is unique (NFT)
+   * @param {string} name - Asset name
+   * @returns {boolean} True if unique
+   */
+  static isUnique(name) {
+    return name.includes('#') && !name.startsWith('#');
+  }
+
+  /**
+   * Check if asset is a sub-asset
+   * @param {string} name - Asset name
+   * @returns {boolean} True if sub-asset
+   */
+  static isSub(name) {
+    return name.includes('/') && !name.startsWith('#');
+  }
+
+  /**
+   * Build unique asset name
+   * @param {string} rootName - Root asset name
+   * @param {string} tag - Unique tag
+   * @returns {string} Full unique asset name
+   */
+  static buildUniqueName(rootName, tag) {
+    return `${rootName}#${tag}`;
+  }
+
+  /**
+   * Build sub-asset name
+   * @param {string} rootName - Root asset name
+   * @param {string} subName - Sub-asset name
+   * @returns {string} Full sub-asset name
+   */
+  static buildSubName(rootName, subName) {
+    return `${rootName}/${subName}`;
+  }
+}
+
+module.exports = AssetNameParser;

package/src/utils/index.js

@@ -0,0 +1,16 @@
+/**
+ * Utils Module
+ * Exports all utility classes
+ */
+
+const AssetNameParser = require('./assetNameParser');
+const AmountConverter = require('./amountConverter');
+const NetworkDetector = require('./networkDetector');
+const OutputFormatter = require('./outputFormatter');
+
+module.exports = {
+  AssetNameParser,
+  AmountConverter,
+  NetworkDetector,
+  OutputFormatter
+};

package/src/utils/networkDetector.js

@@ -0,0 +1,144 @@
+/**
+ * Network Detector
+ * Detects network type from various sources
+ */
+
+const { NETWORKS } = require('../constants');
+
+class NetworkDetector {
+  /**
+   * Detect network from RPC client
+   * Calls getblockchaininfo to determine network
+   * @param {Function} rpc - RPC function
+   * @returns {Promise<string>} Network name ('xna' or 'xna-test')
+   */
+  static async detectFromRPC(rpc) {
+    try {
+      const blockchainInfo = await rpc('getblockchaininfo', []);
+
+      // Check chain name
+      if (blockchainInfo.chain === 'main') {
+        return 'xna';
+      } else if (blockchainInfo.chain === 'test') {
+        return 'xna-test';
+      } else if (blockchainInfo.chain === 'regtest') {
+        return 'xna-test';  // Treat regtest as testnet
+      }
+
+      // Fallback: check if testnet field exists
+      if (blockchainInfo.testnet === true) {
+        return 'xna-test';
+      }
+
+      // Default to mainnet
+      return 'xna';
+    } catch (error) {
+      throw new Error(`Failed to detect network from RPC: ${error.message}`);
+    }
+  }
+
+  /**
+   * Detect network from address
+   * @param {string} address - Neurai address
+   * @returns {string} Network name ('xna' or 'xna-test')
+   */
+  static detectFromAddress(address) {
+    if (!address || typeof address !== 'string') {
+      throw new Error('Address must be a non-empty string');
+    }
+
+    // Mainnet addresses start with 'N'
+    if (address.startsWith(NETWORKS.MAINNET.addressPrefix)) {
+      return 'xna';
+    }
+
+    // Testnet addresses start with 'm' or 'n'
+    if (address.startsWith(NETWORKS.TESTNET.addressPrefix) || address.startsWith('n')) {
+      return 'xna-test';
+    }
+
+    throw new Error(`Cannot detect network from address: ${address}`);
+  }
+
+  /**
+   * Detect network from multiple addresses
+   * @param {string[]} addresses - Array of addresses
+   * @returns {string} Network name ('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]);
+
+    // 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}`);
+      }
+    }
+
+    return network;
+  }
+
+  /**
+   * Validate that addresses match expected network
+   * @param {string[]} addresses - Array of addresses
+   * @param {string} expectedNetwork - Expected network ('xna' or 'xna-test')
+   * @returns {boolean} True if all addresses match network
+   */
+  static validateAddressesNetwork(addresses, expectedNetwork) {
+    if (!Array.isArray(addresses) || addresses.length === 0) {
+      throw new Error('Addresses must be a non-empty array');
+    }
+
+    for (const address of addresses) {
+      const network = this.detectFromAddress(address);
+      if (network !== expectedNetwork) {
+        throw new Error(
+          `Address ${address} is from ${network} but expected ${expectedNetwork}`
+        );
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Get network config from network name
+   * @param {string} network - Network name
+   * @returns {object} Network configuration
+   */
+  static getNetworkConfig(network) {
+    if (network === 'xna' || network === 'mainnet') {
+      return NETWORKS.MAINNET;
+    } else if (network === 'xna-test' || network === 'testnet') {
+      return NETWORKS.TESTNET;
+    } else {
+      throw new Error(`Unknown network: ${network}`);
+    }
+  }
+
+  /**
+   * Check if network is mainnet
+   * @param {string} network - Network name
+   * @returns {boolean} True if mainnet
+   */
+  static isMainnet(network) {
+    return network === 'xna' || network === 'mainnet';
+  }
+
+  /**
+   * Check if network is testnet
+   * @param {string} network - Network name
+   * @returns {boolean} True if testnet
+   */
+  static isTestnet(network) {
+    return network === 'xna-test' || network === 'testnet' || network === 'regtest';
+  }
+}
+
+module.exports = NetworkDetector;

package/src/utils/outputFormatter.js

@@ -0,0 +1,292 @@
+/**
+ * Output Formatter
+ * Formats outputs for createrawtransaction RPC calls
+ */
+
+class OutputFormatter {
+  /**
+   * Format issue operation output
+   * @param {object} params - Issue parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatIssueOutput(params) {
+    const {
+      asset_name,
+      asset_quantity,
+      units,
+      reissuable,
+      has_ipfs,
+      ipfs_hash
+    } = params;
+
+    return {
+      issue: {
+        asset_name,
+        asset_quantity,
+        units,
+        reissuable: reissuable ? 1 : 0,
+        has_ipfs: has_ipfs ? 1 : 0,
+        ipfs_hash: ipfs_hash || ''
+      }
+    };
+  }
+
+  /**
+   * Format issue unique operation output
+   * @param {object} params - Issue unique parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatIssueUniqueOutput(params) {
+    const { root_name, asset_tags, ipfs_hashes } = params;
+
+    return {
+      issue_unique: {
+        root_name,
+        asset_tags,
+        ipfs_hashes: ipfs_hashes || []
+      }
+    };
+  }
+
+  /**
+   * Format issue restricted operation output
+   * @param {object} params - Issue restricted parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatIssueRestrictedOutput(params) {
+    const {
+      asset_name,
+      asset_quantity,
+      verifier_string,
+      units,
+      reissuable,
+      has_ipfs,
+      ipfs_hash
+    } = params;
+
+    return {
+      issue_restricted: {
+        asset_name,
+        asset_quantity,
+        verifier_string,
+        units,
+        reissuable: reissuable ? 1 : 0,
+        has_ipfs: has_ipfs ? 1 : 0,
+        ipfs_hash: ipfs_hash || ''
+      }
+    };
+  }
+
+  /**
+   * Format issue qualifier operation output
+   * @param {object} params - Issue qualifier parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatIssueQualifierOutput(params) {
+    const {
+      asset_name,
+      asset_quantity,
+      has_ipfs,
+      ipfs_hash
+    } = params;
+
+    return {
+      issue_qualifier: {
+        asset_name,
+        asset_quantity,
+        has_ipfs: has_ipfs ? 1 : 0,
+        ipfs_hash: ipfs_hash || ''
+      }
+    };
+  }
+
+  /**
+   * Format reissue operation output
+   * @param {object} params - Reissue parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatReissueOutput(params) {
+    const {
+      asset_name,
+      asset_quantity,
+      reissuable,
+      new_ipfs
+    } = params;
+
+    const output = {
+      reissue: {
+        asset_name,
+        asset_quantity
+      }
+    };
+
+    // Optional parameters
+    if (reissuable !== undefined) {
+      output.reissue.reissuable = reissuable ? 1 : 0;
+    }
+
+    if (new_ipfs) {
+      output.reissue.ipfs_hash = new_ipfs;
+    }
+
+    return output;
+  }
+
+  /**
+   * Format reissue restricted operation output
+   * @param {object} params - Reissue restricted parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatReissueRestrictedOutput(params) {
+    const {
+      asset_name,
+      asset_quantity,
+      change_verifier,
+      new_verifier,
+      reissuable,
+      new_ipfs
+    } = params;
+
+    const output = {
+      reissue_restricted: {
+        asset_name,
+        asset_quantity
+      }
+    };
+
+    // Optional parameters
+    if (change_verifier && new_verifier) {
+      output.reissue_restricted.verifier_string = new_verifier;
+    }
+
+    if (reissuable !== undefined) {
+      output.reissue_restricted.reissuable = reissuable ? 1 : 0;
+    }
+
+    if (new_ipfs) {
+      output.reissue_restricted.ipfs_hash = new_ipfs;
+    }
+
+    return output;
+  }
+
+  /**
+   * Format asset transfer output
+   * @param {string} assetName - Asset name
+   * @param {number} amount - Amount to transfer
+   * @returns {object} Formatted transfer output
+   */
+  static formatTransferOutput(assetName, amount) {
+    return {
+      transfer: {
+        [assetName]: amount
+      }
+    };
+  }
+
+  /**
+   * Format tag addresses operation output
+   * @param {object} params - Tag addresses parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatTagAddressesOutput(params) {
+    const {
+      tag_name,
+      addresses,
+      asset_data
+    } = params;
+
+    return {
+      tag_addresses: {
+        tag_name,
+        addresses,
+        asset_data: asset_data || ''
+      }
+    };
+  }
+
+  /**
+   * Format untag addresses operation output
+   * @param {object} params - Untag addresses parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatUntagAddressesOutput(params) {
+    const {
+      tag_name,
+      addresses
+    } = params;
+
+    return {
+      untag_addresses: {
+        tag_name,
+        addresses
+      }
+    };
+  }
+
+  /**
+   * Format freeze addresses operation output
+   * @param {object} params - Freeze addresses parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatFreezeAddressesOutput(params) {
+    const {
+      asset_name,
+      addresses
+    } = params;
+
+    return {
+      freeze_addresses: {
+        asset_name,
+        addresses
+      }
+    };
+  }
+
+  /**
+   * Format unfreeze addresses operation output
+   * @param {object} params - Unfreeze addresses parameters
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatUnfreezeAddressesOutput(params) {
+    const {
+      asset_name,
+      addresses
+    } = params;
+
+    return {
+      unfreeze_addresses: {
+        asset_name,
+        addresses
+      }
+    };
+  }
+
+  /**
+   * Format freeze asset operation output
+   * @param {string} assetName - Restricted asset name
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatFreezeAssetOutput(assetName) {
+    return {
+      freeze_asset: {
+        asset_name: assetName
+      }
+    };
+  }
+
+  /**
+   * Format unfreeze asset operation output
+   * @param {string} assetName - Restricted asset name
+   * @returns {object} Formatted output for createrawtransaction
+   */
+  static formatUnfreezeAssetOutput(assetName) {
+    return {
+      unfreeze_asset: {
+        asset_name: assetName
+      }
+    };
+  }
+}
+
+module.exports = OutputFormatter;