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

Create Atoms from actions

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeAtomToTokenTransfersMapper = exports.syncMapAtomToTokenTransfers = exports.pgToTokenTransfer = void 0;
const atom_1 = require("@radixdlt/atom");
const _types_1 = require("./_types");
const rxjs_1 = require("rxjs");
const neverthrow_1 = require("neverthrow");
const tokenTransfer_1 = require("./tokenTransfer");
const uniqueAddressCountTTPs = (particles) => {
    return new Set(particles.map((ttp) => ttp.address)).size;
};
const getSenderAndToken = (particleGroup) => {
    const downedTTPsFromSender = particleGroup
        .transferrableTokensParticles(atom_1.Spin.DOWN)
        .map((sp) => sp.particle);
    if (uniqueAddressCountTTPs(downedTTPsFromSender) !== 1)
        return neverthrow_1.err(new Error('Incorrect number of senders.'));
    const downedParticleFromSender = downedTTPsFromSender[0];
    return neverthrow_1.ok({
        particleGroup: particleGroup,
        from: downedParticleFromSender.address,
        tokenDefinition: downedParticleFromSender,
    });
};
const doesPGContainUnallocatedTokensParticleWithSpinUp = (input) => input.particleGroup
    .unallocatedTokensParticles(atom_1.Spin.UP)
    .some((upP) => upP.particle.resourceIdentifier.equals(input.tokenDefinition.resourceIdentifier));
const validateNotIsTransferNotBurn = (input) => doesPGContainUnallocatedTokensParticleWithSpinUp(input)
    ? neverthrow_1.err(new Error('Action seems to be a burn action, which we will omit and not count as a transfer.'))
    : neverthrow_1.ok(input);
const getRecipient = (input) => {
    var _a, _b;
    const sender = input.from;
    const particleGroup = input.particleGroup;
    const upTTPs = particleGroup
        .transferrableTokensParticles(atom_1.Spin.UP)
        .map((sp) => sp.particle);
    const numberOfRecipients = uniqueAddressCountTTPs(upTTPs);
    if (numberOfRecipients < 1 || numberOfRecipients > 2)
        return neverthrow_1.err(new Error('A transfer should have one or two receivers. Unable to parse.'));
    const recipient = (_b = (_a = upTTPs.find((p) => !p.address.equals(sender))) === null || _a === void 0 ? void 0 : _a.address) !== null && _b !== void 0 ? _b : sender;
    return neverthrow_1.ok({ to: recipient, upTTPs });
};
const getRecipientAndAmount = (input) => getRecipient(input).map((toAndTTPWithSpinUp) => {
    const to = toAndTTPWithSpinUp.to;
    const upTTPs = toAndTTPWithSpinUp.upTTPs;
    const upParticleToRecipient = upTTPs.find((p) => p.address.equals(to));
    if (!upParticleToRecipient)
        throw Error('Incorrect implementation, should not happen.');
    return Object.assign(Object.assign({}, input), { to, amount: upParticleToRecipient.amount });
});
const pgToTokenTransfer = (particleGroup) => getSenderAndToken(particleGroup)
    .andThen(validateNotIsTransferNotBurn)
    .andThen(getRecipientAndAmount)
    .map(tokenTransfer_1.executedTokenTransfer);
exports.pgToTokenTransfer = pgToTokenTransfer;
const valuePresent = (value) => {
    return value !== null && value !== undefined;
};
const filterTransfer = (input, transfer) => {
    const actor = input.addressOfActiveAccount;
    return transfer.from.equals(actor) || transfer.to.equals(actor);
};
const syncMapAtomToTokenTransfers = (input) => {
    return input.atom.particleGroups.groups
        .map(exports.pgToTokenTransfer)
        .map((r) => (r.isOk() ? r.value : undefined))
        .filter(valuePresent)
        .filter(filterTransfer.bind(null, input));
};
exports.syncMapAtomToTokenTransfers = syncMapAtomToTokenTransfers;
const makeAtomToTokenTransfersMapper = () => {
    return {
        executedUserActionType: _types_1.ExecutedUserActionType.TOKEN_TRANSFER,
        map: (input) => rxjs_1.from(exports.syncMapAtomToTokenTransfers(input)),
    };
};
exports.makeAtomToTokenTransfersMapper = makeAtomToTokenTransfersMapper;
//# sourceMappingURL=atomToTokenTransfersMapper.js.map