@ledgerhq/coin-casper/lib/bridge/prepareTransaction.test.js

Ledger Casper integration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const bignumber_js_1 = require("bignumber.js");
const prepareTransaction_1 = require("./prepareTransaction");
const fee_1 = require("./bridgeHelpers/fee");
const jsHelpers_1 = require("@ledgerhq/coin-framework/bridge/jsHelpers");
const fixtures_1 = require("../test/fixtures");
// Mock dependencies
jest.mock("./bridgeHelpers/fee", () => ({
    getEstimatedFees: jest.fn(),
}));
jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers", () => ({
    updateTransaction: jest.fn((tx, updates) => ({ ...tx, ...updates })),
}));
describe("prepareTransaction", () => {
    const mockAccount = (0, fixtures_1.createMockAccount)({
        id: "casper:0:testAccount",
        spendableBalance: new bignumber_js_1.BigNumber(10000000),
    });
    const mockTransaction = (0, fixtures_1.createMockTransaction)({
        recipient: "01fedcba0987654321",
        amount: new bignumber_js_1.BigNumber(5000000),
        useAllAmount: false,
        fees: new bignumber_js_1.BigNumber(1000000),
        transferId: "1",
    });
    const mockEstimatedFees = new bignumber_js_1.BigNumber(1000000);
    beforeEach(() => {
        jest.clearAllMocks();
        fee_1.getEstimatedFees.mockReturnValue(mockEstimatedFees);
    });
    test("should prepare a regular transaction with estimated fees", async () => {
        const result = await (0, prepareTransaction_1.prepareTransaction)(mockAccount, mockTransaction);
        expect(fee_1.getEstimatedFees).toHaveBeenCalled();
        expect(jsHelpers_1.updateTransaction).toHaveBeenCalledWith(mockTransaction, {
            fees: mockEstimatedFees,
            amount: mockTransaction.amount,
        });
        expect(result).toEqual({
            ...mockTransaction,
            fees: mockEstimatedFees,
        });
    });
    test("should calculate correct amount for useAllAmount transactions", async () => {
        const useAllAmountTx = (0, fixtures_1.createMockTransaction)({
            ...mockTransaction,
            useAllAmount: true,
        });
        const result = await (0, prepareTransaction_1.prepareTransaction)(mockAccount, useAllAmountTx);
        const expectedAmount = mockAccount.spendableBalance.minus(mockEstimatedFees);
        expect(jsHelpers_1.updateTransaction).toHaveBeenCalledWith(useAllAmountTx, {
            fees: mockEstimatedFees,
            amount: expectedAmount,
        });
        expect(result).toEqual({
            ...useAllAmountTx,
            fees: mockEstimatedFees,
            amount: expectedAmount,
        });
    });
    test("should recalculate amount for useAllAmount transactions after fee update", async () => {
        const useAllAmountTx = (0, fixtures_1.createMockTransaction)({
            ...mockTransaction,
            useAllAmount: true,
        });
        const result = await (0, prepareTransaction_1.prepareTransaction)(mockAccount, useAllAmountTx);
        const expectedAmount = mockAccount.spendableBalance.minus(mockEstimatedFees);
        expect(result.amount).toEqual(expectedAmount);
    });
    // Using parameterized testing with fixtures
    describe("with test case fixtures", () => {
        // Define test cases inline for controlled fee values
        test.each([
            {
                name: "Standard transaction",
                account: (0, fixtures_1.createMockAccount)({
                    spendableBalance: new bignumber_js_1.BigNumber("10000000000"),
                }),
                transaction: (0, fixtures_1.createMockTransaction)({
                    amount: new bignumber_js_1.BigNumber("1000000000"),
                    useAllAmount: false,
                }),
                expectedResult: {
                    fees: mockEstimatedFees,
                    amount: new bignumber_js_1.BigNumber("1000000000"),
                },
            },
            {
                name: "Use all amount transaction",
                account: (0, fixtures_1.createMockAccount)({
                    spendableBalance: new bignumber_js_1.BigNumber("10000000000"),
                }),
                transaction: (0, fixtures_1.createMockTransaction)({
                    useAllAmount: true,
                }),
                expectedResult: {
                    fees: mockEstimatedFees,
                    amount: new bignumber_js_1.BigNumber("10000000000").minus(mockEstimatedFees),
                },
            },
            {
                name: "Low balance account",
                account: (0, fixtures_1.createMockAccount)({
                    spendableBalance: new bignumber_js_1.BigNumber(mockEstimatedFees.div(2)),
                }),
                transaction: (0, fixtures_1.createMockTransaction)({
                    useAllAmount: true,
                }),
                expectedResult: {
                    fees: mockEstimatedFees,
                    // For low balance, amount should be negative (will be handled in the test)
                    amount: new bignumber_js_1.BigNumber(mockEstimatedFees.div(2)).minus(mockEstimatedFees),
                },
            },
            {
                name: "Exactly enough for fees",
                account: (0, fixtures_1.createMockAccount)({
                    spendableBalance: mockEstimatedFees,
                }),
                transaction: (0, fixtures_1.createMockTransaction)({
                    useAllAmount: true,
                }),
                expectedResult: {
                    fees: mockEstimatedFees,
                    // For exact fee balance, amount should be zero
                    amount: new bignumber_js_1.BigNumber("0"),
                },
            },
            {
                name: "Custom fee override",
                account: (0, fixtures_1.createMockAccount)({
                    spendableBalance: new bignumber_js_1.BigNumber("10000000000"),
                }),
                transaction: (0, fixtures_1.createMockTransaction)({
                    fees: new bignumber_js_1.BigNumber("2000000"),
                    useAllAmount: true,
                }),
                expectedResult: {
                    fees: mockEstimatedFees,
                    amount: new bignumber_js_1.BigNumber("10000000000").minus(mockEstimatedFees),
                },
            },
        ])("$name", async ({ account, transaction, expectedResult }) => {
            const result = await (0, prepareTransaction_1.prepareTransaction)(account, transaction);
            expect(result.fees).toEqual(expectedResult.fees);
            // For negative balance scenarios, just check they're less than or equal to zero
            if (account.spendableBalance.lt(mockEstimatedFees) && transaction.useAllAmount) {
                expect(result.amount.lte(new bignumber_js_1.BigNumber("0"))).toBe(true);
            }
            else if (account.spendableBalance.eq(mockEstimatedFees) && transaction.useAllAmount) {
                expect(result.amount.eq(new bignumber_js_1.BigNumber("0"))).toBe(true);
            }
            else {
                expect(result.amount).toEqual(expectedResult.amount);
            }
        });
    });
});
//# sourceMappingURL=prepareTransaction.test.js.map