@nexex/api/utils/assert.js

support trade on nexex network

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var _ = __importStar(require("lodash"));
var signatureUtils_1 = require("./signatureUtils");
var HEX_REGEX = /^0x[0-9A-F]*$/i;
// async function isSenderAddressAvailable(eth: Eth, senderAddress: string): Promise<boolean> {
//     const addresses = await getAvailableAddresses(eth);
//     const normalizedAddress = senderAddress.toLowerCase();
//
//     return _.includes(addresses, normalizedAddress);
// }
// async function getAvailableAddresses(eth: Eth): Promise<string[]> {
//     const addresses = await eth.getAccounts();
//
//     return _.map(addresses, address => address.toLowerCase());
// }
exports.assert = {
    isString: function (variableName, value) {
        this.assert(_.isString(value), this.typeAssertionMessage(variableName, 'string', value));
    },
    isFunction: function (variableName, value) {
        this.assert(_.isFunction(value), this.typeAssertionMessage(variableName, 'function', value));
    },
    isHexString: function (variableName, value) {
        this.assert(_.isString(value) && HEX_REGEX.test(value), this.typeAssertionMessage(variableName, 'HexString', value));
    },
    // isETHAddressHex(variableName: string, value: string): void {
    //     this.assert(_.isString(value), this.typeAssertionMessage(variableName, 'string', value));
    //     this.assert(ethUtil.isValidAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
    // },
    doesBelongToStringEnum: function (variableName, value, stringEnum /* There is no base type for every string enum */) {
        var doesBelongToStringEnum = !_.isUndefined(stringEnum[value]);
        var enumValues = _.keys(stringEnum);
        var enumValuesAsStrings = _.map(enumValues, function (enumValue) { return "'" + enumValue + "'"; });
        var enumValuesAsString = enumValuesAsStrings.join(', ');
        exports.assert.assert(doesBelongToStringEnum, "Expected " + variableName + " to be one of: " + enumValuesAsString + ", encountered: " + value);
    },
    hasAtMostOneUniqueValue: function (value, errMsg) {
        this.assert(_.uniq(value).length <= 1, errMsg);
    },
    isNumber: function (variableName, value) {
        this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
    },
    isBoolean: function (variableName, value) {
        this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
    },
    assert: function (condition, message) {
        if (!condition) {
            throw new Error(message);
        }
    },
    typeAssertionMessage: function (variableName, type, value) {
        return "Expected " + variableName + " to be of type " + type + ", encountered: " + value;
    },
    isValidSignature: function (orderHash, ecSignature, signerAddress) {
        var isValidSignature = signatureUtils_1.signatureUtils.isValidSignature(orderHash, ecSignature, signerAddress);
        this.assert(isValidSignature, "Expected order with hash '" + orderHash + "' to have a valid signature");
    },
    // async isSenderAddressAsync(variableName: string, senderAddressHex: string, eth: Eth): Promise<void> {
    //     this.isETHAddressHex(variableName, senderAddressHex);
    //     const isAvailable = await isSenderAddressAvailable(eth, senderAddressHex);
    //     this.assert(
    //         isAvailable,
    //         `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`
    //     );
    // },
    // async isUserAddressAvailableAsync(eth: Eth): Promise<void> {
    //     const availableAddresses = await getAvailableAddresses(eth);
    //     this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 provider');
    // },
    exists: function (value) {
        this.assert(value !== undefined && value !== null, value + " does not exist");
    },
    notExists: function (value) {
        this.assert(value === undefined || value === null, value + " does exist");
    }
};
//# sourceMappingURL=assert.js.map