@cruxpay/js-sdk/lib/core/entities/crux-spec.js

CruxPay Javascript SDK

var _a;
import { object, optional, string as stringValidator } from "@mojotech/json-type-validation";
import config from "../../config";
import { BaseError, ErrorHelper, PackageErrorCode } from "../../packages/error";
import { CruxId, IdTranslator } from "../../packages/identity-utils";
import globalAssetList from "../global-asset-list.json";
var assetIdRegex = new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$");
// tslint:disable-next-line: tsr-detect-unsafe-regexp
var urlRegex = new RegExp("^(?:http(s)?:\\/\\/)?[\\w.-]+(?:\\.[\\w\\.-]+)+[\\w\\-\\._~:/?#[\\]@!\\$&'\\(\\)\\*\\+,;=.]+$");
var assetGroupRegex = new RegExp("^(.+)_[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$");
var Validations = /** @class */ (function () {
    function Validations() {
    }
    Validations.validateSubdomainString = function (subDomainString) {
        var subdomainRegex = "^[a-z]([a-z]|[0-9]|-|_)*([a-z]|[0-9])$";
        var subdomainMinLength = 4;
        var subdomainMaxLength = 20;
        // tslint:disable-next-line: tsr-detect-non-literal-regexp
        if (!subDomainString.match(new RegExp(subdomainRegex))) {
            throw ErrorHelper.getPackageError(null, PackageErrorCode.SubdomainRegexMatchFailure);
        }
        if (subDomainString.length < subdomainMinLength || subDomainString.length > subdomainMaxLength) {
            throw ErrorHelper.getPackageError(null, PackageErrorCode.SubdomainLengthCheckFailure);
        }
    };
    Validations.validateRegex = function (string, regex) {
        if (!regex.test(string)) {
            throw new BaseError(null, "regex failed for: " + string);
        }
    };
    Validations.validateURL = function (url) {
        try {
            Validations.validateRegex(url, urlRegex);
        }
        catch (e) {
            throw new BaseError(e, "Invalid URL: " + url);
        }
    };
    Validations.validateAssetId = function (assetId) {
        try {
            Validations.validateRegex(assetId, assetIdRegex);
        }
        catch (e) {
            throw new BaseError(e, "Invalid AssetID: " + assetId);
        }
    };
    Validations.validateAssetIdAgainstAssetList = function (assetId, assetList) {
        if (!assetList.find(function (asset) { return asset.assetId === assetId; })) {
            throw new BaseError(null, "AssetID: " + assetId + " is not recognized.");
        }
    };
    Validations.validateGlobalAsset = function (assetObject) {
        // TODO: add validations for all fields
        Validations.validateAssetId(assetObject.assetId);
        // tslint:disable-next-line: no-unused-expression
        assetObject.parentAssetId && Validations.validateAssetId(assetObject.parentAssetId);
    };
    Validations.validateAssetList = function (assetList) {
        assetList.forEach(Validations.validateGlobalAsset);
    };
    Validations.validateAssetMapping = function (assetMapping, assetList) {
        Object.keys(assetMapping).forEach(function (assetSymbol) {
            Validations.validateAssetId(assetMapping[assetSymbol]);
            Validations.validateAssetIdAgainstAssetList(assetMapping[assetSymbol], assetList);
        });
    };
    Validations.validateAssetGroup = function (assetGroup) {
        try {
            Validations.validateRegex(assetGroup, assetGroupRegex);
        }
        catch (error) {
            throw new BaseError(null, "AssetGroup: " + assetGroup + " is not valid.");
        }
    };
    Validations.validateAssetGroups = function (assetGroups) {
        assetGroups.forEach(function (assetGroup) {
            Validations.validateAssetGroup(assetGroup);
        });
    };
    Validations.validateNameServiceConfig = function (nameServiceConfig) {
        // TODO: domain name validation
        if (nameServiceConfig.gaiaHub) {
            Validations.validateURL(nameServiceConfig.gaiaHub);
        }
        if (nameServiceConfig.subdomainRegistrar) {
            Validations.validateURL(nameServiceConfig.subdomainRegistrar);
        }
        if (nameServiceConfig.bnsNodes) {
            nameServiceConfig.bnsNodes.forEach(Validations.validateURL);
        }
    };
    Validations.validateAddressObj = function (addressObject) {
        var addressDecoder = object({
            addressHash: stringValidator(),
            secIdentifier: optional(stringValidator()),
        });
        try {
            addressDecoder.runWithException(addressObject);
        }
        catch (e) {
            throw ErrorHelper.getPackageError(e, PackageErrorCode.AddressMappingDecodingFailure);
        }
    };
    return Validations;
}());
export { Validations };
export var CruxSpec = {
    blockstack: (_a = /** @class */ (function () {
            function blockstack() {
            }
            return blockstack;
        }()),
        _a.infrastructure = {
            bnsNodes: config.BLOCKSTACK.BNS_NODES,
            gaiaHub: config.BLOCKSTACK.GAIA_HUB,
            subdomainRegistrar: config.BLOCKSTACK.SUBDOMAIN_REGISTRAR,
        },
        _a.configSubdomain = "_config",
        _a.getDomainConfigFileName = function (cruxDomainId) {
            return cruxDomainId.components.domain + "_client-config.json";
        },
        _a.getConfigCruxId = function (cruxDomainId) {
            return new CruxId({
                domain: cruxDomainId.components.domain,
                subdomain: CruxSpec.blockstack.configSubdomain,
            });
        },
        _a.getCruxPayFilename = function (cruxDomainId) {
            return cruxDomainId.components.domain + "_cruxpay.json";
        },
        _a.getCruxUserConfigFileName = function (cruxDomainId) {
            return cruxDomainId.components.domain + "_user-config.json";
        },
        _a),
    globalAssetList: globalAssetList,
    idTranslator: IdTranslator,
    validations: Validations,
};