@ellipticltd/aml-utils 0.16.27 → 0.16.28

package/lib/validations/validations.js

@@ -1,478 +1,697 @@
+/* eslint no-underscore-dangle: 0 */
 const V = require('validator');
 const _ = require('lodash');
-const {
-  crypto: { Signature },
-  HDPrivateKey,
-  HDPublicKey,
-  PublicKey,
-  Script,
-  Transaction,
-} = require('bitcore-lib');
-const addressValidator = require('multicoin-address-validator');
+// 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 eip55 = require('eip55');
-const stellarSDK = require('stellar-sdk');
+const stellarBase = require('@stellar/stellar-base');
 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;
-    } 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;
-        }
-      };
-    },
-    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: {
+    // Here we use our regex to validate the shape of the address, and eip55 to validate the checksum
     isAddress(str) {
-      return cryptoValidators.isAddress(str);
+        if (typeof str !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(str))
+            return false;
+        return eip55.verify(str, true);
     },
-    isBlockHash(str) {
-      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    isHexStrict(str) {
+        return typeof str === 'string' && /^0x[0-9a-fA-F]*$/.test(str);
     },
-    isTxHash(str) {
-      return str.length === 66 && cryptoValidators.isHexStrict(str);
-    },
-    isAddressCode(str) {
-      return cryptoValidators.isHexStrict(str);
+    isHex(str) {
+        return typeof str === 'string' && /^(0x)?[0-9a-fA-F]*$/.test(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;
+        return typeof str === 'string' && /^[0-9]+$/.test(str);
     },
-  },
-  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);
+};
+const validations = {
+    _validate(Err, pred, x, msg) {
+        if (pred(x)) {
+            return x;
+        }
+        throw new Err(msg);
     },
-    isTxHash(str) {
-      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    _validateArg(pred, x, msg) {
+        return this._validate(E.InvalidArguments, pred, x, msg);
     },
-  },
-  tron: {
-    isAddress(str) {
-      return addressValidator.validate(str, 'tron');
+    _tryCheck(fn, arg) {
+        try {
+            fn(arg);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
     },
-    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}`);
     },
-    isTxHash(str) {
-      return str.length === 66 && cryptoValidators.isHexStrict(str);
+    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 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 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 && 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);
+        },
+    },
+    fantom: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    celo: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    ethereumClassic: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    mobilecoin: {
+        isAddress(str) {
+            return str.length === 24 && /^[A-Za-z0-9+/]+={0,2}$/.test(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.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 cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.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 && cryptoValidators.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 && cryptoValidators.isHex(str);
+        },
+        isTxHash(str) {
+            return cryptoValidators.isHex(str);
+        },
+    },
+    zksync: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    haqq: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.isHex(str);
+        },
+    },
+    base: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    corechain: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    worldchain: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    injective: {
+        isAddress(str) {
+            return /^[a-z0-9]+$/i.test(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.isHex(str);
+        },
+    },
+    linea: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    xdc: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    internetcomputer: {
+        isAddress(str) {
+            return cryptoValidators.isHex(str);
+        },
+        isTxHash(str) {
+            return cryptoValidators.isHex(str);
+        },
+    },
+    unichain: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    sei: {
+        isAddress(str) {
+            return /^[a-z0-9]+$/i.test(str);
+        },
+        isTxHash(str) {
+            return (str.length === 64 && cryptoValidators.isHex(str)) || (str.length === 66 && cryptoValidators.isHexStrict(str));
+        },
+    },
+    bittensor: {
+        isAddress(str) {
+            return addressValidator.validate(str, 'dot');
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    codex: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    mantra: {
+        isAddress(str) {
+            return /^[a-z0-9]+$/i.test(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.isHex(str);
+        },
+    },
+    nillion: {
+        isAddress(str) {
+            return /^[a-z0-9]+$/i.test(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.isHex(str);
+        },
+    },
+    canton: {
+        isAddress(str) {
+            return str.length > 1;
+        },
+        isTxHash(str) {
+            return cryptoValidators.isHex(str) && str.length === 68;
+        },
+    },
+    starknet: {
+        isAddress(str) {
+            return cryptoValidators.isHex(str);
+        },
+        isTxHash(str) {
+            return cryptoValidators.isHex(str);
+        },
+    },
+    noble: {
+        isAddress(str) {
+            return /^[a-z0-9]+$/i.test(str);
+        },
+        isTxHash(str) {
+            return str.length === 64 && cryptoValidators.isHex(str);
+        },
+    },
+    assethub: {
+        isAddress(str) {
+            return addressValidator.validate(str, 'dot');
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    plasma: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    ink: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    xlayer: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    monad: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    hyperevm: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    tempo: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    morph: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    etherlink: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(str);
+        },
+        isTxHash(str) {
+            return str.length === 66 && cryptoValidators.isHexStrict(str);
+        },
+    },
+    edgex: {
+        isAddress(str) {
+            return cryptoValidators.isAddress(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