@ledgerhq/coin-vechain 3.0.0 → 4.0.0

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

@@ -1,6 +1,7 @@
 import BigNumber from "bignumber.js";
 import type { Operation as LegacyOperation } from "@ledgerhq/types-live";
 import { getLastBlockHeight, getOperations, getTokenOperations } from "../../network";
+import { createMockVechainContext } from "../../test/context";
 import { listOperations } from "./listOperations";
 
 jest.mock("../../network", () => ({
@@ -10,6 +11,7 @@ jest.mock("../../network", () => ({
 }));
 
 const ADDRESS = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+const context = createMockVechainContext();
 
 function makeLegacyOp(overrides: Partial<LegacyOperation> = {}): LegacyOperation {
   return {
@@ -41,7 +43,7 @@ describe("listOperations", () => {
       .mocked(getTokenOperations)
       .mockResolvedValueOnce([makeLegacyOp({ id: "vtho-op", type: "IN" })]);
 
-    const page = await listOperations(ADDRESS, { minHeight: 0 });
+    const page = await listOperations(context, ADDRESS, { minHeight: 0 });
 
     expect(page.items).toHaveLength(2);
     expect(page.items.find(op => op.id === "vet-op")?.asset).toEqual({
@@ -67,7 +69,7 @@ describe("listOperations", () => {
         makeLegacyOp({ id: "vtho-1", date: new Date("2024-01-02T00:00:00Z") }),
       ]);
 
-    const page = await listOperations(ADDRESS, { minHeight: 0 });
+    const page = await listOperations(context, ADDRESS, { minHeight: 0 });
 
     const ids = page.items.map(op => op.id);
     expect(ids).toHaveLength(3);
@@ -87,7 +89,7 @@ describe("listOperations", () => {
     jest.mocked(getOperations).mockResolvedValueOnce([outOp]);
     jest.mocked(getTokenOperations).mockResolvedValueOnce([]);
 
-    const page = await listOperations(ADDRESS, { minHeight: 0 });
+    const page = await listOperations(context, ADDRESS, { minHeight: 0 });
 
     expect(page.items[0].value).toBe(BigInt("1000000000000000000"));
     expect(page.items[0].tx.fees).toBe(0n);
@@ -103,7 +105,7 @@ describe("listOperations", () => {
     jest.mocked(getOperations).mockResolvedValueOnce([]);
     jest.mocked(getTokenOperations).mockResolvedValueOnce([vthoOut]);
 
-    const page = await listOperations(ADDRESS, { minHeight: 0 });
+    const page = await listOperations(context, ADDRESS, { minHeight: 0 });
 
     expect(page.items[0].value).toBe(BigInt("5000000000000000000"));
     expect(page.items[0].tx.fees).toBe(BigInt("21000000000000000"));
@@ -112,7 +114,7 @@ describe("listOperations", () => {
   it("returns an empty page (with a resumable cursor) when the range is already exhausted", async () => {
     jest.mocked(getLastBlockHeight).mockResolvedValueOnce(50);
 
-    const page = await listOperations(ADDRESS, { minHeight: 0, cursor: "100" });
+    const page = await listOperations(context, ADDRESS, { minHeight: 0, cursor: "100" });
 
     expect(page.items).toEqual([]);
     expect(getOperations).not.toHaveBeenCalled();
@@ -124,6 +126,8 @@ describe("listOperations", () => {
     jest.mocked(getOperations).mockRejectedValueOnce(new Error("network down"));
     jest.mocked(getTokenOperations).mockResolvedValueOnce([]);
 
-    await expect(listOperations(ADDRESS, { minHeight: 0 })).rejects.toThrow("network down");
+    await expect(listOperations(context, ADDRESS, { minHeight: 0 })).rejects.toThrow(
+      "network down",
+    );
   });
 });

package/src/logic/transaction/broadcast.msw.test.ts

@@ -1,8 +1,13 @@
 import { http, HttpResponse } from "msw";
 import { server, TEST_VECHAIN_ENDPOINT } from "../../test/msw.mock";
+import { createMockVechainContext } from "../../test/context";
 import { broadcast } from "./broadcast";
 
 const SUBMIT_URL = `${TEST_VECHAIN_ENDPOINT}/transactions`;
+const context = createMockVechainContext({
+  status: { type: "active" },
+  node: { url: TEST_VECHAIN_ENDPOINT },
+});
 
 beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
 afterEach(() => server.resetHandlers());
@@ -12,12 +17,12 @@ describe("broadcast via MSW", () => {
   it("submits the signed raw transaction and returns the transaction id", async () => {
     server.use(http.post(SUBMIT_URL, () => HttpResponse.json({ id: "0xtxid" })));
 
-    expect(await broadcast("0xaabbcc")).toBe("0xtxid");
+    expect(await broadcast(context, "0xaabbcc")).toBe("0xtxid");
   });
 
   it("throws on an HTTP 200 whose body carries no transaction id (never swallows an error body)", async () => {
     server.use(http.post(SUBMIT_URL, () => HttpResponse.json({})));
 
-    await expect(broadcast("0xaabbcc")).rejects.toThrow("Expected an ID to be returned");
+    await expect(broadcast(context, "0xaabbcc")).rejects.toThrow("Expected an ID to be returned");
   });
 });

package/src/logic/transaction/broadcast.ts

@@ -1,10 +1,16 @@
 import type { BroadcastConfig } from "@ledgerhq/coin-module-framework/api/types";
+import type { VechainContext } from "../../config";
 import { submit } from "../../network";
 import type { VechainSDKTransaction } from "../../types";
 
 // Submit a signed tx (hex from combine) via Thor POST /transactions.
-export async function broadcast(tx: string, _broadcastConfig?: BroadcastConfig): Promise<string> {
+export async function broadcast(
+  context: VechainContext,
+  tx: string,
+  _broadcastConfig?: BroadcastConfig,
+): Promise<string> {
+  const config = await context.config();
   const encoded = Uint8Array.from(Buffer.from(tx.replace(/^0x/, ""), "hex"));
 
-  return submit({ encoded } as VechainSDKTransaction);
+  return submit(config, { encoded } as VechainSDKTransaction);
 }

package/src/logic/transaction/broadcast.unit.test.ts

@@ -1,8 +1,11 @@
 import { submit } from "../../network";
+import { createMockVechainContext } from "../../test/context";
 import { broadcast } from "./broadcast";
 
 jest.mock("../../network", () => ({ submit: jest.fn() }));
 
+const context = createMockVechainContext();
+
 describe("broadcast", () => {
   afterEach(() => {
     jest.clearAllMocks();
@@ -11,16 +14,16 @@ describe("broadcast", () => {
   it("decodes the hex raw transaction and delegates to submit", async () => {
     jest.mocked(submit).mockResolvedValueOnce("0xtxid");
 
-    const id = await broadcast("0xaabbcc");
+    const id = await broadcast(context, "0xaabbcc");
 
     expect(id).toBe("0xtxid");
-    const [passed] = jest.mocked(submit).mock.calls[0];
+    const [, passed] = jest.mocked(submit).mock.calls[0];
     expect(Array.from(passed.encoded as Uint8Array)).toEqual([0xaa, 0xbb, 0xcc]);
   });
 
   it("propagates an error from submit", async () => {
     jest.mocked(submit).mockRejectedValueOnce(new Error("vechain: broadcast rejected"));
 
-    await expect(broadcast("0xaabbcc")).rejects.toThrow("vechain: broadcast rejected");
+    await expect(broadcast(context, "0xaabbcc")).rejects.toThrow("vechain: broadcast rejected");
   });
 });

package/src/logic/transaction/combine.ts

@@ -2,9 +2,13 @@ import type { VechainSDKTransactionBody } from "../../types";
 import { VechainSDKTransaction } from "../../types";
 
 // Attach the signature to the crafted body and return the signed, hex-encoded tx for broadcast.
-export function combine(tx: string, signature: string): string {
+export function combine(tx: string, signature: string[]): string {
+  if (signature.length !== 1) {
+    throw new Error(`VeChain combine expects exactly one signature, got ${signature.length}`);
+  }
+
   const body = JSON.parse(tx) as VechainSDKTransactionBody;
-  const signed = VechainSDKTransaction.of(body, Buffer.from(signature, "hex"));
+  const signed = VechainSDKTransaction.of(body, Buffer.from(signature[0], "hex"));
 
   return `0x${Buffer.from(signed.encoded).toString("hex")}`;
 }

package/src/logic/transaction/combine.unit.test.ts

@@ -17,7 +17,7 @@ describe("combine", () => {
   it("returns a hex-encoded signed transaction", () => {
     const signature = "aa".repeat(65);
 
-    const signed = combine(JSON.stringify(BODY), signature);
+    const signed = combine(JSON.stringify(BODY), [signature]);
 
     expect(signed).toMatch(/^0x[0-9a-f]+$/);
   });
@@ -25,13 +25,13 @@ describe("combine", () => {
   it("produces a different (longer) payload than the unsigned body JSON, reflecting the signature", () => {
     const signature = "bb".repeat(65);
 
-    const signed = combine(JSON.stringify(BODY), signature);
+    const signed = combine(JSON.stringify(BODY), [signature]);
 
     expect(signed.length).toBeGreaterThan(0);
     expect(signed).not.toBe(JSON.stringify(BODY));
   });
 
   it("throws on a malformed transaction payload", () => {
-    expect(() => combine("not-json", "aa".repeat(65))).toThrow();
+    expect(() => combine("not-json", ["aa".repeat(65)])).toThrow();
   });
 });

package/src/logic/transaction/craftTransaction.ts

@@ -12,7 +12,7 @@ import {
 } from "../../common-logic";
 import { estimateGas } from "../../common-logic/estimateGas";
 import { getThorClient } from "../../common-logic/getThorClient";
-import { getChainTag } from "../../config";
+import { getChainTag, type VechainContext, type VechainCurrencyConfig } from "../../config";
 import { getAccount, getBlockRef } from "../../network";
 import type { VechainSDKTransactionBody, VechainSDKTransactionClause } from "../../types";
 
@@ -28,16 +28,21 @@ function isTokenAsset(intent: TransactionIntent): boolean {
   return intent.asset.type !== "native";
 }
 
-async function resolveAmount(intent: TransactionIntent, isToken: boolean): Promise<BigNumber> {
+async function resolveAmount(
+  config: VechainCurrencyConfig,
+  intent: TransactionIntent,
+  isToken: boolean,
+): Promise<BigNumber> {
   if (!intent.useAllAmount) {
     return new BigNumber(intent.amount.toString());
   }
 
-  const { balance, energy } = await getAccount(intent.sender);
+  const { balance, energy } = await getAccount(config, intent.sender);
   return new BigNumber((isToken ? energy : balance) || "0");
 }
 
 async function resolveGasFees(
+  config: VechainCurrencyConfig,
   clauses: VechainSDKTransactionClause[],
   sender: string,
   customFees?: FeeEstimation,
@@ -57,8 +62,8 @@ async function resolveGasFees(
     };
   }
 
-  const gasResult = await estimateGas(clauses, sender);
-  const thorClient = getThorClient();
+  const gasResult = await estimateGas(config, clauses, sender);
+  const thorClient = getThorClient(config);
   const body = await thorClient.transactions.buildTransactionBody(clauses, gasResult.totalGas, {});
 
   // Partial override: apply each provided field individually over the estimate, so e.g. a
@@ -75,6 +80,7 @@ async function resolveGasFees(
 // Craft an unsigned single-clause Thor tx (VET transfer, or VIP-180 transfer for VTHO). The returned
 // transaction is the JSON VechainSDKTransactionBody that combine() parses back — keep them in sync.
 export async function craftTransaction(
+  context: VechainContext,
   intent: TransactionIntent,
   customFees?: FeeEstimation,
 ): Promise<CraftedTransaction> {
@@ -87,8 +93,9 @@ export async function craftTransaction(
     throw new Error("vechain: invalid sender address");
   }
 
+  const config = await context.config();
   const isToken = isTokenAsset(intent);
-  let amount = await resolveAmount(intent, isToken);
+  let amount = await resolveAmount(config, intent, isToken);
   if (amount.lte(0)) {
     throw new Error("vechain: transaction amount must be positive");
   }
@@ -98,8 +105,8 @@ export async function craftTransaction(
     : await calculateClausesVet(intent.recipient, amount);
 
   const [{ gas, maxFeePerGas, maxPriorityFeePerGas }, blockRef] = await Promise.all([
-    resolveGasFees(clauses, intent.sender, customFees),
-    getBlockRef(),
+    resolveGasFees(config, clauses, intent.sender, customFees),
+    getBlockRef(config),
   ]);
 
   const fee = new BigNumber(maxFeePerGas).times(gas);
@@ -113,7 +120,7 @@ export async function craftTransaction(
   }
 
   const body: VechainSDKTransactionBody = {
-    chainTag: getChainTag(),
+    chainTag: getChainTag(config),
     blockRef,
     expiration: EXPIRATION,
     clauses,

package/src/logic/transaction/craftTransaction.unit.test.ts

@@ -3,7 +3,8 @@ import type { TransactionIntent } from "@ledgerhq/coin-module-framework/api/inde
 import { calculateClausesVet, calculateClausesVtho, parseAddress } from "../../common-logic";
 import { estimateGas } from "../../common-logic/estimateGas";
 import { getThorClient } from "../../common-logic/getThorClient";
-import { setCoinConfig } from "../../config";
+import type { VechainCurrencyConfig } from "../../config";
+import { createMockVechainContext } from "../../test/context";
 import { getAccount, getBlockRef } from "../../network";
 import { craftTransaction } from "./craftTransaction";
 
@@ -44,7 +45,14 @@ function mockBuildTransactionBody() {
   };
 }
 
+const DEFAULT_CONFIG: VechainCurrencyConfig = {
+  status: { type: "active" },
+  node: { url: "https://vechain.coin.ledger.com" },
+};
+
 describe("craftTransaction", () => {
+  let context = createMockVechainContext(DEFAULT_CONFIG);
+
   beforeEach(() => {
     jest
       .mocked(calculateClausesVet)
@@ -55,10 +63,7 @@ describe("craftTransaction", () => {
     jest.mocked(estimateGas).mockResolvedValue({ totalGas: 21000 } as never);
     jest.mocked(getThorClient).mockReturnValue(mockBuildTransactionBody() as never);
     jest.mocked(getBlockRef).mockResolvedValue("0xblockref12345678");
-    setCoinConfig(() => ({
-      status: { type: "active" },
-      node: { url: "https://vechain.coin.ledger.com" },
-    }));
+    context = createMockVechainContext(DEFAULT_CONFIG);
   });
 
   afterEach(() => {
@@ -66,7 +71,7 @@ describe("craftTransaction", () => {
   });
 
   it("crafts a native VET transaction using calculateClausesVet", async () => {
-    const crafted = await craftTransaction(NATIVE_INTENT);
+    const crafted = await craftTransaction(context, NATIVE_INTENT);
 
     expect(calculateClausesVet).toHaveBeenCalled();
     expect(calculateClausesVtho).not.toHaveBeenCalled();
@@ -78,27 +83,23 @@ describe("craftTransaction", () => {
   });
 
   it("defaults chainTag to mainnet (74) when the config has no chainTag", async () => {
-    const crafted = await craftTransaction(NATIVE_INTENT);
+    const crafted = await craftTransaction(context, NATIVE_INTENT);
 
     const body = JSON.parse(crafted.transaction);
     expect(body.chainTag).toBe(74);
   });
 
   it("uses the config-provided chainTag when set", async () => {
-    setCoinConfig(() => ({
-      status: { type: "active" },
-      node: { url: "https://vechain.coin.ledger.com" },
-      chainTag: 39,
-    }));
+    context = createMockVechainContext({ ...DEFAULT_CONFIG, chainTag: 39 });
 
-    const crafted = await craftTransaction(NATIVE_INTENT);
+    const crafted = await craftTransaction(context, NATIVE_INTENT);
 
     const body = JSON.parse(crafted.transaction);
     expect(body.chainTag).toBe(39);
   });
 
   it("crafts a VTHO transaction using calculateClausesVtho", async () => {
-    const crafted = await craftTransaction(TOKEN_INTENT);
+    const crafted = await craftTransaction(context, TOKEN_INTENT);
 
     expect(calculateClausesVtho).toHaveBeenCalled();
     expect(calculateClausesVet).not.toHaveBeenCalled();
@@ -106,7 +107,7 @@ describe("craftTransaction", () => {
   });
 
   it("computes the fee as maxFeePerGas * gas", async () => {
-    const crafted = await craftTransaction(NATIVE_INTENT);
+    const crafted = await craftTransaction(context, NATIVE_INTENT);
 
     expect(crafted.details?.fee).toBe((1000 * 21000).toString());
   });
@@ -118,14 +119,14 @@ describe("craftTransaction", () => {
       hasCode: false,
     });
 
-    await craftTransaction({ ...NATIVE_INTENT, useAllAmount: true, amount: 0n });
+    await craftTransaction(context, { ...NATIVE_INTENT, useAllAmount: true, amount: 0n });
 
-    expect(getAccount).toHaveBeenCalledWith(SENDER);
+    expect(getAccount).toHaveBeenCalledWith(DEFAULT_CONFIG, SENDER);
     expect(calculateClausesVet).toHaveBeenCalledWith(RECIPIENT, expect.any(Object));
   });
 
   it("uses custom fee parameters instead of re-estimating gas when provided", async () => {
-    await craftTransaction(NATIVE_INTENT, {
+    await craftTransaction(context, NATIVE_INTENT, {
       value: 5000n,
       parameters: { gas: 30000, maxFeePerGas: 50, maxPriorityFeePerGas: 5 },
     });
@@ -134,7 +135,7 @@ describe("craftTransaction", () => {
   });
 
   it("applies a partial fee override (gas only) over the estimate instead of discarding it", async () => {
-    const crafted = await craftTransaction(NATIVE_INTENT, {
+    const crafted = await craftTransaction(context, NATIVE_INTENT, {
       value: 0n,
       parameters: { gas: 30000 },
     });
@@ -149,7 +150,7 @@ describe("craftTransaction", () => {
   it("coerces bigint fee parameters to numbers so the body stays JSON-serializable", async () => {
     // The generic coin-framework hands fee parameters back as bigint; JSON.stringify cannot
     // serialize a bigint, so craftTransaction must coerce them to numbers before building the body.
-    const crafted = await craftTransaction(NATIVE_INTENT, {
+    const crafted = await craftTransaction(context, NATIVE_INTENT, {
       value: 5000n,
       parameters: { gas: 30000n, maxFeePerGas: 50n, maxPriorityFeePerGas: 5n },
     } as never);
@@ -162,7 +163,7 @@ describe("craftTransaction", () => {
   });
 
   it("throws when the recipient is missing", async () => {
-    await expect(craftTransaction({ ...NATIVE_INTENT, recipient: "" })).rejects.toThrow(
+    await expect(craftTransaction(context, { ...NATIVE_INTENT, recipient: "" })).rejects.toThrow(
       "vechain: recipient is required",
     );
   });
@@ -170,13 +171,13 @@ describe("craftTransaction", () => {
   it("throws when the sender is not a valid address", async () => {
     jest.mocked(parseAddress).mockReturnValueOnce(false);
 
-    await expect(craftTransaction({ ...NATIVE_INTENT, sender: "0xbad" })).rejects.toThrow(
+    await expect(craftTransaction(context, { ...NATIVE_INTENT, sender: "0xbad" })).rejects.toThrow(
       "vechain: invalid sender address",
     );
   });
 
   it("throws when the resolved amount is not positive", async () => {
-    await expect(craftTransaction({ ...NATIVE_INTENT, amount: 0n })).rejects.toThrow(
+    await expect(craftTransaction(context, { ...NATIVE_INTENT, amount: 0n })).rejects.toThrow(
       "vechain: transaction amount must be positive",
     );
   });
@@ -186,7 +187,7 @@ describe("craftTransaction", () => {
       .mocked(getAccount)
       .mockResolvedValueOnce({ balance: "0x0", energy: "0x5F5E100", hasCode: false });
 
-    await craftTransaction({ ...TOKEN_INTENT, useAllAmount: true, amount: 0n });
+    await craftTransaction(context, { ...TOKEN_INTENT, useAllAmount: true, amount: 0n });
 
     const calls = jest.mocked(calculateClausesVtho).mock.calls;
     expect(calls).toHaveLength(2);
@@ -199,12 +200,12 @@ describe("craftTransaction", () => {
       .mockResolvedValueOnce({ balance: "0x0", energy: "0x3E8", hasCode: false });
 
     await expect(
-      craftTransaction({ ...TOKEN_INTENT, useAllAmount: true, amount: 0n }),
+      craftTransaction(context, { ...TOKEN_INTENT, useAllAmount: true, amount: 0n }),
     ).rejects.toThrow("vechain: VTHO balance too low to cover the transaction gas fee");
   });
 
   it("crafts a dust native amount (1 wei)", async () => {
-    const crafted = await craftTransaction({ ...NATIVE_INTENT, amount: 1n });
+    const crafted = await craftTransaction(context, { ...NATIVE_INTENT, amount: 1n });
 
     expect(calculateClausesVet).toHaveBeenCalledWith(RECIPIENT, expect.any(Object));
     expect(JSON.parse(crafted.transaction).gas).toBe(21000);
@@ -215,7 +216,7 @@ describe("craftTransaction", () => {
       .mocked(getAccount)
       .mockResolvedValueOnce({ balance: "0x0", energy: "21000001", hasCode: false });
 
-    await craftTransaction({ ...TOKEN_INTENT, useAllAmount: true, amount: 0n });
+    await craftTransaction(context, { ...TOKEN_INTENT, useAllAmount: true, amount: 0n });
 
     const calls = jest.mocked(calculateClausesVtho).mock.calls;
     expect(calls[calls.length - 1][1].toString()).toBe("1");
@@ -227,7 +228,7 @@ describe("craftTransaction", () => {
       .mockResolvedValueOnce({ balance: "0x0", energy: "21000000", hasCode: false });
 
     await expect(
-      craftTransaction({ ...TOKEN_INTENT, useAllAmount: true, amount: 0n }),
+      craftTransaction(context, { ...TOKEN_INTENT, useAllAmount: true, amount: 0n }),
     ).rejects.toThrow("vechain: VTHO balance too low to cover the transaction gas fee");
   });
 });

package/src/logic/transaction/estimateFees.ts

@@ -1,9 +1,11 @@
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-module-framework/api/index";
 import { parseAddress } from "../../common-logic";
+import type { VechainContext } from "../../config";
 import { craftTransaction } from "./craftTransaction";
 
 // Estimate VTHO gas by crafting the unsigned tx and reading back its settled fee/gas parameters.
 export async function estimateFees(
+  context: VechainContext,
   intent: TransactionIntent,
   customFeesParameters?: FeeEstimation["parameters"],
 ): Promise<FeeEstimation> {
@@ -15,6 +17,7 @@ export async function estimateFees(
     !intent.useAllAmount && intent.amount <= 0n ? { ...intent, amount: 1n } : intent;
 
   const { details } = await craftTransaction(
+    context,
     estimationIntent,
     customFeesParameters ? { value: 0n, parameters: customFeesParameters } : undefined,
   );

package/src/logic/transaction/estimateFees.unit.test.ts

@@ -1,9 +1,12 @@
 import type { TransactionIntent } from "@ledgerhq/coin-module-framework/api/index";
+import { createMockVechainContext } from "../../test/context";
 import { craftTransaction } from "./craftTransaction";
 import { estimateFees } from "./estimateFees";
 
 jest.mock("./craftTransaction", () => ({ craftTransaction: jest.fn() }));
 
+const context = createMockVechainContext();
+
 const INTENT: TransactionIntent = {
   intentType: "transaction",
   type: "send",
@@ -24,9 +27,9 @@ describe("estimateFees", () => {
       details: { fee: "21000000", gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
     });
 
-    const fees = await estimateFees(INTENT);
+    const fees = await estimateFees(context, INTENT);
 
-    expect(craftTransaction).toHaveBeenCalledWith(INTENT, undefined);
+    expect(craftTransaction).toHaveBeenCalledWith(context, INTENT, undefined);
     expect(fees).toEqual({
       value: 21000000n,
       parameters: { gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
@@ -39,9 +42,9 @@ describe("estimateFees", () => {
       details: { fee: "1", gas: 1, maxFeePerGas: 1, maxPriorityFeePerGas: 1 },
     });
 
-    await estimateFees(INTENT, { gas: 30000 });
+    await estimateFees(context, INTENT, { gas: 30000 });
 
-    expect(craftTransaction).toHaveBeenCalledWith(INTENT, {
+    expect(craftTransaction).toHaveBeenCalledWith(context, INTENT, {
       value: 0n,
       parameters: { gas: 30000 },
     });
@@ -50,7 +53,7 @@ describe("estimateFees", () => {
   it("defaults the fee to 0 when craftTransaction returns no details", async () => {
     jest.mocked(craftTransaction).mockResolvedValueOnce({ transaction: "{}" });
 
-    const fees = await estimateFees(INTENT);
+    const fees = await estimateFees(context, INTENT);
 
     expect(fees.value).toBe(0n);
   });
@@ -60,7 +63,7 @@ describe("estimateFees", () => {
       .mocked(craftTransaction)
       .mockRejectedValueOnce(new Error("vechain: recipient is required"));
 
-    await expect(estimateFees(INTENT)).rejects.toThrow("vechain: recipient is required");
+    await expect(estimateFees(context, INTENT)).rejects.toThrow("vechain: recipient is required");
   });
 
   it("substitutes a 1-wei placeholder amount for a zero-amount pre-estimation", async () => {
@@ -69,9 +72,9 @@ describe("estimateFees", () => {
       details: { fee: "21000000", gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
     });
 
-    await estimateFees({ ...INTENT, amount: 0n });
+    await estimateFees(context, { ...INTENT, amount: 0n });
 
-    expect(craftTransaction).toHaveBeenCalledWith({ ...INTENT, amount: 1n }, undefined);
+    expect(craftTransaction).toHaveBeenCalledWith(context, { ...INTENT, amount: 1n }, undefined);
   });
 
   it("does not substitute a placeholder when useAllAmount is set (craftTransaction resolves the balance)", async () => {
@@ -81,20 +84,20 @@ describe("estimateFees", () => {
     });
 
     const maxIntent = { ...INTENT, amount: 0n, useAllAmount: true };
-    await estimateFees(maxIntent);
+    await estimateFees(context, maxIntent);
 
-    expect(craftTransaction).toHaveBeenCalledWith(maxIntent, undefined);
+    expect(craftTransaction).toHaveBeenCalledWith(context, maxIntent, undefined);
   });
 
   it("returns a zero estimate without crafting when the recipient is missing", async () => {
-    const fees = await estimateFees({ ...INTENT, recipient: "" });
+    const fees = await estimateFees(context, { ...INTENT, recipient: "" });
 
     expect(fees).toEqual({ value: 0n, parameters: {} });
     expect(craftTransaction).not.toHaveBeenCalled();
   });
 
   it("returns a zero estimate without crafting when the recipient is not a valid address", async () => {
-    const fees = await estimateFees({ ...INTENT, recipient: "0xnot-an-address" });
+    const fees = await estimateFees(context, { ...INTENT, recipient: "0xnot-an-address" });
 
     expect(fees).toEqual({ value: 0n, parameters: {} });
     expect(craftTransaction).not.toHaveBeenCalled();

package/src/network/getBlock.ts

@@ -1,10 +1,11 @@
 import network from "@ledgerhq/live-network";
-import { getNodeUrl } from "../config";
+import { getNodeUrl, type VechainCurrencyConfig } from "../config";
 import type { ApiResponseBlock } from "../types";
 
 // Thor GET /blocks/{revision}. `expanded` returns full clause/output detail (getBlock) vs. tx
 // hashes only (getBlockInfo/lastBlock).
 export const getBlock = async (
+  config: VechainCurrencyConfig,
   revision: number,
   expanded = false,
 ): Promise<ApiResponseBlock | null> => {
@@ -16,7 +17,7 @@ export const getBlock = async (
 
   const { data } = await network<ApiResponseBlock | null>({
     method: "GET",
-    url: `${getNodeUrl()}/blocks/${revision}?${query}`,
+    url: `${getNodeUrl(config)}/blocks/${revision}?${query}`,
   });
 
   return data;

package/src/network/getBlock.unit.test.ts

@@ -1,5 +1,6 @@
 import network from "@ledgerhq/live-network";
 import { getBlock } from "./getBlock";
+import { mockVechainConfig } from "../test/context";
 
 jest.mock("@ledgerhq/live-network", () => jest.fn());
 
@@ -12,7 +13,7 @@ describe("getBlock", () => {
     const block = { id: "0xabc", number: 42, timestamp: 1_700_000_000, transactions: [] };
     jest.mocked(network).mockResolvedValueOnce({ data: block, status: 200 });
 
-    const result = await getBlock(42);
+    const result = await getBlock(mockVechainConfig, 42, undefined);
 
     expect(result).toEqual(block);
   });
@@ -20,7 +21,7 @@ describe("getBlock", () => {
   it("requests expanded=false by default", async () => {
     jest.mocked(network).mockResolvedValueOnce({ data: null, status: 200 });
 
-    await getBlock(42);
+    await getBlock(mockVechainConfig, 42, undefined);
 
     expect(network).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -33,7 +34,7 @@ describe("getBlock", () => {
   it("requests expanded=true when asked", async () => {
     jest.mocked(network).mockResolvedValueOnce({ data: null, status: 200 });
 
-    await getBlock(42, true);
+    await getBlock(mockVechainConfig, 42, true);
 
     expect(network).toHaveBeenCalledWith(
       expect.objectContaining({ url: expect.stringContaining("expanded=true") }),
@@ -41,18 +42,22 @@ describe("getBlock", () => {
   });
 
   it("rejects a negative revision without making a network call", async () => {
-    await expect(getBlock(-1)).rejects.toThrow("vechain: getBlock: invalid revision -1");
+    await expect(getBlock(mockVechainConfig, -1, undefined)).rejects.toThrow(
+      "vechain: getBlock: invalid revision -1",
+    );
     expect(network).not.toHaveBeenCalled();
   });
 
   it("rejects a non-integer revision without making a network call", async () => {
-    await expect(getBlock(1.5)).rejects.toThrow("vechain: getBlock: invalid revision 1.5");
+    await expect(getBlock(mockVechainConfig, 1.5, undefined)).rejects.toThrow(
+      "vechain: getBlock: invalid revision 1.5",
+    );
     expect(network).not.toHaveBeenCalled();
   });
 
   it("propagates a network error", async () => {
     jest.mocked(network).mockRejectedValueOnce(new Error("status 500"));
 
-    await expect(getBlock(42)).rejects.toThrow("status 500");
+    await expect(getBlock(mockVechainConfig, 42, undefined)).rejects.toThrow("status 500");
   });
 });