@ledgerhq/coin-vechain 3.0.0 → 4.0.0

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

@@ -1,6 +1,6 @@
 import { getThorClient } from "./getThorClient";
 import { ThorClient } from "@vechain/sdk-network";
-import { setCoinConfig } from "../config";
+import type { VechainCurrencyConfig } from "../config";
 
 // Mock the ThorClient
 jest.mock("@vechain/sdk-network", () => ({
@@ -10,14 +10,14 @@ jest.mock("@vechain/sdk-network", () => ({
 }));
 
 const NODE_URL = "https://testnet.veblocks.net";
+// The endpoint comes from the coin config, threaded in explicitly.
+const config: VechainCurrencyConfig = { status: { type: "active" }, node: { url: NODE_URL } };
 
 const mockedThorClient = jest.mocked(ThorClient);
 
 describe("getThorClient", () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    // The endpoint comes from the coin config, not from the environment.
-    setCoinConfig(() => ({ status: { type: "active" }, node: { url: NODE_URL } }));
   });
 
   it("should create a ThorClient instance with the configured node url", () => {
@@ -26,7 +26,7 @@ describe("getThorClient", () => {
     };
     mockedThorClient.at.mockReturnValue(mockClient as any);
 
-    const result = getThorClient();
+    const result = getThorClient(config);
 
     expect(mockedThorClient.at).toHaveBeenCalledWith(NODE_URL);
     expect(result).toBe(mockClient);
@@ -40,7 +40,7 @@ describe("getThorClient", () => {
     };
     mockedThorClient.at.mockReturnValue(mockClient as any);
 
-    const result = getThorClient();
+    const result = getThorClient(config);
 
     expect(result).toEqual(mockClient);
   });
@@ -49,7 +49,7 @@ describe("getThorClient", () => {
     const mockClient = {};
     mockedThorClient.at.mockReturnValue(mockClient as any);
 
-    getThorClient();
+    getThorClient(config);
 
     expect(mockedThorClient.at).toHaveBeenCalledTimes(1);
   });
@@ -58,7 +58,7 @@ describe("getThorClient", () => {
     const mockClient = {};
     mockedThorClient.at.mockReturnValue(mockClient as any);
 
-    getThorClient();
+    getThorClient(config);
 
     expect(mockedThorClient.at).toHaveBeenCalledWith("https://testnet.veblocks.net");
   });

package/src/common-logic/getThorClient.ts

@@ -1,10 +1,10 @@
 import { ThorClient } from "@vechain/sdk-network";
-import { getNodeUrl } from "../config";
+import { getNodeUrl, type VechainCurrencyConfig } from "../config";
 
 /**
  * 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(getNodeUrl());
+export const getThorClient = (config: VechainCurrencyConfig): ThorClient => {
+  return ThorClient.at(getNodeUrl(config));
 };

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

@@ -25,6 +25,7 @@ import {
   mapTokenTransfersToOperations,
 } from "./mapTransfersToOperations";
 import { getFees } from "../network/getFees";
+import { mockVechainConfig } from "../test/context";
 
 const { ABIEvent, Hex, VIP180_ABI } = jest.requireMock("@vechain/sdk-core");
 
@@ -76,6 +77,7 @@ describe("mapVetTransfersToOperations", () => {
 
   it("should map incoming VET transfers to operations", async () => {
     const result = await mapVetTransfersToOperations(
+      mockVechainConfig,
       [mockTransferLogs[0]],
       mockAccountId,
       mockAddr,
@@ -100,6 +102,7 @@ describe("mapVetTransfersToOperations", () => {
 
   it("should map outgoing VET transfers to operations", async () => {
     const result = await mapVetTransfersToOperations(
+      mockVechainConfig,
       [mockTransferLogs[1]],
       mockAccountId,
       mockAddr,
@@ -123,7 +126,12 @@ describe("mapVetTransfersToOperations", () => {
   });
 
   it("should handle multiple transfers", async () => {
-    const result = await mapVetTransfersToOperations(mockTransferLogs, mockAccountId, mockAddr);
+    const result = await mapVetTransfersToOperations(
+      mockVechainConfig,
+      mockTransferLogs,
+      mockAccountId,
+      mockAddr,
+    );
 
     expect(result).toHaveLength(2);
     expect(result[0].type).toBe("IN");
@@ -131,11 +139,11 @@ describe("mapVetTransfersToOperations", () => {
   });
 
   it("should call getFees for each transfer", async () => {
-    await mapVetTransfersToOperations(mockTransferLogs, mockAccountId, mockAddr);
+    await mapVetTransfersToOperations(mockVechainConfig, mockTransferLogs, mockAccountId, mockAddr);
 
     expect(mockedGetFees).toHaveBeenCalledTimes(2);
-    expect(mockedGetFees).toHaveBeenCalledWith("0xtx123");
-    expect(mockedGetFees).toHaveBeenCalledWith("0xtx456");
+    expect(mockedGetFees).toHaveBeenCalledWith(mockVechainConfig, "0xtx123");
+    expect(mockedGetFees).toHaveBeenCalledWith(mockVechainConfig, "0xtx456");
   });
 
   it("should handle case-insensitive address comparison", async () => {
@@ -146,6 +154,7 @@ describe("mapVetTransfersToOperations", () => {
     };
 
     const result = await mapVetTransfersToOperations(
+      mockVechainConfig,
       [transferWithUpperCase],
       mockAccountId,
       mockAddr,
@@ -162,6 +171,7 @@ describe("mapVetTransfersToOperations", () => {
     };
 
     const result = await mapVetTransfersToOperations(
+      mockVechainConfig,
       [transferWithMixedCase],
       mockAccountId,
       mockAddr,
@@ -216,7 +226,12 @@ describe("mapTokenTransfersToOperations", () => {
   });
 
   it("should map incoming token transfers to operations", async () => {
-    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    const result = await mapTokenTransfersToOperations(
+      mockVechainConfig,
+      mockEventLogs,
+      mockAccountId,
+      mockAddr,
+    );
 
     expect(result).toHaveLength(1);
     expect(result[0]).toEqual({
@@ -246,14 +261,19 @@ describe("mapTokenTransfersToOperations", () => {
     };
     mockedABIEvent.parseLog.mockReturnValue(outgoingEvent);
 
-    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    const result = await mapTokenTransfersToOperations(
+      mockVechainConfig,
+      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);
+    await mapTokenTransfersToOperations(mockVechainConfig, mockEventLogs, mockAccountId, mockAddr);
 
     expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].data);
     expect(mockedHex.of).toHaveBeenCalledWith(mockEventLogs[0].topics[0]);
@@ -280,16 +300,21 @@ describe("mapTokenTransfersToOperations", () => {
     };
     mockedABIEvent.parseLog.mockReturnValue(largeValueEvent);
 
-    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    const result = await mapTokenTransfersToOperations(
+      mockVechainConfig,
+      mockEventLogs,
+      mockAccountId,
+      mockAddr,
+    );
 
     expect(result[0].value).toEqual(new BigNumber("123456789012345678901234567890"));
   });
 
   it("should call getFees for each event", async () => {
-    await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    await mapTokenTransfersToOperations(mockVechainConfig, mockEventLogs, mockAccountId, mockAddr);
 
     expect(mockedGetFees).toHaveBeenCalledTimes(1);
-    expect(mockedGetFees).toHaveBeenCalledWith("0xtx789");
+    expect(mockedGetFees).toHaveBeenCalledWith(mockVechainConfig, "0xtx789");
   });
 
   it("should handle multiple events", async () => {
@@ -301,7 +326,7 @@ describe("mapTokenTransfersToOperations", () => {
       },
     ];
 
-    await mapTokenTransfersToOperations(multipleEvents, mockAccountId, mockAddr);
+    await mapTokenTransfersToOperations(mockVechainConfig, multipleEvents, mockAccountId, mockAddr);
 
     expect(mockedGetFees).toHaveBeenCalledTimes(2);
     expect(mockedABIEvent.parseLog).toHaveBeenCalledTimes(2);
@@ -318,7 +343,12 @@ describe("mapTokenTransfersToOperations", () => {
     };
     mockedABIEvent.parseLog.mockReturnValue(upperCaseEvent);
 
-    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    const result = await mapTokenTransfersToOperations(
+      mockVechainConfig,
+      mockEventLogs,
+      mockAccountId,
+      mockAddr,
+    );
 
     expect(result[0].type).toBe("IN");
   });
@@ -334,7 +364,12 @@ describe("mapTokenTransfersToOperations", () => {
     };
     mockedABIEvent.parseLog.mockReturnValue(mixedCaseEvent);
 
-    const result = await mapTokenTransfersToOperations(mockEventLogs, mockAccountId, mockAddr);
+    const result = await mapTokenTransfersToOperations(
+      mockVechainConfig,
+      mockEventLogs,
+      mockAccountId,
+      mockAddr,
+    );
 
     expect(result[0].senders[0]).toBe("0x5034aa590125b64023a0262112b98d72e3c8e40e");
     expect(result[0].recipients[0]).toBe("0x742d35cc6634c0532925a3b8d0b251d8c1743ec4");

package/src/common-logic/mapTransfersToOperations.ts

@@ -4,15 +4,17 @@ import { EventLog, TransferLog } from "../types";
 import { encodeOperationId } from "@ledgerhq/ledger-wallet-framework/operation";
 import { getFees } from "../network/getFees";
 import { ABIEvent, Hex, VIP180_ABI } from "@vechain/sdk-core";
+import type { VechainCurrencyConfig } from "../config";
 
 export const mapVetTransfersToOperations = async (
+  config: VechainCurrencyConfig,
   txs: TransferLog[],
   accountId: string,
   addr: string,
 ): Promise<Operation[]> => {
   return Promise.all(
     txs.map(async tx => {
-      const fees = await getFees(tx.meta.txID);
+      const fees = await getFees(config, tx.meta.txID);
       return {
         id: encodeOperationId(
           accountId,
@@ -36,6 +38,7 @@ export const mapVetTransfersToOperations = async (
 };
 
 export const mapTokenTransfersToOperations = async (
+  config: VechainCurrencyConfig,
   events: EventLog[],
   accountId: string,
   addr: string,
@@ -57,7 +60,7 @@ export const mapTokenTransfersToOperations = async (
       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);
+      const fees = await getFees(config, event.meta.txID);
       return {
         id: encodeOperationId(accountId, event.meta.txID, type),
         hash: event.meta.txID,

package/src/config.test.ts

@@ -49,7 +49,7 @@ describe("getChainTag", () => {
       chainTag: 39,
     }));
 
-    expect(getChainTag()).toBe(39);
+    expect(getChainTag(getCoinConfig())).toBe(39);
   });
 
   it("falls back to mainnet when the currency config omits a chainTag", () => {
@@ -58,7 +58,7 @@ describe("getChainTag", () => {
       node: { url: "https://vechain.coin.ledger.com" },
     }));
 
-    expect(getChainTag()).toBe(MAINNET_CHAIN_TAG);
+    expect(getChainTag(getCoinConfig())).toBe(MAINNET_CHAIN_TAG);
   });
 
   it.each([-1, 256, 74.5, NaN])(
@@ -70,7 +70,7 @@ describe("getChainTag", () => {
         chainTag: invalid,
       }));
 
-      expect(getChainTag()).toBe(MAINNET_CHAIN_TAG);
+      expect(getChainTag(getCoinConfig())).toBe(MAINNET_CHAIN_TAG);
     },
   );
 });

package/src/config.ts

@@ -1,4 +1,4 @@
-import { CurrencyConfig, CoinConfig } from "@ledgerhq/coin-module-framework/config";
+import { CurrencyConfig, CoinConfig, type Context } from "@ledgerhq/coin-module-framework/config";
 import { MissingCoinConfig } from "@ledgerhq/coin-module-framework/errors";
 import { MAINNET_CHAIN_TAG } from "./types";
 
@@ -15,6 +15,9 @@ export type VechainCurrencyConfig = CurrencyConfig & {
 
 export type VechainCoinConfig = () => VechainCurrencyConfig;
 
+/** The {@link Context} threaded through the coin-vechain API layer (ADR-019). */
+export type VechainContext = Context<VechainCurrencyConfig>;
+
 let coinConfig: CoinConfig<VechainCurrencyConfig> | undefined;
 
 export function setCoinConfig(config: CoinConfig<VechainCurrencyConfig>): void {
@@ -29,9 +32,13 @@ export function getCoinConfig(): VechainCurrencyConfig {
   return coinConfig();
 }
 
-/** Thor REST endpoint, resolved per call so a config change is picked up without a reload. */
-export function getNodeUrl(): string {
-  const { node } = getCoinConfig();
+/**
+ * Thor REST endpoint. Config is threaded in explicitly by every caller: the Alpaca (`createApi`)
+ * path resolves it from `context.config()`, and the classic bridge resolves it once from the
+ * {@link getCoinConfig} singleton at its entry points and passes it down.
+ */
+export function getNodeUrl(config: VechainCurrencyConfig): string {
+  const { node } = config;
 
   if (!node?.url) {
     throw new Error("vechain: node.url is missing from the coin config");
@@ -40,8 +47,8 @@ export function getNodeUrl(): string {
   return node.url;
 }
 
-export function getChainTag(): number {
-  const { chainTag } = getCoinConfig();
+export function getChainTag(config: VechainCurrencyConfig): number {
+  const { chainTag } = config;
   return typeof chainTag === "number" &&
     Number.isInteger(chainTag) &&
     chainTag >= 0 &&

package/src/logic/account/getBalance.ts

@@ -1,5 +1,6 @@
 import type { AssetInfo, Balance } from "@ledgerhq/coin-module-framework/api/index";
 import { VTHO_ADDRESS } from "@vechain/sdk-core";
+import type { VechainContext } from "../../config";
 import { getAccount } from "../../network";
 
 export const NATIVE_ASSET: AssetInfo = { type: "native", name: "VET" };
@@ -14,8 +15,9 @@ export const vthoAsset = (address: string): AssetInfo => ({
 });
 
 // VET + VTHO balances from Thor's /accounts/{address} (both returned in one call); 0 if absent.
-export async function getBalance(address: string): Promise<Balance[]> {
-  const { balance, energy } = await getAccount(address);
+export async function getBalance(context: VechainContext, address: string): Promise<Balance[]> {
+  const config = await context.config();
+  const { balance, energy } = await getAccount(config, address);
 
   return [
     { value: BigInt(balance || "0"), asset: NATIVE_ASSET },

package/src/logic/account/getBalance.unit.test.ts

@@ -1,9 +1,11 @@
 import { getAccount } from "../../network";
+import { createMockVechainContext, mockVechainConfig } from "../../test/context";
 import { getBalance, NATIVE_ASSET, vthoAsset } from "./getBalance";
 
 jest.mock("../../network", () => ({ getAccount: jest.fn() }));
 
 const ADDRESS = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+const context = createMockVechainContext();
 
 describe("getBalance", () => {
   afterEach(() => {
@@ -17,9 +19,9 @@ describe("getBalance", () => {
       hasCode: false,
     });
 
-    const balances = await getBalance(ADDRESS);
+    const balances = await getBalance(context, ADDRESS);
 
-    expect(getAccount).toHaveBeenCalledWith(ADDRESS);
+    expect(getAccount).toHaveBeenCalledWith(mockVechainConfig, ADDRESS);
     expect(balances).toEqual([
       { value: BigInt("0x1bc16d674ec80000"), asset: NATIVE_ASSET },
       { value: BigInt("0xde0b6b3a7640000"), asset: vthoAsset(ADDRESS) },
@@ -29,7 +31,7 @@ describe("getBalance", () => {
   it("defaults both balances to 0 for a pristine account", async () => {
     jest.mocked(getAccount).mockResolvedValueOnce({ balance: "", energy: "", hasCode: false });
 
-    const balances = await getBalance(ADDRESS);
+    const balances = await getBalance(context, ADDRESS);
 
     expect(balances).toEqual([
       { value: 0n, asset: NATIVE_ASSET },
@@ -42,7 +44,7 @@ describe("getBalance", () => {
       .mocked(getAccount)
       .mockResolvedValueOnce({ balance: "0x1", energy: "0x2", hasCode: false });
 
-    const [nativeBalance, tokenBalance] = await getBalance(ADDRESS);
+    const [nativeBalance, tokenBalance] = await getBalance(context, ADDRESS);
 
     expect(nativeBalance.asset.type).toBe("native");
     expect(tokenBalance.asset.type).not.toBe("native");

package/src/logic/history/getBlock.ts

@@ -3,14 +3,16 @@ import type {
   BlockOperation,
   BlockTransaction,
 } from "@ledgerhq/coin-module-framework/api/index";
+import type { VechainContext } from "../../config";
 import { getBlock as getBlockFromNetwork } from "../../network";
 import type { ApiResponseBlockTransaction } from "../../types";
 import { toBlockInfo } from "./getBlockInfo";
 
 // Full expanded block; block info is derived from it (no separate fetch). Only native VET transfers
 // map to operations; VTHO (VIP-180) movements are ABI-encoded events, not decoded here.
-export async function getBlock(height: number): Promise<Block> {
-  const block = await getBlockFromNetwork(height, true);
+export async function getBlock(context: VechainContext, height: number): Promise<Block> {
+  const config = await context.config();
+  const block = await getBlockFromNetwork(config, height, true);
 
   if (!block) {
     throw new Error(`vechain: no block at height ${height}`);

package/src/logic/history/getBlock.unit.test.ts

@@ -1,8 +1,11 @@
 import { getBlock as getBlockFromNetwork } from "../../network";
+import { createMockVechainContext, mockVechainConfig } from "../../test/context";
 import { getBlock } from "./getBlock";
 
 jest.mock("../../network", () => ({ getBlock: jest.fn() }));
 
+const context = createMockVechainContext();
+
 describe("getBlock", () => {
   afterEach(() => {
     jest.clearAllMocks();
@@ -31,10 +34,10 @@ describe("getBlock", () => {
       ],
     });
 
-    const block = await getBlock(10);
+    const block = await getBlock(context, 10);
 
     expect(getBlockFromNetwork).toHaveBeenCalledTimes(1);
-    expect(getBlockFromNetwork).toHaveBeenCalledWith(10, true);
+    expect(getBlockFromNetwork).toHaveBeenCalledWith(mockVechainConfig, 10, true);
     expect(block.info).toEqual({
       height: 10,
       hash: "0xabc",
@@ -69,7 +72,7 @@ describe("getBlock", () => {
       ],
     });
 
-    const block = await getBlock(10);
+    const block = await getBlock(context, 10);
 
     expect(block.transactions[0].failed).toBe(true);
     expect(block.transactions[0].operations).toEqual([]);
@@ -78,7 +81,7 @@ describe("getBlock", () => {
   it("throws when there is no block at the given height", async () => {
     jest.mocked(getBlockFromNetwork).mockResolvedValueOnce(null);
 
-    await expect(getBlock(1)).rejects.toThrow("vechain: no block at height 1");
+    await expect(getBlock(context, 1)).rejects.toThrow("vechain: no block at height 1");
   });
 
   it("uses the VIP-191 gasPayer as feesPayer when a tx is fee-delegated", async () => {
@@ -99,7 +102,7 @@ describe("getBlock", () => {
       ],
     });
 
-    const block = await getBlock(10);
+    const block = await getBlock(context, 10);
 
     expect(block.transactions[0].feesPayer).toBe("0xdelegate");
   });

package/src/logic/history/getBlockInfo.ts

@@ -1,4 +1,5 @@
 import type { BlockInfo } from "@ledgerhq/coin-module-framework/api/index";
+import type { VechainContext } from "../../config";
 import { getBlock as getBlockFromNetwork } from "../../network";
 import type { ApiResponseBlock } from "../../types";
 
@@ -13,8 +14,9 @@ export function toBlockInfo(block: ApiResponseBlock): BlockInfo {
 }
 
 /** Block metadata (height/hash/time) at a given block height, via Thor `GET /blocks/{height}`. */
-export async function getBlockInfo(height: number): Promise<BlockInfo> {
-  const block = await getBlockFromNetwork(height);
+export async function getBlockInfo(context: VechainContext, height: number): Promise<BlockInfo> {
+  const config = await context.config();
+  const block = await getBlockFromNetwork(config, height, false);
 
   if (!block) {
     throw new Error(`vechain: no block at height ${height}`);

package/src/logic/history/getBlockInfo.unit.test.ts

@@ -1,8 +1,11 @@
 import { getBlock as getBlockFromNetwork } from "../../network";
+import { createMockVechainContext, mockVechainConfig } from "../../test/context";
 import { getBlockInfo } from "./getBlockInfo";
 
 jest.mock("../../network", () => ({ getBlock: jest.fn() }));
 
+const context = createMockVechainContext();
+
 describe("getBlockInfo", () => {
   afterEach(() => {
     jest.clearAllMocks();
@@ -16,15 +19,15 @@ describe("getBlockInfo", () => {
       transactions: [],
     });
 
-    const info = await getBlockInfo(42);
+    const info = await getBlockInfo(context, 42);
 
-    expect(getBlockFromNetwork).toHaveBeenCalledWith(42);
+    expect(getBlockFromNetwork).toHaveBeenCalledWith(mockVechainConfig, 42, false);
     expect(info).toEqual({ height: 42, hash: "0xabc", time: new Date(1_700_000_000 * 1000) });
   });
 
   it("throws when there is no block at the given height", async () => {
     jest.mocked(getBlockFromNetwork).mockResolvedValueOnce(null);
 
-    await expect(getBlockInfo(999)).rejects.toThrow("vechain: no block at height 999");
+    await expect(getBlockInfo(context, 999)).rejects.toThrow("vechain: no block at height 999");
   });
 });

package/src/logic/history/lastBlock.ts

@@ -1,9 +1,11 @@
 import type { BlockInfo } from "@ledgerhq/coin-module-framework/api/index";
+import type { VechainContext } from "../../config";
 import { getLastBlockHeight } from "../../network";
 import { getBlockInfo } from "./getBlockInfo";
 
 // Latest block; /blocks/best exposes only the height, so hash/time come from getBlockInfo.
-export async function lastBlock(): Promise<BlockInfo> {
-  const height = await getLastBlockHeight();
-  return getBlockInfo(height);
+export async function lastBlock(context: VechainContext): Promise<BlockInfo> {
+  const config = await context.config();
+  const height = await getLastBlockHeight(config);
+  return getBlockInfo(context, height);
 }

package/src/logic/history/lastBlock.unit.test.ts

@@ -1,10 +1,13 @@
 import { getLastBlockHeight } from "../../network";
+import { createMockVechainContext } from "../../test/context";
 import { getBlockInfo } from "./getBlockInfo";
 import { lastBlock } from "./lastBlock";
 
 jest.mock("../../network", () => ({ getLastBlockHeight: jest.fn() }));
 jest.mock("./getBlockInfo", () => ({ getBlockInfo: jest.fn() }));
 
+const context = createMockVechainContext();
+
 describe("lastBlock", () => {
   afterEach(() => {
     jest.clearAllMocks();
@@ -15,16 +18,16 @@ describe("lastBlock", () => {
     const info = { height: 123, hash: "0xabc", time: new Date() };
     jest.mocked(getBlockInfo).mockResolvedValueOnce(info);
 
-    const result = await lastBlock();
+    const result = await lastBlock(context);
 
-    expect(getBlockInfo).toHaveBeenCalledWith(123);
+    expect(getBlockInfo).toHaveBeenCalledWith(context, 123);
     expect(result).toBe(info);
   });
 
   it("propagates an error from the height lookup", async () => {
     jest.mocked(getLastBlockHeight).mockRejectedValueOnce(new Error("network down"));
 
-    await expect(lastBlock()).rejects.toThrow("network down");
+    await expect(lastBlock(context)).rejects.toThrow("network down");
     expect(getBlockInfo).not.toHaveBeenCalled();
   });
 });

package/src/logic/history/listOperations.ts

@@ -7,6 +7,7 @@ import type {
 } from "@ledgerhq/coin-module-framework/api/index";
 import type { Operation as LegacyOperation } from "@ledgerhq/types-live";
 import { VTHO_ADDRESS } from "@vechain/sdk-core";
+import type { VechainContext } from "../../config";
 import { getLastBlockHeight, getOperations, getTokenOperations } from "../../network";
 import { NATIVE_ASSET, vthoAsset } from "../account/getBalance";
 
@@ -37,19 +38,21 @@ function parseCursor(options: ListOperationsOptions): number {
 
 // Merged VET + VTHO operations; `next` is one block past the current head for incremental resume.
 export async function listOperations(
+  context: VechainContext,
   address: string,
   options: ListOperationsOptions,
 ): Promise<Page<Operation<MemoNotSupported>>> {
+  const config = await context.config();
   const startAt = parseCursor(options);
-  const stopAt = await getLastBlockHeight();
+  const stopAt = await getLastBlockHeight(config);
 
   if (startAt > stopAt) {
     return { items: [], next: String(startAt) };
   }
 
   const [vetOps, vthoOps] = await Promise.all([
-    getOperations(address, address, startAt, stopAt),
-    getTokenOperations(address, address, VTHO_ADDRESS, startAt, stopAt),
+    getOperations(config, address, address, startAt, stopAt),
+    getTokenOperations(config, address, address, VTHO_ADDRESS, startAt, stopAt),
   ]);
 
   const items = [