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

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

@@ -13,20 +13,16 @@ const generateTransaction = jest.fn(() => "tx");
 
 jest.mock("../../network/client", () => {
   return {
-    AptosAPI: function () {
-      return {
-        generateTransaction,
-      };
-    },
+    AptosAPI: () => ({
+      generateTransaction,
+    }),
   };
 });
 
-jest.mock("../../bridge/buildTransaction", () => {
-  return function () {
-    return {
-      sequence_number: "789",
-    };
-  };
+jest.mock("../../logic/buildTransaction", () => {
+  return () => ({
+    sequence_number: "789",
+  });
 });
 
 jest.mock("../../network");

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__/{bridge → logic}/buildTransaction.test.ts

@@ -4,23 +4,30 @@ import {
   createFixtureTransaction,
   createFixtureTransactionWithSubAccount,
 } from "../../bridge/bridge.fixture";
-import buildTransaction from "../../bridge/buildTransaction";
+import buildTransaction from "../../logic/buildTransaction";
 import { AptosAPI } from "../../network";
-import { normalizeTransactionOptions } from "../../bridge/logic";
-import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
-import { TransactionOptions } from "../../types";
+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("../../bridge/logic", () => ({
+jest.mock("../../logic/normalizeTransactionOptions", () => ({
   normalizeTransactionOptions: jest.fn(() => ({
     maxGasAmount: "100",
     gasUnitPrice: "200",
   })),
-  DEFAULT_GAS: 100,
-  DEFAULT_GAS_PRICE: 200,
 }));
 
+jest.mock("../../constants", () => {
+  const originalModules = jest.requireActual("../../constants");
+  return {
+    ...originalModules,
+    DEFAULT_GAS: 100,
+    DEFAULT_GAS_PRICE: 200,
+  };
+});
+
 jest.mock("../../network", () => {
   return {
     AptosAPI: function () {

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,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import createTransaction from "../../bridge/createTransaction";
+import createTransaction from "../../logic/createTransaction";
 
 jest.mock("../../constants", () => ({
   DEFAULT_GAS: 100,

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();
+  });
+});

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

@@ -0,0 +1,241 @@
+import { WriteSetChange, Event } from "@aptos-labs/ts-sdk";
+import { AptosTransaction } from "../../types";
+import { getResourceAddress } from "../../logic/getResourceAddress";
+import { APTOS_ASSET_ID, APTOS_COIN_CHANGE, APTOS_FUNGIBLE_STORE } from "../../constants";
+import { getEventCoinAddress, getEventFAAddress } from "../../logic/getCoinAndAmounts";
+
+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);
+  });
+});