multichain-address-validator 0.7.4 → 0.7.6

package/test/multichain-address-validator.test.ts

@@ -1,168 +1,173 @@
 import {describe, it} from 'mocha'
 import {expect} from 'chai'
 
-import {validate, Address, Chain, NetworkType} from '../src'
+import {validate, Chain, NetworkType} from '../src'
 // @ts-ignore
-import addresses from './addresses/addresses'
+import addresses, {TestAddress} from './addresses/addresses'
 
+function check(address: TestAddress, chain: Chain) {
+    address.invalid
+        ? invalid(address, chain)
+        : valid(address, chain)
+}
 
-function valid(address: Address, chain: Chain) {
+function valid(address: TestAddress, chain: Chain) {
     const valid = validate(address, chain);
     expect({address, chain, valid}).to.deep.equal({address, chain, valid: true});
 }
 
-function invalid(address: Address, chain: Chain) {
+function invalid(address: TestAddress, chain: Chain) {
     const valid = validate(address, chain);
     expect({address, chain, valid}).to.deep.equal({address, chain, valid: false});
 }
 
 interface TestCase {
     alternatives: string[],
-    valid: keyof typeof addresses,
+    testAddresses: keyof typeof addresses,
     exclude?: (keyof typeof addresses)[]
     testnet?: {
-        valid: keyof typeof addresses
+        testAddresses: keyof typeof addresses
     }
 }
 
 const TestCases: Record<string, TestCase> = {
     'algorand': {
         alternatives: [],
-        valid: 'algorand',
+        testAddresses: 'algorand',
     },
     'aptos': {
         alternatives: [],
-        valid: 'aptos',
+        testAddresses: 'aptos',
         exclude: ['sui']
     },
     'bitcoin': {
         alternatives: ['btc', 'omni'],
-        valid: 'btc', // corresponds to addresses.js
+        testAddresses: 'btc', // corresponds to addresses.js
         exclude: ['bch', 'ltc'],
         testnet: {
-            valid: 'btc-testnet'
+            testAddresses: 'btc-testnet'
         }
     },
     'bitcoin-cash': {
         alternatives: ['bch', 'bitcoincash', 'bitcoin cash'],
-        valid: 'bch',
+        testAddresses: 'bch',
         exclude: ['btc', 'ltc'],
         testnet: {
-            valid: 'bch-testnet',
+            testAddresses: 'bch-testnet',
         }
     },
     'cardano': {
         alternatives: ['ada'],
-        valid: 'cardano',
+        testAddresses: 'cardano',
     },
     'doge': {
         alternatives: ['dogecoin'],
         exclude: ['btc'],
-        valid: 'doge',
+        testAddresses: 'doge',
         testnet: {
-            valid: 'doge-testnet',
+            testAddresses: 'doge-testnet',
         }
     },
     'eos': {
         alternatives: [],
-        valid: 'eos',
+        testAddresses: 'eos',
     },
     'ethereum': {
         alternatives: ['eth', 'flare', 'avalanche', 'avalanche-c', 'bsc', 'bnb', 'binance', 'sonic', 'berachain', 'story'],
-        valid: 'evm',
+        testAddresses: 'evm',
     },
     'hedera': {
         alternatives: [],
-        valid: 'hbar'
+        testAddresses: 'hbar'
     },
     'litecoin': {
         alternatives: ['ltc'],
         exclude: ['btc', 'bch'],
-        valid: 'ltc',
+        testAddresses: 'ltc',
         testnet: {
-            valid: 'ltc-testnet'
+            testAddresses: 'ltc-testnet'
         }
     },
     'monero': {
         alternatives: [],
-        valid: 'monero',
+        testAddresses: 'monero',
         testnet: {
-            valid: 'monero-testnet',
+            testAddresses: 'monero-testnet',
         }
     },
     'nano': {
         alternatives: [],
-        valid: 'nano',
+        testAddresses: 'nano',
     },
     'nem': {
         alternatives: [],
-        valid: 'nem',
+        testAddresses: 'nem',
     },
     'polkadot': {
         alternatives: [],
-        valid: 'polkadot',
+        testAddresses: 'polkadot',
     },
     'ripple': {
         alternatives: ['xrp'],
-        valid: 'ripple'
+        testAddresses: 'ripple'
     },
     'sia': {
         alternatives: [],
-        valid: 'sia',
+        testAddresses: 'sia',
     },
     'solana': {
         alternatives: ['spl'],
-        valid: 'solana'
+        testAddresses: 'solana'
     },
     'sui': {
         alternatives: [],
-        valid: 'sui',
+        testAddresses: 'sui',
         exclude: ['aptos']
     },
     'tezos': {
         alternatives: [],
-        valid: 'tezos',
+        testAddresses: 'tezos',
         exclude: ['btc', 'bch', 'btc-testnet', 'ltc-testnet', 'bch-testnet', 'doge', 'doge-testnet', 'ltc', 'tron'],
     },
     'tron': {
         alternatives: ['trc20'],
-        valid: 'tron',
+        testAddresses: 'tron',
     },
     'xlm': {
         alternatives: ['stellar'],
-        valid: 'xlm',
+        testAddresses: 'xlm',
     }
 }
 
 describe('multichain address validator', function () {
 
-    it('should validate valid addresses for chains', function () {
+    it('should check valid addresses for chains', function () {
         for (const chain in TestCases) {
             for (const c of [chain, ...TestCases[chain].alternatives]) {
-                if (!addresses[TestCases[chain].valid]) {
-                    throw new Error(`No valid addresses for chain '${chain}'`)
+                if (!addresses[TestCases[chain].testAddresses]) {
+                    throw new Error(`No test addresses for chain '${chain}'`)
                 }
-                for (const address of addresses[TestCases[chain].valid]) {
-                    valid(address, c)
+                for (const address of addresses[TestCases[chain].testAddresses]) {
+                    check(address, c)
                 }
 
                 if (TestCases[chain].testnet) {
-                    if (!addresses[TestCases[chain].testnet.valid]) {
-                        throw new Error(`No valid testnet addresses for chain '${chain}'`)
+                    if (!addresses[TestCases[chain].testnet.testAddresses]) {
+                        throw new Error(`No test testnet addresses for chain '${chain}'`)
                     }
-                    for (const address of addresses[TestCases[chain].testnet.valid]) {
-                        valid(address, { chain: c, networkType: NetworkType.TestNet })
+                    for (const address of addresses[TestCases[chain].testnet.testAddresses]) {
+                        check(address, { chain: c, networkType: NetworkType.TestNet })
                     }
                 }
             }
         }
     })
 
-    it('should invalidate invalid addresses for chains', function () {
+    it('should check invalid addresses for chains', function () {
         for (const chain in TestCases) {
             for (const c of [chain, ...TestCases[chain].alternatives]) {
                 const invalidChains = Object.keys(addresses)
-                    .filter(key => key !== TestCases[chain].valid)
+                    .filter(key => key !== TestCases[chain].testAddresses)
                     .filter(key => !TestCases[chain].exclude?.includes(key as any))
 
                 for (const invalidChain of invalidChains) {