@ledgerhq/coin-vechain 3.0.0 → 4.0.0

package/src/api/index.unit.test.ts

@@ -5,6 +5,7 @@
  */
 import type {
   Balance,
+  BalanceOptions,
   CoinModuleApi,
   CraftedTransaction,
   FeeEstimation,
@@ -13,7 +14,8 @@ import type {
   TransactionIntent,
 } from "@ledgerhq/coin-module-framework/api/index";
 import { createApi } from "./index";
-import { getCoinConfig } from "../config";
+import { getCoinConfig, setCoinConfig, type VechainCurrencyConfig } from "../config";
+import { createMockVechainContext } from "../test/context";
 import { broadcast } from "../logic/transaction/broadcast";
 import { combine } from "../logic/transaction/combine";
 import { craftTransaction } from "../logic/transaction/craftTransaction";
@@ -58,8 +60,8 @@ describe("createApi", () => {
     jest.clearAllMocks();
   });
 
-  it("sets the coin config, forcing status active", () => {
-    createApi(config, "vechain");
+  it("exposes the coin config through the singleton", () => {
+    setCoinConfig(config);
 
     expect(getCoinConfig()).toEqual({
       status: { type: "active" },
@@ -68,7 +70,7 @@ describe("createApi", () => {
   });
 
   it("returns an object with every CoinModuleApi method", () => {
-    const api = createApi(config, "vechain");
+    const api = createApi();
 
     expect(api).toEqual(
       expect.objectContaining({
@@ -96,73 +98,78 @@ describe("createApi", () => {
 
   it("delegates broadcast to the logic function", async () => {
     jest.mocked(broadcast).mockResolvedValueOnce("txHash");
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.broadcast("signedTx");
+    const result = await api.broadcast(context, "signedTx");
 
-    expect(broadcast).toHaveBeenCalledWith("signedTx");
+    expect(broadcast).toHaveBeenCalledWith(context, "signedTx", undefined);
     expect(result).toBe("txHash");
   });
 
   it("delegates combine to the logic function", () => {
     jest.mocked(combine).mockReturnValueOnce("0xsigned");
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = api.combine("tx", "sig");
+    const result = api.combine(context, "tx", ["sig"]);
 
-    expect(combine).toHaveBeenCalledWith("tx", "sig");
+    expect(combine).toHaveBeenCalledWith("tx", ["sig"]);
     expect(result).toBe("0xsigned");
   });
 
   it("delegates craftTransaction to the logic function (intent, customFees)", async () => {
     const crafted: CraftedTransaction = { transaction: "{}", details: { fee: "1000" } };
     jest.mocked(craftTransaction).mockResolvedValueOnce(crafted);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
     const customFees: FeeEstimation = { value: 5000n };
 
-    const result = await api.craftTransaction(nativeIntent, customFees);
+    const result = await api.craftTransaction(context, nativeIntent, { customFees });
 
-    expect(craftTransaction).toHaveBeenCalledWith(nativeIntent, customFees);
+    expect(craftTransaction).toHaveBeenCalledWith(context, nativeIntent, customFees);
     expect(result).toEqual(crafted);
   });
 
   it("delegates estimateFees to the logic function (intent, params)", async () => {
     const fees: FeeEstimation = { value: 1000n };
     jest.mocked(estimateFees).mockResolvedValueOnce(fees);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.estimateFees(nativeIntent);
+    const result = await api.estimateFees(context, nativeIntent);
 
-    expect(estimateFees).toHaveBeenCalledWith(nativeIntent, undefined);
+    expect(estimateFees).toHaveBeenCalledWith(context, nativeIntent, undefined);
     expect(result).toEqual(fees);
   });
 
   it("delegates getBalance to the logic function (address)", async () => {
     const balances: Balance[] = [{ value: 1000n, asset: { type: "native" } }];
     jest.mocked(getBalance).mockResolvedValueOnce(balances);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.getBalance(SENDER);
+    const result = await api.getBalance(context, SENDER);
 
-    expect(getBalance).toHaveBeenCalledWith(SENDER);
+    expect(getBalance).toHaveBeenCalledWith(context, SENDER);
     expect(result).toEqual(balances);
   });
 
   it("rejects getBalance when options are provided (not supported)", async () => {
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    await expect(
-      api.getBalance(SENDER, {} as Parameters<CoinModuleApi["getBalance"]>[1]),
-    ).rejects.toThrow();
+    await expect(api.getBalance(context, SENDER, {} as BalanceOptions)).rejects.toThrow();
     expect(getBalance).not.toHaveBeenCalled();
   });
 
   it("delegates lastBlock to the logic function", async () => {
     const block = { height: 100, hash: "abc", time: new Date() };
     jest.mocked(lastBlock).mockResolvedValueOnce(block);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.lastBlock();
+    const result = await api.lastBlock(context);
 
     expect(lastBlock).toHaveBeenCalled();
     expect(result).toEqual(block);
@@ -171,70 +178,83 @@ describe("createApi", () => {
   it("delegates getBlockInfo to the logic function (height)", async () => {
     const info = { height: 42, hash: "abc", time: new Date() };
     jest.mocked(getBlockInfo).mockResolvedValueOnce(info);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.getBlockInfo(42);
+    const result = await api.getBlockInfo(context, 42);
 
-    expect(getBlockInfo).toHaveBeenCalledWith(42);
+    expect(getBlockInfo).toHaveBeenCalledWith(context, 42);
     expect(result).toEqual(info);
   });
 
   it("delegates getBlock to the logic function (height)", async () => {
     const block = { info: { height: 42, hash: "abc", time: new Date() }, transactions: [] };
     jest.mocked(getBlock).mockResolvedValueOnce(block);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.getBlock(42);
+    const result = await api.getBlock(context, 42);
 
-    expect(getBlock).toHaveBeenCalledWith(42);
+    expect(getBlock).toHaveBeenCalledWith(context, 42);
     expect(result).toEqual(block);
   });
 
   it("delegates listOperations to the logic function (address, options)", async () => {
     const page: Page<Operation> = { items: [], next: undefined };
     jest.mocked(listOperations).mockResolvedValueOnce(page);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.listOperations(SENDER, { minHeight: 0 });
+    const result = await api.listOperations(context, SENDER, { minHeight: 0 });
 
-    expect(listOperations).toHaveBeenCalledWith(SENDER, { minHeight: 0 });
+    expect(listOperations).toHaveBeenCalledWith(context, SENDER, { minHeight: 0 });
     expect(result).toEqual(page);
   });
 
   it("delegates validateIntent to the logic function (intent, balances, customFees)", async () => {
     const validation = { errors: {}, warnings: {}, estimatedFees: 0n, amount: 0n, totalSpent: 0n };
     jest.mocked(validateIntent).mockResolvedValueOnce(validation);
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    const result = await api.validateIntent(nativeIntent, [], undefined);
+    const result = await api.validateIntent(context, nativeIntent, [], undefined);
 
     expect(validateIntent).toHaveBeenCalledWith(nativeIntent, [], undefined);
     expect(result).toEqual(validation);
   });
 
   it("throws synchronously for methods not applicable/supported for Vechain", () => {
-    const api = createApi(config, "vechain");
+    const api = createApi();
+    const context = createMockVechainContext();
 
-    expect(() => api.getNextSequence(SENDER)).toThrow(
+    expect(() => api.getNextSequence(context, SENDER)).toThrow(
       "getNextSequence is not applicable for Vechain",
     );
-    expect(() => api.craftRawTransaction("raw", SENDER, "pubkey", 0n)).toThrow(
+    expect(() => api.craftRawTransaction(context, "raw", SENDER, "pubkey", 0n)).toThrow(
       "craftRawTransaction is not supported",
     );
-    expect(() => api.getStakes(SENDER)).toThrow("getStakes is not supported");
-    expect(() => api.getRewards(SENDER)).toThrow("getRewards is not supported");
-    expect(() => api.getValidators()).toThrow("getValidators is not supported");
+    expect(() => api.getStakes(context, SENDER)).toThrow("getStakes is not supported");
+    expect(() => api.getRewards(context, SENDER)).toThrow("getRewards is not supported");
+    expect(() => api.getValidators(context)).toThrow("getValidators is not supported");
   });
 
   it("throws for call (not supported)", () => {
-    const api = createApi(config, "vechain");
-    expect(() => api.call({})).toThrow("call is not supported");
+    const api = createApi();
+    const context = createMockVechainContext();
+    expect(() => api.call(context, {})).toThrow("call is not supported");
+  });
+
+  it("throws for register (not supported)", async () => {
+    const api = createApi();
+    const context = createMockVechainContext();
+    await expect(api.register(context, SENDER)).rejects.toThrow("register is not supported");
   });
 
   it("validates addresses via parseAddress", async () => {
-    const api = createApi(config, "vechain");
-    await expect(api.validateAddress(SENDER, {})).resolves.toBe(true);
-    await expect(api.validateAddress("0xnot-an-address", {})).resolves.toBe(false);
-    await expect(api.validateAddress("", {})).resolves.toBe(false);
+    const api = createApi();
+    const context = createMockVechainContext();
+    await expect(api.validateAddress(context, SENDER, {})).resolves.toBe(true);
+    await expect(api.validateAddress(context, "0xnot-an-address", {})).resolves.toBe(false);
+    await expect(api.validateAddress(context, "", {})).resolves.toBe(false);
   });
 });

package/src/bridge/broadcast.integ.test.ts

@@ -1,13 +1,14 @@
 import { Transaction, Secp256k1, Hex } from "@vechain/sdk-core";
 import broadcast from "./broadcast";
 import { getBlockRef } from "../network";
+import { getCoinConfig } from "../config";
 
 describe("Broadcast", () => {
   it("throws on insufficient funds", async () => {
     const privateKey = await Secp256k1.generatePrivateKey();
     const body = {
       chainTag: 74,
-      blockRef: await getBlockRef(),
+      blockRef: await getBlockRef(getCoinConfig()),
       expiration: 18,
       clauses: [
         {

package/src/bridge/broadcast.test.ts

@@ -107,7 +107,7 @@ describe("broadcast", () => {
       mockTransactionBody,
       Buffer.from("1234567890abcdef", "hex"),
     );
-    expect(mockedSubmit).toHaveBeenCalledWith(mockTransaction);
+    expect(mockedSubmit).toHaveBeenCalledWith(expect.anything(), mockTransaction);
     expect(mockedPatchOperationWithHash).toHaveBeenCalledWith(mockOperation, mockTxHash);
     expect(result).toEqual(mockPatchedOperation);
   });

package/src/bridge/broadcast.ts

@@ -3,6 +3,7 @@ import { patchOperationWithHash } from "@ledgerhq/ledger-wallet-framework/operat
 
 import { Transaction, VechainSDKTransaction } from "../types";
 import { submit } from "../network";
+import { getCoinConfig } from "../config";
 
 /**
  * Broadcast the signed transaction
@@ -14,7 +15,7 @@ export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
     (rawData as unknown as VechainSDKTransaction).body,
     Buffer.from(signature, "hex"),
   );
-  const hash = await submit(transaction);
+  const hash = await submit(getCoinConfig(), transaction);
 
   return patchOperationWithHash(operation, hash);
 };

package/src/bridge/createTransaction.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { generateNonce } from "../common-logic";
-import { getChainTag } from "../config";
+import { getChainTag, getCoinConfig } from "../config";
 import { Transaction } from "../types";
 
 /**
@@ -10,7 +10,7 @@ import { Transaction } from "../types";
  * @returns {Transaction}
  */
 export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
-  const chainTag = getChainTag();
+  const chainTag = getChainTag(getCoinConfig());
 
   return {
     family: "vechain",

package/src/bridge/estimateMaxSpendable.test.ts

@@ -116,7 +116,12 @@ describe("estimateMaxSpendable", () => {
       });
 
       expect(result).toEqual(new BigNumber("999790000000000000000")); // 1000 - 0.21 VTHO
-      expect(mockedCalculateGasFees).toHaveBeenCalledWith(mockTransaction, true, "0x123");
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        expect.anything(),
+        mockTransaction,
+        true,
+        "0x123",
+      );
     });
 
     it("should calculate max spendable for token account with sufficient balance, when parentAccount provided", async () => {
@@ -128,6 +133,7 @@ describe("estimateMaxSpendable", () => {
 
       expect(result).toEqual(new BigNumber("999790000000000000000")); // 1000 - 0.21 VTHO
       expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        expect.anything(),
         mockTransaction,
         true,
         mockAccount.freshAddress,
@@ -190,7 +196,12 @@ describe("estimateMaxSpendable", () => {
         transaction: mockTransaction,
       });
 
-      expect(mockedCalculateGasFees).toHaveBeenCalledWith(mockTransaction, true, "0x123");
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        expect.anything(),
+        mockTransaction,
+        true,
+        "0x123",
+      );
       expect(mockedCalculateGasFees).toHaveBeenCalledTimes(1);
     });
 
@@ -263,7 +274,12 @@ describe("estimateMaxSpendable", () => {
         transaction: tokenTransaction,
       });
 
-      expect(mockedCalculateGasFees).toHaveBeenCalledWith(tokenTransaction, true, "0x123");
+      expect(mockedCalculateGasFees).toHaveBeenCalledWith(
+        expect.anything(),
+        tokenTransaction,
+        true,
+        "0x123",
+      );
     });
   });
 

package/src/bridge/estimateMaxSpendable.ts

@@ -2,6 +2,7 @@ import BigNumber from "bignumber.js";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { calculateGasFees } from "../common-logic";
 import type { Transaction } from "../types";
+import { getCoinConfig } from "../config";
 
 const PATTERN_ADDRESS_IN_TOKEN_ACCOUNT_ID = /:(0x\w+):/;
 
@@ -22,6 +23,7 @@ export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpenda
 
     if (originAddress) {
       const { estimatedGasFees: maxTokenFees } = await calculateGasFees(
+        getCoinConfig(),
         transaction,
         true,
         originAddress,

package/src/bridge/getTransactionStatus.test.ts

@@ -333,12 +333,17 @@ describe("getTransactionStatus", () => {
     it("should call calculateTransactionInfo with correct parameters", async () => {
       await getTransactionStatus(mockAccount, mockTransaction);
 
-      expect(mockedCalculateTransactionInfo).toHaveBeenCalledWith(mockAccount, mockTransaction, {
-        estimatedGas: mockTransaction.body.gas,
-        estimatedGasFees: new BigNumber(mockTransaction.estimatedFees),
-        maxFeePerGas: mockTransaction.body.maxFeePerGas,
-        maxPriorityFeePerGas: mockTransaction.body.maxPriorityFeePerGas,
-      });
+      expect(mockedCalculateTransactionInfo).toHaveBeenCalledWith(
+        expect.anything(),
+        mockAccount,
+        mockTransaction,
+        {
+          estimatedGas: mockTransaction.body.gas,
+          estimatedGasFees: new BigNumber(mockTransaction.estimatedFees),
+          maxFeePerGas: mockTransaction.body.maxFeePerGas,
+          maxPriorityFeePerGas: mockTransaction.body.maxPriorityFeePerGas,
+        },
+      );
     });
 
     it("should handle calculateTransactionInfo errors", async () => {

package/src/bridge/getTransactionStatus.ts

@@ -11,6 +11,7 @@ import { AccountBridge } from "@ledgerhq/types-live";
 import { calculateTransactionInfo, parseAddress } from "../common-logic";
 import type { Transaction } from "../types";
 import { NotEnoughVTHO } from "../errors";
+import { getCoinConfig } from "../config";
 
 export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
   account,
@@ -21,6 +22,7 @@ export const getTransactionStatus: AccountBridge<Transaction>["getTransactionSta
   const errors: Record<string, Error> = {};
   const warnings: Record<string, Error> = {};
   const { isTokenAccount, spendableBalance } = await calculateTransactionInfo(
+    getCoinConfig(),
     account,
     transaction,
     {

package/src/bridge/prepareTransaction.test.ts

@@ -188,7 +188,11 @@ describe("prepareTransaction", () => {
     it("should call calculateTransactionInfo with correct parameters", async () => {
       await prepareTransaction(mockAccount, mockTransaction);
 
-      expect(mockedCalculateTransactionInfo).toHaveBeenCalledWith(mockAccount, mockTransaction);
+      expect(mockedCalculateTransactionInfo).toHaveBeenCalledWith(
+        expect.anything(),
+        mockAccount,
+        mockTransaction,
+      );
     });
 
     it("should use transaction info results in the prepared transaction", async () => {

package/src/bridge/prepareTransaction.ts

@@ -7,6 +7,7 @@ import {
 } from "../common-logic";
 import { Transaction, VechainSDKTransactionClause } from "../types";
 import { getBlockRef } from "../network";
+import { getCoinConfig } from "../config";
 
 /**
  * Prepare transaction before checking status
@@ -18,6 +19,7 @@ export const prepareTransaction = async (
   account: Account,
   transaction: Transaction,
 ): Promise<Transaction> => {
+  const config = getCoinConfig();
   const {
     amount,
     isTokenAccount,
@@ -25,13 +27,13 @@ export const prepareTransaction = async (
     estimatedGas,
     maxFeePerGas,
     maxPriorityFeePerGas,
-  } = await calculateTransactionInfo(account, transaction);
+  } = await calculateTransactionInfo(config, account, transaction);
 
   let blockRef = "";
 
   let clauses: Array<VechainSDKTransactionClause> = [];
   if (transaction.recipient && parseAddress(transaction.recipient)) {
-    blockRef = await getBlockRef();
+    blockRef = await getBlockRef(config);
     if (isTokenAccount) {
       clauses = await calculateClausesVtho(transaction.recipient, amount);
     } else {

package/src/bridge/synchronisation.ts

@@ -13,6 +13,7 @@ import { Account } from "@ledgerhq/types-live";
 import { isAccountEmpty } from "./helpers";
 import { VTHO_ADDRESS } from "@vechain/sdk-core";
 import { getCryptoAssetsStore } from "@ledgerhq/ledger-wallet-framework/cryptoAssetsStore";
+import { getCoinConfig } from "../config";
 
 export const getAccountShape: GetAccountShape<Account> = async info => {
   const { initialAccount, currency, derivationMode } = info;
@@ -29,20 +30,23 @@ export const getAccountShape: GetAccountShape<Account> = async info => {
     derivationMode,
   });
 
+  const config = getCoinConfig();
+
   // get the current account balance state depending your api implementation
-  const { balance, energy } = await getAccount(address);
+  const { balance, energy } = await getAccount(config, address);
 
   // get the current block height
-  const blockHeight = await getLastBlockHeight();
+  const blockHeight = await getLastBlockHeight(config);
 
   // Merge new operations with the previously synced ones
-  const newOperations = await getOperations(accountId, address, startAt, blockHeight);
+  const newOperations = await getOperations(config, accountId, address, startAt, blockHeight);
 
   //Get last token operations
   const vthoToken = await getCryptoAssetsStore().findTokenById("vechain/vip180/vtho");
   if (!vthoToken) throw new Error("VTHO token not found");
   const vthoAccountId = encodeTokenAccountId(accountId, vthoToken);
   const vthoOperations = await getTokenOperations(
+    config,
     vthoAccountId,
     address,
     VTHO_ADDRESS,