@ledgerhq/coin-vechain 2.9.1-nightly.0 → 2.10.0-nightly.2

package/src/common-logic/fixPrefixCase.test.ts

@@ -0,0 +1,51 @@
+import { fixPrefixCase } from "./fixPrefixCase";
+
+describe("fixPrefixCase", () => {
+  it("should convert uppercase 0X prefix to lowercase 0x", () => {
+    const input = "0X1234567890abcdef";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x1234567890abcdef");
+  });
+
+  it("should keep lowercase 0x prefix unchanged", () => {
+    const input = "0x1234567890abcdef";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x1234567890abcdef");
+  });
+
+  it("should add 0x prefix when missing", () => {
+    const input = "1234567890abcdef";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x1234567890abcdef");
+  });
+
+  it("should handle empty string by adding 0x prefix", () => {
+    const input = "";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x");
+  });
+
+  it("should handle mixed case prefix 0X", () => {
+    const input = "0X123abc";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x123abc");
+  });
+
+  it("should handle string starting with just 0 by adding x", () => {
+    const input = "01234";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x01234");
+  });
+
+  it("should handle valid ethereum address", () => {
+    const input = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4");
+  });
+
+  it("should handle address without prefix", () => {
+    const input = "742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const result = fixPrefixCase(input);
+    expect(result).toBe("0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4");
+  });
+});

package/src/common-logic/fixPrefixCase.ts

@@ -0,0 +1,5 @@
+const PREFIX_REGEX = /^0[xX]/;
+
+export const fixPrefixCase = (hex: string): string => {
+  return PREFIX_REGEX.test(hex) ? hex.replace(PREFIX_REGEX, "0x") : `${"0x"}${hex}`;
+};

package/src/common-logic/generateNonce.test.ts

@@ -0,0 +1,72 @@
+import { generateNonce } from "./generateNonce";
+import { Hex } from "@vechain/sdk-core";
+
+// Mock the Hex.random method
+jest.mock("@vechain/sdk-core", () => ({
+  Hex: {
+    random: jest.fn(),
+  },
+}));
+
+const mockedHex = jest.mocked(Hex);
+
+describe("generateNonce", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should generate a nonce using Hex.random with length 8", () => {
+    const mockHexValue = {
+      toString: jest.fn().mockReturnValue("0x1234567890abcdef"),
+    };
+    mockedHex.random.mockReturnValue(mockHexValue as any);
+
+    const result = generateNonce();
+
+    expect(mockedHex.random).toHaveBeenCalledWith(8);
+    expect(mockHexValue.toString).toHaveBeenCalled();
+    expect(result).toBe("0x1234567890abcdef");
+  });
+
+  it("should return a string", () => {
+    const mockHexValue = {
+      toString: jest.fn().mockReturnValue("0xabcdef1234567890"),
+    };
+    mockedHex.random.mockReturnValue(mockHexValue as any);
+
+    const result = generateNonce();
+
+    expect(typeof result).toBe("string");
+  });
+
+  it("should call toString on the hex value", () => {
+    const mockHexValue = {
+      toString: jest.fn().mockReturnValue("0x123456789abcdef0"),
+    };
+    mockedHex.random.mockReturnValue(mockHexValue as any);
+
+    generateNonce();
+
+    expect(mockHexValue.toString).toHaveBeenCalledTimes(1);
+  });
+
+  it("should handle different hex values", () => {
+    const testCases = [
+      "0x0000000000000000",
+      "0xffffffffffffffff",
+      "0x123456789abcdef0",
+      "0xa1b2c3d4e5f67890",
+    ];
+
+    testCases.forEach(expectedValue => {
+      const mockHexValue = {
+        toString: jest.fn().mockReturnValue(expectedValue),
+      };
+      mockedHex.random.mockReturnValue(mockHexValue as any);
+
+      const result = generateNonce();
+
+      expect(result).toBe(expectedValue);
+    });
+  });
+});

package/src/common-logic/generateNonce.ts

@@ -0,0 +1,9 @@
+import { Hex } from "@vechain/sdk-core";
+
+/**
+ * Generate a Unique ID to be used as a nonce
+ * @returns a unique string
+ */
+export const generateNonce = (): string => {
+  return Hex.random(8).toString();
+};

package/src/common-logic/getThorClient.test.ts

@@ -0,0 +1,66 @@
+import { getThorClient } from "./getThorClient";
+import { ThorClient } from "@vechain/sdk-network";
+import { VECHAIN_NODE_URL } from "../constants";
+
+// Mock the ThorClient
+jest.mock("@vechain/sdk-network", () => ({
+  ThorClient: {
+    at: jest.fn(),
+  },
+}));
+
+// Mock the constants
+jest.mock("../constants", () => ({
+  VECHAIN_NODE_URL: "https://testnet.veblocks.net",
+}));
+
+const mockedThorClient = jest.mocked(ThorClient);
+
+describe("getThorClient", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should create a ThorClient instance with VECHAIN_NODE_URL", () => {
+    const mockClient = {
+      /* mock ThorClient properties */
+    };
+    mockedThorClient.at.mockReturnValue(mockClient as any);
+
+    const result = getThorClient();
+
+    expect(mockedThorClient.at).toHaveBeenCalledWith(VECHAIN_NODE_URL);
+    expect(result).toBe(mockClient);
+  });
+
+  it("should return the same type of object from ThorClient.at", () => {
+    const mockClient = {
+      test: "thorClient",
+      transactions: {},
+      gas: {},
+    };
+    mockedThorClient.at.mockReturnValue(mockClient as any);
+
+    const result = getThorClient();
+
+    expect(result).toEqual(mockClient);
+  });
+
+  it("should call ThorClient.at exactly once", () => {
+    const mockClient = {};
+    mockedThorClient.at.mockReturnValue(mockClient as any);
+
+    getThorClient();
+
+    expect(mockedThorClient.at).toHaveBeenCalledTimes(1);
+  });
+
+  it("should use the correct URL from constants", () => {
+    const mockClient = {};
+    mockedThorClient.at.mockReturnValue(mockClient as any);
+
+    getThorClient();
+
+    expect(mockedThorClient.at).toHaveBeenCalledWith("https://testnet.veblocks.net");
+  });
+});

package/src/common-logic/getThorClient.ts

@@ -0,0 +1,10 @@
+import { ThorClient } from "@vechain/sdk-network";
+import { VECHAIN_NODE_URL } from "../constants";
+
+/**
+ * Returns a ThorClient instance configured with the VeChain node URL
+ * @returns {ThorClient} Configured ThorClient instance for interacting with the VeChain network
+ */
+export const getThorClient = (): ThorClient => {
+  return ThorClient.at(VECHAIN_NODE_URL);
+};

package/src/common-logic/index.ts

@@ -1,6 +1,8 @@
-export * from "./address-utils";
-export * from "./hex-utils";
-export * from "./logic";
-export * from "./mapping-utils";
-export * from "./pad-address";
-export * from "./transaction-utils";
+export * from "./fixPrefixCase";
+export * from "./calculateClauses";
+export * from "./mapTransfersToOperations";
+export * from "./padAddress";
+export * from "./calculateTransactionInfo";
+export * from "./calculateGasFees";
+export * from "./generateNonce";
+export * from "./parseAddress";

package/src/common-logic/mapTransfersToOperations.test.ts

@@ -0,0 +1,342 @@
+import BigNumber from "bignumber.js";
+import { TransferLog, EventLog } from "../types";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+
+// Mock dependencies before importing the function under test
+jest.mock("../network", () => ({
+  getFees: jest.fn(),
+}));
+jest.mock("@ledgerhq/coin-framework/operation", () => ({
+  encodeOperationId: jest.fn(),
+}));
+jest.mock("@vechain/sdk-core", () => ({
+  ABIEvent: {
+    parseLog: jest.fn(),
+  },
+  Hex: {
+    of: jest.fn(),
+  },
+  VIP180_ABI: {},
+}));
+
+// Import the functions under test after mocking
+import {
+  mapVetTransfersToOperations,
+  mapTokenTransfersToOperations,
+} from "./mapTransfersToOperations";
+import { getFees } from "../network";
+
+const { ABIEvent, Hex, VIP180_ABI } = jest.requireMock("@vechain/sdk-core");
+
+const mockedGetFees = jest.mocked(getFees);
+const mockedEncodeOperationId = jest.mocked(encodeOperationId);
+const mockedABIEvent = ABIEvent;
+const mockedHex = Hex;
+
+describe("mapVetTransfersToOperations", () => {
+  const mockAccountId = "vechain:1:0x123:";
+  const mockAddr = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+
+  const mockTransferLogs: TransferLog[] = [
+    {
+      sender: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+      recipient: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+      amount: "1000000000000000000",
+      meta: {
+        blockID: "0xblock123",
+        blockNumber: 12345,
+        blockTimestamp: 1640995200,
+        txID: "0xtx123",
+        txOrigin: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+        clauseIndex: 0,
+      },
+    },
+    {
+      sender: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+      recipient: "0x456789012345678901234567890123456789abcd",
+      amount: "2000000000000000000",
+      meta: {
+        blockID: "0xblock456",
+        blockNumber: 12346,
+        blockTimestamp: 1640995260,
+        txID: "0xtx456",
+        txOrigin: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+        clauseIndex: 0,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGetFees.mockResolvedValue(new BigNumber("21000000000000000"));
+    mockedEncodeOperationId.mockImplementation(
+      (accountId, hash, type) => `${accountId}${hash}${type}`,
+    );
+  });
+
+  it("should map incoming VET transfers to operations", async () => {
+    const result = await mapVetTransfersToOperations(
+      [mockTransferLogs[0]],
+      mockAccountId,
+      mockAddr,
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      id: `${mockAccountId}0xtx123IN`,
+      hash: "0xtx123",
+      type: "IN",
+      value: new BigNumber("1000000000000000000"),
+      fee: new BigNumber("21000000000000000"),
+      senders: ["0x5034aa590125b64023a0262112b98d72e3c8e40e"],
+      recipients: ["0x742d35cc6634c0532925a3b8d0b251d8c1743ec4"],
+      blockHeight: 12345,
+      blockHash: "0xblock123",
+      accountId: mockAccountId,
+      date: new Date(1640995200 * 1000),
+      extra: {},
+    });
+  });
+
+  it("should map outgoing VET transfers to operations", async () => {
+    const result = await mapVetTransfersToOperations(
+      [mockTransferLogs[1]],
+      mockAccountId,
+      mockAddr,
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      id: `${mockAccountId}0xtx456OUT`,
+      hash: "0xtx456",
+      type: "OUT",
+      value: new BigNumber("2000000000000000000"),
+      fee: new BigNumber("21000000000000000"),
+      senders: ["0x742d35cc6634c0532925a3b8d0b251d8c1743ec4"],
+      recipients: ["0x456789012345678901234567890123456789abcd"],
+      blockHeight: 12346,
+      blockHash: "0xblock456",
+      accountId: mockAccountId,
+      date: new Date(1640995260 * 1000),
+      extra: {},
+    });
+  });
+
+  it("should handle multiple transfers", async () => {
+    const result = await mapVetTransfersToOperations(mockTransferLogs, mockAccountId, mockAddr);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].type).toBe("IN");
+    expect(result[1].type).toBe("OUT");
+  });
+
+  it("should call getFees for each transfer", async () => {
+    await mapVetTransfersToOperations(mockTransferLogs, mockAccountId, mockAddr);
+
+    expect(mockedGetFees).toHaveBeenCalledTimes(2);
+    expect(mockedGetFees).toHaveBeenCalledWith("0xtx123");
+    expect(mockedGetFees).toHaveBeenCalledWith("0xtx456");
+  });
+
+  it("should handle case-insensitive address comparison", async () => {
+    const upperCaseAddr = mockAddr.toUpperCase();
+    const transferWithUpperCase: TransferLog = {
+      ...mockTransferLogs[0],
+      recipient: upperCaseAddr,
+    };
+
+    const result = await mapVetTransfersToOperations(
+      [transferWithUpperCase],
+      mockAccountId,
+      mockAddr,
+    );
+
+    expect(result[0].type).toBe("IN");
+  });
+
+  it("should convert addresses to lowercase in the operation", async () => {
+    const transferWithMixedCase: TransferLog = {
+      ...mockTransferLogs[0],
+      sender: "0x5034AA590125B64023A0262112B98D72E3C8E40E",
+      recipient: "0x742D35CC6634C0532925A3B8D0B251D8C1743EC4",
+    };
+
+    const result = await mapVetTransfersToOperations(
+      [transferWithMixedCase],
+      mockAccountId,
+      mockAddr,
+    );
+
+    expect(result[0].senders[0]).toBe("0x5034aa590125b64023a0262112b98d72e3c8e40e");
+    expect(result[0].recipients[0]).toBe("0x742d35cc6634c0532925a3b8d0b251d8c1743ec4");
+  });
+});
+
+describe("mapTokenTransfersToOperations", () => {
+  const mockAccountId = "vechain:1:0x123:";
+  const mockAddr = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+
+  const mockEventLogs: EventLog[] = [
+    {
+      address: "0x0000000000000000000000000000456e65726779",
+      topics: [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x0000000000000000000000005034aa590125b64023a0262112b98d72e3c8e40e",
+        "0x000000000000000000000000742d35cc6634c0532925a3b8d0b251d8c1743ec4",
+      ],
+      data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+      meta: {
+        blockID: "0xblock789",
+        blockNumber: 12347,
+        blockTimestamp: 1640995320,
+        txID: "0xtx789",
+        txOrigin: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+        clauseIndex: 0,
+      },
+    },
+  ];
+
+  const mockDecodedEvent = {
+    eventName: "Transfer" as const,
+    args: {
+      from: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+      to: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+      value: BigInt("1000000000000000000"),
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGetFees.mockResolvedValue(new BigNumber("37000000000000000"));
+    mockedEncodeOperationId.mockImplementation(
+      (accountId, hash, type) => `${accountId}${hash}${type}`,
+    );
+    mockedHex.of.mockImplementation((exp: any) => ({ toString: () => exp.toString() }) as any);
+    mockedABIEvent.parseLog.mockReturnValue(mockDecodedEvent);
+  });
+
+  it("should map incoming token transfers to operations", async () => {
+    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      id: `${mockAccountId}0xtx789IN`,
+      hash: "0xtx789",
+      type: "IN",
+      value: new BigNumber("1000000000000000000"),
+      fee: new BigNumber("37000000000000000"),
+      senders: ["0x5034aa590125b64023a0262112b98d72e3c8e40e"],
+      recipients: ["0x742d35cc6634c0532925a3b8d0b251d8c1743ec4"],
+      blockHeight: 12347,
+      blockHash: "0xblock789",
+      accountId: mockAccountId,
+      date: new Date(1640995320 * 1000),
+      extra: {},
+    });
+  });
+
+  it("should map outgoing token transfers to operations", async () => {
+    const outgoingEvent = {
+      eventName: "Transfer" as const,
+      args: {
+        from: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+        to: "0x456789012345678901234567890123456789abcd",
+        value: BigInt("2000000000000000000"),
+      },
+    };
+    mockedABIEvent.parseLog.mockReturnValue(outgoingEvent);
+
+    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(result[0].type).toBe("OUT");
+    expect(result[0].value).toEqual(new BigNumber("2000000000000000000"));
+  });
+
+  it("should decode event logs correctly", async () => {
+    await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].data);
+    expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].topics[0]);
+    expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].topics[1]);
+    expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].topics[2]);
+
+    expect(mockedABIEvent.parseLog).toHaveBeenCalledWith(
+      VIP180_ABI,
+      expect.objectContaining({
+        data: expect.anything(),
+        topics: expect.any(Array),
+      }),
+    );
+  });
+
+  it("should handle bigint values correctly", async () => {
+    const largeValueEvent = {
+      eventName: "Transfer" as const,
+      args: {
+        from: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+        to: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+        value: BigInt("123456789012345678901234567890"),
+      },
+    };
+    mockedABIEvent.parseLog.mockReturnValue(largeValueEvent);
+
+    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(result[0].value).toEqual(new BigNumber("123456789012345678901234567890"));
+  });
+
+  it("should call getFees for each event", async () => {
+    await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(mockedGetFees).toHaveBeenCalledTimes(1);
+    expect(mockedGetFees).toHaveBeenCalledWith("0xtx789");
+  });
+
+  it("should handle multiple events", async () => {
+    const multipleEvents = [
+      mockEventLogs[0],
+      {
+        ...mockEventLogs[0],
+        meta: { ...mockEventLogs[0].meta, txID: "0xtx790" },
+      },
+    ];
+
+    await mapTokenTransfersToOperations(multipleEvents, mockAccountId, mockAddr);
+
+    expect(mockedGetFees).toHaveBeenCalledTimes(2);
+    expect(mockedABIEvent.parseLog).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle case-insensitive address comparison for tokens", async () => {
+    const upperCaseEvent = {
+      eventName: "Transfer" as const,
+      args: {
+        from: "0x5034aa590125b64023a0262112b98d72e3c8e40e",
+        to: mockAddr.toUpperCase(),
+        value: BigInt("1000000000000000000"),
+      },
+    };
+    mockedABIEvent.parseLog.mockReturnValue(upperCaseEvent);
+
+    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(result[0].type).toBe("IN");
+  });
+
+  it("should convert token addresses to lowercase", async () => {
+    const mixedCaseEvent = {
+      eventName: "Transfer" as const,
+      args: {
+        from: "0x5034AA590125B64023A0262112B98D72E3C8E40E",
+        to: "0x742D35CC6634C0532925A3B8D0B251D8C1743EC4",
+        value: BigInt("1000000000000000000"),
+      },
+    };
+    mockedABIEvent.parseLog.mockReturnValue(mixedCaseEvent);
+
+    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+
+    expect(result[0].senders[0]).toBe("0x5034aa590125b64023a0262112b98d72e3c8e40e");
+    expect(result[0].recipients[0]).toBe("0x742d35cc6634c0532925a3b8d0b251d8c1743ec4");
+  });
+});

package/src/common-logic/mapTransfersToOperations.ts

@@ -0,0 +1,77 @@
+import BigNumber from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+import { EventLog, TransferLog } from "../types";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getFees } from "../network";
+import { ABIEvent, Hex, VIP180_ABI } from "@vechain/sdk-core";
+
+export const mapVetTransfersToOperations = async (
+  txs: TransferLog[],
+  accountId: string,
+  addr: string,
+): Promise<Operation[]> => {
+  return Promise.all(
+    txs.map(async tx => {
+      const fees = await getFees(tx.meta.txID);
+      return {
+        id: encodeOperationId(
+          accountId,
+          tx.meta.txID,
+          tx.recipient.toLowerCase() === addr.toLowerCase() ? "IN" : "OUT",
+        ),
+        hash: tx.meta.txID,
+        type: tx.recipient.toLowerCase() === addr.toLowerCase() ? "IN" : "OUT",
+        value: new BigNumber(tx.amount),
+        fee: new BigNumber(fees),
+        senders: [tx.sender.toLowerCase()],
+        recipients: [tx.recipient.toLowerCase()],
+        blockHeight: tx.meta.blockNumber,
+        blockHash: tx.meta.blockID,
+        accountId,
+        date: new Date(tx.meta.blockTimestamp * 1000),
+        extra: {},
+      };
+    }),
+  );
+};
+
+export const mapTokenTransfersToOperations = async (
+  events: EventLog[],
+  accountId: string,
+  addr: string,
+): Promise<Operation[]> => {
+  return Promise.all(
+    events.map(async event => {
+      const decoded = ABIEvent.parseLog(VIP180_ABI, {
+        data: Hex.of(event.data),
+        topics: event.topics.map(topic => Hex.of(topic)),
+      }) as {
+        eventName: "Transfer";
+        args: {
+          from: string;
+          to: string;
+          value: bigint;
+        };
+      };
+      const from = decoded.args.from;
+      const to = decoded.args.to;
+      const value = decoded.args.value;
+      const type = to.toLowerCase() === addr.toLowerCase() ? "IN" : "OUT";
+      const fees = await getFees(event.meta.txID);
+      return {
+        id: encodeOperationId(accountId, event.meta.txID, type),
+        hash: event.meta.txID,
+        type,
+        value: new BigNumber(value.toString()),
+        fee: fees,
+        senders: [from.toLowerCase()],
+        recipients: [to.toLowerCase()],
+        blockHeight: event.meta.blockNumber,
+        blockHash: event.meta.blockID,
+        accountId,
+        date: new Date(event.meta.blockTimestamp * 1000),
+        extra: {},
+      };
+    }),
+  );
+};