@ledgerhq/coin-vechain 2.27.0 → 2.28.0

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

@@ -0,0 +1,102 @@
+import type { TransactionIntent } from "@ledgerhq/coin-module-framework/api/index";
+import { craftTransaction } from "./craftTransaction";
+import { estimateFees } from "./estimateFees";
+
+jest.mock("./craftTransaction", () => ({ craftTransaction: jest.fn() }));
+
+const INTENT: TransactionIntent = {
+  intentType: "transaction",
+  type: "send",
+  sender: "0x0fe6688548f0C303932bB197B0A96034f1d74dba",
+  recipient: "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86",
+  amount: 1_000n,
+  asset: { type: "native" },
+};
+
+describe("estimateFees", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("crafts the transaction and reads back the settled fee/gas parameters", async () => {
+    jest.mocked(craftTransaction).mockResolvedValueOnce({
+      transaction: "{}",
+      details: { fee: "21000000", gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
+    });
+
+    const fees = await estimateFees(INTENT);
+
+    expect(craftTransaction).toHaveBeenCalledWith(INTENT, undefined);
+    expect(fees).toEqual({
+      value: 21000000n,
+      parameters: { gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
+    });
+  });
+
+  it("forwards customFeesParameters to craftTransaction", async () => {
+    jest.mocked(craftTransaction).mockResolvedValueOnce({
+      transaction: "{}",
+      details: { fee: "1", gas: 1, maxFeePerGas: 1, maxPriorityFeePerGas: 1 },
+    });
+
+    await estimateFees(INTENT, { gas: 30000 });
+
+    expect(craftTransaction).toHaveBeenCalledWith(INTENT, {
+      value: 0n,
+      parameters: { gas: 30000 },
+    });
+  });
+
+  it("defaults the fee to 0 when craftTransaction returns no details", async () => {
+    jest.mocked(craftTransaction).mockResolvedValueOnce({ transaction: "{}" });
+
+    const fees = await estimateFees(INTENT);
+
+    expect(fees.value).toBe(0n);
+  });
+
+  it("propagates an error from craftTransaction", async () => {
+    jest
+      .mocked(craftTransaction)
+      .mockRejectedValueOnce(new Error("vechain: recipient is required"));
+
+    await expect(estimateFees(INTENT)).rejects.toThrow("vechain: recipient is required");
+  });
+
+  it("substitutes a 1-wei placeholder amount for a zero-amount pre-estimation", async () => {
+    jest.mocked(craftTransaction).mockResolvedValueOnce({
+      transaction: "{}",
+      details: { fee: "21000000", gas: 21000, maxFeePerGas: 1000, maxPriorityFeePerGas: 100 },
+    });
+
+    await estimateFees({ ...INTENT, amount: 0n });
+
+    expect(craftTransaction).toHaveBeenCalledWith({ ...INTENT, amount: 1n }, undefined);
+  });
+
+  it("does not substitute a placeholder when useAllAmount is set (craftTransaction resolves the balance)", async () => {
+    jest.mocked(craftTransaction).mockResolvedValueOnce({
+      transaction: "{}",
+      details: { fee: "1", gas: 1, maxFeePerGas: 1, maxPriorityFeePerGas: 1 },
+    });
+
+    const maxIntent = { ...INTENT, amount: 0n, useAllAmount: true };
+    await estimateFees(maxIntent);
+
+    expect(craftTransaction).toHaveBeenCalledWith(maxIntent, undefined);
+  });
+
+  it("returns a zero estimate without crafting when the recipient is missing", async () => {
+    const fees = await estimateFees({ ...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" });
+
+    expect(fees).toEqual({ value: 0n, parameters: {} });
+    expect(craftTransaction).not.toHaveBeenCalled();
+  });
+});

package/src/logic/validateAddress.ts

@@ -0,0 +1,15 @@
+import type { AddressValidationCurrencyParameters } from "@ledgerhq/coin-module-framework/api/index";
+import { parseAddress } from "../common-logic";
+
+// Validate a VeChain address. Kept in logic/ so api/ depends on the logic layer for validation
+// like every other method, rather than reaching into common-logic directly.
+export function isValidAddress(address: string): boolean {
+  return parseAddress(address);
+}
+
+export async function validateAddress(
+  address: string,
+  _parameters: Partial<AddressValidationCurrencyParameters>,
+): Promise<boolean> {
+  return isValidAddress(address);
+}

package/src/logic/validateAddress.unit.test.ts

@@ -0,0 +1,15 @@
+import { isValidAddress, validateAddress } from "./validateAddress";
+
+const VALID = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+
+describe("validateAddress", () => {
+  it("returns true for a valid VeChain address", async () => {
+    expect(isValidAddress(VALID)).toBe(true);
+    await expect(validateAddress(VALID, {})).resolves.toBe(true);
+  });
+
+  it("returns false for a malformed address", async () => {
+    expect(isValidAddress("0xnot-an-address")).toBe(false);
+    await expect(validateAddress("0xnot-an-address", {})).resolves.toBe(false);
+  });
+});

package/src/logic/validateIntent.ts

@@ -0,0 +1,96 @@
+import type {
+  Balance,
+  FeeEstimation,
+  MemoNotSupported,
+  TransactionIntent,
+  TransactionValidation,
+} from "@ledgerhq/coin-module-framework/api/index";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/ledger-wallet-framework/errors";
+import { parseAddress } from "../common-logic";
+import { NotEnoughVTHO } from "../errors";
+
+function isTokenAsset(intent: TransactionIntent): boolean {
+  return intent.asset.type !== "native";
+}
+
+function spendable(balances: Balance[], isToken: boolean): bigint {
+  const asset = balances.find(b =>
+    isToken ? b.asset.type !== "native" : b.asset.type === "native",
+  );
+  return (asset?.value ?? 0n) - (asset?.locked ?? 0n);
+}
+
+function amountError(
+  intent: TransactionIntent<MemoNotSupported>,
+  isToken: boolean,
+  amount: bigint,
+  maxAmount: bigint,
+  estimatedFees: bigint,
+  availableAsset: bigint,
+): Error | undefined {
+  if (intent.useAllAmount && maxAmount === 0n) {
+    return new NotEnoughBalance();
+  }
+  if (!intent.useAllAmount && amount <= 0n) {
+    return new AmountRequired();
+  }
+  if (isToken && amount + estimatedFees > availableAsset) {
+    return new NotEnoughBalance();
+  }
+  if (!isToken && amount > availableAsset) {
+    return new NotEnoughBalance();
+  }
+  return undefined;
+}
+
+// Validate recipient, a positive amount, and enough balance incl. the VTHO gas fee (always VTHO).
+export async function validateIntent(
+  intent: TransactionIntent<MemoNotSupported>,
+  balances: Balance[],
+  customFees?: FeeEstimation,
+): Promise<TransactionValidation> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  const isToken = isTokenAsset(intent);
+  const estimatedFees = customFees?.value ?? 0n;
+  const availableAsset = spendable(balances, isToken);
+  const availableVtho = spendable(balances, true);
+
+  if (!intent.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (intent.sender.toLowerCase() === intent.recipient.toLowerCase()) {
+    warnings.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!parseAddress(intent.recipient)) {
+    errors.recipient = new InvalidAddress("", { currencyName: "VeChain" });
+  }
+
+  const spendableForAmount = isToken ? availableAsset - estimatedFees : availableAsset;
+  const maxAmount = spendableForAmount > 0n ? spendableForAmount : 0n;
+  const amount = intent.useAllAmount ? maxAmount : intent.amount;
+
+  const amountErr = amountError(intent, isToken, amount, maxAmount, estimatedFees, availableAsset);
+  if (amountErr) {
+    errors.amount = amountErr;
+  }
+
+  if (!errors.amount && estimatedFees > availableVtho) {
+    errors.amount = new NotEnoughVTHO();
+  }
+
+  const totalSpent = isToken ? amount + estimatedFees : amount;
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+}

package/src/logic/validateIntent.unit.test.ts

@@ -0,0 +1,156 @@
+import type { Balance, TransactionIntent } from "@ledgerhq/coin-module-framework/api/index";
+import { validateIntent } from "./validateIntent";
+
+const SENDER = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+const RECIPIENT = "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86";
+
+const NATIVE_INTENT: TransactionIntent = {
+  intentType: "transaction",
+  type: "send",
+  sender: SENDER,
+  recipient: RECIPIENT,
+  amount: 1_000n,
+  asset: { type: "native" },
+};
+
+const BALANCES: Balance[] = [
+  { value: 10_000n, asset: { type: "native" } },
+  { value: 5_000n, asset: { type: "token", assetReference: "0xvtho" } },
+];
+
+describe("validateIntent", () => {
+  it("passes for a well-formed native send with sufficient balance and fees", async () => {
+    const result = await validateIntent(NATIVE_INTENT, BALANCES, { value: 100n });
+
+    expect(result.errors).toEqual({});
+    expect(result.amount).toBe(1_000n);
+    expect(result.totalSpent).toBe(1_000n);
+  });
+
+  it("flags a missing recipient", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, recipient: "" }, BALANCES);
+
+    expect(result.errors.recipient).toBeInstanceOf(Error);
+  });
+
+  it("flags an ill-formed recipient address", async () => {
+    const result = await validateIntent(
+      { ...NATIVE_INTENT, recipient: "not-an-address" },
+      BALANCES,
+    );
+
+    expect(result.errors.recipient).toBeInstanceOf(Error);
+  });
+
+  it("warns when the recipient equals the sender", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, recipient: SENDER }, BALANCES);
+
+    expect(result.warnings.recipient).toBeInstanceOf(Error);
+  });
+
+  it("flags a zero amount when not sending the full balance", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, amount: 0n }, BALANCES);
+
+    expect(result.errors.amount).toBeInstanceOf(Error);
+  });
+
+  it("flags insufficient native balance for the requested amount", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, amount: 999_999n }, BALANCES);
+
+    expect(result.errors.amount).toBeInstanceOf(Error);
+  });
+
+  it("flags NotEnoughVTHO when fees exceed the VTHO balance, even with enough VET", async () => {
+    const result = await validateIntent(NATIVE_INTENT, BALANCES, { value: 999_999n });
+
+    expect(result.errors.amount?.name).toBe("NotEnoughVTHO");
+  });
+
+  it("subtracts the estimated fee from the spendable amount for a max VTHO send", async () => {
+    const tokenIntent: TransactionIntent = {
+      ...NATIVE_INTENT,
+      asset: { type: "token", assetReference: "0xvtho" },
+      useAllAmount: true,
+    };
+
+    const result = await validateIntent(tokenIntent, BALANCES, { value: 100n });
+
+    expect(result.amount).toBe(4_900n); // 5000 VTHO balance - 100 fee
+    expect(result.totalSpent).toBe(5_000n);
+  });
+
+  it("flags NotEnoughBalance for a max VTHO send when the fee consumes the whole balance", async () => {
+    const tokenIntent: TransactionIntent = {
+      ...NATIVE_INTENT,
+      asset: { type: "token", assetReference: "0xvtho" },
+      useAllAmount: true,
+    };
+
+    const result = await validateIntent(tokenIntent, BALANCES, { value: 5_000n }); // fee == full VTHO balance
+
+    expect(result.amount).toBe(0n);
+    expect(result.errors.amount?.name).toBe("NotEnoughBalance");
+  });
+
+  it("does not subtract fees from a max native VET send (fees are paid in VTHO)", async () => {
+    const nativeMax: TransactionIntent = { ...NATIVE_INTENT, useAllAmount: true };
+
+    const result = await validateIntent(nativeMax, BALANCES, { value: 100n });
+
+    expect(result.amount).toBe(10_000n);
+  });
+
+  it("passes a native send at the exact balance boundary (amount == available)", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, amount: 10_000n }, BALANCES, {
+      value: 100n,
+    });
+    expect(result.errors).toEqual({});
+    expect(result.amount).toBe(10_000n);
+  });
+
+  it("flags a native send one wei over the balance", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, amount: 10_001n }, BALANCES, {
+      value: 100n,
+    });
+    expect(result.errors.amount?.name).toBe("NotEnoughBalance");
+  });
+
+  it("passes a dust native amount (1 wei)", async () => {
+    const result = await validateIntent({ ...NATIVE_INTENT, amount: 1n }, BALANCES, {
+      value: 100n,
+    });
+    expect(result.errors).toEqual({});
+    expect(result.amount).toBe(1n);
+  });
+
+  it("does not flag NotEnoughVTHO when the fee equals the VTHO balance exactly", async () => {
+    const result = await validateIntent(NATIVE_INTENT, BALANCES, { value: 5_000n });
+    expect(result.errors.amount).toBeUndefined();
+  });
+
+  it("flags NotEnoughVTHO when the fee is one wei over the VTHO balance", async () => {
+    const result = await validateIntent(NATIVE_INTENT, BALANCES, { value: 5_001n });
+    expect(result.errors.amount?.name).toBe("NotEnoughVTHO");
+  });
+
+  const tokenIntent = (amount: bigint): TransactionIntent => ({
+    ...NATIVE_INTENT,
+    asset: { type: "token", assetReference: "0xvtho" },
+    amount,
+  });
+
+  it("passes a VTHO send at the exact spendable boundary (amount + fee == balance)", async () => {
+    const result = await validateIntent(tokenIntent(4_900n), BALANCES, { value: 100n });
+    expect(result.errors).toEqual({});
+  });
+
+  it("flags a VTHO send one wei over the spendable boundary (amount + fee > balance)", async () => {
+    const result = await validateIntent(tokenIntent(4_901n), BALANCES, { value: 100n });
+    expect(result.errors.amount?.name).toBe("NotEnoughBalance");
+  });
+
+  it("passes a dust VTHO amount (1 wei)", async () => {
+    const result = await validateIntent(tokenIntent(1n), BALANCES, { value: 100n });
+    expect(result.errors).toEqual({});
+  });
+});

package/src/network/getBlock.ts

@@ -0,0 +1,23 @@
+import network from "@ledgerhq/live-network";
+import { VECHAIN_NODE_URL as BASE_URL } from "../constants";
+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 (
+  revision: number,
+  expanded = false,
+): Promise<ApiResponseBlock | null> => {
+  if (!Number.isInteger(revision) || revision < 0) {
+    throw new Error(`vechain: getBlock: invalid revision ${revision}`);
+  }
+
+  const query = new URLSearchParams({ expanded: String(expanded) });
+
+  const { data } = await network<ApiResponseBlock | null>({
+    method: "GET",
+    url: `${BASE_URL}/blocks/${revision}?${query}`,
+  });
+
+  return data;
+};

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

@@ -0,0 +1,58 @@
+import network from "@ledgerhq/live-network";
+import { getBlock } from "./getBlock";
+
+jest.mock("@ledgerhq/live-network", () => jest.fn());
+
+describe("getBlock", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns the parsed block on a successful response", async () => {
+    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);
+
+    expect(result).toEqual(block);
+  });
+
+  it("requests expanded=false by default", async () => {
+    jest.mocked(network).mockResolvedValueOnce({ data: null, status: 200 });
+
+    await getBlock(42);
+
+    expect(network).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: "GET",
+        url: expect.stringContaining("/blocks/42?expanded=false"),
+      }),
+    );
+  });
+
+  it("requests expanded=true when asked", async () => {
+    jest.mocked(network).mockResolvedValueOnce({ data: null, status: 200 });
+
+    await getBlock(42, true);
+
+    expect(network).toHaveBeenCalledWith(
+      expect.objectContaining({ url: expect.stringContaining("expanded=true") }),
+    );
+  });
+
+  it("rejects a negative revision without making a network call", async () => {
+    await expect(getBlock(-1)).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");
+    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");
+  });
+});

package/src/network/getFees.ts

@@ -1,8 +1,6 @@
 import BigNumber from "bignumber.js";
 import network from "@ledgerhq/live-network";
-import { getEnv } from "@ledgerhq/live-env";
-
-const BASE_URL = getEnv("API_VECHAIN_THOREST");
+import { VECHAIN_NODE_URL as BASE_URL } from "../constants";
 
 /**
  * Get fees paid for the transaction

package/src/network/index.ts

@@ -1,2 +1,3 @@
 export { getAccount, getOperations } from "./sdk";
 export * from "./sdk";
+export * from "./getBlock";

package/src/network/sdk.test.ts

@@ -1,6 +1,6 @@
 import BigNumber from "bignumber.js";
 import type { Operation } from "@ledgerhq/types-live";
-import { LedgerAPI4xx } from "@ledgerhq/errors";
+import { LedgerAPI4xx } from "@ledgerhq/live-network/errors";
 import {
   getAccount,
   getBlockRef,
@@ -203,6 +203,21 @@ describe("sdk", () => {
       });
     });
 
+    describe("when the range is inverted (no new block since the last known operation)", () => {
+      test("returns an empty array without querying the network", async () => {
+        mockGetTransferLogs.mockClear();
+        const operations = await getOperations(
+          "my-account-id",
+          "0xmy-address",
+          LAST_BLOCK_COUNT + 1,
+          LAST_BLOCK_COUNT,
+        );
+
+        expect(operations).toEqual([]);
+        expect(mockGetTransferLogs).not.toHaveBeenCalled();
+      });
+    });
+
     describe("when logged operations exceed limit in the given range", () => {
       beforeEach(() => {
         mockGetTransferLogs.mockImplementationOnce(throws403ExceedsLimit);
@@ -280,6 +295,22 @@ describe("sdk", () => {
       });
     });
 
+    describe("when the range is inverted (no new block since the last known operation)", () => {
+      test("returns an empty array without querying the network", async () => {
+        mockGetEventLogs.mockClear();
+        const operations = await getTokenOperations(
+          "my-account-id",
+          "0xmy-address",
+          "0xmy-token-address",
+          LAST_BLOCK_COUNT + 1,
+          LAST_BLOCK_COUNT,
+        );
+
+        expect(operations).toEqual([]);
+        expect(mockGetEventLogs).not.toHaveBeenCalled();
+      });
+    });
+
     describe("when logged operations exceed limit in the given range", () => {
       beforeEach(() => {
         mockGetEventLogs.mockImplementationOnce(throws403ExceedsLimit);

package/src/network/sdk.ts

@@ -13,9 +13,8 @@ import {
   mapTokenTransfersToOperations,
   padAddress,
 } from "../common-logic";
-import { getEnv } from "@ledgerhq/live-env";
+import { VECHAIN_NODE_URL as BASE_URL } from "../constants";
 
-const BASE_URL = getEnv("API_VECHAIN_THOREST");
 const NET_ERROR_LOG_TRANSFERS_LIMIT = {
   status: 403,
   msgPattern: /exceeds the maximum allowed/,
@@ -149,6 +148,14 @@ const getLogsWithPagination = async (
   stopAt: number,
   fetchRangeOfLogs: (from: number, to: number) => Promise<Operation[]>,
 ): Promise<Operation[]> => {
+  // No new block since the last known operation (startAt = lastOp.blockHeight + 1 can exceed the
+  // current best height when nothing has happened since the previous sync) — Thor's `/logs/*`
+  // endpoints reject an inverted range with a 400, so treat it as "nothing new" instead of
+  // querying at all.
+  if (stopAt < startAt) {
+    return [];
+  }
+
   let completed = false;
   const ops: Operation[] = [];
 

package/src/test/bridgeDatasetTest.ts

@@ -11,7 +11,7 @@ import { MAINNET_CHAIN_TAG } from "../types";
 import { vechain1, vechain3 } from "../datasets";
 import { generateNonce } from "../common-logic";
 import vechainScanAccounts1 from "../datasets/vechain.scanAccounts.1";
-import { AmountRequired, NotEnoughBalance } from "@ledgerhq/errors";
+import { AmountRequired, NotEnoughBalance } from "@ledgerhq/ledger-wallet-framework/errors";
 import { NotEnoughVTHO } from "../errors";
 import { ABIContract, VIP180_ABI } from "@vechain/sdk-core";
 

package/src/test/msw-setup.ts

@@ -0,0 +1,7 @@
+import { setEnv } from "@ledgerhq/live-env";
+import { TEST_VECHAIN_ENDPOINT } from "./msw.mock";
+
+// Runs as a jest `setupFiles` entry (before the test modules load), so `constants/env.ts` — which
+// reads `API_VECHAIN_THOREST` into a module-level const at import time — resolves to the test host
+// that the MSW handlers intercept.
+setEnv("API_VECHAIN_THOREST", TEST_VECHAIN_ENDPOINT);

package/src/test/msw.mock.ts

@@ -0,0 +1,6 @@
+import { setupServer } from "msw/node";
+
+// Test host that `msw-setup.ts` points `API_VECHAIN_THOREST` at, so MSW handlers intercept the exact
+// URL the network layer builds. Shared, empty MSW server; each suite registers handlers via `server.use`.
+export const TEST_VECHAIN_ENDPOINT = "https://vechain-test.ledger.com";
+export const server = setupServer();

package/src/types/network.ts

@@ -79,3 +79,37 @@ export interface QueryResponse {
   reverted: boolean;
   vmError: string;
 }
+
+/** Thor `GET /blocks/{revision}` transfer (VET or VIP180 event, when `expanded=true`). */
+export interface ApiResponseBlockTransfer {
+  sender: string;
+  recipient: string;
+  amount: string;
+}
+
+/** A single clause output, part of an expanded block transaction. */
+export interface ApiResponseBlockOutput {
+  contractAddress: string | null;
+  events: EventLog[];
+  transfers: ApiResponseBlockTransfer[];
+}
+
+/** An expanded transaction, as returned by Thor `GET /blocks/{revision}?expanded=true`. */
+export interface ApiResponseBlockTransaction {
+  id: string;
+  origin: string;
+  gasPayer?: string;
+  gasUsed: number;
+  paid: string;
+  reverted: boolean;
+  outputs: ApiResponseBlockOutput[];
+}
+
+/** Thor `GET /blocks/{revision}` response. */
+export interface ApiResponseBlock {
+  id: string;
+  number: number;
+  timestamp: number;
+  /** Transaction ids (`string[]`) when `expanded=false`, full transactions when `expanded=true`. */
+  transactions: unknown[];
+}