@neuraiproject/neurai-assets 1.0.0

package/tests/unit/NeuraiAssets.test.js

@@ -0,0 +1,217 @@
+/**
+ * Tests for NeuraiAssets main class
+ */
+
+const { expect } = require('chai');
+const NeuraiAssets = require('../../src/NeuraiAssets');
+const { createMockRPC } = require('../mocks/rpcMock');
+
+describe('NeuraiAssets', () => {
+  let assets;
+  let mockRPC;
+
+  beforeEach(() => {
+    mockRPC = createMockRPC();
+    assets = new NeuraiAssets(mockRPC, {
+      network: 'xna',
+      addresses: ['N123...'],
+      changeAddress: 'N123...',
+      toAddress: 'N456...'
+    });
+  });
+
+  describe('constructor', () => {
+    it('should initialize with RPC and config', () => {
+      expect(assets.rpc).to.be.a('function');
+      expect(assets.config.network).to.equal('xna');
+      expect(assets.config.addresses).to.deep.equal(['N123...']);
+      expect(assets.config.changeAddress).to.equal('N123...');
+      expect(assets.config.toAddress).to.equal('N456...');
+    });
+
+    it('should use default config values when not provided', () => {
+      const defaultAssets = new NeuraiAssets(mockRPC);
+      expect(defaultAssets.config.network).to.equal('xna');
+      expect(defaultAssets.config.addresses).to.deep.equal([]);
+      expect(defaultAssets.config.changeAddress).to.be.null;
+      expect(defaultAssets.config.toAddress).to.be.null;
+    });
+
+    it('should throw error if RPC is not provided', () => {
+      expect(() => new NeuraiAssets())
+        .to.throw('RPC function is required');
+    });
+
+    it('should throw error if RPC is not a function', () => {
+      expect(() => new NeuraiAssets('not a function'))
+        .to.throw('RPC function is required');
+    });
+
+    it('should initialize queries instance', () => {
+      expect(assets.queries).to.exist;
+    });
+  });
+
+  describe('updateConfig', () => {
+    it('should update configuration', () => {
+      assets.updateConfig({
+        network: 'xna-test',
+        changeAddress: 'N789...'
+      });
+
+      expect(assets.config.network).to.equal('xna-test');
+      expect(assets.config.changeAddress).to.equal('N789...');
+      expect(assets.config.addresses).to.deep.equal(['N123...']);
+    });
+  });
+
+  describe('_buildParams', () => {
+    it('should merge params with config', () => {
+      const params = assets._buildParams({
+        assetName: 'MYTOKEN',
+        quantity: 1000
+      });
+
+      expect(params.assetName).to.equal('MYTOKEN');
+      expect(params.quantity).to.equal(1000);
+      expect(params.network).to.equal('xna');
+      expect(params.addresses).to.deep.equal(['N123...']);
+      expect(params.changeAddress).to.equal('N123...');
+      expect(params.toAddress).to.equal('N456...');
+    });
+
+    it('should allow params to override config values', () => {
+      const params = assets._buildParams({
+        assetName: 'MYTOKEN',
+        changeAddress: 'N999...'
+      });
+
+      expect(params.changeAddress).to.equal('N999...');
+    });
+  });
+
+  describe('Asset Type Detection', () => {
+    it('should detect ROOT asset type', () => {
+      const type = assets.getAssetType('MYTOKEN');
+      expect(type).to.equal('ROOT');
+    });
+
+    it('should detect SUB asset type', () => {
+      const type = assets.getAssetType('MYTOKEN/SUB');
+      expect(type).to.equal('SUB');
+    });
+
+    it('should detect UNIQUE asset type', () => {
+      const type = assets.getAssetType('MYTOKEN#NFT1');
+      expect(type).to.equal('UNIQUE');
+    });
+
+    it('should detect QUALIFIER asset type', () => {
+      const type = assets.getAssetType('#KYC');
+      expect(type).to.equal('QUALIFIER');
+    });
+
+    it('should detect RESTRICTED asset type', () => {
+      const type = assets.getAssetType('$SECURITY');
+      expect(type).to.equal('RESTRICTED');
+    });
+
+    it('should detect OWNER token type', () => {
+      const type = assets.getAssetType('MYTOKEN!');
+      expect(type).to.equal('OWNER');
+    });
+  });
+
+  describe('Query Methods', () => {
+    it('should call getAssetData', async () => {
+      const mockData = { name: 'MYTOKEN', amount: 1000000 };
+      const rpcMock = createMockRPC({ 'getassetdata': mockData });
+      const testAssets = new NeuraiAssets(rpcMock);
+
+      const result = await testAssets.getAssetData('MYTOKEN');
+      expect(result).to.deep.equal(mockData);
+    });
+
+    it('should call listAssets', async () => {
+      const mockList = ['TOKEN1', 'TOKEN2', 'TOKEN3'];
+      const rpcMock = createMockRPC({ 'listassets': mockList });
+      const testAssets = new NeuraiAssets(rpcMock);
+
+      const result = await testAssets.listAssets('*', false, 100, 0);
+      expect(result).to.deep.equal(mockList);
+    });
+
+    it('should call listMyAssets', async () => {
+      const mockAssets = { 'MYTOKEN': 1000, 'MYTOKEN2': 500 };
+      const rpcMock = createMockRPC({ 'listmyassets': mockAssets });
+      const testAssets = new NeuraiAssets(rpcMock);
+
+      const result = await testAssets.listMyAssets();
+      expect(result).to.deep.equal(mockAssets);
+    });
+
+    it('should call checkAddressTag', async () => {
+      const rpcMock = createMockRPC({ 'checkaddresstag': true });
+      const testAssets = new NeuraiAssets(rpcMock);
+
+      const result = await testAssets.checkAddressTag('N123...', '#KYC');
+      expect(result).to.be.true;
+    });
+
+    it('should call assetExists', async () => {
+      const rpcMock = createMockRPC({ 'getassetdata': { name: 'MYTOKEN' } });
+      const testAssets = new NeuraiAssets(rpcMock);
+
+      const result = await testAssets.assetExists('MYTOKEN');
+      expect(result).to.exist;
+    });
+  });
+
+  describe('Method Availability', () => {
+    it('should have all ROOT asset methods', () => {
+      expect(assets.createRootAsset).to.be.a('function');
+      expect(assets.createSubAsset).to.be.a('function');
+      expect(assets.reissueAsset).to.be.a('function');
+    });
+
+    it('should have all UNIQUE asset methods', () => {
+      expect(assets.createUniqueAssets).to.be.a('function');
+    });
+
+    it('should have all QUALIFIER methods', () => {
+      expect(assets.createQualifier).to.be.a('function');
+      expect(assets.tagAddresses).to.be.a('function');
+      expect(assets.untagAddresses).to.be.a('function');
+    });
+
+    it('should have all RESTRICTED asset methods', () => {
+      expect(assets.createRestrictedAsset).to.be.a('function');
+      expect(assets.reissueRestrictedAsset).to.be.a('function');
+      expect(assets.freezeAddresses).to.be.a('function');
+      expect(assets.unfreezeAddresses).to.be.a('function');
+      expect(assets.freezeAssetGlobally).to.be.a('function');
+      expect(assets.unfreezeAssetGlobally).to.be.a('function');
+    });
+
+    it('should have all query methods', () => {
+      expect(assets.getAssetData).to.be.a('function');
+      expect(assets.listAssets).to.be.a('function');
+      expect(assets.listMyAssets).to.be.a('function');
+      expect(assets.listAddressesByAsset).to.be.a('function');
+      expect(assets.listAssetBalancesByAddress).to.be.a('function');
+      expect(assets.checkAddressTag).to.be.a('function');
+      expect(assets.listTagsForAddress).to.be.a('function');
+      expect(assets.listAddressesForTag).to.be.a('function');
+      expect(assets.checkAddressRestriction).to.be.a('function');
+      expect(assets.isAddressFrozen).to.be.a('function');
+      expect(assets.checkGlobalRestriction).to.be.a('function');
+      expect(assets.getVerifierString).to.be.a('function');
+      expect(assets.isValidVerifierString).to.be.a('function');
+      expect(assets.getSnapshotRequest).to.be.a('function');
+      expect(assets.cancelSnapshotRequest).to.be.a('function');
+      expect(assets.assetExists).to.be.a('function');
+      expect(assets.getAssetType).to.be.a('function');
+      expect(assets.getAssetCount).to.be.a('function');
+    });
+  });
+});

package/tests/unit/utils/amountConverter.test.js

@@ -0,0 +1,171 @@
+/**
+ * Tests for AmountConverter
+ */
+
+const { expect } = require('chai');
+const AmountConverter = require('../../../src/utils/amountConverter');
+
+describe('AmountConverter', () => {
+  describe('toSatoshis', () => {
+    it('should convert whole numbers with 0 units', () => {
+      expect(AmountConverter.toSatoshis(100, 0)).to.equal(100);
+      expect(AmountConverter.toSatoshis(1000, 0)).to.equal(1000);
+    });
+
+    it('should convert decimal amounts with various units', () => {
+      expect(AmountConverter.toSatoshis(1.5, 1)).to.equal(15);
+      expect(AmountConverter.toSatoshis(1.5, 2)).to.equal(150);
+      expect(AmountConverter.toSatoshis(1.00000001, 8)).to.equal(100000001);
+    });
+
+    it('should handle very small amounts', () => {
+      expect(AmountConverter.toSatoshis(0.00000001, 8)).to.equal(1);
+      expect(AmountConverter.toSatoshis(0.0001, 4)).to.equal(1);
+    });
+
+    it('should handle large amounts', () => {
+      expect(AmountConverter.toSatoshis(1000000, 0)).to.equal(1000000);
+      expect(AmountConverter.toSatoshis(1000000, 8)).to.equal(100000000000000);
+    });
+
+    it('should round to avoid floating point issues', () => {
+      expect(AmountConverter.toSatoshis(0.1 + 0.2, 1)).to.equal(3);
+    });
+
+    it('should throw error for invalid amounts', () => {
+      expect(() => AmountConverter.toSatoshis('100', 0))
+        .to.throw('Amount must be a valid number');
+
+      expect(() => AmountConverter.toSatoshis(NaN, 0))
+        .to.throw('Amount must be a valid number');
+    });
+
+    it('should throw error for invalid units', () => {
+      expect(() => AmountConverter.toSatoshis(100, -1))
+        .to.throw('Units must be a number between 0 and 8');
+
+      expect(() => AmountConverter.toSatoshis(100, 9))
+        .to.throw('Units must be a number between 0 and 8');
+
+      expect(() => AmountConverter.toSatoshis(100, 'two'))
+        .to.throw('Units must be a number between 0 and 8');
+    });
+  });
+
+  describe('fromSatoshis', () => {
+    it('should convert satoshis to whole numbers with 0 units', () => {
+      expect(AmountConverter.fromSatoshis(100, 0)).to.equal(100);
+      expect(AmountConverter.fromSatoshis(1000, 0)).to.equal(1000);
+    });
+
+    it('should convert satoshis to decimal amounts with various units', () => {
+      expect(AmountConverter.fromSatoshis(15, 1)).to.equal(1.5);
+      expect(AmountConverter.fromSatoshis(150, 2)).to.equal(1.5);
+      expect(AmountConverter.fromSatoshis(100000001, 8)).to.equal(1.00000001);
+    });
+
+    it('should handle very small satoshi amounts', () => {
+      expect(AmountConverter.fromSatoshis(1, 8)).to.equal(0.00000001);
+      expect(AmountConverter.fromSatoshis(1, 4)).to.equal(0.0001);
+    });
+
+    it('should throw error for invalid satoshis', () => {
+      expect(() => AmountConverter.fromSatoshis('100', 0))
+        .to.throw('Satoshis must be a valid number');
+
+      expect(() => AmountConverter.fromSatoshis(NaN, 0))
+        .to.throw('Satoshis must be a valid number');
+    });
+
+    it('should throw error for invalid units', () => {
+      expect(() => AmountConverter.fromSatoshis(100, -1))
+        .to.throw('Units must be a number between 0 and 8');
+
+      expect(() => AmountConverter.fromSatoshis(100, 9))
+        .to.throw('Units must be a number between 0 and 8');
+    });
+  });
+
+  describe('format', () => {
+    it('should format amounts with 0 units as integers', () => {
+      expect(AmountConverter.format(100, 0)).to.equal('100');
+      expect(AmountConverter.format(1000, 0)).to.equal('1000');
+    });
+
+    it('should format amounts with decimal places', () => {
+      expect(AmountConverter.format(1.5, 1)).to.equal('1.5');
+      expect(AmountConverter.format(1.5, 2)).to.equal('1.50');
+      expect(AmountConverter.format(1.00000001, 8)).to.equal('1.00000001');
+    });
+
+    it('should pad with zeros to match units', () => {
+      expect(AmountConverter.format(1, 2)).to.equal('1.00');
+      expect(AmountConverter.format(1, 8)).to.equal('1.00000000');
+    });
+  });
+
+  describe('parse', () => {
+    it('should parse formatted amounts', () => {
+      expect(AmountConverter.parse('100')).to.equal(100);
+      expect(AmountConverter.parse('1.5')).to.equal(1.5);
+      expect(AmountConverter.parse('0.00000001')).to.equal(0.00000001);
+    });
+
+    it('should throw error for invalid formats', () => {
+      expect(() => AmountConverter.parse('abc'))
+        .to.throw('Invalid number format');
+
+      expect(() => AmountConverter.parse(''))
+        .to.throw('Invalid number format');
+    });
+  });
+
+  describe('getDecimalPlaces', () => {
+    it('should count decimal places correctly', () => {
+      expect(AmountConverter.getDecimalPlaces(100)).to.equal(0);
+      expect(AmountConverter.getDecimalPlaces(1.5)).to.equal(1);
+      expect(AmountConverter.getDecimalPlaces(1.25)).to.equal(2);
+      expect(AmountConverter.getDecimalPlaces(0.00000001)).to.equal(8);
+    });
+
+    it('should handle scientific notation', () => {
+      expect(AmountConverter.getDecimalPlaces(1e-8)).to.equal(8);
+      expect(AmountConverter.getDecimalPlaces(1.5e2)).to.equal(0);
+    });
+  });
+
+  describe('adjustToUnits', () => {
+    it('should not modify amounts with fewer decimals than units', () => {
+      expect(AmountConverter.adjustToUnits(1.5, 2)).to.equal(1.5);
+      expect(AmountConverter.adjustToUnits(1, 8)).to.equal(1);
+    });
+
+    it('should round amounts with more decimals than units', () => {
+      expect(AmountConverter.adjustToUnits(1.123, 2)).to.equal(1.12);
+      expect(AmountConverter.adjustToUnits(1.567, 2)).to.equal(1.57);
+    });
+
+    it('should handle edge cases', () => {
+      expect(AmountConverter.adjustToUnits(1.999, 2)).to.equal(2);
+      expect(AmountConverter.adjustToUnits(0.001, 2)).to.equal(0);
+    });
+  });
+
+  describe('round-trip conversion', () => {
+    it('should convert back and forth without loss', () => {
+      const amount = 1.5;
+      const units = 2;
+      const satoshis = AmountConverter.toSatoshis(amount, units);
+      const back = AmountConverter.fromSatoshis(satoshis, units);
+      expect(back).to.equal(amount);
+    });
+
+    it('should handle maximum precision', () => {
+      const amount = 1.00000001;
+      const units = 8;
+      const satoshis = AmountConverter.toSatoshis(amount, units);
+      const back = AmountConverter.fromSatoshis(satoshis, units);
+      expect(back).to.equal(amount);
+    });
+  });
+});

package/tests/unit/utils/assetNameParser.test.js

@@ -0,0 +1,203 @@
+/**
+ * Tests for AssetNameParser
+ */
+
+const { expect } = require('chai');
+const AssetNameParser = require('../../../src/utils/assetNameParser');
+const { AssetType } = require('../../../src/constants');
+
+describe('AssetNameParser', () => {
+  describe('parse', () => {
+    it('should parse ROOT asset names', () => {
+      const result = AssetNameParser.parse('MYTOKEN');
+      expect(result.type).to.equal(AssetType.ROOT);
+      expect(result.name).to.equal('MYTOKEN');
+      expect(result.parent).to.be.null;
+      expect(result.isOwner).to.be.false;
+      expect(result.isRestricted).to.be.false;
+      expect(result.isQualifier).to.be.false;
+    });
+
+    it('should parse SUB asset names', () => {
+      const result = AssetNameParser.parse('MYTOKEN/SUB');
+      expect(result.type).to.equal(AssetType.SUB);
+      expect(result.parent).to.equal('MYTOKEN');
+      expect(result.subName).to.equal('SUB');
+      expect(result.name).to.equal('MYTOKEN/SUB');
+    });
+
+    it('should parse UNIQUE asset names', () => {
+      const result = AssetNameParser.parse('MYTOKEN#NFT1');
+      expect(result.type).to.equal(AssetType.UNIQUE);
+      expect(result.parent).to.equal('MYTOKEN');
+      expect(result.tag).to.equal('NFT1');
+      expect(result.name).to.equal('MYTOKEN#NFT1');
+    });
+
+    it('should parse QUALIFIER asset names', () => {
+      const result = AssetNameParser.parse('#KYC');
+      expect(result.type).to.equal(AssetType.QUALIFIER);
+      expect(result.prefix).to.equal('#');
+      expect(result.isQualifier).to.be.true;
+      expect(result.name).to.equal('#KYC');
+    });
+
+    it('should parse SUB_QUALIFIER asset names', () => {
+      const result = AssetNameParser.parse('#KYC/TIER1');
+      expect(result.type).to.equal(AssetType.SUB_QUALIFIER);
+      expect(result.parent).to.equal('#KYC');
+      expect(result.subName).to.equal('TIER1');
+      expect(result.prefix).to.equal('#');
+    });
+
+    it('should parse RESTRICTED asset names', () => {
+      const result = AssetNameParser.parse('$SECURITY');
+      expect(result.type).to.equal(AssetType.RESTRICTED);
+      expect(result.prefix).to.equal('$');
+      expect(result.isRestricted).to.be.true;
+      expect(result.name).to.equal('$SECURITY');
+    });
+
+    it('should parse OWNER token names', () => {
+      const result = AssetNameParser.parse('MYTOKEN!');
+      expect(result.type).to.equal(AssetType.OWNER);
+      expect(result.isOwner).to.be.true;
+      expect(result.baseName).to.equal('MYTOKEN');
+      expect(result.fullName).to.equal('MYTOKEN!');
+    });
+
+    it('should parse RESTRICTED OWNER token names', () => {
+      const result = AssetNameParser.parse('$SECURITY!');
+      expect(result.type).to.equal(AssetType.OWNER);
+      expect(result.isOwner).to.be.true;
+      expect(result.isRestricted).to.be.true;
+      expect(result.baseName).to.equal('$SECURITY');
+    });
+  });
+
+  describe('getType', () => {
+    it('should return correct type for various asset names', () => {
+      expect(AssetNameParser.getType('MYTOKEN')).to.equal(AssetType.ROOT);
+      expect(AssetNameParser.getType('MYTOKEN/SUB')).to.equal(AssetType.SUB);
+      expect(AssetNameParser.getType('MYTOKEN#NFT')).to.equal(AssetType.UNIQUE);
+      expect(AssetNameParser.getType('#KYC')).to.equal(AssetType.QUALIFIER);
+      expect(AssetNameParser.getType('#KYC/TIER1')).to.equal(AssetType.SUB_QUALIFIER);
+      expect(AssetNameParser.getType('$SECURITY')).to.equal(AssetType.RESTRICTED);
+      expect(AssetNameParser.getType('MYTOKEN!')).to.equal(AssetType.OWNER);
+    });
+  });
+
+  describe('getParent', () => {
+    it('should return parent for SUB assets', () => {
+      expect(AssetNameParser.getParent('MYTOKEN/SUB')).to.equal('MYTOKEN');
+    });
+
+    it('should return parent for UNIQUE assets', () => {
+      expect(AssetNameParser.getParent('MYTOKEN#NFT')).to.equal('MYTOKEN');
+    });
+
+    it('should return null for ROOT assets', () => {
+      expect(AssetNameParser.getParent('MYTOKEN')).to.be.null;
+    });
+
+    it('should return parent for SUB_QUALIFIER', () => {
+      expect(AssetNameParser.getParent('#KYC/TIER1')).to.equal('#KYC');
+    });
+  });
+
+  describe('isOwnerToken', () => {
+    it('should identify owner tokens', () => {
+      expect(AssetNameParser.isOwnerToken('MYTOKEN!')).to.be.true;
+      expect(AssetNameParser.isOwnerToken('$SECURITY!')).to.be.true;
+    });
+
+    it('should return false for non-owner tokens', () => {
+      expect(AssetNameParser.isOwnerToken('MYTOKEN')).to.be.false;
+      expect(AssetNameParser.isOwnerToken('MYTOKEN/SUB')).to.be.false;
+    });
+  });
+
+  describe('getOwnerTokenName', () => {
+    it('should add ! to get owner token name', () => {
+      expect(AssetNameParser.getOwnerTokenName('MYTOKEN')).to.equal('MYTOKEN!');
+      expect(AssetNameParser.getOwnerTokenName('$SECURITY')).to.equal('$SECURITY!');
+    });
+
+    it('should return as-is if already an owner token', () => {
+      expect(AssetNameParser.getOwnerTokenName('MYTOKEN!')).to.equal('MYTOKEN!');
+    });
+  });
+
+  describe('getBaseAssetName', () => {
+    it('should remove ! to get base asset name', () => {
+      expect(AssetNameParser.getBaseAssetName('MYTOKEN!')).to.equal('MYTOKEN');
+      expect(AssetNameParser.getBaseAssetName('$SECURITY!')).to.equal('$SECURITY');
+    });
+
+    it('should return as-is if not an owner token', () => {
+      expect(AssetNameParser.getBaseAssetName('MYTOKEN')).to.equal('MYTOKEN');
+    });
+  });
+
+  describe('isRestricted', () => {
+    it('should identify restricted assets', () => {
+      expect(AssetNameParser.isRestricted('$SECURITY')).to.be.true;
+      expect(AssetNameParser.isRestricted('$TOKEN')).to.be.true;
+    });
+
+    it('should return false for non-restricted assets', () => {
+      expect(AssetNameParser.isRestricted('MYTOKEN')).to.be.false;
+      expect(AssetNameParser.isRestricted('#KYC')).to.be.false;
+    });
+  });
+
+  describe('isQualifier', () => {
+    it('should identify qualifiers', () => {
+      expect(AssetNameParser.isQualifier('#KYC')).to.be.true;
+      expect(AssetNameParser.isQualifier('#KYC/TIER1')).to.be.true;
+    });
+
+    it('should return false for non-qualifiers', () => {
+      expect(AssetNameParser.isQualifier('MYTOKEN')).to.be.false;
+      expect(AssetNameParser.isQualifier('MYTOKEN#NFT')).to.be.false;
+    });
+  });
+
+  describe('isUnique', () => {
+    it('should identify unique assets', () => {
+      expect(AssetNameParser.isUnique('MYTOKEN#NFT')).to.be.true;
+      expect(AssetNameParser.isUnique('TOKEN#123')).to.be.true;
+    });
+
+    it('should return false for non-unique assets', () => {
+      expect(AssetNameParser.isUnique('MYTOKEN')).to.be.false;
+      expect(AssetNameParser.isUnique('#KYC')).to.be.false;
+    });
+  });
+
+  describe('isSub', () => {
+    it('should identify sub-assets', () => {
+      expect(AssetNameParser.isSub('MYTOKEN/SUB')).to.be.true;
+      expect(AssetNameParser.isSub('TOKEN/ALPHA')).to.be.true;
+    });
+
+    it('should return false for non-sub assets', () => {
+      expect(AssetNameParser.isSub('MYTOKEN')).to.be.false;
+      expect(AssetNameParser.isSub('#KYC/TIER1')).to.be.false;
+    });
+  });
+
+  describe('buildUniqueName', () => {
+    it('should build unique asset names', () => {
+      expect(AssetNameParser.buildUniqueName('MYTOKEN', 'NFT1')).to.equal('MYTOKEN#NFT1');
+      expect(AssetNameParser.buildUniqueName('TOKEN', '123')).to.equal('TOKEN#123');
+    });
+  });
+
+  describe('buildSubName', () => {
+    it('should build sub-asset names', () => {
+      expect(AssetNameParser.buildSubName('MYTOKEN', 'SUB')).to.equal('MYTOKEN/SUB');
+      expect(AssetNameParser.buildSubName('TOKEN', 'ALPHA')).to.equal('TOKEN/ALPHA');
+    });
+  });
+});