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

package/src/__tests__/bridge/logic.test.ts

@@ -1,52 +1,17 @@
-import {
-  EntryFunctionPayloadResponse,
-  Event,
-  InputEntryFunctionData,
-  WriteSetChange,
-} from "@aptos-labs/ts-sdk";
-import type { Operation, OperationType } from "@ledgerhq/types-live";
+import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
 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 type { AptosTransaction, TransactionOptions } from "../../types";
 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);
@@ -183,616 +148,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: InputEntryFunctionData = {
-        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: [],
-      } as InputEntryFunctionData;
-
-      const result = getFunctionAddress(payload);
-      expect(result).toBeUndefined();
-    });
-
-    it("should return undefined when payload is empty", () => {
-      const payload = {} as InputEntryFunctionData;
-
-      const result = getFunctionAddress(payload);
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe("processRecipients", () => {
-    let op: Operation;
-
-    beforeEach(() => {
-      op = {
-        id: "",
-        hash: "",
-        type: "" as OperationType,
-        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: InputEntryFunctionData = {
-        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: InputEntryFunctionData = {
-        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: InputEntryFunctionData = {
-        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: InputEntryFunctionData = {
-        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: InputEntryFunctionData = {
-        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",
-                },
-              },
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x11",
-          creation_number: "2",
-        },
-        type: "0x1::coin::WithdrawEvent",
-      } as Event;
-
-      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",
-                },
-              },
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x11",
-          creation_number: "1",
-        },
-        type: "0x1::coin::WithdrawEvent",
-      } as Event;
-
-      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",
-                },
-              },
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x11",
-          creation_number: "1",
-        },
-        type: "0x1::coin::WithdrawEvent",
-      } as Event;
-
-      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",
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x0",
-          creation_number: "0",
-        },
-        type: "0x1::fungible_asset::Deposit",
-        data: {
-          amount: "100",
-          store: "0xsomeaddress",
-        },
-      } as Event;
-
-      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",
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x0",
-          creation_number: "0",
-        },
-        type: "0x1::fungible_asset::Deposit",
-        data: {
-          amount: "100",
-          store: "0xsomeaddress",
-        },
-      } as Event;
-
-      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",
-            },
-          },
-        },
-      } as unknown as WriteSetChange;
-
-      const tx: AptosTransaction = {
-        hash: "0x123",
-        block: { hash: "0xabc", height: 1 },
-        timestamp: "1000000",
-        sequence_number: "1",
-        version: "1",
-        changes: [change],
-      } as unknown as AptosTransaction;
-
-      const event = {
-        guid: {
-          account_address: "0x0",
-          creation_number: "0",
-        },
-        type: "0x1::fungible_asset::Deposit",
-        data: {
-          amount: "100",
-          store: "0xwrongaddress",
-        },
-      } as Event;
-
-      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",
-                    },
-                  },
-                },
-              },
-            },
-          },
-        ],
-      } as unknown as AptosTransaction;
-
-      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",
-                    },
-                  },
-                },
-              },
-            },
-          },
-        ],
-      } as unknown as AptosTransaction;
-
-      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",
-            },
-          },
-        ],
-      } as unknown as AptosTransaction;
-
-      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";
@@ -876,7 +231,7 @@ describe("Aptos sync logic ", () => {
         blockHash: "0xabc",
         blockHeight: 1,
         senders: ["0x11"],
-        recipients: ["0x12"],
+        recipients: ["0x0000000000000000000000000000000000000000000000000000000000000012"],
         accountId: id,
         date: new Date(1000),
         extra: { version: undefined },
@@ -1075,7 +430,7 @@ describe("Aptos sync logic ", () => {
         blockHash: "0xc496",
         blockHeight: 1,
         senders: ["0xa0d8"],
-        recipients: ["0x4e5e"],
+        recipients: ["0x0000000000000000000000000000000000000000000000000000000000004e5e"],
         accountId: id,
         date: new Date(1000),
         extra: { version: undefined },
@@ -1355,7 +710,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 },
@@ -1373,7 +728,7 @@ describe("Aptos sync logic ", () => {
         blockHash: "0xabc",
         blockHeight: 1,
         senders: ["0xa0d"],
-        recipients: ["0x4e5"],
+        recipients: ["0x00000000000000000000000000000000000000000000000000000000000004e5"],
         date: new Date(1000),
         extra: { version: undefined },
         transactionSequenceNumber: 1,
@@ -1669,7 +1024,7 @@ describe("Aptos sync logic ", () => {
         blockHash: "0xabc",
         blockHeight: 1,
         senders: ["0xa0d8"],
-        recipients: ["0x6b8c"],
+        recipients: ["0x0000000000000000000000000000000000000000000000000000000000006b8c"],
         date: new Date(1000),
         extra: { version: undefined },
         transactionSequenceNumber: 1,