@neuraiproject/neurai-assets 1.0.0

package/examples/03-create-nfts.js

@@ -0,0 +1,140 @@
+/**
+ * Example: Create UNIQUE Assets (NFTs)
+ *
+ * This example demonstrates how to create UNIQUE assets (NFTs).
+ * UNIQUE assets are one-of-a-kind tokens with the format: ROOT#TAG
+ *
+ * Requirements:
+ * - Must own the parent ROOT asset's owner token (ROOT!)
+ *
+ * Cost: 10 XNA per NFT (burned)
+ * Format: ROOT#TAG (e.g., MYTOKEN#001, MYTOKEN#GENESIS)
+ */
+
+const NeuraiAssets = require('@neuraiproject/neurai-assets');
+
+async function createNFTs() {
+  // Mock RPC function (replace with your actual RPC client)
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+    // Your RPC implementation here
+  };
+
+  // Initialize NeuraiAssets
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Verify you own the ROOT asset's owner token
+    const rootOwnerToken = 'MYTOKEN!';
+    const myAssets = await assets.listMyAssets(rootOwnerToken);
+
+    if (!myAssets[rootOwnerToken]) {
+      throw new Error(`You must own ${rootOwnerToken} to create UNIQUE assets`);
+    }
+
+    console.log(`✓ Owner token found: ${rootOwnerToken}`);
+
+    // Create multiple NFTs in a single transaction
+    const result = await assets.createUniqueAssets({
+      rootAssetName: 'MYTOKEN',
+      assetTags: [
+        {
+          tag: 'GENESIS',                    // First NFT: MYTOKEN#GENESIS
+          hasIpfs: true,
+          ipfsHash: 'QmNFT1GenesisMetadata...'
+        },
+        {
+          tag: '001',                        // Second NFT: MYTOKEN#001
+          hasIpfs: true,
+          ipfsHash: 'QmNFT2Metadata...'
+        },
+        {
+          tag: '002',                        // Third NFT: MYTOKEN#002
+          hasIpfs: true,
+          ipfsHash: 'QmNFT3Metadata...'
+        },
+        {
+          tag: 'SPECIAL_EDITION',            // Fourth NFT: MYTOKEN#SPECIAL_EDITION
+          hasIpfs: true,
+          ipfsHash: 'QmNFT4Metadata...'
+        }
+      ]
+    });
+
+    console.log('NFT Collection created successfully!');
+    console.log('Raw Transaction:', result.rawTx);
+    console.log('Total Fee:', result.fee, 'XNA');
+    console.log('Total Burn:', result.burn, 'XNA (10 XNA per NFT)');
+    console.log('NFTs Created:', result.metadata.assetTags.length);
+    console.log('Owner Token Used:', result.metadata.ownerTokenUsed);
+
+    console.log('\nNFTs created:');
+    result.metadata.assetTags.forEach((tag, index) => {
+      console.log(`${index + 1}. MYTOKEN#${tag}`);
+    });
+
+    // IMPORTANT: Each UNIQUE asset has a quantity of 1 and cannot be reissued
+    // Each NFT is truly unique and one-of-a-kind
+
+    console.log('\nNFT Properties:');
+    console.log('- Quantity: 1 (fixed, cannot be changed)');
+    console.log('- Reissuable: No (unique forever)');
+    console.log('- Units: 0 (not divisible)');
+    console.log('- IPFS: Each NFT can have its own metadata');
+
+  } catch (error) {
+    console.error('Error creating NFTs:', error.message);
+
+    if (error.name === 'OwnerTokenNotFoundError') {
+      console.error('You do not own the required ROOT owner token');
+    } else if (error.name === 'InvalidAssetNameError') {
+      console.error('Invalid NFT tag format');
+    }
+  }
+}
+
+// Alternative: Create a single NFT
+async function createSingleNFT() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Create just one NFT
+    const result = await assets.createUniqueAssets({
+      rootAssetName: 'MYTOKEN',
+      assetTags: [
+        {
+          tag: 'LEGENDARY',
+          hasIpfs: true,
+          ipfsHash: 'QmLegendaryNFTMetadata...'
+        }
+      ]
+    });
+
+    console.log('Single NFT created: MYTOKEN#LEGENDARY');
+    console.log('Burn:', result.burn, 'XNA');
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Run the examples
+console.log('=== Example 1: Create NFT Collection ===\n');
+createNFTs();
+
+console.log('\n\n=== Example 2: Create Single NFT ===\n');
+createSingleNFT();

package/examples/04-reissue-asset.js

@@ -0,0 +1,164 @@
+/**
+ * Example: Reissue Assets (Mint More Supply)
+ *
+ * This example demonstrates how to reissue (mint more) of an existing asset.
+ * Reissuing allows you to increase the total supply of a ROOT or SUB asset.
+ *
+ * Requirements:
+ * - Must own the asset's owner token (ASSET!)
+ * - Asset must be reissuable (reissuable flag must be true)
+ *
+ * Cost: 200 XNA (burned)
+ */
+
+const NeuraiAssets = require('@neuraiproject/neurai-assets');
+
+async function reissueAsset() {
+  // Mock RPC function (replace with your actual RPC client)
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+    // Your RPC implementation here
+  };
+
+  // Initialize NeuraiAssets
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Step 1: Check current asset data
+    const assetName = 'MYTOKEN';
+    const assetData = await assets.getAssetData(assetName);
+
+    console.log('Current Asset Info:');
+    console.log('- Name:', assetData.name);
+    console.log('- Current Supply:', assetData.amount);
+    console.log('- Units:', assetData.units);
+    console.log('- Reissuable:', assetData.reissuable);
+
+    // Step 2: Verify asset is reissuable
+    if (!assetData.reissuable) {
+      throw new Error('Asset supply is locked and cannot be reissued');
+    }
+
+    // Step 3: Verify you own the owner token
+    const ownerToken = `${assetName}!`;
+    const myAssets = await assets.listMyAssets(ownerToken);
+
+    if (!myAssets[ownerToken]) {
+      throw new Error(`You must own ${ownerToken} to reissue this asset`);
+    }
+
+    console.log(`✓ Owner token found: ${ownerToken}`);
+
+    // Step 4: Reissue (mint more supply)
+    const result = await assets.reissueAsset({
+      assetName: assetName,
+      quantity: 500000,           // Additional amount to mint
+      reissuable: true,            // Keep it reissuable (false to lock forever)
+      newIpfs: ''                  // Optional: update IPFS metadata
+    });
+
+    const newTotalSupply = assetData.amount + 500000;
+
+    console.log('\nReissue transaction created successfully!');
+    console.log('Raw Transaction:', result.rawTx);
+    console.log('Fee:', result.fee, 'XNA');
+    console.log('Burn:', result.burn, 'XNA');
+    console.log('Amount to Mint:', result.metadata.quantityMinted);
+    console.log('Previous Supply:', result.metadata.previousSupply);
+    console.log('New Total Supply:', result.metadata.newTotalSupply);
+
+    console.log('\nNext steps:');
+    console.log('1. Sign the transaction');
+    console.log('2. Broadcast to network');
+    console.log('3. New tokens will be added to your balance');
+
+  } catch (error) {
+    console.error('Error reissuing asset:', error.message);
+
+    if (error.name === 'AssetNotReissuableError') {
+      console.error('This asset supply is locked and cannot be reissued');
+    } else if (error.name === 'OwnerTokenNotFoundError') {
+      console.error('You do not own the required owner token');
+    } else if (error.name === 'MaxSupplyExceededError') {
+      console.error('Reissuing would exceed maximum supply of 21 billion');
+    }
+  }
+}
+
+// Example: Lock the supply forever
+async function lockSupply() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Reissue with reissuable=false to lock supply forever
+    const result = await assets.reissueAsset({
+      assetName: 'MYTOKEN',
+      quantity: 0,                 // No additional supply
+      reissuable: false,           // LOCK SUPPLY FOREVER
+      newIpfs: ''
+    });
+
+    console.log('Supply locked permanently!');
+    console.log('No more tokens can ever be minted for this asset');
+    console.log('Reissuable Status:', result.metadata.reissuableLocked ? 'LOCKED' : 'UNLOCKED');
+
+    // WARNING: This action is PERMANENT and cannot be undone!
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Example: Update IPFS metadata
+async function updateMetadata() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Reissue to update IPFS hash without minting new supply
+    const result = await assets.reissueAsset({
+      assetName: 'MYTOKEN',
+      quantity: 0,                              // No new supply
+      reissuable: true,                         // Keep reissuable
+      newIpfs: 'QmNewUpdatedMetadata...'       // New IPFS hash
+    });
+
+    console.log('Metadata updated successfully!');
+    console.log('New IPFS hash:', 'QmNewUpdatedMetadata...');
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Run the examples
+console.log('=== Example 1: Mint More Supply ===\n');
+reissueAsset();
+
+console.log('\n\n=== Example 2: Lock Supply Forever ===\n');
+lockSupply();
+
+console.log('\n\n=== Example 3: Update Metadata ===\n');
+updateMetadata();

package/examples/05-create-qualifier-and-tag.js

@@ -0,0 +1,209 @@
+/**
+ * Example: Create QUALIFIERs and Tag Addresses
+ *
+ * This example demonstrates how to create QUALIFIER assets (KYC/compliance tags)
+ * and assign them to addresses. QUALIFIERs are used for compliance in RESTRICTED assets.
+ *
+ * Format: #NAME (e.g., #KYC_VERIFIED, #ACCREDITED)
+ *
+ * Costs:
+ * - Create QUALIFIER (root): 2000 XNA
+ * - Create SUB_QUALIFIER: 200 XNA
+ * - Tag/Untag address: 0.1 XNA per address
+ */
+
+const NeuraiAssets = require('@neuraiproject/neurai-assets');
+
+async function createQualifierAndTagAddresses() {
+  // Mock RPC function (replace with your actual RPC client)
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+    // Your RPC implementation here
+  };
+
+  // Initialize NeuraiAssets
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Step 1: Create a QUALIFIER (KYC tag)
+    console.log('=== Step 1: Create QUALIFIER ===\n');
+
+    const createResult = await assets.createQualifier({
+      qualifierName: '#KYC_VERIFIED',    // Must start with #
+      quantity: 1,                        // Usually 1-10 (limited quantity)
+      hasIpfs: true,
+      ipfsHash: 'QmKYCMetadata...'       // Metadata about the qualifier
+    });
+
+    console.log('QUALIFIER created successfully!');
+    console.log('Name:', '#KYC_VERIFIED');
+    console.log('Owner Token:', '#KYC_VERIFIED!');
+    console.log('Burn:', createResult.burn, 'XNA');
+
+    // Step 2: Tag addresses with the qualifier
+    console.log('\n=== Step 2: Tag Addresses ===\n');
+
+    const tagResult = await assets.tagAddresses({
+      qualifierName: '#KYC_VERIFIED',
+      addresses: [
+        'NAddress1ToKYC...',
+        'NAddress2ToKYC...',
+        'NAddress3ToKYC...'
+      ],
+      assetData: 'KYC expires 2025-12-31'  // Optional data
+    });
+
+    console.log('Addresses tagged successfully!');
+    console.log('Qualifier:', tagResult.metadata.qualifierName);
+    console.log('Addresses tagged:', tagResult.metadata.addressCount);
+    console.log('Burn:', tagResult.burn, 'XNA (0.1 per address)');
+
+    // Step 3: Verify tags
+    console.log('\n=== Step 3: Verify Tags ===\n');
+
+    for (const address of tagResult.metadata.targetAddresses) {
+      const hasTag = await assets.checkAddressTag(address, '#KYC_VERIFIED');
+      console.log(`${address}: ${hasTag ? '✓ Tagged' : '✗ Not tagged'}`);
+    }
+
+    // Step 4: List all tags for an address
+    console.log('\n=== Step 4: List Address Tags ===\n');
+
+    const tags = await assets.listTagsForAddress('NAddress1ToKYC...');
+    console.log('Tags for NAddress1ToKYC:');
+    tags.forEach(tag => console.log(`- ${tag}`));
+
+  } catch (error) {
+    console.error('Error:', error.message);
+
+    if (error.name === 'InvalidAssetNameError') {
+      console.error('Qualifier name must start with #');
+    } else if (error.name === 'OwnerTokenNotFoundError') {
+      console.error('You need the qualifier owner token to tag addresses');
+    }
+  }
+}
+
+// Example: Create multiple qualifiers for different compliance levels
+async function createComplianceSystem() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Create different compliance qualifiers
+    const qualifiers = [
+      { name: '#KYC_BASIC', metadata: 'QmBasicKYC...' },
+      { name: '#KYC_ADVANCED', metadata: 'QmAdvancedKYC...' },
+      { name: '#ACCREDITED_INVESTOR', metadata: 'QmAccredited...' },
+      { name: '#INSTITUTIONAL', metadata: 'QmInstitutional...' }
+    ];
+
+    console.log('Creating compliance qualifier system...\n');
+
+    for (const qualifier of qualifiers) {
+      const result = await assets.createQualifier({
+        qualifierName: qualifier.name,
+        quantity: 1,
+        hasIpfs: true,
+        ipfsHash: qualifier.metadata
+      });
+
+      console.log(`✓ Created: ${qualifier.name} (burn: ${result.burn} XNA)`);
+    }
+
+    console.log('\nCompliance system created!');
+    console.log('You can now tag addresses with different compliance levels.');
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Example: Remove tags from addresses
+async function untagAddresses() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Remove KYC tag from addresses
+    const result = await assets.untagAddresses({
+      qualifierName: '#KYC_VERIFIED',
+      addresses: [
+        'NAddressToUntag1...',
+        'NAddressToUntag2...'
+      ]
+    });
+
+    console.log('Tags removed successfully!');
+    console.log('Addresses untagged:', result.metadata.addressCount);
+    console.log('Burn:', result.burn, 'XNA');
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Example: Create SUB_QUALIFIER
+async function createSubQualifier() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna',
+    addresses: ['NYourAddress1...'],
+    changeAddress: 'NChangeAddress...',
+    toAddress: 'NReceivingAddress...'
+  });
+
+  try {
+    // Create a sub-qualifier (requires parent qualifier owner token)
+    const result = await assets.createQualifier({
+      qualifierName: '#KYC/#LEVEL_2',   // Format: #PARENT/#SUB
+      quantity: 1,
+      hasIpfs: true,
+      ipfsHash: 'QmLevel2Metadata...'
+    });
+
+    console.log('SUB_QUALIFIER created!');
+    console.log('Name:', '#KYC/#LEVEL_2');
+    console.log('Burn:', result.burn, 'XNA (200 for sub-qualifier)');
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Run the examples
+console.log('=== Example 1: Create Qualifier and Tag Addresses ===\n');
+createQualifierAndTagAddresses();
+
+console.log('\n\n=== Example 2: Create Compliance System ===\n');
+createComplianceSystem();
+
+console.log('\n\n=== Example 3: Untag Addresses ===\n');
+untagAddresses();
+
+console.log('\n\n=== Example 4: Create SUB_QUALIFIER ===\n');
+createSubQualifier();