multichain-address-validator 0.7.5 → 0.7.6

package/dist/cjs/crypto/blake256.d.ts

@@ -3,20 +3,21 @@ declare function Blake256(): void;
 declare class Blake256 {
     _h: number[];
     _s: number[];
-    _block: any;
+    _block: Buffer;
     _blockOffset: number;
     _length: number[];
     _nullt: boolean;
-    _zo: any;
-    _oo: any;
+    _zo: Buffer;
+    _oo: Buffer;
     _length_carry(arr: any): void;
     update(data: any, encoding: any): this;
     _compress(): void;
     _padding(): void;
-    digest(encoding: any): any;
+    digest(encoding: any): string;
 }
 declare namespace Blake256 {
     let sigma: number[][];
     let u256: number[];
-    let padding: any;
+    let padding: Buffer;
 }
+import { Buffer } from 'buffer';

package/dist/cjs/crypto/blake256.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_1 = require("buffer");
 /**
  * Credits to https://github.com/cryptocoinjs/blake-hash
  */
@@ -27,7 +28,7 @@ Blake256.u256 = [
     0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
     0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
 ];
-Blake256.padding = Buffer.from([
+Blake256.padding = buffer_1.Buffer.from([
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -46,7 +47,7 @@ Blake256.prototype._length_carry = function (arr) {
     }
 };
 Blake256.prototype.update = function (data, encoding) {
-    data = Buffer.from(data, encoding);
+    data = buffer_1.Buffer.from(data, encoding);
     var block = this._block;
     var offset = 0;
     while (this._blockOffset + data.length - offset >= block.length) {
@@ -61,8 +62,8 @@ Blake256.prototype.update = function (data, encoding) {
         block[this._blockOffset++] = data[offset++];
     return this;
 };
-var zo = Buffer.from([0x01]);
-var oo = Buffer.from([0x81]);
+var zo = buffer_1.Buffer.from([0x01]);
+var oo = buffer_1.Buffer.from([0x81]);
 function rot(x, n) {
     return ((x << (32 - n)) | (x >>> n)) >>> 0;
 }
@@ -84,7 +85,7 @@ function Blake256() {
         0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
     ];
     this._s = [0, 0, 0, 0];
-    this._block = Buffer.allocUnsafe(64);
+    this._block = buffer_1.Buffer.allocUnsafe(64);
     this._blockOffset = 0;
     this._length = [0, 0];
     this._nullt = false;
@@ -134,7 +135,7 @@ Blake256.prototype._padding = function () {
         lo -= 0x0100000000;
         hi += 1;
     }
-    var msglen = Buffer.allocUnsafe(8);
+    var msglen = buffer_1.Buffer.allocUnsafe(8);
     msglen.writeUInt32BE(hi, 0);
     msglen.writeUInt32BE(lo, 4);
     if (this._blockOffset === 55) {
@@ -163,7 +164,7 @@ Blake256.prototype._padding = function () {
 };
 Blake256.prototype.digest = function (encoding) {
     this._padding();
-    var buffer = Buffer.allocUnsafe(32);
+    var buffer = buffer_1.Buffer.allocUnsafe(32);
     for (var i = 0; i < 8; ++i)
         buffer.writeUInt32BE(this._h[i], i * 4);
     return buffer.toString(encoding);

package/dist/cjs/crypto/utils.d.ts

@@ -9,7 +9,7 @@ declare const _default: {
     sha256Checksum: (payload: any) => any;
     sha512: (payload: any, format?: string) => string;
     sha512_256: (payload: any, format?: string) => string;
-    blake256: (hexString: string) => any;
+    blake256: (hexString: string) => string;
     blake256Checksum: (payload: any) => any;
     blake2b: (hexString: string, outlen: number) => any;
     keccak256: (hexString: string) => string;

package/dist/cjs/helpers.d.ts

@@ -1,2 +1,3 @@
 import { Address } from './types.js';
 export declare function getAddress(address: Address): string;
+export declare function getMemo(address: Address): string | undefined;

package/dist/cjs/helpers.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAddress = getAddress;
+exports.getMemo = getMemo;
 function getAddress(address) {
     return typeof address === 'string'
         ? address
         : address.address;
 }
+function getMemo(address) {
+    return typeof address === 'string'
+        ? undefined
+        : address.memo;
+}

package/dist/cjs/validators/ripple_validator.d.ts

@@ -4,7 +4,7 @@ declare const _default: {
      * ripple address validation
      */
     isValidAddress: (address: Address) => any;
-    verifyMemo(destinationTag: string | null): boolean;
-    verifyChecksum: (address: string) => boolean;
+    verifyMemo(memo?: string): boolean;
+    verifyChecksum(address: string): boolean;
 };
 export default _default;

package/dist/cjs/validators/ripple_validator.js

@@ -15,18 +15,18 @@ exports.default = {
      */
     isValidAddress: function (address) {
         const addr = (0, helpers_js_1.getAddress)(address);
-        const destinationTag = address.destinationTag;
+        const memo = (0, helpers_js_1.getMemo)(address);
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-        return validAddress && this.verifyMemo(destinationTag);
+        return validAddress && this.verifyMemo(memo);
     },
-    verifyMemo(destinationTag) {
-        if (!destinationTag)
+    verifyMemo(memo) {
+        if (!memo)
             return true; // Optional
-        const tagNumber = Number(destinationTag);
-        // A destination tag is a 32-bit unsigned integer.
-        return /^[0-9]+$/.test(destinationTag) && tagNumber >= 0 && tagNumber <= 4294967295;
+        const memoNumber = Number(memo);
+        // A memo is a 32-bit unsigned integer.
+        return /^[0-9]+$/.test(memo) && memoNumber >= 0 && memoNumber <= 4294967295;
     },
-    verifyChecksum: function (address) {
+    verifyChecksum(address) {
         const bytes = codec.decode(address);
         const computedChecksum = utils_js_1.default.sha256Checksum(utils_js_1.default.toHex(bytes.slice(0, -4)));
         const checksum = utils_js_1.default.toHex(bytes.slice(-4));

package/dist/cjs/validators/xlm_validator.d.ts

@@ -1,7 +1,7 @@
 import { Address } from '../types.js';
 declare const _default: {
     isValidAddress: (address: Address) => any;
-    verifyMemo(memo: string | null): boolean;
+    verifyMemo(memo?: string): boolean;
     verifyChecksum: (address: string) => boolean;
 };
 export default _default;

package/dist/cjs/validators/xlm_validator.js

@@ -19,9 +19,9 @@ function swap16(number) {
 exports.default = {
     isValidAddress: function (address) {
         const addr = (0, helpers_js_1.getAddress)(address);
-        const destinationTag = address.destinationTag;
+        const memo = (0, helpers_js_1.getMemo)(address);
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-        return validAddress && this.verifyMemo(destinationTag);
+        return validAddress && this.verifyMemo(memo);
     },
     verifyMemo(memo) {
         if (!memo)

package/dist/esm/crypto/blake256.d.ts

@@ -3,20 +3,21 @@ declare function Blake256(): void;
 declare class Blake256 {
     _h: number[];
     _s: number[];
-    _block: any;
+    _block: Buffer;
     _blockOffset: number;
     _length: number[];
     _nullt: boolean;
-    _zo: any;
-    _oo: any;
+    _zo: Buffer;
+    _oo: Buffer;
     _length_carry(arr: any): void;
     update(data: any, encoding: any): this;
     _compress(): void;
     _padding(): void;
-    digest(encoding: any): any;
+    digest(encoding: any): string;
 }
 declare namespace Blake256 {
     let sigma: number[][];
     let u256: number[];
-    let padding: any;
+    let padding: Buffer;
 }
+import { Buffer } from 'buffer';

package/dist/esm/crypto/blake256.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer';
 /**
  * Credits to https://github.com/cryptocoinjs/blake-hash
  */

package/dist/esm/crypto/utils.d.ts

@@ -9,7 +9,7 @@ declare const _default: {
     sha256Checksum: (payload: any) => any;
     sha512: (payload: any, format?: string) => string;
     sha512_256: (payload: any, format?: string) => string;
-    blake256: (hexString: string) => any;
+    blake256: (hexString: string) => string;
     blake256Checksum: (payload: any) => any;
     blake2b: (hexString: string, outlen: number) => any;
     keccak256: (hexString: string) => string;

package/dist/esm/helpers.d.ts

@@ -1,2 +1,3 @@
 import { Address } from './types.js';
 export declare function getAddress(address: Address): string;
+export declare function getMemo(address: Address): string | undefined;

package/dist/esm/helpers.js

@@ -3,3 +3,8 @@ export function getAddress(address) {
         ? address
         : address.address;
 }
+export function getMemo(address) {
+    return typeof address === 'string'
+        ? undefined
+        : address.memo;
+}

package/dist/esm/validators/ripple_validator.d.ts

@@ -4,7 +4,7 @@ declare const _default: {
      * ripple address validation
      */
     isValidAddress: (address: Address) => any;
-    verifyMemo(destinationTag: string | null): boolean;
-    verifyChecksum: (address: string) => boolean;
+    verifyMemo(memo?: string): boolean;
+    verifyChecksum(address: string): boolean;
 };
 export default _default;

package/dist/esm/validators/ripple_validator.js

@@ -1,6 +1,6 @@
 import baseX from 'base-x';
 import cryptoUtils from '../crypto/utils.js';
-import { getAddress } from '../helpers.js';
+import { getAddress, getMemo } from '../helpers.js';
 const ALLOWED_CHARS = 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz';
 const codec = baseX(ALLOWED_CHARS);
 const regexp = new RegExp('^r[' + ALLOWED_CHARS + ']{27,35}$');
@@ -10,18 +10,18 @@ export default {
      */
     isValidAddress: function (address) {
         const addr = getAddress(address);
-        const destinationTag = address.destinationTag;
+        const memo = getMemo(address);
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-        return validAddress && this.verifyMemo(destinationTag);
+        return validAddress && this.verifyMemo(memo);
     },
-    verifyMemo(destinationTag) {
-        if (!destinationTag)
+    verifyMemo(memo) {
+        if (!memo)
             return true; // Optional
-        const tagNumber = Number(destinationTag);
-        // A destination tag is a 32-bit unsigned integer.
-        return /^[0-9]+$/.test(destinationTag) && tagNumber >= 0 && tagNumber <= 4294967295;
+        const memoNumber = Number(memo);
+        // A memo is a 32-bit unsigned integer.
+        return /^[0-9]+$/.test(memo) && memoNumber >= 0 && memoNumber <= 4294967295;
     },
-    verifyChecksum: function (address) {
+    verifyChecksum(address) {
         const bytes = codec.decode(address);
         const computedChecksum = cryptoUtils.sha256Checksum(cryptoUtils.toHex(bytes.slice(0, -4)));
         const checksum = cryptoUtils.toHex(bytes.slice(-4));

package/dist/esm/validators/xlm_validator.d.ts

@@ -1,7 +1,7 @@
 import { Address } from '../types.js';
 declare const _default: {
     isValidAddress: (address: Address) => any;
-    verifyMemo(memo: string | null): boolean;
+    verifyMemo(memo?: string): boolean;
     verifyChecksum: (address: string) => boolean;
 };
 export default _default;

package/dist/esm/validators/xlm_validator.js

@@ -1,7 +1,7 @@
 import baseX from 'base-x';
 import crc from 'crc';
 import cryptoUtils from '../crypto/utils.js';
-import { getAddress } from '../helpers.js';
+import { getAddress, getMemo } from '../helpers.js';
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
 const base32 = baseX(ALPHABET);
 const regexp = new RegExp('^[' + ALPHABET + ']{56}$');
@@ -14,9 +14,9 @@ function swap16(number) {
 export default {
     isValidAddress: function (address) {
         const addr = getAddress(address);
-        const destinationTag = address.destinationTag;
+        const memo = getMemo(address);
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-        return validAddress && this.verifyMemo(destinationTag);
+        return validAddress && this.verifyMemo(memo);
     },
     verifyMemo(memo) {
         if (!memo)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "multichain-address-validator",
     "description": "Multichain address validator for Bitcoin and other blockchains.",
-    "version": "0.7.5",
+    "version": "0.7.6",
     "keywords": [
         "0x",
         "zrx",

package/src/crypto/blake256.js

@@ -1,3 +1,5 @@
+import {Buffer} from 'buffer'
+
 /**
  * Credits to https://github.com/cryptocoinjs/blake-hash
  */

package/src/helpers.ts

@@ -5,3 +5,9 @@ export function getAddress(address: Address): string {
         ? address
         : address.address
 }
+
+export function getMemo(address: Address): string | undefined {
+    return typeof address === 'string'
+        ? undefined
+        : address.memo
+}

package/src/validators/ripple_validator.ts

@@ -2,7 +2,7 @@ import baseX from 'base-x'
 
 import cryptoUtils from '../crypto/utils.js'
 import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
+import {getAddress, getMemo} from '../helpers.js'
 
 const ALLOWED_CHARS = 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz';
 
@@ -15,22 +15,22 @@ export default {
      */
     isValidAddress: function (address: Address) {
         const addr = getAddress(address)
-        const destinationTag = (address as any).destinationTag
+        const memo = getMemo(address)
 
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
 
-        return validAddress && this.verifyMemo(destinationTag)
+        return validAddress && this.verifyMemo(memo)
     },
 
-    verifyMemo(destinationTag: string | null): boolean {
-        if (!destinationTag) return true; // Optional
+    verifyMemo(memo?: string): boolean {
+        if (!memo) return true; // Optional
 
-        const tagNumber = Number(destinationTag);
-        // A destination tag is a 32-bit unsigned integer.
-        return /^[0-9]+$/.test(destinationTag) && tagNumber >= 0 && tagNumber <= 4294967295;
+        const memoNumber = Number(memo);
+        // A memo is a 32-bit unsigned integer.
+        return /^[0-9]+$/.test(memo) && memoNumber >= 0 && memoNumber <= 4294967295;
     },
 
-    verifyChecksum: function (address: string) {
+    verifyChecksum(address: string): boolean {
         const bytes = codec.decode(address);
         const computedChecksum = cryptoUtils.sha256Checksum(cryptoUtils.toHex(bytes.slice(0, -4)));
         const checksum = cryptoUtils.toHex(bytes.slice(-4));

package/src/validators/xlm_validator.ts

@@ -3,7 +3,7 @@ import crc from 'crc'
 
 import cryptoUtils from '../crypto/utils.js'
 import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
+import {getAddress, getMemo} from '../helpers.js'
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
 
@@ -20,14 +20,14 @@ function swap16(number: number) {
 export default {
     isValidAddress: function (address: Address) {
         const addr = getAddress(address)
-        const destinationTag = (address as any).destinationTag
+        const memo = getMemo(address)
 
         const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
 
-        return validAddress && this.verifyMemo(destinationTag)
+        return validAddress && this.verifyMemo(memo)
     },
 
-    verifyMemo(memo: string | null): boolean {
+    verifyMemo(memo?: string): boolean {
         if (!memo) return true; // Optional
 
         // Ensure it's a valid UTF-8 string and does not exceed 28 bytes

package/test/addresses/addresses.ts

@@ -24,8 +24,11 @@ import sui from './sui.json'
 import tezos from './tezos.json'
 import tron from './tron.json'
 import xlm from './xlm.json'
+import {Address} from '../../src'
 
-export default {
+export type TestAddress = Address & { invalid?: boolean }
+
+const testAddresses: Record<string, TestAddress[]> = {
     aptos,
     algorand,
     bch,
@@ -52,4 +55,6 @@ export default {
     tezos,
     tron,
     xlm,
-}
+} as const;
+
+export default testAddresses

package/test/addresses/ripple.json

@@ -5,11 +5,16 @@
     "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
     {
         "address": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
-        "destinationTag": 4294967295
+        "memo": "4294967295"
     },
     "rDTXLQ7ZKZVKz33zJbHjgVShjsBnqMBhmN",
     {
         "address": "rDTXLQ7ZKZVKz33zJbHjgVShjsBnqMBhmN",
-        "destinationTag": 50000
+        "memo": "50000"
+    },
+    {
+        "address": "rDTXLQ7ZKZVKz33zJbHjgVShjsBnqMBhmN",
+        "memo": "non-numeric-memo",
+        "invalid": true
     }
 ]

package/test/addresses/xlm.json

@@ -11,6 +11,11 @@
     "GDTYVCTAUQVPKEDZIBWEJGKBQHB4UGGXI2SXXUEW7LXMD4B7MK37CWLJ",
     {
         "address": "GDTYVCTAUQVPKEDZIBWEJGKBQHB4UGGXI2SXXUEW7LXMD4B7MK37CWLJ",
-        "destinationTag": "3fdsfsdfasdfdsfgasdgfdsfgas"
+        "memo": "3fdsfsdfasdfdsfgasdgfdsfgas"
+    },
+    {
+        "address": "GDTYVCTAUQVPKEDZIBWEJGKBQHB4UGGXI2SXXUEW7LXMD4B7MK37CWLJ",
+        "memo": "really long memo that exceeds 28 bytes",
+        "invalid": true
     }
 ]

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) {