@ledgerhq/coin-vechain 3.0.0 → 4.0.0

package/src/network/getFees.ts

@@ -1,16 +1,19 @@
 import BigNumber from "bignumber.js";
 import network from "@ledgerhq/live-network";
-import { getNodeUrl } from "../config";
+import { getNodeUrl, type VechainCurrencyConfig } from "../config";
 
 /**
  * Get fees paid for the transaction
  * @param transactionId - the id of the transaction
  * @return the fee paid in VTHO or 0
  */
-export const getFees = async (transactionId: string): Promise<BigNumber> => {
+export const getFees = async (
+  config: VechainCurrencyConfig,
+  transactionId: string,
+): Promise<BigNumber> => {
   const { data } = await network<{ paid: string }>({
     method: "GET",
-    url: `${getNodeUrl()}/transactions/${transactionId}/receipt`,
+    url: `${getNodeUrl(config)}/transactions/${transactionId}/receipt`,
     params: { id: transactionId },
   });
 

package/src/network/sdk.integ.test.ts

@@ -3,9 +3,10 @@ import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { EventLog, TransferLog, VetTxsQuery } from "../types";
 import { TEST_VECHAIN_ENDPOINT } from "../test/constants";
-import { setCoinConfig } from "../config";
+import { setCoinConfig, type VechainCurrencyConfig } from "../config";
 
 const BASE_URL = TEST_VECHAIN_ENDPOINT;
+const config: VechainCurrencyConfig = { status: { type: "active" }, node: { url: BASE_URL } };
 const LAST_BLOCK_COUNT = 24580112;
 const MAX_OPS_IN_BLOCK_RANGE = 1000;
 const N_OPS_IN_BLOCK = 3;
@@ -114,6 +115,7 @@ describe("sdk", () => {
     describe("when logged operations are less than 1000 in the given range", () => {
       test("retrieves all the operations", async () => {
         const operations = await getOperations(
+          config,
           "my-account-id",
           "0xmy-address",
           LAST_BLOCK_COUNT - 332,
@@ -128,6 +130,7 @@ describe("sdk", () => {
     describe("when logged operations are more than 1000 in the given range", () => {
       test("retrieves all the operations", async () => {
         const operations = await getOperations(
+          config,
           "my-account-id",
           "0xmy-address",
           LAST_BLOCK_COUNT - 333,
@@ -148,6 +151,7 @@ describe("sdk", () => {
       test("rethrows the error", async () => {
         try {
           await getOperations(
+            config,
             "my-account-id",
             "0xmy-address",
             LAST_BLOCK_COUNT - 5,
@@ -167,6 +171,7 @@ describe("sdk", () => {
     describe("when logged operations are less than 1000 in the given range", () => {
       test("retrieves all the operations", async () => {
         const operations = await getTokenOperations(
+          config,
           "my-account-id",
           "0xmy-address",
           "0xmy-token-address",
@@ -182,6 +187,7 @@ describe("sdk", () => {
     describe("when logged operations are more than 1000 in the given range", () => {
       test("retrieves all the operations", async () => {
         const operations = await getTokenOperations(
+          config,
           "my-account-id",
           "0xmy-address",
           "0xmy-token-address",
@@ -203,6 +209,7 @@ describe("sdk", () => {
       test("rethrows the error", async () => {
         try {
           await getTokenOperations(
+            config,
             "my-account-id",
             "0xmy-address",
             "0xmy-token-address",

package/src/network/sdk.test.ts

@@ -11,6 +11,7 @@ import {
 } from "./sdk";
 import { getFees } from "./getFees";
 import type { AccountResponse, VechainSDKTransaction } from "../types";
+import { mockVechainConfig } from "../test/context";
 
 const LAST_BLOCK_COUNT = 24580112;
 const mockAccount = {
@@ -105,21 +106,21 @@ const throws500ServerError = () => {
 describe("sdk", () => {
   describe("getAccount", () => {
     test("retrieves an account", async () => {
-      const account = await getAccount("0xmy-address");
+      const account = await getAccount(mockVechainConfig, "0xmy-address");
       expect(account).toBe(mockAccount);
     });
   });
 
   describe("getLastBlockHeight", () => {
     test("retrieves the last block height", async () => {
-      const account = await getLastBlockHeight();
+      const account = await getLastBlockHeight(mockVechainConfig);
       expect(account).toBe(LAST_BLOCK_COUNT);
     });
   });
 
   describe("getBlockRef", () => {
     test("retrieves the block ref to use in transaction", async () => {
-      const account = await getBlockRef();
+      const account = await getBlockRef(mockVechainConfig);
       expect(account).toBe("abcdefghiklmnopqrs");
     });
   });
@@ -129,14 +130,14 @@ describe("sdk", () => {
       test("retrieves fees paid for the transaction", async () => {
         mockGetFees.mockImplementationOnce(async () => ({ data: {} }));
 
-        const account = await getFees("0xtransaxtion");
+        const account = await getFees(mockVechainConfig, "0xtransaxtion");
         expect(account).toStrictEqual(new BigNumber(0));
       });
     });
 
     describe("when the transaction's receipt has data.paid", () => {
       test("retrieves fees paid for the transaction", async () => {
-        const account = await getFees("0xtransaxtion");
+        const account = await getFees(mockVechainConfig, "0xtransaxtion");
         expect(account).toStrictEqual(new BigNumber(42));
       });
     });
@@ -145,7 +146,7 @@ describe("sdk", () => {
   describe("submit", () => {
     describe("when transaction id is included in the transaction payload returned by the server", () => {
       test("returns the transaction id", async () => {
-        const transactionId = await submit(mockTransaction);
+        const transactionId = await submit(mockVechainConfig, mockTransaction);
         expect(transactionId).toBe("123");
       });
     });
@@ -155,7 +156,7 @@ describe("sdk", () => {
         mockSubmit.mockImplementationOnce(async () => ({ data: {} }));
 
         try {
-          await submit(mockTransaction);
+          await submit(mockVechainConfig, mockTransaction);
         } catch (err: unknown) {
           const error = err as { message: string };
           expect(error.message).toMatch("Expected an ID");
@@ -175,6 +176,7 @@ describe("sdk", () => {
       test("rethrows the error", async () => {
         try {
           await getOperations(
+            mockVechainConfig,
             "my-account-id",
             "0xmy-address",
             LAST_BLOCK_COUNT - 1,
@@ -192,6 +194,7 @@ describe("sdk", () => {
     describe("when logs retrieved in each network request are within the maximum allowed limit", () => {
       test("retrieves all the operations", async () => {
         const operations = await getOperations(
+          mockVechainConfig,
           "my-account-id",
           "0xmy-address",
           LAST_BLOCK_COUNT - 1,
@@ -207,6 +210,7 @@ describe("sdk", () => {
       test("returns an empty array without querying the network", async () => {
         mockGetTransferLogs.mockClear();
         const operations = await getOperations(
+          mockVechainConfig,
           "my-account-id",
           "0xmy-address",
           LAST_BLOCK_COUNT + 1,
@@ -227,6 +231,7 @@ describe("sdk", () => {
         test("throws an error: Unable to split Vechain operations range further", async () => {
           try {
             await getOperations(
+              mockVechainConfig,
               "my-account-id",
               "0xmy-address",
               LAST_BLOCK_COUNT - 1,
@@ -244,6 +249,7 @@ describe("sdk", () => {
       describe("and Vechain operations range can be split further", () => {
         test("retrieves all the operations", async () => {
           const operations = await getOperations(
+            mockVechainConfig,
             "my-account-id",
             "0xmy-address",
             LAST_BLOCK_COUNT - 6,
@@ -266,6 +272,7 @@ describe("sdk", () => {
       test("rethrows the error", async () => {
         try {
           await getOperations(
+            mockVechainConfig,
             "my-account-id",
             "0xmy-address",
             LAST_BLOCK_COUNT - 1,
@@ -283,6 +290,7 @@ describe("sdk", () => {
     describe("when logs retrieved in each network request are within the maximum allowed limit", () => {
       test("retrieves all the operations", async () => {
         const operations = await getTokenOperations(
+          mockVechainConfig,
           "my-account-id",
           "0xmy-address",
           "0xmy-token-address",
@@ -299,6 +307,7 @@ describe("sdk", () => {
       test("returns an empty array without querying the network", async () => {
         mockGetEventLogs.mockClear();
         const operations = await getTokenOperations(
+          mockVechainConfig,
           "my-account-id",
           "0xmy-address",
           "0xmy-token-address",
@@ -320,6 +329,7 @@ describe("sdk", () => {
         test("throws an error: Unable to split Vechain operations range further", async () => {
           try {
             await getTokenOperations(
+              mockVechainConfig,
               "my-account-id",
               "0xmy-address",
               "0xmt-token-address",
@@ -338,6 +348,7 @@ describe("sdk", () => {
       describe("and Vechain operations range can be split further", () => {
         test("retrieves all the operations", async () => {
           const operations = await getTokenOperations(
+            mockVechainConfig,
             "my-account-id",
             "0xmy-address",
             "0xmt-token-address",

package/src/network/sdk.ts

@@ -13,26 +13,29 @@ import {
   mapTokenTransfersToOperations,
   padAddress,
 } from "../common-logic";
-import { getNodeUrl } from "../config";
+import { getNodeUrl, type VechainCurrencyConfig } from "../config";
 
 const NET_ERROR_LOG_TRANSFERS_LIMIT = {
   status: 403,
   msgPattern: /exceeds the maximum allowed/,
 };
 
-export const getAccount = async (address: string): Promise<AccountResponse> => {
+export const getAccount = async (
+  config: VechainCurrencyConfig,
+  address: string,
+): Promise<AccountResponse> => {
   const { data } = await network<AccountResponse>({
     method: "GET",
-    url: `${getNodeUrl()}/accounts/${address}`,
+    url: `${getNodeUrl(config)}/accounts/${address}`,
   });
 
   return data;
 };
 
-export const getLastBlockHeight = async (): Promise<number> => {
+export const getLastBlockHeight = async (config: VechainCurrencyConfig): Promise<number> => {
   const { data } = await network<{ number: number }>({
     method: "GET",
-    url: `${getNodeUrl()}/blocks/best`,
+    url: `${getNodeUrl(config)}/blocks/best`,
   });
 
   return data.number;
@@ -47,6 +50,7 @@ export const getLastBlockHeight = async (): Promise<number> => {
  * @returns an array of operations
  */
 const fetchRangeOfOperations = async (
+  config: VechainCurrencyConfig,
   accountId: string,
   addr: string,
   startAt: number,
@@ -64,11 +68,11 @@ const fetchRangeOfOperations = async (
 
   const { data } = await network<TransferLog[]>({
     method: "POST",
-    url: `${getNodeUrl()}/logs/transfer`,
+    url: `${getNodeUrl(config)}/logs/transfer`,
     data: JSON.stringify(query),
   });
 
-  return mapVetTransfersToOperations(data, accountId, addr);
+  return mapVetTransfersToOperations(config, data, accountId, addr);
 };
 
 /**
@@ -80,6 +84,7 @@ const fetchRangeOfOperations = async (
  * @returns an array of operations
  */
 const fetchRangeOfTokenOperations = async (
+  config: VechainCurrencyConfig,
   accountId: string,
   addr: string,
   tokenAddr: string,
@@ -114,11 +119,11 @@ const fetchRangeOfTokenOperations = async (
 
   const { data } = await network<EventLog[]>({
     method: "POST",
-    url: `${getNodeUrl()}/logs/event`,
+    url: `${getNodeUrl(config)}/logs/event`,
     data: JSON.stringify(query),
   });
 
-  return mapTokenTransfersToOperations(data, accountId, addr);
+  return mapTokenTransfersToOperations(config, data, accountId, addr);
 };
 
 /**
@@ -213,13 +218,14 @@ const getLogsWithPagination = async (
  * @returns an array of operations
  */
 export const getOperations = async (
+  config: VechainCurrencyConfig,
   accountId: string,
   addr: string,
   startAt: number,
   stopAt: number,
 ): Promise<Operation[]> => {
   const fetchRange = async (from: number, to: number) =>
-    fetchRangeOfOperations(accountId, addr, from, to);
+    fetchRangeOfOperations(config, accountId, addr, from, to);
   return getLogsWithPagination(startAt, stopAt, fetchRange);
 };
 
@@ -234,6 +240,7 @@ export const getOperations = async (
  * @returns an array of operations
  */
 export const getTokenOperations = async (
+  config: VechainCurrencyConfig,
   accountId: string,
   addr: string,
   tokenAddr: string,
@@ -241,7 +248,7 @@ export const getTokenOperations = async (
   stopAt: number,
 ): Promise<Operation[]> => {
   const fetchRange = async (from: number, to: number) =>
-    fetchRangeOfTokenOperations(accountId, addr, tokenAddr, from, to);
+    fetchRangeOfTokenOperations(config, accountId, addr, tokenAddr, from, to);
   return getLogsWithPagination(startAt, stopAt, fetchRange);
 };
 
@@ -250,14 +257,17 @@ export const getTokenOperations = async (
  * @param transaction - The transaction to submit
  * @returns transaction ID
  */
-export const submit = async (transaction: VechainSDKTransaction): Promise<string> => {
+export const submit = async (
+  config: VechainCurrencyConfig,
+  transaction: VechainSDKTransaction,
+): Promise<string> => {
   const encodedRawTx = {
     raw: `0x${Buffer.from(transaction.encoded).toString("hex")}`,
   };
 
   const { data } = await network<{ id: string }>({
     method: "POST",
-    url: `${getNodeUrl()}/transactions`,
+    url: `${getNodeUrl(config)}/transactions`,
     data: encodedRawTx,
   });
 
@@ -271,10 +281,10 @@ export const submit = async (transaction: VechainSDKTransaction): Promise<string
  * Get the block ref to use in a transaction
  * @returns the block ref of head
  */
-export const getBlockRef = async (): Promise<string> => {
+export const getBlockRef = async (config: VechainCurrencyConfig): Promise<string> => {
   const { data } = await network<{ id: string }>({
     method: "GET",
-    url: `${getNodeUrl()}/blocks/best`,
+    url: `${getNodeUrl(config)}/blocks/best`,
   });
 
   return data.id.slice(0, 18);

package/src/test/context.ts

@@ -0,0 +1,15 @@
+import type { VechainContext, VechainCurrencyConfig } from "../config";
+
+/** The resolved config every mocked endpoint points at. */
+export const mockVechainConfig: VechainCurrencyConfig = {
+  status: { type: "active" },
+  node: { url: "https://vechain.coin.ledger.com" },
+};
+
+/** A {@link VechainContext} backed by the mocked config, for api tests. */
+export const createMockVechainContext = (
+  config: VechainCurrencyConfig = mockVechainConfig,
+): VechainContext => ({
+  config: async () => config,
+  logger: () => {},
+});