@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/lib/families/cosmos/synchronisation.unit.test.js

@@ -0,0 +1,660 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 Cosmos_1 = require("./api/Cosmos");
+const synchronisation_1 = require("./synchronisation");
+const jsHelpers = __importStar(require("../../bridge/jsHelpers"));
+jest.mock("./api/Cosmos");
+jest.mock("../../account");
+jest.mock("../../bridge/jsHelpers");
+const infoMock = {
+    currency: {
+        units: [{}, { code: "uatom" }],
+    },
+    address: "address",
+    index: 0,
+};
+const baseAccountInfoMock = {
+    txs: [],
+    delegations: [],
+    unbondings: [],
+    balances: new bignumber_js_1.default(0),
+    accountInfo: { sequence: 0, accountNumber: 0 },
+};
+const baseTxMock = {
+    logs: [],
+    txhash: "2",
+    tx: {
+        auth_info: {
+            signer_infos: [{ sequence: "seq" }],
+            fee: { amount: [{ denom: "uatom", amount: new bignumber_js_1.default(1) }] },
+        },
+    },
+};
+const syncConfig = {};
+function mockAccountInfo(partialMock) {
+    // @ts-expect-error mocked
+    Cosmos_1.CosmosAPI.mockReturnValueOnce({
+        getAccountInfo: jest.fn().mockResolvedValue(Object.assign(Object.assign({}, baseAccountInfoMock), partialMock)),
+    });
+}
+function mockCosmosTx(tx) {
+    return Object.assign({ events: [
+            {
+                type: "withdraw_rewards",
+                attributes: [
+                    {
+                        key: "amount",
+                        value: "10uatom",
+                    },
+                    {
+                        key: "validator",
+                        value: "validatorAddressHehe",
+                    },
+                ],
+            },
+        ], logs: [], txhash: "2", tx: {
+            "@type": "/cosmos.tx.v1beta1.Tx",
+            body: {
+                messages: [
+                    {
+                        "@type": "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                        delegator_address: "address",
+                        validator_address: "validatorAddressHehe",
+                    },
+                ],
+                memo: "Ledger Live",
+                timeout_height: "0",
+                extension_options: [],
+                non_critical_extension_options: [],
+            },
+            auth_info: {
+                signer_infos: [{ sequence: "seq" }],
+                fee: { amount: [{ denom: "uatom", amount: new bignumber_js_1.default(0) }] },
+            },
+        }, code: 0 }, tx);
+}
+describe("getAccountShape", () => {
+    let mergeOpsSpy;
+    beforeEach(() => {
+        // @ts-expect-error mocked
+        Cosmos_1.CosmosAPI.mockClear();
+        mergeOpsSpy = jest
+            .spyOn(jsHelpers, "mergeOps")
+            .mockImplementation((existing, newlyFetched) => [
+            ...existing,
+            ...newlyFetched,
+        ]);
+    });
+    afterEach(() => {
+        mergeOpsSpy.mockReset();
+    });
+    it("should sum up delegations to balance", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            balances: new bignumber_js_1.default(1),
+            delegations: [{ amount: new bignumber_js_1.default(2) }],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.balance).toEqual(new bignumber_js_1.default(3));
+    }));
+    it("should sum up delegation balances and assign it in cosmosResources delegatedBalances", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            delegations: [{ amount: new bignumber_js_1.default(1) }, { amount: new bignumber_js_1.default(2) }],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.cosmosResources.delegatedBalance).toEqual(new bignumber_js_1.default(3));
+    }));
+    it("should sum up unbondings to balance", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            balances: new bignumber_js_1.default(2),
+            unbondings: [{ amount: new bignumber_js_1.default(3) }],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.balance).toEqual(new bignumber_js_1.default(5));
+    }));
+    it("estimate spendable balance correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+        // Shouldn't it be 97 ?
+        mockAccountInfo({
+            balances: new bignumber_js_1.default(100),
+            unbondings: [{ amount: new bignumber_js_1.default(1) }],
+            delegations: [{ amount: new bignumber_js_1.default(2) }],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.spendableBalance).toEqual(new bignumber_js_1.default(100));
+    }));
+    it("should reduce balance to 0 if spendable balance is negative", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            balances: new bignumber_js_1.default(-10),
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.spendableBalance).toEqual(new bignumber_js_1.default(0));
+    }));
+    it("should sum up pendingRewards and insert it in cosmosResources", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            delegations: [
+                {
+                    pendingRewards: new bignumber_js_1.default(1),
+                },
+                {
+                    pendingRewards: new bignumber_js_1.default(2),
+                },
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.cosmosResources.pendingRewardsBalance).toEqual(new bignumber_js_1.default(3));
+    }));
+    it("set spendable balance to 0 if spendable balance is negative in initial account", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({});
+        const account = yield (0, synchronisation_1.getAccountShape)(Object.assign(Object.assign({}, infoMock), { initialAccount: {
+                spendableBalance: new bignumber_js_1.default(-10),
+            } }), syncConfig);
+        expect(account.spendableBalance).toEqual(new bignumber_js_1.default(0));
+    }));
+    it("should estimate operations count correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({});
+        const account = yield (0, synchronisation_1.getAccountShape)(Object.assign(Object.assign({}, infoMock), { initialAccount: {
+                operations: [{}, {}],
+            } }), syncConfig);
+        expect(account.operationsCount).toEqual(2);
+    }));
+    it("should merge old operations with newly fetched ones", () => __awaiter(void 0, void 0, void 0, function* () {
+        const existingOperations = [{ hash: "3", id: "3" }];
+        mockAccountInfo({});
+        yield (0, synchronisation_1.getAccountShape)(Object.assign(Object.assign({}, infoMock), { initialAccount: {
+                operations: existingOperations,
+            } }), syncConfig);
+        expect(mergeOpsSpy.mock.calls[0][0]).toEqual(existingOperations);
+    }));
+    it("should add newly fetched operations", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({ txs: [mockCosmosTx({})] });
+        yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(mergeOpsSpy.mock.calls[0][1]).toBeTruthy();
+    }));
+    it("should get the memo correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({ txs: [mockCosmosTx({})] });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].extra.memo).toEqual("Ledger Live");
+    }));
+    it("should list claim reward operations correctly with one delegation", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    events: [
+                        {
+                            type: "withdraw_rewards",
+                            attributes: [
+                                {
+                                    key: "amount",
+                                    value: "3uatom",
+                                },
+                                {
+                                    key: "validator",
+                                    value: "validatorAddressNumeroUno",
+                                },
+                            ],
+                        },
+                    ],
+                    logs: [],
+                    tx: {
+                        "@type": "/cosmos.tx.v1beta1.Tx",
+                        body: {
+                            messages: [
+                                {
+                                    "@type": "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                                    delegator_address: "address",
+                                    validator_address: "cosmosvaloper1crqm3598z6qmyn2kkcl9dz7uqs4qdqnr6s8jdn",
+                                },
+                            ],
+                            memo: "Ledger Live",
+                            timeout_height: "0",
+                            extension_options: [],
+                            non_critical_extension_options: [],
+                        },
+                        auth_info: {
+                            signer_infos: [{ sequence: "seq" }],
+                            fee: { amount: [{ denom: "uatom", amount: new bignumber_js_1.default(0) }] },
+                        },
+                        signatures: [],
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(3));
+        expect(account.operations[0].extra.validators).toEqual([
+            {
+                address: "validatorAddressNumeroUno",
+                amount: new bignumber_js_1.default(3),
+            },
+        ]);
+    }));
+    it("should list claim reward operations correctly with multiple delegations", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    events: [
+                        {
+                            type: "withdraw_rewards",
+                            attributes: [
+                                {
+                                    key: "amount",
+                                    value: "10uatom",
+                                },
+                                {
+                                    key: "validator",
+                                    value: "validatorAddressHehe",
+                                },
+                            ],
+                        },
+                        {
+                            type: "withdraw_rewards",
+                            attributes: [
+                                {
+                                    key: "amount",
+                                    value: "5uatom",
+                                },
+                                {
+                                    key: "validator",
+                                    value: "validatorAddressTwo",
+                                },
+                            ],
+                        },
+                        {
+                            type: "withdraw_rewards",
+                            attributes: [
+                                {
+                                    key: "amount",
+                                    value: "56ibc/0025F8A87464A471E66B234C4F93AEC5B4DA3D42D7986451A059273426290DD5,512ibc/6B8A3F5C2AD51CD6171FA41A7E8C35AD594AB69226438DB94450436EA57B3A89,7uatom",
+                                },
+                                {
+                                    key: "validator",
+                                    value: "validatorAddressThree",
+                                },
+                            ],
+                        },
+                    ],
+                    tx: {
+                        "@type": "/cosmos.tx.v1beta1.Tx",
+                        body: {
+                            messages: [
+                                {
+                                    "@type": "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                                    delegator_address: "address",
+                                    validator_address: "validatorAddressHehe",
+                                },
+                                {
+                                    "@type": "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                                    delegator_address: "address",
+                                    validator_address: "validatorAddressTwo",
+                                },
+                                {
+                                    "@type": "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                                    delegator_address: "address",
+                                    validator_address: "validatorAddressThree",
+                                },
+                            ],
+                            memo: "Ledger Live",
+                            timeout_height: "0",
+                            extension_options: [],
+                            non_critical_extension_options: [],
+                        },
+                        auth_info: {
+                            signer_infos: [{ sequence: "seq" }],
+                            fee: { amount: [{ denom: "uatom", amount: new bignumber_js_1.default(0) }] },
+                        },
+                        signatures: [],
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(22));
+        expect(account.operations[0].extra.validators).toEqual([
+            {
+                address: "validatorAddressHehe",
+                amount: new bignumber_js_1.default(10),
+            },
+            {
+                address: "validatorAddressTwo",
+                amount: new bignumber_js_1.default(5),
+            },
+            {
+                address: "validatorAddressThree",
+                amount: new bignumber_js_1.default(7),
+            },
+        ]);
+    }));
+    it("should parse an operation correctly when the operation failed)", () => __awaiter(void 0, void 0, void 0, function* () {
+        const failedOperation = mockCosmosTx({
+            tx: {
+                "@type": "/cosmos.tx.v1beta1.Tx",
+                body: {
+                    messages: [
+                        {
+                            "@type": "/cosmos.bank.v1beta1.MsgSend",
+                            from_address: "address",
+                            to_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                            amount: [
+                                {
+                                    denom: "uatom",
+                                    amount: "10000",
+                                },
+                            ],
+                        },
+                    ],
+                    memo: "",
+                    timeout_height: "0",
+                    extension_options: [],
+                    non_critical_extension_options: [],
+                },
+                auth_info: baseTxMock.tx.auth_info,
+            },
+            code: 11,
+        });
+        mockAccountInfo({
+            txs: [failedOperation],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(10001)); // 10000(amount) + 1(fees)
+        expect(account.operations[0].type).toEqual("OUT");
+        expect(account.operations[0].hasFailed).toEqual(true);
+    }));
+    it("should parse an operation correctly with multiple transfers(received operations)", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        "@type": "/cosmos.tx.v1beta1.Tx",
+                        body: {
+                            messages: [
+                                {
+                                    "@type": "/cosmos.bank.v1beta1.MsgSend",
+                                    from_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                                    to_address: "address",
+                                    amount: [
+                                        {
+                                            denom: "uatom",
+                                            amount: "5",
+                                        },
+                                    ],
+                                },
+                                {
+                                    "@type": "/cosmos.bank.v1beta1.MsgSend",
+                                    from_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                                    to_address: "address",
+                                    amount: [
+                                        {
+                                            denom: "uatom",
+                                            amount: "6",
+                                        },
+                                    ],
+                                },
+                            ],
+                            memo: "",
+                            timeout_height: "0",
+                            extension_options: [],
+                            non_critical_extension_options: [],
+                        },
+                        auth_info: baseTxMock.tx.auth_info,
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(11)); // 5 + 6
+        expect(account.operations[0].type).toEqual("IN");
+    }));
+    it("should parse an operation correctly with multiple transfers(sent operations)", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        "@type": "/cosmos.tx.v1beta1.Tx",
+                        body: {
+                            messages: [
+                                {
+                                    "@type": "/cosmos.bank.v1beta1.MsgSend",
+                                    from_address: "address",
+                                    to_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                                    amount: [
+                                        {
+                                            denom: "uatom",
+                                            amount: "5",
+                                        },
+                                    ],
+                                },
+                                {
+                                    "@type": "/cosmos.bank.v1beta1.MsgSend",
+                                    from_address: "address",
+                                    to_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                                    amount: [
+                                        {
+                                            denom: "uatom",
+                                            amount: "6",
+                                        },
+                                    ],
+                                },
+                            ],
+                            memo: "",
+                            timeout_height: "0",
+                            extension_options: [],
+                            non_critical_extension_options: [],
+                        },
+                        auth_info: baseTxMock.tx.auth_info,
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(12)); // 5 + 6 + 1(fees)
+        expect(account.operations[0].type).toEqual("OUT");
+    }));
+    it("should parse an operation correctly with multiple delegations", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        body: {
+                            memo: "memo",
+                            messages: [
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgDelegate",
+                                    delegator_address: "address",
+                                    validator_address: "address1",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "5",
+                                    },
+                                },
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgDelegate",
+                                    delegator_address: "address",
+                                    validator_address: "address2",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "6",
+                                    },
+                                },
+                            ],
+                        },
+                        auth_info: baseTxMock.tx.auth_info,
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(1)); // fees
+        expect(account.operations[0].type).toEqual("DELEGATE");
+        expect(account.operations[0].extra.validators).toEqual([
+            {
+                address: "address1",
+                amount: new bignumber_js_1.default(5),
+            },
+            {
+                address: "address2",
+                amount: new bignumber_js_1.default(6),
+            },
+        ]);
+    }));
+    it("should parse an operation correctly with multiple redelegate", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        body: {
+                            memo: "memo",
+                            messages: [
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+                                    delegator_address: "address",
+                                    validator_src_address: "address_src",
+                                    validator_dst_address: "address1",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "5",
+                                    },
+                                },
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+                                    delegator_address: "address",
+                                    validator_src_address: "address_src",
+                                    validator_dst_address: "address2",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "6",
+                                    },
+                                },
+                            ],
+                        },
+                        auth_info: baseTxMock.tx.auth_info,
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(1)); // fees
+        expect(account.operations[0].type).toEqual("REDELEGATE");
+        expect(account.operations[0].extra.sourceValidator).toEqual("address_src");
+        expect(account.operations[0].extra.validators).toEqual([
+            {
+                address: "address1",
+                amount: new bignumber_js_1.default(5),
+            },
+            {
+                address: "address2",
+                amount: new bignumber_js_1.default(6),
+            },
+        ]);
+    }));
+    it("should parse an operation correctly with multiple unredelegate", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        body: {
+                            memo: "memo",
+                            messages: [
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgUndelegate",
+                                    delegator_address: "address",
+                                    validator_address: "address1",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "5",
+                                    },
+                                },
+                                {
+                                    "@type": "/cosmos.staking.v1beta1.MsgUndelegate",
+                                    delegator_address: "address",
+                                    validator_address: "address2",
+                                    amount: {
+                                        denom: "uatom",
+                                        amount: "6",
+                                    },
+                                },
+                            ],
+                        },
+                        auth_info: baseTxMock.tx.auth_info,
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toEqual(new bignumber_js_1.default(1)); // fees
+        expect(account.operations[0].type).toEqual("UNDELEGATE");
+        expect(account.operations[0].extra.validators).toEqual([
+            {
+                address: "address1",
+                amount: new bignumber_js_1.default(5),
+            },
+            {
+                address: "address2",
+                amount: new bignumber_js_1.default(6),
+            },
+        ]);
+    }));
+    it("should parse an operation correctly with missing auth_info", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockAccountInfo({
+            txs: [
+                mockCosmosTx({
+                    tx: {
+                        body: {
+                            memo: "memo",
+                            messages: [
+                                {
+                                    "@type": "/cosmos.bank.v1beta1.MsgSend",
+                                    from_address: "address",
+                                    to_address: "cosmos1lptvx486j7630632q3ah0dwq20ghdrpxgl8xzg",
+                                    amount: [
+                                        {
+                                            denom: "uatom",
+                                            amount: "5",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                }),
+            ],
+        });
+        const account = yield (0, synchronisation_1.getAccountShape)(infoMock, syncConfig);
+        expect(account.operations[0].value).toBeDefined();
+    }));
+});
+//# sourceMappingURL=synchronisation.unit.test.js.map