@ledgerhq/coin-tezos/lib/bridge/getTransactionStatus.test.js

Tezos Coin integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const getTransactionStatus_1 = require("./getTransactionStatus");
const logic_1 = require("../logic");
const bakers_1 = require("../network/bakers");
const tzkt_1 = __importDefault(require("../network/tzkt"));
const errors_1 = require("@ledgerhq/errors");
jest.mock("../logic", () => ({
    validateRecipient: jest.fn(),
}));
jest.mock("../network/bakers", () => ({
    isAccountDelegating: jest.fn(),
}));
jest.mock("../network/tzkt", () => ({
    getAccountByAddress: jest.fn(),
}));
describe("getTransactionStatus", () => {
    const mockAccount = {
        type: "Account",
        freshAddress: "tz1SourceAddress",
        balance: new bignumber_js_1.default(1000000),
        currency: {
            type: "CryptoCurrency",
            units: [
                {
                    name: "tezos",
                    code: "XTZ",
                    magnitude: 6,
                },
            ],
        },
        tezosResources: {
            revealed: true,
            counter: 0,
        },
    };
    const mockTransaction = {
        family: "tezos",
        mode: "send",
        amount: new bignumber_js_1.default(500000),
        recipient: "tz1RecipientAddress",
        estimatedFees: new bignumber_js_1.default(1000),
        useAllAmount: false,
    };
    beforeEach(() => {
        jest.clearAllMocks();
        logic_1.validateRecipient.mockResolvedValue({
            recipientError: null,
            recipientWarning: null,
        });
        tzkt_1.default.getAccountByAddress.mockResolvedValue({ type: "empty" });
    });
    it("should return an error if the recipient is the same as the source address", async () => {
        const transaction = { ...mockTransaction, recipient: mockAccount.freshAddress };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.errors.recipient).toBeInstanceOf(errors_1.InvalidAddressBecauseDestinationIsAlsoSource);
    });
    it("should return an error if the amount is zero and useAllAmount is false", async () => {
        const transaction = { ...mockTransaction, amount: new bignumber_js_1.default(0) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.errors.amount).toBeInstanceOf(errors_1.AmountRequired);
    });
    it("should return a warning if the fees are too high compared to the amount", async () => {
        const transaction = { ...mockTransaction, amount: new bignumber_js_1.default(1000) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.warnings.feeTooHigh).toBeInstanceOf(errors_1.FeeTooHigh);
    });
    it("should return a warning if the balance after transaction is below the threshold", async () => {
        bakers_1.isAccountDelegating.mockReturnValue(true);
        const transaction = { ...mockTransaction, amount: new bignumber_js_1.default(999000) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.warnings.amount).toBeInstanceOf(errors_1.RecommendUndelegation);
    });
    it("should map taquito errors to appropriate errors", async () => {
        const transaction = { ...mockTransaction, taquitoError: "balance_too_low" };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.errors.amount).toBeInstanceOf(errors_1.NotEnoughBalance);
    });
    it("should return an error if the account balance is zero or less", async () => {
        const account = { ...mockAccount, balance: new bignumber_js_1.default(0) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(account, mockTransaction);
        expect(result.errors.amount).toBeInstanceOf(errors_1.NotEnoughBalance);
    });
    it("should return an error if the account balance is less than the estimated fees for delegation", async () => {
        const transaction = { ...mockTransaction, mode: "delegate" };
        const account = { ...mockAccount, balance: new bignumber_js_1.default(500) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(account, transaction);
        expect(result.errors.amount).toBeInstanceOf(errors_1.NotEnoughBalance);
    });
    it("should return an error if the recipient account is empty and the amount is below the existential deposit", async () => {
        const transaction = { ...mockTransaction, amount: new bignumber_js_1.default(100000) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(mockAccount, transaction);
        expect(result.errors.amount).toBeInstanceOf(errors_1.NotEnoughBalanceBecauseDestinationNotCreated);
    });
    it("should return no errors or warnings for a valid transaction", async () => {
        const account = { ...mockAccount, balance: new bignumber_js_1.default(2000000) };
        const transaction = { ...mockTransaction, amount: new bignumber_js_1.default(500000) };
        const result = await (0, getTransactionStatus_1.getTransactionStatus)(account, transaction);
        expect(result.errors).toEqual({});
        expect(result.warnings).toEqual({});
    });
});
//# sourceMappingURL=getTransactionStatus.test.js.map