@ledgerhq/coin-vechain 3.0.0 → 4.0.0

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

@@ -5,6 +5,7 @@ import { parseAddress } from "./parseAddress";
 import { calculateClausesVet, calculateClausesVtho } from "./calculateClauses";
 import { estimateGas } from "./estimateGas";
 import { getThorClient } from "./getThorClient";
+import { mockVechainConfig } from "../test/context";
 
 // Mock all dependencies
 jest.mock("./parseAddress");
@@ -70,7 +71,12 @@ describe("calculateGasFees", () => {
     });
 
     it("should calculate gas fees for VET transfer", async () => {
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(mockedParseAddress).toHaveBeenCalledWith(mockTransaction.recipient);
       expect(mockedCalculateClausesVet).toHaveBeenCalledWith(
@@ -78,7 +84,11 @@ describe("calculateGasFees", () => {
         mockTransaction.amount,
       );
       expect(mockedCalculateClausesVtho).not.toHaveBeenCalled();
-      expect(mockedEstimateGas).toHaveBeenCalledWith(mockClauses, mockOriginAddress);
+      expect(mockedEstimateGas).toHaveBeenCalledWith(
+        mockVechainConfig,
+        mockClauses,
+        mockOriginAddress,
+      );
       expect(mockThorClient.transactions.buildTransactionBody).toHaveBeenCalledWith(
         mockClauses,
         mockGasEstimation.totalGas,
@@ -99,7 +109,12 @@ describe("calculateGasFees", () => {
         maxPriorityFeePerGas: null,
       });
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 21000,
@@ -112,7 +127,12 @@ describe("calculateGasFees", () => {
     it("should handle transaction body with undefined gas values", async () => {
       mockThorClient.transactions.buildTransactionBody.mockResolvedValue({});
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 21000,
@@ -131,7 +151,12 @@ describe("calculateGasFees", () => {
       };
       mockedEstimateGas.mockResolvedValue(customGasEstimation);
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 50000,
@@ -150,7 +175,12 @@ describe("calculateGasFees", () => {
     });
 
     it("should calculate gas fees for VTHO transfer", async () => {
-      const result = await calculateGasFees(mockTransaction, true, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        true,
+        mockOriginAddress,
+      );
 
       expect(mockedParseAddress).toHaveBeenCalledWith(mockTransaction.recipient);
       expect(mockedCalculateClausesVtho).toHaveBeenCalledWith(
@@ -158,7 +188,11 @@ describe("calculateGasFees", () => {
         mockTransaction.amount,
       );
       expect(mockedCalculateClausesVet).not.toHaveBeenCalled();
-      expect(mockedEstimateGas).toHaveBeenCalledWith(mockClauses, mockOriginAddress);
+      expect(mockedEstimateGas).toHaveBeenCalledWith(
+        mockVechainConfig,
+        mockClauses,
+        mockOriginAddress,
+      );
       expect(mockThorClient.transactions.buildTransactionBody).toHaveBeenCalledWith(
         mockClauses,
         mockGasEstimation.totalGas,
@@ -179,7 +213,12 @@ describe("calculateGasFees", () => {
         amount: new BigNumber("999999999999999999999999"),
       };
 
-      const result = await calculateGasFees(largeAmountTransaction, true, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        largeAmountTransaction,
+        true,
+        mockOriginAddress,
+      );
 
       expect(mockedCalculateClausesVtho).toHaveBeenCalledWith(
         largeAmountTransaction.recipient,
@@ -197,7 +236,12 @@ describe("calculateGasFees", () => {
         recipient: undefined,
       } as any;
 
-      const result = await calculateGasFees(transactionWithoutRecipient, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        transactionWithoutRecipient,
+        false,
+        mockOriginAddress,
+      );
 
       expect(mockedParseAddress).not.toHaveBeenCalled();
       expect(mockedCalculateClausesVet).not.toHaveBeenCalled();
@@ -218,7 +262,12 @@ describe("calculateGasFees", () => {
         recipient: null,
       } as any;
 
-      const result = await calculateGasFees(transactionWithNullRecipient, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        transactionWithNullRecipient,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 0,
@@ -231,7 +280,12 @@ describe("calculateGasFees", () => {
     it("should return zero values when parseAddress returns null/undefined", async () => {
       mockedParseAddress.mockReturnValue(false);
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(mockedParseAddress).toHaveBeenCalledWith(mockTransaction.recipient);
       expect(mockedCalculateClausesVet).not.toHaveBeenCalled();
@@ -249,7 +303,12 @@ describe("calculateGasFees", () => {
     it("should return zero values when parseAddress returns empty string", async () => {
       mockedParseAddress.mockReturnValue(false);
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 0,
@@ -269,18 +328,18 @@ describe("calculateGasFees", () => {
       const error = new Error("Failed to calculate VET clauses");
       mockedCalculateClausesVet.mockRejectedValue(error);
 
-      await expect(calculateGasFees(mockTransaction, false, mockOriginAddress)).rejects.toThrow(
-        "Failed to calculate VET clauses",
-      );
+      await expect(
+        calculateGasFees(mockVechainConfig, mockTransaction, false, mockOriginAddress),
+      ).rejects.toThrow("Failed to calculate VET clauses");
     });
 
     it("should throw error when calculateClausesVtho fails", async () => {
       const error = new Error("Failed to calculate VTHO clauses");
       mockedCalculateClausesVtho.mockRejectedValue(error);
 
-      await expect(calculateGasFees(mockTransaction, true, mockOriginAddress)).rejects.toThrow(
-        "Failed to calculate VTHO clauses",
-      );
+      await expect(
+        calculateGasFees(mockVechainConfig, mockTransaction, true, mockOriginAddress),
+      ).rejects.toThrow("Failed to calculate VTHO clauses");
     });
 
     it("should throw error when estimateGas fails", async () => {
@@ -288,9 +347,9 @@ describe("calculateGasFees", () => {
       const error = new Error("Failed to estimate gas");
       mockedEstimateGas.mockRejectedValue(error);
 
-      await expect(calculateGasFees(mockTransaction, false, mockOriginAddress)).rejects.toThrow(
-        "Failed to estimate gas",
-      );
+      await expect(
+        calculateGasFees(mockVechainConfig, mockTransaction, false, mockOriginAddress),
+      ).rejects.toThrow("Failed to estimate gas");
     });
 
     it("should throw error when buildTransactionBody fails", async () => {
@@ -299,9 +358,9 @@ describe("calculateGasFees", () => {
       const error = new Error("Failed to build transaction body");
       mockThorClient.transactions.buildTransactionBody.mockRejectedValue(error);
 
-      await expect(calculateGasFees(mockTransaction, false, mockOriginAddress)).rejects.toThrow(
-        "Failed to build transaction body",
-      );
+      await expect(
+        calculateGasFees(mockVechainConfig, mockTransaction, false, mockOriginAddress),
+      ).rejects.toThrow("Failed to build transaction body");
     });
   });
 
@@ -318,7 +377,12 @@ describe("calculateGasFees", () => {
         amount: new BigNumber("0"),
       };
 
-      const result = await calculateGasFees(zeroAmountTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        zeroAmountTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(mockedCalculateClausesVet).toHaveBeenCalledWith(
         zeroAmountTransaction.recipient,
@@ -335,7 +399,12 @@ describe("calculateGasFees", () => {
         vmErrors: [],
       });
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 0,
@@ -352,7 +421,12 @@ describe("calculateGasFees", () => {
       };
       mockThorClient.transactions.buildTransactionBody.mockResolvedValue(highGasTransactionBody);
 
-      const result = await calculateGasFees(mockTransaction, false, mockOriginAddress);
+      const result = await calculateGasFees(
+        mockVechainConfig,
+        mockTransaction,
+        false,
+        mockOriginAddress,
+      );
 
       expect(result).toEqual({
         estimatedGas: 21000,

package/src/common-logic/calculateGasFees.ts

@@ -1,11 +1,13 @@
 import BigNumber from "bignumber.js";
 import { Transaction } from "../types";
+import type { VechainCurrencyConfig } from "../config";
 import { parseAddress } from "./parseAddress";
 import { calculateClausesVet, calculateClausesVtho } from "./calculateClauses";
 import { estimateGas } from "./estimateGas";
 import { getThorClient } from "./getThorClient";
 
 export const calculateGasFees = async (
+  config: VechainCurrencyConfig,
   transaction: Transaction,
   isTokenAccount: boolean,
   originAddress: string,
@@ -24,8 +26,8 @@ export const calculateGasFees = async (
       clauses = await calculateClausesVet(transaction.recipient, transaction.amount);
     }
 
-    const gasEstimation = await estimateGas(clauses, originAddress);
-    const thorClient = getThorClient();
+    const gasEstimation = await estimateGas(config, clauses, originAddress);
+    const thorClient = getThorClient(config);
     const body = await thorClient.transactions.buildTransactionBody(
       clauses,
       gasEstimation.totalGas,

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

@@ -4,6 +4,7 @@ import { calculateTransactionInfo } from "./calculateTransactionInfo";
 import { Transaction } from "../types";
 import { ImpossibleToCalculateAmountAndFees } from "../errors";
 import { calculateGasFees } from "./calculateGasFees";
+import { mockVechainConfig } from "../test/context";
 
 // Mock dependencies
 jest.mock("./calculateGasFees");
@@ -71,7 +72,11 @@ describe("calculateTransactionInfo", () => {
 
   describe("VET transactions", () => {
     it("should calculate transaction info for normal VET transaction", async () => {
-      const result = await calculateTransactionInfo(mockAccount, mockBaseTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        mockBaseTransaction,
+      );
 
       expect(result).toEqual({
         isTokenAccount: false,
@@ -92,16 +97,21 @@ describe("calculateTransactionInfo", () => {
         useAllAmount: true,
       };
 
-      const result = await calculateTransactionInfo(mockAccount, useAllAmountTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        useAllAmountTransaction,
+      );
 
       expect(result.amount).toEqual(new BigNumber("5000000000000000000"));
       expect(result.spendableBalance).toEqual(new BigNumber("5000000000000000000"));
     });
 
     it("should call calculateGasFees with correct parameters for VET", async () => {
-      await calculateTransactionInfo(mockAccount, mockBaseTransaction);
+      await calculateTransactionInfo(mockVechainConfig, mockAccount, mockBaseTransaction);
 
       expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        mockVechainConfig,
         expect.objectContaining({
           amount: new BigNumber("1000000000000000000"),
         }),
@@ -123,7 +133,11 @@ describe("calculateTransactionInfo", () => {
     };
 
     it("should calculate transaction info for normal token transaction", async () => {
-      const result = await calculateTransactionInfo(mockAccountWithToken, mockTokenTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccountWithToken,
+        mockTokenTransaction,
+      );
 
       expect(result).toEqual({
         isTokenAccount: true,
@@ -145,6 +159,7 @@ describe("calculateTransactionInfo", () => {
       };
 
       const result = await calculateTransactionInfo(
+        mockVechainConfig,
         mockAccountWithToken,
         useAllAmountTokenTransaction,
       );
@@ -160,15 +175,20 @@ describe("calculateTransactionInfo", () => {
       };
       mockedCalculateGasFees.mockResolvedValue(highGasResult);
 
-      const result = await calculateTransactionInfo(mockAccountWithToken, mockTokenTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccountWithToken,
+        mockTokenTransaction,
+      );
 
       expect(result.spendableBalance).toEqual(new BigNumber("0"));
     });
 
     it("should call calculateGasFees with correct parameters for token", async () => {
-      await calculateTransactionInfo(mockAccountWithToken, mockTokenTransaction);
+      await calculateTransactionInfo(mockVechainConfig, mockAccountWithToken, mockTokenTransaction);
 
       expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        mockVechainConfig,
         expect.objectContaining({
           amount: new BigNumber("1000000000000000000"),
         }),
@@ -184,6 +204,7 @@ describe("calculateTransactionInfo", () => {
       };
 
       const result = await calculateTransactionInfo(
+        mockVechainConfig,
         mockAccountWithToken,
         transactionWithNonExistentToken,
       );
@@ -202,7 +223,12 @@ describe("calculateTransactionInfo", () => {
     };
 
     it("should use fixed gas fees when provided", async () => {
-      const result = await calculateTransactionInfo(mockAccount, mockBaseTransaction, fixedGasFees);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        mockBaseTransaction,
+        fixedGasFees,
+      );
 
       expect(mockedCalculateGasFees).not.toHaveBeenCalled();
       expect(result.estimatedFees).toBe("500000000000000000");
@@ -223,6 +249,7 @@ describe("calculateTransactionInfo", () => {
       };
 
       const result = await calculateTransactionInfo(
+        mockVechainConfig,
         mockAccountWithToken,
         mockTokenTransaction,
         fixedGasFees,
@@ -255,7 +282,11 @@ describe("calculateTransactionInfo", () => {
         useAllAmount: true,
       };
 
-      const result = await calculateTransactionInfo(mockAccount, useAllAmountTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        useAllAmountTransaction,
+      );
 
       expect(result.amount).toEqual(new BigNumber("5000000000000000000"));
       expect(mockedCalculateGasFees).toHaveBeenCalledTimes(2);
@@ -287,7 +318,7 @@ describe("calculateTransactionInfo", () => {
       });
 
       await expect(
-        calculateTransactionInfo(mockAccountWithToken, mockTokenTransaction),
+        calculateTransactionInfo(mockVechainConfig, mockAccountWithToken, mockTokenTransaction),
       ).rejects.toThrow(ImpossibleToCalculateAmountAndFees);
     });
 
@@ -306,7 +337,7 @@ describe("calculateTransactionInfo", () => {
         useAllAmount: true,
       };
 
-      await calculateTransactionInfo(mockAccount, useAllAmountTransaction);
+      await calculateTransactionInfo(mockVechainConfig, mockAccount, useAllAmountTransaction);
 
       // Should be called at least once, might be called twice in the loop
       expect(mockedCalculateGasFees).toHaveBeenCalledTimes(2);
@@ -320,7 +351,11 @@ describe("calculateTransactionInfo", () => {
         amount: new BigNumber(NaN),
       };
 
-      const result = await calculateTransactionInfo(mockAccount, nanAmountTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        nanAmountTransaction,
+      );
 
       expect(mockedCalculateGasFees).not.toHaveBeenCalled();
       expect(result.amount.isNaN()).toBe(true);
@@ -334,7 +369,11 @@ describe("calculateTransactionInfo", () => {
         amount: new BigNumber(NaN),
       };
 
-      const result = await calculateTransactionInfo(mockAccount, nanAmountTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        nanAmountTransaction,
+      );
 
       expect(result.balance).toEqual(mockAccount.balance);
       expect(result.spendableBalance).toEqual(mockAccount.balance);
@@ -348,7 +387,11 @@ describe("calculateTransactionInfo", () => {
         subAccounts: [],
       };
 
-      const result = await calculateTransactionInfo(accountWithoutSubAccounts, mockBaseTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        accountWithoutSubAccounts,
+        mockBaseTransaction,
+      );
 
       expect(result.isTokenAccount).toBe(false);
       expect(result.tokenAccount).toBeUndefined();
@@ -365,7 +408,11 @@ describe("calculateTransactionInfo", () => {
         subAccountId: "some-id",
       };
 
-      const result = await calculateTransactionInfo(accountWithEmptySubAccounts, tokenTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        accountWithEmptySubAccounts,
+        tokenTransaction,
+      );
 
       expect(result.isTokenAccount).toBe(false);
       expect(result.tokenAccount).toBeUndefined();
@@ -377,7 +424,11 @@ describe("calculateTransactionInfo", () => {
         balance: new BigNumber("0"),
       };
 
-      const result = await calculateTransactionInfo(zeroBalanceAccount, mockBaseTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        zeroBalanceAccount,
+        mockBaseTransaction,
+      );
 
       expect(result.balance).toEqual(new BigNumber("0"));
       expect(result.spendableBalance).toEqual(new BigNumber("0"));
@@ -389,7 +440,11 @@ describe("calculateTransactionInfo", () => {
         amount: new BigNumber("0"),
       };
 
-      const result = await calculateTransactionInfo(mockAccount, zeroAmountTransaction);
+      const result = await calculateTransactionInfo(
+        mockVechainConfig,
+        mockAccount,
+        zeroAmountTransaction,
+      );
 
       expect(result.amount).toEqual(new BigNumber("0"));
       expect(mockedCalculateGasFees).toHaveBeenCalled();

package/src/common-logic/calculateTransactionInfo.ts

@@ -1,6 +1,7 @@
 import BigNumber from "bignumber.js";
 import { Account, TokenAccount } from "@ledgerhq/types-live";
 import { Transaction, TransactionInfo } from "../types";
+import type { VechainCurrencyConfig } from "../config";
 import { ImpossibleToCalculateAmountAndFees } from "../errors";
 import { calculateGasFees } from "./calculateGasFees";
 
@@ -25,6 +26,7 @@ const getTokenAccount = (
 // amount -> spendableBalance -> fees -> amount
 
 export const calculateTransactionInfo = async (
+  config: VechainCurrencyConfig,
   account: Account,
   transaction: Transaction,
   fixedMaxTokenFees?: {
@@ -58,7 +60,7 @@ export const calculateTransactionInfo = async (
 
       const estimatedGasAndFees =
         fixedMaxTokenFees ||
-        (await calculateGasFees(tempTransaction, isTokenAccount, account.freshAddress));
+        (await calculateGasFees(config, tempTransaction, isTokenAccount, account.freshAddress));
 
       maxEstimatedGasFees = estimatedGasAndFees.estimatedGasFees;
       maxEstimatedGas = estimatedGasAndFees.estimatedGas;

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

@@ -2,6 +2,7 @@ import { estimateGas } from "./estimateGas";
 import { getThorClient } from "./getThorClient";
 import { TransactionClause } from "@vechain/sdk-core";
 import { EstimateGasResult } from "@vechain/sdk-network";
+import { mockVechainConfig } from "../test/context";
 
 // Mock dependencies
 jest.mock("./getThorClient");
@@ -45,7 +46,7 @@ describe("estimateGas", () => {
   it("should estimate gas for transaction clauses", async () => {
     mockThorClient.gas.estimateGas.mockResolvedValue(mockEstimateGasResult);
 
-    const result = await estimateGas(mockClauses, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
 
     expect(mockedGetThorClient).toHaveBeenCalledTimes(1);
     expect(mockThorClient.gas.estimateGas).toHaveBeenCalledWith(mockClauses, mockOrigin);
@@ -56,7 +57,7 @@ describe("estimateGas", () => {
     const singleClause: TransactionClause[] = [mockClauses[0]];
     mockThorClient.gas.estimateGas.mockResolvedValue(mockEstimateGasResult);
 
-    const result = await estimateGas(singleClause, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, singleClause, mockOrigin);
 
     expect(mockThorClient.gas.estimateGas).toHaveBeenCalledWith(singleClause, mockOrigin);
     expect(result).toEqual(mockEstimateGasResult);
@@ -71,7 +72,7 @@ describe("estimateGas", () => {
       vmErrors: [],
     });
 
-    const result = await estimateGas(emptyClauses, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, emptyClauses, mockOrigin);
 
     expect(mockThorClient.gas.estimateGas).toHaveBeenCalledWith(emptyClauses, mockOrigin);
     expect(result.totalGas).toBe(0);
@@ -86,7 +87,7 @@ describe("estimateGas", () => {
     };
     mockThorClient.gas.estimateGas.mockResolvedValue(revertedResult);
 
-    const result = await estimateGas(mockClauses, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
 
     expect(result).toEqual(revertedResult);
     expect(result.reverted).toBe(true);
@@ -102,7 +103,7 @@ describe("estimateGas", () => {
     };
     mockThorClient.gas.estimateGas.mockResolvedValue(highGasResult);
 
-    const result = await estimateGas(mockClauses, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
 
     expect(result.totalGas).toBe(500000);
   });
@@ -111,7 +112,9 @@ describe("estimateGas", () => {
     const errorMessage = "Network error";
     mockThorClient.gas.estimateGas.mockRejectedValue(new Error(errorMessage));
 
-    await expect(estimateGas(mockClauses, mockOrigin)).rejects.toThrow(errorMessage);
+    await expect(estimateGas(mockVechainConfig, mockClauses, mockOrigin)).rejects.toThrow(
+      errorMessage,
+    );
   });
 
   it("should handle clauses with data for token transfers", async () => {
@@ -131,7 +134,7 @@ describe("estimateGas", () => {
     };
     mockThorClient.gas.estimateGas.mockResolvedValue(tokenGasResult);
 
-    const result = await estimateGas(tokenTransferClause, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, tokenTransferClause, mockOrigin);
 
     expect(mockThorClient.gas.estimateGas).toHaveBeenCalledWith(tokenTransferClause, mockOrigin);
     expect(result.totalGas).toBe(37000);
@@ -140,8 +143,8 @@ describe("estimateGas", () => {
   it("should get a new thor client instance for each call", async () => {
     mockThorClient.gas.estimateGas.mockResolvedValue(mockEstimateGasResult);
 
-    await estimateGas(mockClauses, mockOrigin);
-    await estimateGas(mockClauses, mockOrigin);
+    await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
+    await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
 
     expect(mockedGetThorClient).toHaveBeenCalledTimes(2);
   });
@@ -155,7 +158,7 @@ describe("estimateGas", () => {
     };
     mockThorClient.gas.estimateGas.mockResolvedValue(exactResult);
 
-    const result = await estimateGas(mockClauses, mockOrigin);
+    const result = await estimateGas(mockVechainConfig, mockClauses, mockOrigin);
 
     expect(result).toBe(exactResult);
   });

package/src/common-logic/estimateGas.ts

@@ -1,6 +1,7 @@
 import { TransactionClause } from "@vechain/sdk-core";
 import { getThorClient } from "./getThorClient";
 import { EstimateGasResult } from "@vechain/sdk-network";
+import type { VechainCurrencyConfig } from "../config";
 
 /**
  * Estimates gas fees for transaction clauses
@@ -9,10 +10,11 @@ import { EstimateGasResult } from "@vechain/sdk-network";
  * @return {Promise<EstimateGasResult>} Estimated gas result
  */
 export const estimateGas = async (
+  config: VechainCurrencyConfig,
   clauses: TransactionClause[],
   origin: string,
 ): Promise<EstimateGasResult> => {
-  const thorClient = getThorClient();
+  const thorClient = getThorClient(config);
   const gasResult = await thorClient.gas.estimateGas(clauses, origin);
   return gasResult;
 };