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

package/src/__tests__/index.test.ts

@@ -12,7 +12,7 @@ jest.mock("../types", () => jest.fn());
 jest.mock("../bridge/getTransactionStatus", () => jest.fn());
 jest.mock("../bridge/estimateMaxSpendable", () => jest.fn());
 jest.mock("../bridge/prepareTransaction", () => jest.fn());
-jest.mock("../bridge/createTransaction", () => jest.fn());
+jest.mock("../logic/createTransaction", () => jest.fn());
 jest.mock("../bridge/synchronisation", () => jest.fn());
 jest.mock("../bridge/signOperation", () => jest.fn());
 jest.mock("../bridge/broadcast", () => jest.fn());

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

@@ -0,0 +1,150 @@
+import {
+  createFixtureAccount,
+  createFixtureAccountWithSubAccount,
+  createFixtureTransaction,
+  createFixtureTransactionWithSubAccount,
+} from "../../bridge/bridge.fixture";
+import buildTransaction from "../../logic/buildTransaction";
+import { AptosAPI } from "../../network";
+import { normalizeTransactionOptions } from "../../logic/normalizeTransactionOptions";
+import type { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import type { TransactionOptions } from "../../types";
+
+const generateTransaction = jest.fn(() => "tx");
+
+jest.mock("../../logic/normalizeTransactionOptions", () => ({
+  normalizeTransactionOptions: jest.fn(() => ({
+    maxGasAmount: "100",
+    gasUnitPrice: "200",
+  })),
+}));
+
+jest.mock("../../constants", () => {
+  const originalModules = jest.requireActual("../../constants");
+  return {
+    ...originalModules,
+    DEFAULT_GAS: 100,
+    DEFAULT_GAS_PRICE: 200,
+  };
+});
+
+jest.mock("../../network", () => {
+  return {
+    AptosAPI: function () {
+      return {
+        generateTransaction,
+      };
+    },
+  };
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("buildTransaction Test", () => {
+  it("should return transaction for main account", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+    const aptosClient = new AptosAPI(account.currency.id);
+    const result = await buildTransaction(account, transaction, aptosClient);
+
+    const expected = "tx";
+
+    expect(result).toBe(expected);
+
+    const mockedNormalizeTransactionOptions = jest.mocked(normalizeTransactionOptions);
+
+    expect(mockedNormalizeTransactionOptions).toHaveBeenCalledTimes(1);
+    expect(generateTransaction).toHaveBeenCalledTimes(1);
+
+    const generateTransactionArgs: [string, InputEntryFunctionData, TransactionOptions][] =
+      generateTransaction.mock.calls[0];
+
+    expect(mockedNormalizeTransactionOptions.mock.calls[0][0]).toEqual({
+      maxGasAmount: "0",
+      gasUnitPrice: "0",
+    });
+
+    expect(generateTransactionArgs[0]).toBe("address");
+    expect(generateTransactionArgs[1]).toEqual({
+      function: "0x1::aptos_account::transfer_coins",
+      typeArguments: ["0x1::aptos_coin::AptosCoin"],
+      functionArguments: ["recipient", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+
+  it("should return transaction for token account of type fungible asset", async () => {
+    const account = createFixtureAccountWithSubAccount("fungible_asset");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    const result = await buildTransaction(account, transaction, aptosClient);
+
+    const expected = "tx";
+
+    expect(result).toBe(expected);
+
+    const mockedNormalizeTransactionOptions = jest.mocked(normalizeTransactionOptions);
+
+    expect(mockedNormalizeTransactionOptions).toHaveBeenCalledTimes(1);
+    expect(generateTransaction).toHaveBeenCalledTimes(1);
+
+    const generateTransactionArgs: [string, InputEntryFunctionData, TransactionOptions][] =
+      generateTransaction.mock.calls[0];
+
+    expect(mockedNormalizeTransactionOptions.mock.calls[0][0]).toEqual({
+      maxGasAmount: "0",
+      gasUnitPrice: "0",
+    });
+
+    expect(generateTransactionArgs[0]).toBe("address");
+    expect(generateTransactionArgs[1]).toEqual({
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: ["contract_address", "recipient", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+
+  it("should return transaction for token account of type coin", async () => {
+    const account = createFixtureAccountWithSubAccount("coin");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    const result = await buildTransaction(account, transaction, aptosClient);
+
+    const expected = "tx";
+
+    expect(result).toBe(expected);
+
+    const mockedNormalizeTransactionOptions = jest.mocked(normalizeTransactionOptions);
+
+    expect(mockedNormalizeTransactionOptions).toHaveBeenCalledTimes(1);
+    expect(generateTransaction).toHaveBeenCalledTimes(1);
+
+    const generateTransactionArgs: [string, InputEntryFunctionData, TransactionOptions][] =
+      generateTransaction.mock.calls[0];
+
+    expect(mockedNormalizeTransactionOptions.mock.calls[0][0]).toEqual({
+      maxGasAmount: "0",
+      gasUnitPrice: "0",
+    });
+
+    expect(generateTransactionArgs[0]).toBe("address");
+    expect(generateTransactionArgs[1]).toEqual({
+      function: "0x1::aptos_account::transfer_coins",
+      typeArguments: ["contract_address"],
+      functionArguments: ["recipient", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+
+  it("should throw error if token is not supported", async () => {
+    const account = createFixtureAccountWithSubAccount("not_supported_token_type");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    expect(async () => await buildTransaction(account, transaction, aptosClient)).rejects.toThrow(
+      "Token type not_supported_token_type not supported",
+    );
+  });
+});

package/src/__tests__/logic/calculateAmount.unit.test.ts

@@ -0,0 +1,51 @@
+import BigNumber from "bignumber.js";
+import { calculateAmount } from "../../logic/calculateAmount";
+
+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
+  });
+});

package/src/__tests__/logic/combine.unit.test.ts

@@ -0,0 +1,65 @@
+import { createFixtureAccount } from "../../bridge/bridge.fixture";
+import { Hex, generateSignedTransaction } from "@aptos-labs/ts-sdk";
+import { combine } from "../../logic/combine";
+
+const hexRawTx =
+  "0xfdde1012c0fac1f9a121eb3c8481c90d473df1c4180c070bd4f2549a6d06180400000000000000000200000000000000000000000000000000000000000000000000000000000000010d6170746f735f6163636f756e74087472616e736665720002203f5f0fcc8a909f23806e5efbdc1757e653fcd744de516a7de12b99b8417925c1080a00000000000000400d03000000000064000000000000002c721b6800000000b7";
+
+jest.mock("@aptos-labs/ts-sdk", () => {
+  const originalModule = jest.requireActual("@aptos-labs/ts-sdk");
+  return {
+    ...originalModule,
+    generateSignedTransaction: jest
+      .fn()
+      .mockImplementation(() => Hex.fromHexString(hexRawTx).toUint8Array()),
+  };
+});
+
+describe("combine", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should throws an error when no public key is provided", async () => {
+    const account = createFixtureAccount();
+    const signature = "0x7aa193705193f4";
+
+    expect(() => combine(hexRawTx, signature, account.xpub)).toThrow(
+      "account must have a public key",
+    );
+
+    expect(generateSignedTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should throws an error when no valid hex value is provided for signature", async () => {
+    const account = createFixtureAccount();
+    const signature = "signature";
+
+    expect(() => combine(hexRawTx, signature, account.xpub)).toThrow(
+      "signature must be a valid hex value",
+    );
+
+    expect(generateSignedTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should throws an error when no valid hex value is provided for tx", async () => {
+    const account = createFixtureAccount();
+    const signature = "0x7aa193705193f4";
+
+    expect(() => combine("tx", signature, account.xpub)).toThrow("tx must be a valid hex value");
+
+    expect(generateSignedTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should sign a transaction", async () => {
+    const signature =
+      "0xbcdf10dc816488eca24b108056e2109220542f599caa4d81ac54556d63a777636ded8cafe972f68657bbee176f398cf332030df0f1dc2235f8f3d39456a5b90c";
+    const account = createFixtureAccount();
+    account.xpub = "0xb69a68cc64f7aa193705193f4dd598320a0a74baf7e4b50c9980c5bd60a82390";
+
+    const result = combine(hexRawTx, signature, account.xpub);
+
+    expect(generateSignedTransaction).toHaveBeenCalledTimes(1);
+    expect(result).not.toBe("");
+  });
+});

package/src/__tests__/logic/compareAddress.unit.test.ts

@@ -0,0 +1,27 @@
+import { compareAddress } from "../../logic/getCoinAndAmounts";
+
+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);
+  });
+});

package/src/__tests__/{bridge → logic}/createTransaction.test.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
-import createTransaction from "../../bridge/createTransaction";
+import createTransaction from "../../logic/createTransaction";
 
-jest.mock("../../bridge/logic", () => ({
+jest.mock("../../constants", () => ({
   DEFAULT_GAS: 100,
   DEFAULT_GAS_PRICE: 200,
 }));

package/src/__tests__/logic/getCoinAndAmounts.unit.test.ts

@@ -0,0 +1,195 @@
+import BigNumber from "bignumber.js";
+import { AptosTransaction } from "../../types";
+import { getCoinAndAmounts } from "../../logic/getCoinAndAmounts";
+import {
+  APTOS_ASSET_ID,
+  APTOS_COIN_CHANGE,
+  APTOS_FUNGIBLE_STORE,
+  APTOS_OBJECT_CORE,
+} from "../../constants";
+
+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);
+  });
+});

package/src/__tests__/logic/getFunctionAddress.unit.test.ts

@@ -0,0 +1,33 @@
+import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import { getFunctionAddress } from "../../logic/getFunctionAddress";
+
+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();
+  });
+});