@ledgerhq/coin-vechain 2.9.1 → 2.9.2-nightly.0

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

@@ -0,0 +1,65 @@
+import { padAddress } from "./padAddress";
+
+describe("padAddress", () => {
+  it("should pad a short address to 64 characters after 0x", () => {
+    const input = "0x123";
+    const result = padAddress(input);
+    expect(result).toBe("0x0000000000000000000000000000000000000000000000000000000000000123");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should not modify an already properly padded address", () => {
+    const input = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4000000000000000000000000";
+    const result = padAddress(input);
+    expect(result).toBe(input);
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should pad a normal ethereum address to 64 characters", () => {
+    const input = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const result = padAddress(input);
+    expect(result).toBe("0x000000000000000000000000742d35Cc6634C0532925a3b8D0B251d8c1743eC4");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should handle address with only one character after 0x", () => {
+    const input = "0xa";
+    const result = padAddress(input);
+    expect(result).toBe("0x000000000000000000000000000000000000000000000000000000000000000a");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should handle empty address after 0x", () => {
+    const input = "0x";
+    const result = padAddress(input);
+    expect(result).toBe("0x0000000000000000000000000000000000000000000000000000000000000000");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should pad address with mixed case hex characters", () => {
+    const input = "0xAbCdEf123456";
+    const result = padAddress(input);
+    expect(result).toBe("0x0000000000000000000000000000000000000000000000000000AbCdEf123456");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should handle address that needs only a few padding zeros", () => {
+    const input = "0x123456789012345678901234567890123456789012345678901234567890123";
+    const result = padAddress(input);
+    expect(result).toBe("0x0123456789012345678901234567890123456789012345678901234567890123");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+
+  it("should preserve the 0x prefix", () => {
+    const input = "0x123abc";
+    const result = padAddress(input);
+    expect(result.startsWith("0x")).toBe(true);
+  });
+
+  it("should handle maximum length input (63 chars after 0x)", () => {
+    const input = "0x123456789012345678901234567890123456789012345678901234567890123";
+    const result = padAddress(input);
+    expect(result).toBe("0x0123456789012345678901234567890123456789012345678901234567890123");
+    expect(result.split("x")[1]).toHaveLength(64);
+  });
+});

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

@@ -0,0 +1,130 @@
+import { parseAddress } from "./parseAddress";
+import { Address } from "@vechain/sdk-core";
+import { fixPrefixCase } from "./fixPrefixCase";
+
+// Mock dependencies
+jest.mock("@vechain/sdk-core", () => ({
+  Address: {
+    isValid: jest.fn(),
+  },
+}));
+
+jest.mock("./fixPrefixCase");
+
+const mockedAddress = jest.mocked(Address);
+const mockedFixPrefixCase = jest.mocked(fixPrefixCase);
+
+describe("parseAddress", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return true for a valid address", () => {
+    const inputAddress = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const fixedAddress = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(true);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(true);
+  });
+
+  it("should return false for an invalid address", () => {
+    const inputAddress = "invalid-address";
+    const fixedAddress = "0xinvalid-address";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(false);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(false);
+  });
+
+  it("should handle address without 0x prefix", () => {
+    const inputAddress = "742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const fixedAddress = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(true);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(true);
+  });
+
+  it("should handle address with uppercase 0X prefix", () => {
+    const inputAddress = "0X742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+    const fixedAddress = "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(true);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(true);
+  });
+
+  it("should handle empty string", () => {
+    const inputAddress = "";
+    const fixedAddress = "0x";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(false);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(false);
+  });
+
+  it("should handle short address", () => {
+    const inputAddress = "0x123";
+    const fixedAddress = "0x123";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(false);
+
+    const result = parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+    expect(result).toBe(false);
+  });
+
+  it("should call fixPrefixCase before validation", () => {
+    const inputAddress = "test-address";
+    const fixedAddress = "0xtest-address";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(false);
+
+    parseAddress(inputAddress);
+
+    expect(mockedFixPrefixCase).toHaveBeenCalledWith(inputAddress);
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+  });
+
+  it("should pass the fixed address to Address.isValid", () => {
+    const inputAddress = "some-input";
+    const fixedAddress = "0xsome-input";
+
+    mockedFixPrefixCase.mockReturnValue(fixedAddress);
+    mockedAddress.isValid.mockReturnValue(true);
+
+    parseAddress(inputAddress);
+
+    expect(mockedAddress.isValid).toHaveBeenCalledWith(fixedAddress);
+  });
+});

package/src/common-logic/parseAddress.ts

@@ -0,0 +1,11 @@
+import { Address } from "@vechain/sdk-core";
+import { fixPrefixCase } from "./fixPrefixCase";
+
+/**
+ * Validate the address
+ * @param address - the address to validate
+ * @returns true if the address is valid, false otherwise
+ */
+export const parseAddress = (address: string): boolean => {
+  return Address.isValid(fixPrefixCase(address));
+};

package/src/constants/env.ts

@@ -0,0 +1,3 @@
+import { getEnv } from "@ledgerhq/live-env";
+
+export const VECHAIN_NODE_URL = getEnv("API_VECHAIN_THOREST");

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from "./env";

package/src/network/sdk.ts

@@ -1,21 +1,25 @@
 import BigNumber from "bignumber.js";
-import network from "@ledgerhq/live-network/network";
-import { AccountResponse, VetTxsQuery, TokenTxsQuery, Query, QueryResponse } from "../types";
+import network from "@ledgerhq/live-network";
+import {
+  AccountResponse,
+  VetTxsQuery,
+  TokenTxsQuery,
+  TransferLog,
+  EventLog,
+  VechainSDKTransaction,
+} from "../types";
 import type { Operation } from "@ledgerhq/types-live";
 import {
   mapVetTransfersToOperations,
   mapTokenTransfersToOperations,
   padAddress,
 } from "../common-logic";
-import { TransferEventSignature } from "../contracts/constants";
-import { Transaction } from "thor-devkit";
-import { HEX_PREFIX } from "../types";
 import { getEnv } from "@ledgerhq/live-env";
 
 const BASE_URL = getEnv("API_VECHAIN_THOREST");
 
 export const getAccount = async (address: string): Promise<AccountResponse> => {
-  const { data } = await network({
+  const { data } = await network<AccountResponse>({
     method: "GET",
     url: `${BASE_URL}/accounts/${address}`,
   });
@@ -24,7 +28,7 @@ export const getAccount = async (address: string): Promise<AccountResponse> => {
 };
 
 export const getLastBlockHeight = async (): Promise<number> => {
-  const { data } = await network({
+  const { data } = await network<{ number: number }>({
     method: "GET",
     url: `${BASE_URL}/blocks/best`,
   });
@@ -53,7 +57,7 @@ export const getOperations = async (
     order: "desc",
   };
 
-  const { data } = await network({
+  const { data } = await network<TransferLog[]>({
     method: "POST",
     url: `${BASE_URL}/logs/transfer`,
     data: JSON.stringify(query),
@@ -80,6 +84,9 @@ export const getTokenOperations = async (
 ): Promise<Operation[]> => {
   const paddedAddress = padAddress(addr);
 
+  const TransferEventSignature =
+    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
   const query: TokenTxsQuery = {
     range: {
       unit: "block",
@@ -100,7 +107,7 @@ export const getTokenOperations = async (
     order: "desc",
   };
 
-  const { data } = await network({
+  const { data } = await network<EventLog[]>({
     method: "POST",
     url: `${BASE_URL}/logs/event`,
     data: JSON.stringify(query),
@@ -112,15 +119,15 @@ export const getTokenOperations = async (
 
 /**
  * Submit a transaction and return the ID
- * @param tx - The transaction to submit
+ * @param transaction - The transaction to submit
  * @returns transaction ID
  */
-export const submit = async (tx: Transaction): Promise<string> => {
+export const submit = async (transaction: VechainSDKTransaction): Promise<string> => {
   const encodedRawTx = {
-    raw: `${HEX_PREFIX}${tx.encode().toString("hex")}`,
+    raw: `0x${Buffer.from(transaction.encoded).toString("hex")}`,
   };
 
-  const { data } = await network({
+  const { data } = await network<{ id: string }>({
     method: "POST",
     url: `${BASE_URL}/transactions`,
     data: encodedRawTx,
@@ -132,27 +139,12 @@ export const submit = async (tx: Transaction): Promise<string> => {
   return data.id;
 };
 
-/**
- * Query the blockchain
- * @param queryData - The query data
- * @returns a result of the query
- */
-export const query = async (queryData: Query[]): Promise<QueryResponse[]> => {
-  const { data } = await network({
-    method: "POST",
-    url: `${BASE_URL}/accounts/*`,
-    data: { clauses: queryData },
-  });
-
-  return data;
-};
-
 /**
  * Get the block ref to use in a transaction
  * @returns the block ref of head
  */
 export const getBlockRef = async (): Promise<string> => {
-  const { data } = await network({
+  const { data } = await network<{ id: string }>({
     method: "GET",
     url: `${BASE_URL}/blocks/best`,
   });
@@ -166,7 +158,7 @@ export const getBlockRef = async (): Promise<string> => {
  * @return the fee paid in VTHO or 0
  */
 export const getFees = async (transactionID: string): Promise<BigNumber> => {
-  const { data } = await network({
+  const { data } = await network<{ paid: string }>({
     method: "GET",
     url: `${BASE_URL}/transactions/${transactionID}/receipt`,
     params: { id: transactionID },