@neo-one/node-core/utils/utils.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const client_common_1 = require("@neo-one/client-common");
const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
const bn_js_1 = require("bn.js");
const crypto_1 = require("crypto");
const lodash_1 = tslib_1.__importDefault(require("lodash"));
const toASCII = (bytes) => {
    let result = '';
    lodash_1.default.range(bytes.length).forEach((i) => {
        result += String.fromCharCode(bytes.readUInt8(i));
    });
    return result;
};
const toUTF8 = (bytes) => bytes.toString('utf8');
const calculateClaimAmount = async ({ coins, decrementInterval, generationAmount, getSystemFee, }) => {
    const grouped = Object.values(lodash_1.default.groupBy(coins, (coin) => `${coin.startHeight}:${coin.endHeight}`));
    const claimed = await Promise.all(grouped.map(async (coinsGroup) => {
        const { startHeight, endHeight } = coinsGroup[0];
        let amount = client_common_1.utils.ZERO;
        let ustart = Math.floor(startHeight / decrementInterval);
        if (ustart < generationAmount.length) {
            let istart = startHeight % decrementInterval;
            let uend = Math.floor(endHeight / decrementInterval);
            let iend = endHeight % decrementInterval;
            if (uend >= generationAmount.length) {
                uend = generationAmount.length;
                iend = 0;
            }
            if (iend === 0) {
                uend -= 1;
                iend = decrementInterval;
            }
            while (ustart < uend) {
                amount = amount.addn((decrementInterval - istart) * generationAmount[ustart]);
                ustart += 1;
                istart = 0;
            }
            amount = amount.addn((iend - istart) * generationAmount[ustart]);
        }
        const [sysFeeEnd, sysFeeStart] = await Promise.all([
            getSystemFee(endHeight - 1),
            startHeight === 0 ? Promise.resolve(client_common_1.utils.ZERO) : getSystemFee(startHeight - 1),
        ]);
        amount = amount.add(sysFeeEnd.sub(sysFeeStart).div(client_common_1.utils.ONE_HUNDRED_MILLION));
        const totalValue = coinsGroup.reduce((acc, { value }) => acc.add(value), client_common_1.utils.ZERO);
        return [totalValue, amount];
    }));
    return claimed.reduce((acc, [value, amount]) => acc.add(value.div(client_common_1.utils.ONE_HUNDRED_MILLION).mul(amount)), client_common_1.utils.ZERO);
};
const randomUInt64 = () => new bn_js_1.BN(crypto_1.randomBytes(8).toString('hex'), 16);
const toKeyString = (clazz, toKey) => () => `${clazz.name}:${toKey()}`;
function lazyAsync(getValue) {
    let valuePromise;
    return async (input) => {
        if (valuePromise === undefined) {
            valuePromise = getValue(input);
        }
        return valuePromise;
    };
}
function lazyOrValue(getValue) {
    let settings = typeof getValue === 'function' ? { type: 'lazy', getValue } : { type: 'evaluated', value: getValue };
    return () => {
        if (settings.type === 'lazy') {
            settings = { type: 'evaluated', value: settings.getValue() };
        }
        return settings.value;
    };
}
function weightedAverage(input) {
    let sumWeight = new bignumber_js_1.default(0);
    let sumValue = new bignumber_js_1.default(0);
    input.forEach((value) => {
        sumWeight = sumWeight.plus(value.weight);
        sumValue = sumValue.plus(value.weight.times(value.value));
    });
    if (sumValue.isEqualTo(0) || sumWeight.isEqualTo(0)) {
        return 0;
    }
    return sumValue
        .div(sumWeight)
        .integerValue(bignumber_js_1.default.ROUND_FLOOR)
        .toNumber();
}
function weightedFilter(input, startIn, endIn, getValueIn) {
    const start = new bignumber_js_1.default(startIn);
    const end = new bignumber_js_1.default(endIn);
    const getValue = (value) => new bignumber_js_1.default(getValueIn(value).toString(10));
    const amount = input.reduce((acc, value) => acc.plus(getValue(value)), new bignumber_js_1.default(0));
    let sum = new bignumber_js_1.default(0);
    let current = new bignumber_js_1.default(0);
    const mutableResult = [];
    for (const value of input) {
        if (current.gte(end)) {
            break;
        }
        let weight = getValue(value);
        sum = sum.plus(weight);
        const old = current;
        current = sum.div(amount);
        if (current.lte(start)) {
            continue;
        }
        if (old.lt(start)) {
            weight = current.gt(end) ? end.minus(start).times(amount) : current.minus(start).times(amount);
        }
        else if (current.gt(end)) {
            weight = end.minus(old).times(amount);
        }
        mutableResult.push([
            value,
            weight.gte(0) ? weight.integerValue(bignumber_js_1.default.ROUND_FLOOR) : weight.integerValue(bignumber_js_1.default.ROUND_CEIL),
        ]);
    }
    return mutableResult;
}
function equals(clazz, thiz, equalsFunc) {
    return (other) => other != undefined && (thiz === other || (other instanceof clazz && equalsFunc(other)));
}
exports.utils = Object.assign(Object.assign({}, client_common_1.utils), { toASCII,
    toUTF8,
    calculateClaimAmount,
    randomUInt64,
    toKeyString,
    equals,
    lazyAsync,
    lazyOrValue,
    weightedAverage,
    weightedFilter });

//# sourceMappingURL=utils.js.map