@ellipticltd/aml-utils 0.16.26 → 0.16.27

package/lib/validations/validations.js

@@ -1,686 +1,478 @@
-/* eslint no-underscore-dangle: 0 */
 const V = require('validator');
 const _ = require('lodash');
-// Importing directly from dist to make sure we import the browser-friendly version of the library
-const addressValidator = require('multicoin-address-validator/dist/wallet-address-validator');
-const web3 = require('web3-utils');
-const stellarBase = require('@stellar/stellar-base');
+const {
+  crypto: { Signature },
+  HDPrivateKey,
+  HDPublicKey,
+  PublicKey,
+  Script,
+  Transaction,
+} = require('bitcore-lib');
+const addressValidator = require('multicoin-address-validator');
+const eip55 = require('eip55');
+const stellarSDK = require('stellar-sdk');
 const E = require('../errors/errors');
+
+const cryptoValidators = {
+  // Here we use our regex to validate the shape of the address, and eip55 to validate the checksum
+  isAddress(str) {
+    if (typeof str !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(str)) return false;
+    return eip55.verify(str, true);
+  },
+  isHexStrict(str) {
+    return typeof str === 'string' && /^0x[0-9a-fA-F]*$/.test(str);
+  },
+  isHex(str) {
+    return typeof str === 'string' && /^(0x)?[0-9a-fA-F]*$/.test(str);
+  },
+  isValidWeiAmount(str) {
+    return typeof str === 'string' && /^[0-9]+$/.test(str);
+  },
+};
+
 const validations = {
-    _validate(Err, pred, x, msg) {
-        if (pred(x)) {
-            return x;
-        }
-        throw new Err(msg);
-    },
-    _validateArg(pred, x, msg) {
-        return this._validate(E.InvalidArguments, pred, x, msg);
-    },
-    _tryCheck(fn, arg) {
-        try {
-            fn(arg);
-            return true;
+  _validate(Err, pred, x, msg) {
+    if (pred(x)) {
+      return x;
+    }
+    throw new Err(msg);
+  },
+  _validateArg(pred, x, msg) {
+    return this._validate(E.InvalidArguments, pred, x, msg);
+  },
+  _tryCheck(fn, arg) {
+    try {
+      fn(arg);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+
+  exists(x) {
+    return x != null;
+  },
+  nonEmpty(x) {
+    return (x != null ? x.length : undefined) > 0;
+  },
+  isNonEmptyString(x) {
+    return _.isString(x) && (x != null ? x.length : undefined) > 0;
+  },
+  isSafeString(str) {
+    // eslint-disable-next-line no-useless-escape
+    return RegExp(/^(\p{L}|[0-9]|-|=|!|\.|:|\s|@|\+|_|,|\$|£|&)+$/, 'u').test(str);
+  },
+  ensureShortEnough(limit, x) {
+    const l = x != null ? x.length : undefined;
+    if (l <= limit) {
+      return true;
+    }
+    throw new E.BadRequest(`Max query size exceeded: ${l} / ${limit}`);
+  },
+  ensure(crit, msg) {
+    if (crit) {
+      return true;
+    }
+    throw new E.BadRequest(msg);
+  },
+  argExists(x, msg) {
+    return this._validateArg(this.exists, x, msg);
+  },
+
+  check: {
+    matches(required, given, msg) {
+      const newGiven = _.uniq(given);
+      const crit = _.intersection(newGiven, required).length === given.length;
+      if (crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+    wasFound(type) {
+      return (item) => {
+        if (item == null) {
+          throw new E.NotFound(`Unknown ${type}`);
+        } else {
+          return item;
         }
-        catch (error) {
-            return false;
+      };
+    },
+    wasCreated(msg) {
+      return (arr) => {
+        if (!arr[1]) {
+          throw new E.BadRequest(msg);
+        } else {
+          return arr;
         }
+      };
+    },
+    isTrue(crit, msg) {
+      if (crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+    isFalse(crit, msg) {
+      if (!crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+  },
+
+  isCustomerReference(x) {
+    return (
+      _.isString(x)
+      && (x != null ? x.length : undefined) > 0
+      && (x != null ? x.length : undefined) <= 100
+    );
+  },
+  isCustomerLabelName(x) {
+    return (
+      _.isString(x)
+      && (x != null ? x.length : undefined) > 0
+      && (x != null ? x.length : undefined) <= 50
+    );
+  },
+  binanceChain: {
+    isAddress(str) {
+      return /^(bnb)([a-z0-9]{39})$/.test(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  bitcoin: {
+    isAddress(str) {
+      const network = process.env.BITCOIN_NETWORK === 'testnet' ? 'testnet' : 'prod';
+      return typeof str === 'string' && addressValidator.validate(str.trim(), 'btc', network);
+    },
+    isBech32Address(str) {
+      return /^bc1[ac-hj-np-z02-9]{6,86}|^BC1[AC-HJ-NP-Z02-9]{6,86}/.test(str);
+    },
+    isHDPublicKey(str) {
+      try {
+        HDPublicKey(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isPublicKey(str) {
+      try {
+        PublicKey(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+    isTxHex(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      try {
+        Transaction(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isHDPath(str) {
+      return HDPrivateKey.isValidPath(str);
+    },
+    isScriptHex(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      try {
+        Script(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isTxSignature(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      try {
+        const b = Buffer.from(str, 'hex');
+        Signature.fromTxFormat(b);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isBlockHeight(obj) {
+      return _.isInteger(+obj) && parseInt(obj, 10) >= 0;
+    },
+  },
+  bitcoinCash: {
+    isAddress(str) {
+      return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$|^(bitcoincash:)?[q|p][a-z0-9]{41}$|^(BITCOINCASH:)?[Q|P][A-Z0-9]{41}$/.test(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  ethereum: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isBlockHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+    isAddressCode(str) {
+      return cryptoValidators.isHexStrict(str);
+    },
+    isValidWeiAmount(str) {
+      return cryptoValidators.isValidWeiAmount(str);
+    },
+  },
+  horizen: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'zen');
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  litecoin: {
+    isAddress(str) {
+      return /^[3LM][a-km-zA-HJ-NP-Z1-9]{24,33}$|^ltc1[ac-hj-np-z02-9]{6,86}$|^LTC1[AC-HJ-NP-Z02-9]{6,86}$|^ltcmweb[a-zA-Z0-9]{114}$/.test(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  ripple: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'xrp');
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  stellar: {
+    isAddress(str) {
+      return stellarSDK.StrKey.isValidEd25519PublicKey(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  zcash: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'zec');
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  zilliqa: {
+    isAddress(str) {
+      // https://pub.dev/documentation/laksadart/latest/laksadart/isBech32.html
+      return !!str.match(/^zil1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38}$/);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  algorand: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'algo');
+    },
+    isTxHash(str) {
+      return str.length === 52;
+    },
+  },
+  tezos: {
+    isAddress(str) {
+      return str[0] !== 'o' && addressValidator.validate(str, 'xtz');
+    },
+    isTxHash(str) {
+      return str.length === 51;
+    },
+  },
+  polkadot: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'dot');
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  cardano: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'ada');
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  cryptocom: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'cro');
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(str)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  near: {
+    isAddress(str) {
+      // https://nomicon.io/DataStructures/Account
+      return /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/.test(str);
+    },
+    isTxHash(str) {
+      return str.length === 44 || str.length === 43;
+    },
+  },
+  doge: {
+    isAddress(str) {
+      return /^[a-zA-Z\d]{34}$/.test(str);
+    },
+    isTxHash(str) {
+      return str.length === 64;
+    },
+  },
+  cosmos: {
+    isAddress(str) {
+      return /^cosmos{1}[a-zA-Z\d]{39}$/.test(str);
+    },
+    isTxHash(str) {
+      return str.length === 64 && cryptoValidators.isHex(str);
+    },
+  },
+  solana: {
+    isAddress(str) {
+      return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(str);
+    },
+    isTxHash(str) {
+      return /^[1-9A-HJ-NP-Za-km-z]{77,88}$/.test(str);
+    },
+  },
+  binanceSmartChain: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  polygon: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  filecoin: {
+    isAddress(str) {
+      return /^(f0|f1|f2|f3)/.test(str);
+    },
+    isTxHash(str) {
+      return str.length === 62 && /^bafy2bza/.test(str);
+    },
+  },
+  optimism: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  avalanche: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  arbitrum: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    },
+  },
+  tron: {
+    isAddress(str) {
+      return addressValidator.validate(str, 'tron');
+    },
+    isTxHash(str) {
+      return str.length === 64 && cryptoValidators.isHex(str);
     },
-    exists(x) {
-        return x != null;
+  },
+  fantom: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
     },
-    nonEmpty(x) {
-        return (x != null ? x.length : undefined) > 0;
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
     },
-    isNonEmptyString(x) {
-        return _.isString(x) && (x != null ? x.length : undefined) > 0;
+  },
+  celo: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
     },
-    isSafeString(str) {
-        // eslint-disable-next-line no-useless-escape, prefer-regex-literals
-        return RegExp(/^(\p{L}|[0-9]|-|=|!|\.|:|\s|@|\+|_|,|\$|£|&)+$/, 'u').test(str);
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
     },
-    isAssetSafeString(str) {
-        // eslint-disable-next-line no-useless-escape, prefer-regex-literals
-        return RegExp(/^(\p{L}|[0-9]|-|=|!|\.|:|\s|@|\+|_|,|\$|£|&|\/)+$/, 'u').test(str);
+  },
+  ethereumClassic: {
+    isAddress(str) {
+      return cryptoValidators.isAddress(str);
     },
-    ensureShortEnough(limit, x) {
-        const l = x != null ? x.length : undefined;
-        if (l <= limit) {
-            return true;
-        }
-        throw new E.BadRequest(`Max query size exceeded: ${l} / ${limit}`);
-    },
-    ensure(crit, msg) {
-        if (crit) {
-            return true;
-        }
-        throw new E.BadRequest(msg);
-    },
-    argExists(x, msg) {
-        return this._validateArg(this.exists, x, msg);
-    },
-    check: {
-        matches(required, given, msg) {
-            const newGiven = _.uniq(given);
-            const crit = _.intersection(newGiven, required).length === given.length;
-            if (crit) {
-                return true;
-            }
-            throw new E.BadRequest(msg);
-        },
-        wasFound(type) {
-            return (item) => {
-                if (item == null) {
-                    throw new E.NotFound(`Unknown ${type}`);
-                }
-                else {
-                    return item;
-                }
-            };
-        },
-        wasCreated(msg) {
-            return (arr) => {
-                if (!arr[1]) {
-                    throw new E.BadRequest(msg);
-                }
-                else {
-                    return arr;
-                }
-            };
-        },
-        isTrue(crit, msg) {
-            if (crit) {
-                return true;
-            }
-            throw new E.BadRequest(msg);
-        },
-        isFalse(crit, msg) {
-            if (!crit) {
-                return true;
-            }
-            throw new E.BadRequest(msg);
-        },
-    },
-    isCustomerReference(x) {
-        return _.isString(x) && (x != null ? x.length : undefined) > 0 && (x != null ? x.length : undefined) <= 100;
-    },
-    isCustomerLabelName(x) {
-        return _.isString(x) && (x != null ? x.length : undefined) > 0 && (x != null ? x.length : undefined) <= 50;
-    },
-    binanceChain: {
-        isAddress(str) {
-            return /^(bnb)([a-z0-9]{39})$/.test(str);
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    bitcoin: {
-        isAddress(str, asset) {
-            if (asset === 'lightning') {
-                return validations.isNonEmptyString(str);
-            }
-            return typeof str === 'string' && addressValidator.validate(str.trim(), 'btc', 'prod');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    bitcoinCash: {
-        isAddress(str) {
-            return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$|^(bitcoincash:)?[q|p][a-z0-9]{41}$|^(BITCOINCASH:)?[Q|P][A-Z0-9]{41}$/.test(str);
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    ethereum: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isBlockHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-        isAddressCode(str) {
-            return web3.isHexStrict(str);
-        },
-        isValidWeiAmount(str) {
-            try {
-                web3.fromWei(str);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
-        },
-    },
-    horizen: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'zen');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    litecoin: {
-        isAddress(str) {
-            return /^[3LM][a-km-zA-HJ-NP-Z1-9]{24,33}$|^ltc1[ac-hj-np-z02-9]{6,86}$|^LTC1[AC-HJ-NP-Z02-9]{6,86}$|^ltcmweb[a-zA-Z0-9]{114}$/.test(str);
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    ripple: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'xrp');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    stellar: {
-        isAddress(str) {
-            return stellarBase.StrKey.isValidEd25519PublicKey(str);
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    zcash: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'zec');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    zilliqa: {
-        isAddress(str) {
-            // https://pub.dev/documentation/laksadart/latest/laksadart/isBech32.html
-            return !!str.match(/^zil1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38}$/);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    algorand: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'algo');
-        },
-        isTxHash(str) {
-            return str.length === 52;
-        },
-    },
-    tezos: {
-        isAddress(str) {
-            return str[0] !== 'o' && addressValidator.validate(str, 'xtz');
-        },
-        isTxHash(str) {
-            return str.length === 51;
-        },
-    },
-    polkadot: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'dot');
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    cardano: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'ada');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    cryptocom: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'cro');
-        },
-        isTxHash(str) {
-            if (!V.isHexadecimal(str)) {
-                return false;
-            }
-            return str.length === 64;
-        },
-    },
-    near: {
-        isAddress(str) {
-            // https://nomicon.io/DataStructures/Account
-            return /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 44 || str.length === 43;
-        },
-    },
-    doge: {
-        isAddress(str) {
-            return /^[a-zA-Z\d]{34}$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64;
-        },
-    },
-    cosmos: {
-        isAddress(str) {
-            return /^cosmos{1}[a-zA-Z\d]{39}$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    solana: {
-        isAddress(str) {
-            return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(str);
-        },
-        isTxHash(str) {
-            return /^[1-9A-HJ-NP-Za-km-z]{77,88}$/.test(str);
-        },
-    },
-    binanceSmartChain: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    polygon: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    filecoin: {
-        isAddress(str) {
-            return /^(f0|f1|f2|f3)/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 62 && /^bafy2bza/.test(str);
-        },
-    },
-    optimism: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    avalanche: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    arbitrum: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    tron: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'tron');
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    fantom: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    celo: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    ethereumClassic: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    mobilecoin: {
-        isAddress(str) {
-            return str.length === 24 && /^[A-Za-z0-9+/]+={0,2}$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    sui: {
-        isAddress(str) {
-            return str.length === 66 && /^[A-Za-z0-9+/]+$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 44;
-        },
-    },
-    flare: {
-        isAddress(str) {
-            return str.length === 42 && /^[A-Za-z0-9+/]+$/.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 66;
-        },
-    },
-    ton: {
-        isAddress(str) {
-            return /^[A-Za-z0-9+/]{64}$/.test(str);
-        },
-        isTxHash(str) {
-            return /^[A-Za-z0-9+/]{64}$/.test(str);
-        },
-    },
-    gnosis: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    dydx: {
-        isAddress(str) {
-            return /^[a-z]+1[a-zA-Z0-9]{38}$/.test(str) || str === 'dydx_chain';
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    hederaHashgraph: {
-        isAddress(str) {
-            return /^\d+\.\d+\.\d+$/.test(str);
-        },
-        isTxHash(str) {
-            return /^[xa-f0-9+/]{98}$/.test(str);
-        },
-    },
-    aptos: {
-        isAddress(str) {
-            return str.length <= 66 && web3.isHex(str);
-        },
-        isTxHash(str) {
-            return web3.isHex(str);
-        },
-    },
-    zksync: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    haqq: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    base: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    corechain: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    worldchain: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    injective: {
-        isAddress(str) {
-            return /^[a-z0-9]+$/i.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    linea: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    xdc: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    internetcomputer: {
-        isAddress(str) {
-            return web3.isHex(str);
-        },
-        isTxHash(str) {
-            return web3.isHex(str);
-        },
-    },
-    unichain: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    sei: {
-        isAddress(str) {
-            return /^[a-z0-9]+$/i.test(str);
-        },
-        isTxHash(str) {
-            return (str.length === 64 && web3.isHex(str)) || (str.length === 66 && web3.isHexStrict(str));
-        },
-    },
-    bittensor: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'dot');
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    codex: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    mantra: {
-        isAddress(str) {
-            return /^[a-z0-9]+$/i.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    nillion: {
-        isAddress(str) {
-            return /^[a-z0-9]+$/i.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    canton: {
-        isAddress(str) {
-            return str.length > 1;
-        },
-        isTxHash(str) {
-            return web3.isHex(str) && str.length === 68;
-        },
-    },
-    starknet: {
-        isAddress(str) {
-            return web3.isHex(str);
-        },
-        isTxHash(str) {
-            return web3.isHex(str);
-        },
-    },
-    noble: {
-        isAddress(str) {
-            return /^[a-z0-9]+$/i.test(str);
-        },
-        isTxHash(str) {
-            return str.length === 64 && web3.isHex(str);
-        },
-    },
-    assethub: {
-        isAddress(str) {
-            return addressValidator.validate(str, 'dot');
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    plasma: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    ink: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    xlayer: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    monad: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    hyperevm: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    tempo: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    morph: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    etherlink: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
-    },
-    edgex: {
-        isAddress(str) {
-            return web3.isAddress(str);
-        },
-        isTxHash(str) {
-            return str.length === 66 && web3.isHexStrict(str);
-        },
+    isTxHash(str) {
+      return str.length === 66 && cryptoValidators.isHexStrict(str);
     },
+  },
 };
+
 Object.keys(V).forEach((k) => {
-    const v = V[k];
-    // don't trigger validation with null values (prevents swagger 500 error)
-    validations[k] = (x) => (x === null ? false : v(x));
+  const v = V[k];
+  // don't trigger validation with null values (prevents swagger 500 error)
+  validations[k] = (x) => (x === null ? false : v(x));
 });
+
 module.exports = validations;
-//# sourceMappingURL=validations.js.map