@ledgerhq/coin-aptos 2.0.0 → 2.1.0-next.0

package/lib-es/__tests__/bridge/logic.test.js

@@ -1,20 +1,13 @@
 import BigNumber from "bignumber.js";
-import { APTOS_ASSET_ID, APTOS_COIN_CHANGE, APTOS_FUNGIBLE_STORE, APTOS_OBJECT_CORE, DIRECTION, } from "../../constants";
-import { calculateAmount, compareAddress, getCoinAndAmounts, getFunctionAddress, getResourceAddress, isTestnet, processRecipients, getMaxSendBalance, normalizeTransactionOptions, getBlankOperation, txsToOps, getEventCoinAddress, getEventFAAddress, } from "../../bridge/logic";
+import { APTOS_COIN_CHANGE, DIRECTION } from "../../constants";
+import { getMaxSendBalance, getBlankOperation, txsToOps } from "../../bridge/logic";
 import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 import { decodeTokenAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { normalizeTransactionOptions } from "../../logic/normalizeTransactionOptions";
 jest.mock("@ledgerhq/cryptoassets");
 jest.mock("@ledgerhq/coin-framework/account/index");
 describe("Aptos logic ", () => {
-    describe("isTestnet", () => {
-        it("should return true for testnet currencies", () => {
-            expect(isTestnet("aptos_testnet")).toBe(true);
-        });
-        it("should return false for mainnet currencies", () => {
-            expect(isTestnet("aptos")).toBe(false);
-        });
-    });
     describe("getMaxSendBalance", () => {
         it("should return the correct max send balance when amount is greater than total gas", () => {
             const amount = new BigNumber(1000000);
@@ -136,549 +129,6 @@ describe("Aptos logic ", () => {
     });
 });
 describe("Aptos sync logic ", () => {
-    describe("compareAddress", () => {
-        it("should return true for identical addresses", () => {
-            const addressA = "0x1234567890abcdef";
-            const addressB = "0x1234567890abcdef";
-            expect(compareAddress(addressA, addressB)).toBe(true);
-        });
-        it("should return true for addresses with different cases", () => {
-            const addressA = "0x1234567890abcdef";
-            const addressB = "0x1234567890ABCDEF";
-            expect(compareAddress(addressA, addressB)).toBe(true);
-        });
-        it("should return true for addresses with different hex formats", () => {
-            const addressA = "0x1234567890abcdef";
-            const addressB = "1234567890abcdef";
-            expect(compareAddress(addressA, addressB)).toBe(true);
-        });
-        it("should return false for different addresses", () => {
-            const addressA = "0x1234567890abcdef";
-            const addressB = "0xfedcba0987654321";
-            expect(compareAddress(addressA, addressB)).toBe(false);
-        });
-    });
-    describe("getFunctionAddress", () => {
-        it("should return the function address when payload contains a function", () => {
-            const payload = {
-                function: "0x1::coin::transfer",
-                typeArguments: [],
-                functionArguments: [],
-            };
-            const result = getFunctionAddress(payload);
-            expect(result).toBe("0x1");
-        });
-        it("should return undefined when payload does not contain a function", () => {
-            const payload = {
-                function: "::::",
-                typeArguments: [],
-                functionArguments: [],
-            };
-            const result = getFunctionAddress(payload);
-            expect(result).toBeUndefined();
-        });
-        it("should return undefined when payload is empty", () => {
-            const payload = {};
-            const result = getFunctionAddress(payload);
-            expect(result).toBeUndefined();
-        });
-    });
-    describe("processRecipients", () => {
-        let op;
-        beforeEach(() => {
-            op = {
-                id: "",
-                hash: "",
-                type: "",
-                value: new BigNumber(0),
-                fee: new BigNumber(0),
-                blockHash: "",
-                blockHeight: 0,
-                senders: [],
-                recipients: [],
-                accountId: "",
-                date: new Date(),
-                extra: {},
-                transactionSequenceNumber: 0,
-                hasFailed: false,
-            };
-        });
-        it("should add recipient for transfer-like functions from LL account", () => {
-            const payload = {
-                function: "0x1::coin::transfer",
-                typeArguments: [],
-                functionArguments: ["0x13", 1], // from: &signer, to: address, amount: u64
-            };
-            processRecipients(payload, "0x13", op, "0x1");
-            expect(op.recipients).toContain("0x13");
-        });
-        it("should add recipient for transfer-like functions from external account", () => {
-            const payload = {
-                function: "0x1::coin::transfer",
-                typeArguments: [],
-                functionArguments: ["0x12", 1], // from: &signer, to: address, amount: u64
-            };
-            processRecipients(payload, "0x13", op, "0x1");
-            expect(op.recipients).toContain("0x12");
-        });
-        it("should add recipients for batch transfer functions", () => {
-            const payload = {
-                function: "0x1::aptos_account::batch_transfer_coins",
-                typeArguments: [APTOS_ASSET_ID],
-                functionArguments: [
-                    ["0x12", "0x13"],
-                    [1, 2],
-                ],
-            };
-            op.senders.push("0x11");
-            processRecipients(payload, "0x12", op, "0x1");
-            expect(op.recipients).toContain("0x12");
-        });
-        it("should add function address as recipient for other smart contracts", () => {
-            const payload = {
-                function: "0x2::other::contract",
-                typeArguments: [],
-                functionArguments: [["0x12"], [1]],
-            };
-            processRecipients(payload, "0x11", op, "0x2");
-            expect(op.recipients).toContain("0x2");
-        });
-        it("should add recipient for fungible assets transfer-like functions", () => {
-            const payload = {
-                function: "0x1::primary_fungible_store::transfer",
-                typeArguments: [],
-                functionArguments: [["0xfff"], "0x13"],
-            };
-            processRecipients(payload, "0x13", op, "0x1");
-            expect(op.recipients).toContain("0x13");
-        });
-    });
-    describe("getResourceAddress", () => {
-        it("should return coin name from the change", () => {
-            const change = {
-                type: "write_resource",
-                data: {
-                    type: APTOS_COIN_CHANGE,
-                    data: {
-                        withdraw_events: {
-                            guid: {
-                                id: {
-                                    addr: "0x11",
-                                    creation_num: "2",
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x11",
-                    creation_number: "2",
-                },
-                type: "0x1::coin::WithdrawEvent",
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
-            expect(result).toEqual(APTOS_ASSET_ID);
-        });
-        it("should return null for not finding the valid coin in change", () => {
-            const change = {
-                type: "write_resource",
-                data: {
-                    type: APTOS_COIN_CHANGE,
-                    data: {
-                        withdraw_events: {
-                            guid: {
-                                id: {
-                                    addr: "0x12",
-                                    creation_num: "2",
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x11",
-                    creation_number: "1",
-                },
-                type: "0x1::coin::WithdrawEvent",
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
-            expect(result).toBe(null);
-        });
-        it("should return null for not finding the event name in change", () => {
-            const change = {
-                type: "write_resource",
-                data: {
-                    type: APTOS_COIN_CHANGE,
-                    data: {
-                        other_events: {
-                            guid: {
-                                id: {
-                                    addr: "0x12",
-                                    creation_num: "2",
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x11",
-                    creation_number: "1",
-                },
-                type: "0x1::coin::WithdrawEvent",
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
-            expect(result).toBe(null);
-        });
-        it("should return fungible asset address", () => {
-            const change = {
-                type: "write_resource",
-                address: "0xsomeaddress",
-                data: {
-                    type: APTOS_FUNGIBLE_STORE,
-                    data: {
-                        metadata: {
-                            inner: "0xassetaddress",
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x0",
-                    creation_number: "0",
-                },
-                type: "0x1::fungible_asset::Deposit",
-                data: {
-                    amount: "100",
-                    store: "0xsomeaddress",
-                },
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
-            expect(result).toEqual("0xassetaddress");
-        });
-        it("should return null address instead of fungible asset when wrong type", () => {
-            const change = {
-                type: "write_resource",
-                address: "0xsomeaddress",
-                data: {
-                    type: APTOS_COIN_CHANGE,
-                    data: {
-                        metadata: {
-                            inner: "0xassetaddress",
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x0",
-                    creation_number: "0",
-                },
-                type: "0x1::fungible_asset::Deposit",
-                data: {
-                    amount: "100",
-                    store: "0xsomeaddress",
-                },
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
-            expect(result).toEqual(null);
-        });
-        it("should return null address instead of fungible asset when wrong event address", () => {
-            const change = {
-                type: "write_resource",
-                address: "0xsomeaddress",
-                data: {
-                    type: APTOS_FUNGIBLE_STORE,
-                    data: {
-                        metadata: {
-                            inner: "0xassetaddress",
-                        },
-                    },
-                },
-            };
-            const tx = {
-                hash: "0x123",
-                block: { hash: "0xabc", height: 1 },
-                timestamp: "1000000",
-                sequence_number: "1",
-                version: "1",
-                changes: [change],
-            };
-            const event = {
-                guid: {
-                    account_address: "0x0",
-                    creation_number: "0",
-                },
-                type: "0x1::fungible_asset::Deposit",
-                data: {
-                    amount: "100",
-                    store: "0xwrongaddress",
-                },
-            };
-            const result = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
-            expect(result).toEqual(null);
-        });
-    });
-    describe("getCoinAndAmounts", () => {
-        it("should calculate the correct legacy coins amounts for withdraw and deposit events", () => {
-            const tx = {
-                events: [
-                    {
-                        type: "0x1::coin::WithdrawEvent",
-                        guid: {
-                            account_address: "0x11",
-                            creation_number: "1",
-                        },
-                        data: {
-                            amount: "100",
-                        },
-                    },
-                    {
-                        type: "0x1::coin::DepositEvent",
-                        guid: {
-                            account_address: "0x11",
-                            creation_number: "2",
-                        },
-                        data: {
-                            amount: "50",
-                        },
-                    },
-                ],
-                changes: [
-                    {
-                        type: "write_resource",
-                        data: {
-                            type: APTOS_COIN_CHANGE,
-                            data: {
-                                withdraw_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x11",
-                                            creation_num: "1",
-                                        },
-                                    },
-                                },
-                                deposit_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x11",
-                                            creation_num: "2",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            };
-            const address = "0x11";
-            const result = getCoinAndAmounts(tx, address);
-            expect(result.amount_in).toEqual(new BigNumber(50));
-            expect(result.amount_out).toEqual(new BigNumber(100));
-            expect(result.coin_id).toEqual(APTOS_ASSET_ID);
-        });
-        it("should calculate the correct fungible asset amounts for withdraw and deposit events", () => {
-            const tx = {
-                events: [
-                    {
-                        type: "0x1::fungible_asset::Withdraw",
-                        guid: {
-                            account_address: "0x11",
-                            creation_number: "1",
-                        },
-                        data: {
-                            amount: "100",
-                            store: "0x22",
-                        },
-                    },
-                    {
-                        type: "0x1::fungible_asset::Deposit",
-                        guid: {
-                            account_address: "0x11",
-                            creation_number: "2",
-                        },
-                        data: {
-                            amount: "50",
-                            store: "0x33",
-                        },
-                    },
-                ],
-                changes: [
-                    {
-                        type: "write_resource",
-                        address: "0x22",
-                        data: {
-                            type: APTOS_FUNGIBLE_STORE,
-                            data: {
-                                metadata: {
-                                    inner: "0x44",
-                                },
-                                transfer_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x11",
-                                            creation_num: "2",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    {
-                        type: "write_resource",
-                        address: "0x22",
-                        data: {
-                            type: APTOS_OBJECT_CORE,
-                            data: {
-                                owner: "0x11",
-                                transfer_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x22",
-                                            creation_num: "2",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    {
-                        type: "write_resource",
-                        data: {
-                            type: APTOS_COIN_CHANGE,
-                            data: {
-                                withdraw_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x11",
-                                            creation_num: "1",
-                                        },
-                                    },
-                                },
-                                deposit_events: {
-                                    guid: {
-                                        id: {
-                                            addr: "0x11",
-                                            creation_num: "2",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            };
-            const address = "0x11";
-            const result = getCoinAndAmounts(tx, address);
-            expect(result.amount_in).toEqual(new BigNumber(0));
-            expect(result.amount_out).toEqual(new BigNumber(100));
-            expect(result.coin_id).toEqual("0x44");
-        });
-        it("should handle transactions with other events", () => {
-            const tx = {
-                events: [
-                    {
-                        type: "0x1::coin::OtherEvent",
-                        guid: {
-                            account_address: "0x11",
-                            creation_number: "1",
-                        },
-                        data: {
-                            amount: "100",
-                        },
-                    },
-                ],
-            };
-            const address = "0x1";
-            const result = getCoinAndAmounts(tx, address);
-            expect(result.amount_in).toEqual(new BigNumber(0));
-            expect(result.amount_out).toEqual(new BigNumber(0));
-            expect(result.coin_id).toEqual(null);
-        });
-    });
-    describe("calculateAmount", () => {
-        it("should calculate the correct amount when the address is the sender", () => {
-            const address = "0x11";
-            const sender = "0x11";
-            const amount_in = new BigNumber(50);
-            const amount_out = new BigNumber(100);
-            const result = calculateAmount(sender, address, amount_in, amount_out);
-            // LL negates the amount for SEND transactions during output
-            expect(result).toEqual(new BigNumber(50)); // -(50 - 100 - 10)
-        });
-        it("should calculate the correct amount when the address is not the sender", () => {
-            const address = "0x11";
-            const sender = "0x12";
-            const amount_in = new BigNumber(100);
-            const amount_out = new BigNumber(50);
-            const result = calculateAmount(sender, address, amount_in, amount_out);
-            expect(result).toEqual(new BigNumber(50)); // 100 - 50
-        });
-        it("should handle transactions with zero amounts", () => {
-            const address = "0x11";
-            const sender = "0x11";
-            const amount_in = new BigNumber(0);
-            const amount_out = new BigNumber(0);
-            const result = calculateAmount(sender, address, amount_in, amount_out);
-            // LL negates the amount for SEND transactions during output
-            expect(result).toEqual(new BigNumber(0)); // -(0 - 0 - 10)
-        });
-        it("should get negative numbers (for send tx with deposit to account)", () => {
-            const address = "0x11";
-            const sender = "0x11";
-            const amount_in = new BigNumber(100);
-            const amount_out = new BigNumber(0);
-            const result = calculateAmount(sender, address, amount_in, amount_out);
-            // LL negates the amount for SEND transactions during output
-            expect(result).toEqual(new BigNumber(100).negated()); // 100 - 10
-        });
-    });
     describe("txsToOps", () => {
         it("should convert Aptos transactions to operations correctly", () => {
             const address = "0x11";
@@ -760,7 +210,7 @@ describe("Aptos sync logic ", () => {
                 blockHash: "0xabc",
                 blockHeight: 1,
                 senders: ["0x11"],
-                recipients: ["0x12"],
+                recipients: ["0x0000000000000000000000000000000000000000000000000000000000000012"],
                 accountId: id,
                 date: new Date(1000),
                 extra: { version: undefined },
@@ -950,7 +400,7 @@ describe("Aptos sync logic ", () => {
                 blockHash: "0xc496",
                 blockHeight: 1,
                 senders: ["0xa0d8"],
-                recipients: ["0x4e5e"],
+                recipients: ["0x0000000000000000000000000000000000000000000000000000000000004e5e"],
                 accountId: id,
                 date: new Date(1000),
                 extra: { version: undefined },
@@ -1224,7 +674,7 @@ describe("Aptos sync logic ", () => {
                 blockHash: "0xabc",
                 blockHeight: 1,
                 senders: ["0xa0d"],
-                recipients: ["0x4e5"],
+                recipients: ["0x00000000000000000000000000000000000000000000000000000000000004e5"],
                 accountId: "token_account_id",
                 date: new Date(1000),
                 extra: { version: undefined },
@@ -1241,7 +691,7 @@ describe("Aptos sync logic ", () => {
                 blockHash: "0xabc",
                 blockHeight: 1,
                 senders: ["0xa0d"],
-                recipients: ["0x4e5"],
+                recipients: ["0x00000000000000000000000000000000000000000000000000000000000004e5"],
                 date: new Date(1000),
                 extra: { version: undefined },
                 transactionSequenceNumber: 1,
@@ -1530,7 +980,7 @@ describe("Aptos sync logic ", () => {
                 blockHash: "0xabc",
                 blockHeight: 1,
                 senders: ["0xa0d8"],
-                recipients: ["0x6b8c"],
+                recipients: ["0x0000000000000000000000000000000000000000000000000000000000006b8c"],
                 date: new Date(1000),
                 extra: { version: undefined },
                 transactionSequenceNumber: 1,