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

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

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

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

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

@@ -0,0 +1,15 @@
+import { normalizeAddress } from "../../logic/normalizeAddress";
+
+describe("normalizeAddress", () => {
+  it("should return always 64 bytes address", () => {
+    expect(normalizeAddress("0xfff")).toEqual(
+      "0x0000000000000000000000000000000000000000000000000000000000000fff",
+    );
+  });
+
+  it("should return the same 64 address", () => {
+    expect(
+      normalizeAddress("0x1230000000000000000000000000000000000000000000000000000000000fff"),
+    ).toEqual("0x1230000000000000000000000000000000000000000000000000000000000fff");
+  });
+});

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

@@ -0,0 +1,95 @@
+import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import { processRecipients } from "../../logic/processRecipients";
+import { APTOS_ASSET_ID } from "../../constants";
+import BigNumber from "bignumber.js";
+import { Operation, OperationType } from "@ledgerhq/types-live";
+
+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(
+      "0x0000000000000000000000000000000000000000000000000000000000000013",
+    );
+  });
+
+  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(
+      "0x0000000000000000000000000000000000000000000000000000000000000012",
+    );
+  });
+
+  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(
+      "0x0000000000000000000000000000000000000000000000000000000000000012",
+    );
+  });
+
+  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(
+      "0x0000000000000000000000000000000000000000000000000000000000000013",
+    );
+  });
+});