@ledgerhq/coin-multiversx/lib/buildOptimisticOperation.js

Ledger MultiversX Coin integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildOptimisticOperation = void 0;
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const errors_1 = require("@ledgerhq/errors");
const sdk_core_1 = require("@multiversx/sdk-core");
const binary_utils_1 = require("./utils/binary.utils");
const operation_1 = require("@ledgerhq/coin-framework/operation");
function getOptimisticOperationType(transactionMode) {
    switch (transactionMode) {
        case "delegate":
            return "DELEGATE";
        case "unDelegate":
            return "UNDELEGATE";
        case "withdraw":
            return "WITHDRAW_UNBONDED";
        case "claimRewards":
            return "REWARD";
        case "reDelegateRewards":
            return "DELEGATE";
        default:
            return "OUT";
    }
}
function getOptimisticOperationDelegationAmount(transaction) {
    let dataDecoded;
    switch (transaction.mode) {
        case "delegate":
            return transaction.amount;
        case "unDelegate":
            dataDecoded = binary_utils_1.BinaryUtils.base64Decode(transaction.data ?? "");
            return new bignumber_js_1.default(`0x${dataDecoded.split("@")[1]}`);
        default:
            return new bignumber_js_1.default(0);
    }
}
const buildOptimisticOperation = (account, transaction, unsignedTx) => {
    const senders = [account.freshAddress];
    const recipients = [transaction.recipient];
    const { subAccountId, fees } = transaction;
    if (!fees) {
        throw new errors_1.FeeNotLoaded();
    }
    const type = getOptimisticOperationType(transaction.mode);
    const tokenAccount = (subAccountId &&
        account.subAccounts &&
        account.subAccounts.find(ta => ta.id === subAccountId)) ||
        null;
    const value = tokenAccount || (transaction.mode !== "send" && transaction.mode !== "delegate")
        ? fees
        : transaction.amount.plus(transaction.fees || new bignumber_js_1.default(0));
    const delegationAmount = getOptimisticOperationDelegationAmount(transaction);
    const operation = {
        id: (0, operation_1.encodeOperationId)(account.id, "", type),
        hash: "",
        type,
        value,
        fee: fees,
        blockHash: null,
        blockHeight: null,
        senders,
        recipients,
        accountId: account.id,
        transactionSequenceNumber: new bignumber_js_1.default(unsignedTx.nonce),
        date: new Date(),
        extra: {
            amount: delegationAmount,
        },
    };
    const contract = new sdk_core_1.Address(transaction.recipient).isContractAddress()
        ? transaction.recipient
        : undefined;
    if (contract) {
        operation.contract = contract;
    }
    if (tokenAccount && subAccountId) {
        operation.subOperations = [
            {
                id: (0, operation_1.encodeOperationId)(subAccountId, "", "OUT"),
                hash: "",
                type: "OUT",
                value: transaction.amount,
                fee: new bignumber_js_1.default(0),
                blockHash: null,
                blockHeight: null,
                senders,
                recipients,
                accountId: subAccountId,
                date: new Date(),
                extra: {},
            },
        ];
    }
    return operation;
};
exports.buildOptimisticOperation = buildOptimisticOperation;
//# sourceMappingURL=buildOptimisticOperation.js.map