@radixdlt/atom-transaction-mapping/dist/fromAtom/tokenBalancesForOneAccountReducer.js

Create Atoms from actions

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.tokenBalancesForOneAccountReducer = exports.mergeMaps = exports.mergeTokenBalance = exports.tokenBalance = exports.emptyTokenBalancesForOneAccount = exports.tokenBalancesForOneAccountFromParticle = exports.tokenBalancesForOneAccount = void 0;
const _types_1 = require("./_types");
const atom_1 = require("@radixdlt/atom");
const neverthrow_1 = require("neverthrow");
const util_1 = require("@radixdlt/util");
const particleReducer_1 = require("./particleReducer");
const tokenBalancesForOneAccount = (input) => ({
    stateType: _types_1.ApplicationStateType.TOKEN_BALANCES_FOR_ONE_ACCOUNT,
    balances: input.balances,
    owner: input.owner,
    size: input.balances.size,
    balanceOf: (resourceIdentifier) => input.balances.get(resourceIdentifier),
});
exports.tokenBalancesForOneAccount = tokenBalancesForOneAccount;
const tokenBalancesForOneAccountFromParticle = (transferrableTokensParticle) => {
    const tokenBalance_ = exports.tokenBalance(transferrableTokensParticle);
    return exports.tokenBalancesForOneAccount({
        owner: transferrableTokensParticle.address,
        balances: new Map([
            [transferrableTokensParticle.resourceIdentifier, tokenBalance_],
        ]),
    });
};
exports.tokenBalancesForOneAccountFromParticle = tokenBalancesForOneAccountFromParticle;
const emptyTokenBalancesForOneAccount = (owner) => exports.tokenBalancesForOneAccount({
    owner,
    balances: new Map(),
});
exports.emptyTokenBalancesForOneAccount = emptyTokenBalancesForOneAccount;
const tokenBalance = (ttp) => {
    return {
        owner: ttp.address,
        tokenAmount: {
            amount: ttp.amount,
            token: ttp,
        },
    };
};
exports.tokenBalance = tokenBalance;
const ownerMismatchError = new Error(`Cannot merge TokenBalance's with different owners.`);
const mergeTokenBalance = (lhs, rhs) => {
    if (!lhs.tokenAmount.token.resourceIdentifier.equals(rhs.tokenAmount.token.resourceIdentifier)) {
        return neverthrow_1.err(new Error(`Cannot merge TokenBalance's with different token types.`));
    }
    if (!lhs.owner.equals(rhs.owner)) {
        return neverthrow_1.err(ownerMismatchError);
    }
    return lhs.tokenAmount.amount.adding(rhs.tokenAmount.amount).map((sum) => ({
        owner: lhs.owner,
        tokenAmount: {
            token: lhs.tokenAmount.token,
            amount: sum,
        },
    }));
};
exports.mergeTokenBalance = mergeTokenBalance;
const mergeMaps = (input) => {
    const lhs = input.first;
    const rhs = input.second;
    const uniqueKeys = Array.from(new Set([]
        .concat(Array.from(lhs.keys()))
        .concat(Array.from(rhs.keys()))));
    /* eslint-disable functional/immutable-data, functional/no-let, functional/no-loop-statement, prefer-const */
    let combinedMap = new Map();
    for (const key of uniqueKeys) {
        const lhsVal = lhs.get(key);
        const rhsVal = rhs.get(key);
        if (lhsVal && rhsVal) {
            // Found duplicates...
            const mergeResult = input.onDuplicates(lhsVal, rhsVal, key);
            if (mergeResult.isOk()) {
                combinedMap.set(key, mergeResult.value);
            }
            else {
                return neverthrow_1.err(mergeResult.error);
            }
        }
        else if (lhsVal) {
            combinedMap.set(key, lhsVal);
        }
        else if (rhsVal) {
            combinedMap.set(key, rhsVal);
        }
        else {
            throw Error('Incorrect implementation, should never happen.');
        }
    }
    return neverthrow_1.ok(combinedMap);
};
exports.mergeMaps = mergeMaps;
// eslint-disable-next-line max-lines-per-function
const tokenBalancesForOneAccountReducer = (owner) => {
    const combine = (input) => {
        if (!input.current.owner.equals(owner) ||
            !input.current.owner.equals(input.newState.owner))
            return neverthrow_1.err(new Error('Incorrect implementation, owner mismatch'));
        if (util_1.mapEquals(input.current.balances, input.newState.balances))
            return neverthrow_1.ok(input.current);
        return exports.mergeMaps({
            first: input.current.balances,
            second: input.newState.balances,
            onDuplicates: (a, b, _) => exports.mergeTokenBalance(a, b),
        }).map((balances) => exports.tokenBalancesForOneAccount({
            owner: input.current.owner,
            balances: balances,
        }));
    };
    return particleReducer_1.makeParticleReducer({
        applicationStateType: _types_1.ApplicationStateType.TOKEN_BALANCES_FOR_ONE_ACCOUNT,
        initialState: exports.emptyTokenBalancesForOneAccount(owner),
        reduce: (input) => {
            const particle = input.upParticle.particle;
            if (!atom_1.isTransferrableTokensParticle(particle))
                return neverthrow_1.ok(input.state);
            if (!particle.address.equals(owner))
                return neverthrow_1.err(ownerMismatchError);
            const tokenBalancesForOneAccount_ = exports.tokenBalancesForOneAccountFromParticle(particle);
            return combine({
                current: input.state,
                newState: tokenBalancesForOneAccount_,
            });
        },
        combine: combine,
    });
};
exports.tokenBalancesForOneAccountReducer = tokenBalancesForOneAccountReducer;
//# sourceMappingURL=tokenBalancesForOneAccountReducer.js.map