@ledgerhq/coin-vechain 2.27.0 → 2.28.0

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

@@ -0,0 +1,234 @@
+/**
+ * Unit tests for the createApi factory — verifies the coin config is set, every CoinModuleApi
+ * method is wired and delegates to its logic function with the right arguments, and unsupported
+ * methods throw. Network and logic layers are mocked; no network access.
+ */
+import type {
+  Balance,
+  CoinModuleApi,
+  CraftedTransaction,
+  FeeEstimation,
+  Operation,
+  Page,
+  TransactionIntent,
+} from "@ledgerhq/coin-module-framework/api/index";
+import { createApi } from "./index";
+import { getCoinConfig } from "../config";
+import { broadcast } from "../logic/transaction/broadcast";
+import { combine } from "../logic/transaction/combine";
+import { craftTransaction } from "../logic/transaction/craftTransaction";
+import { estimateFees } from "../logic/transaction/estimateFees";
+import { getBalance } from "../logic/account/getBalance";
+import { getBlock } from "../logic/history/getBlock";
+import { getBlockInfo } from "../logic/history/getBlockInfo";
+import { lastBlock } from "../logic/history/lastBlock";
+import { listOperations } from "../logic/history/listOperations";
+import { validateIntent } from "../logic/validateIntent";
+
+jest.mock("../logic/transaction/broadcast", () => ({ broadcast: jest.fn() }));
+jest.mock("../logic/transaction/combine", () => ({ combine: jest.fn() }));
+jest.mock("../logic/transaction/craftTransaction", () => ({ craftTransaction: jest.fn() }));
+jest.mock("../logic/transaction/estimateFees", () => ({ estimateFees: jest.fn() }));
+jest.mock("../logic/account/getBalance", () => ({ getBalance: jest.fn() }));
+jest.mock("../logic/history/getBlock", () => ({ getBlock: jest.fn() }));
+jest.mock("../logic/history/getBlockInfo", () => ({ getBlockInfo: jest.fn() }));
+jest.mock("../logic/history/lastBlock", () => ({ lastBlock: jest.fn() }));
+jest.mock("../logic/history/listOperations", () => ({ listOperations: jest.fn() }));
+jest.mock("../logic/validateIntent", () => ({ validateIntent: jest.fn() }));
+
+const config = () => ({ status: { type: "active" as const } });
+
+const SENDER = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+const RECIPIENT = "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86";
+
+const nativeIntent: TransactionIntent = {
+  intentType: "transaction",
+  type: "send",
+  sender: SENDER,
+  recipient: RECIPIENT,
+  amount: 100_000_000n,
+  asset: { type: "native" },
+};
+
+describe("createApi", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("sets the coin config, forcing status active", () => {
+    createApi(config, "vechain");
+
+    expect(getCoinConfig()).toEqual({ status: { type: "active" } });
+  });
+
+  it("returns an object with every CoinModuleApi method", () => {
+    const api = createApi(config, "vechain");
+
+    expect(api).toEqual(
+      expect.objectContaining({
+        broadcast: expect.any(Function),
+        combine: expect.any(Function),
+        craftTransaction: expect.any(Function),
+        craftRawTransaction: expect.any(Function),
+        craftTransactionData: expect.any(Function),
+        estimateFees: expect.any(Function),
+        getBalance: expect.any(Function),
+        lastBlock: expect.any(Function),
+        listOperations: expect.any(Function),
+        getBlock: expect.any(Function),
+        getBlockInfo: expect.any(Function),
+        getRewards: expect.any(Function),
+        getStakes: expect.any(Function),
+        getValidators: expect.any(Function),
+        validateIntent: expect.any(Function),
+        getNextSequence: expect.any(Function),
+        validateAddress: expect.any(Function),
+        call: expect.any(Function),
+      }),
+    );
+  });
+
+  it("delegates broadcast to the logic function", async () => {
+    jest.mocked(broadcast).mockResolvedValueOnce("txHash");
+    const api = createApi(config, "vechain");
+
+    const result = await api.broadcast("signedTx");
+
+    expect(broadcast).toHaveBeenCalledWith("signedTx");
+    expect(result).toBe("txHash");
+  });
+
+  it("delegates combine to the logic function", () => {
+    jest.mocked(combine).mockReturnValueOnce("0xsigned");
+    const api = createApi(config, "vechain");
+
+    const result = api.combine("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 customFees: FeeEstimation = { value: 5000n };
+
+    const result = await api.craftTransaction(nativeIntent, customFees);
+
+    expect(craftTransaction).toHaveBeenCalledWith(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 result = await api.estimateFees(nativeIntent);
+
+    expect(estimateFees).toHaveBeenCalledWith(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 result = await api.getBalance(SENDER);
+
+    expect(getBalance).toHaveBeenCalledWith(SENDER);
+    expect(result).toEqual(balances);
+  });
+
+  it("rejects getBalance when options are provided (not supported)", async () => {
+    const api = createApi(config, "vechain");
+
+    await expect(
+      api.getBalance(SENDER, {} as Parameters<CoinModuleApi["getBalance"]>[1]),
+    ).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 result = await api.lastBlock();
+
+    expect(lastBlock).toHaveBeenCalled();
+    expect(result).toEqual(block);
+  });
+
+  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 result = await api.getBlockInfo(42);
+
+    expect(getBlockInfo).toHaveBeenCalledWith(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 result = await api.getBlock(42);
+
+    expect(getBlock).toHaveBeenCalledWith(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 result = await api.listOperations(SENDER, { minHeight: 0 });
+
+    expect(listOperations).toHaveBeenCalledWith(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 result = await api.validateIntent(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");
+
+    expect(() => api.getNextSequence(SENDER)).toThrow(
+      "getNextSequence is not applicable for Vechain",
+    );
+    expect(() => api.craftRawTransaction("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");
+  });
+
+  it("throws for call (not supported)", () => {
+    const api = createApi(config, "vechain");
+    expect(() => api.call({})).toThrow("call 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);
+  });
+});

package/src/bridge/getTransactionStatus.test.ts

@@ -10,7 +10,7 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalance,
   RecipientRequired,
-} from "@ledgerhq/errors";
+} from "@ledgerhq/ledger-wallet-framework/errors";
 import { NotEnoughVTHO } from "../errors";
 
 // Mock dependencies

package/src/bridge/getTransactionStatus.ts

@@ -6,7 +6,7 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalance,
   RecipientRequired,
-} from "@ledgerhq/errors";
+} from "@ledgerhq/ledger-wallet-framework/errors";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { calculateTransactionInfo, parseAddress } from "../common-logic";
 import type { Transaction } from "../types";

package/src/bridge/synchronisation.test.ts

@@ -3,7 +3,11 @@ import { makeScanAccounts } from "@ledgerhq/ledger-wallet-framework/bridge/jsHel
 import { getCryptoCurrencyById } from "@ledgerhq/ledger-wallet-framework/currencies";
 import { getCryptoAssetsStore } from "@ledgerhq/ledger-wallet-framework/cryptoAssetsStore";
 import { setCryptoAssetsStore } from "@ledgerhq/ledger-wallet-framework/cryptoAssetsStore";
-import type { TokenCurrency } from "@ledgerhq/ledger-wallet-framework/types";
+import {
+  CryptoCurrencyIdSchema,
+  TokenCurrencyIdSchema,
+  type TokenCurrency,
+} from "@ledgerhq/ledger-wallet-framework/types";
 import BigNumber from "bignumber.js";
 import { setupServer } from "msw/node";
 import { firstValueFrom } from "rxjs";
@@ -34,9 +38,9 @@ describe("scanAccounts", () => {
   beforeAll(() => {
     const vthoToken: TokenCurrency = {
       type: "TokenCurrency",
-      id: "vechain/vip180/vtho",
+      id: TokenCurrencyIdSchema.parse("vechain/vip180/vtho"),
       contractAddress: "0x0000000000000000000000000000456E65726779",
-      parentCurrencyId: "vechain",
+      parentCurrencyId: CryptoCurrencyIdSchema.parse("vechain"),
       tokenType: "vip180",
       name: "VeThor",
       ticker: "VTHO",

package/src/logic/account/getBalance.ts

@@ -0,0 +1,24 @@
+import type { AssetInfo, Balance } from "@ledgerhq/coin-module-framework/api/index";
+import { VTHO_ADDRESS } from "@vechain/sdk-core";
+import { getAccount } from "../../network";
+
+export const NATIVE_ASSET: AssetInfo = { type: "native", name: "VET" };
+
+// `assetOwner` lets the generic coin-framework adapter attach the VTHO balance to its sub-account
+// (buildSubAccounts filters by `extra.assetReference` + `extra.assetOwner`). Mirrors coin-tron.
+export const vthoAsset = (address: string): AssetInfo => ({
+  type: "token",
+  assetReference: VTHO_ADDRESS,
+  assetOwner: address,
+  name: "VTHO",
+});
+
+// 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);
+
+  return [
+    { value: BigInt(balance || "0"), asset: NATIVE_ASSET },
+    { value: BigInt(energy || "0"), asset: vthoAsset(address) },
+  ];
+}

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

@@ -0,0 +1,50 @@
+import { getAccount } from "../../network";
+import { getBalance, NATIVE_ASSET, vthoAsset } from "./getBalance";
+
+jest.mock("../../network", () => ({ getAccount: jest.fn() }));
+
+const ADDRESS = "0x0fe6688548f0C303932bB197B0A96034f1d74dba";
+
+describe("getBalance", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns VET and VTHO balances parsed from the account response", async () => {
+    jest.mocked(getAccount).mockResolvedValueOnce({
+      balance: "0x1bc16d674ec80000",
+      energy: "0xde0b6b3a7640000",
+      hasCode: false,
+    });
+
+    const balances = await getBalance(ADDRESS);
+
+    expect(getAccount).toHaveBeenCalledWith(ADDRESS);
+    expect(balances).toEqual([
+      { value: BigInt("0x1bc16d674ec80000"), asset: NATIVE_ASSET },
+      { value: BigInt("0xde0b6b3a7640000"), asset: vthoAsset(ADDRESS) },
+    ]);
+  });
+
+  it("defaults both balances to 0 for a pristine account", async () => {
+    jest.mocked(getAccount).mockResolvedValueOnce({ balance: "", energy: "", hasCode: false });
+
+    const balances = await getBalance(ADDRESS);
+
+    expect(balances).toEqual([
+      { value: 0n, asset: NATIVE_ASSET },
+      { value: 0n, asset: vthoAsset(ADDRESS) },
+    ]);
+  });
+
+  it("returns a token asset for VTHO distinguished from the native asset", async () => {
+    jest
+      .mocked(getAccount)
+      .mockResolvedValueOnce({ balance: "0x1", energy: "0x2", hasCode: false });
+
+    const [nativeBalance, tokenBalance] = await getBalance(ADDRESS);
+
+    expect(nativeBalance.asset.type).toBe("native");
+    expect(tokenBalance.asset.type).not.toBe("native");
+  });
+});

package/src/logic/history/getBlock.ts

@@ -0,0 +1,47 @@
+import type {
+  Block,
+  BlockOperation,
+  BlockTransaction,
+} from "@ledgerhq/coin-module-framework/api/index";
+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);
+
+  if (!block) {
+    throw new Error(`vechain: no block at height ${height}`);
+  }
+
+  const transactions = block.transactions as ApiResponseBlockTransaction[];
+
+  return {
+    info: toBlockInfo(block),
+    transactions: transactions.map(toBlockTransaction),
+  };
+}
+
+function toBlockTransaction(tx: ApiResponseBlockTransaction): BlockTransaction {
+  const operations: BlockOperation[] = tx.outputs.flatMap(output =>
+    output.transfers.map(
+      (transfer): BlockOperation => ({
+        type: "transfer",
+        address: transfer.recipient,
+        peer: transfer.sender,
+        asset: { type: "native" },
+        amount: BigInt(transfer.amount || "0"),
+      }),
+    ),
+  );
+
+  return {
+    hash: tx.id,
+    failed: tx.reverted,
+    operations,
+    fees: BigInt(tx.paid || "0"),
+    feesPayer: tx.gasPayer ?? tx.origin,
+  };
+}

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

@@ -0,0 +1,106 @@
+import { getBlock as getBlockFromNetwork } from "../../network";
+import { getBlock } from "./getBlock";
+
+jest.mock("../../network", () => ({ getBlock: jest.fn() }));
+
+describe("getBlock", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("maps VET transfers within an expanded block to transfer operations", async () => {
+    jest.mocked(getBlockFromNetwork).mockResolvedValueOnce({
+      id: "0xabc",
+      number: 10,
+      timestamp: 1_700_000_000,
+      transactions: [
+        {
+          id: "0xtx1",
+          origin: "0xsender",
+          gasUsed: 21000,
+          paid: "0x100",
+          reverted: false,
+          outputs: [
+            {
+              contractAddress: null,
+              events: [],
+              transfers: [{ sender: "0xsender", recipient: "0xrecipient", amount: "0x64" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    const block = await getBlock(10);
+
+    expect(getBlockFromNetwork).toHaveBeenCalledTimes(1);
+    expect(getBlockFromNetwork).toHaveBeenCalledWith(10, true);
+    expect(block.info).toEqual({
+      height: 10,
+      hash: "0xabc",
+      time: new Date(1_700_000_000 * 1000),
+    });
+    expect(block.transactions).toEqual([
+      {
+        hash: "0xtx1",
+        failed: false,
+        fees: BigInt("0x100"),
+        feesPayer: "0xsender",
+        operations: [
+          {
+            type: "transfer",
+            address: "0xrecipient",
+            peer: "0xsender",
+            asset: { type: "native" },
+            amount: BigInt("0x64"),
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("marks a reverted transaction as failed", async () => {
+    jest.mocked(getBlockFromNetwork).mockResolvedValueOnce({
+      id: "0xabc",
+      number: 10,
+      timestamp: 1_700_000_000,
+      transactions: [
+        { id: "0xtx2", origin: "0xsender", gasUsed: 0, paid: "0x0", reverted: true, outputs: [] },
+      ],
+    });
+
+    const block = await getBlock(10);
+
+    expect(block.transactions[0].failed).toBe(true);
+    expect(block.transactions[0].operations).toEqual([]);
+  });
+
+  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");
+  });
+
+  it("uses the VIP-191 gasPayer as feesPayer when a tx is fee-delegated", async () => {
+    jest.mocked(getBlockFromNetwork).mockResolvedValueOnce({
+      id: "0xabc",
+      number: 10,
+      timestamp: 1_700_000_000,
+      transactions: [
+        {
+          id: "0xtx3",
+          origin: "0xsender",
+          gasPayer: "0xdelegate",
+          gasUsed: 21000,
+          paid: "0x100",
+          reverted: false,
+          outputs: [],
+        },
+      ],
+    });
+
+    const block = await getBlock(10);
+
+    expect(block.transactions[0].feesPayer).toBe("0xdelegate");
+  });
+});

package/src/logic/history/getBlockInfo.ts

@@ -0,0 +1,24 @@
+import type { BlockInfo } from "@ledgerhq/coin-module-framework/api/index";
+import { getBlock as getBlockFromNetwork } from "../../network";
+import type { ApiResponseBlock } from "../../types";
+
+// Map a Thor block to BlockInfo (id/number/timestamp are present regardless of `expanded`).
+export function toBlockInfo(block: ApiResponseBlock): BlockInfo {
+  return {
+    height: block.number,
+    hash: block.id,
+    // Thor block timestamps are unix seconds.
+    time: new Date(block.timestamp * 1000),
+  };
+}
+
+/** 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);
+
+  if (!block) {
+    throw new Error(`vechain: no block at height ${height}`);
+  }
+
+  return toBlockInfo(block);
+}

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

@@ -0,0 +1,30 @@
+import { getBlock as getBlockFromNetwork } from "../../network";
+import { getBlockInfo } from "./getBlockInfo";
+
+jest.mock("../../network", () => ({ getBlock: jest.fn() }));
+
+describe("getBlockInfo", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("maps the network block to BlockInfo", async () => {
+    jest.mocked(getBlockFromNetwork).mockResolvedValueOnce({
+      id: "0xabc",
+      number: 42,
+      timestamp: 1_700_000_000,
+      transactions: [],
+    });
+
+    const info = await getBlockInfo(42);
+
+    expect(getBlockFromNetwork).toHaveBeenCalledWith(42);
+    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");
+  });
+});

package/src/logic/history/lastBlock.ts

@@ -0,0 +1,9 @@
+import type { BlockInfo } from "@ledgerhq/coin-module-framework/api/index";
+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);
+}

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

@@ -0,0 +1,30 @@
+import { getLastBlockHeight } from "../../network";
+import { getBlockInfo } from "./getBlockInfo";
+import { lastBlock } from "./lastBlock";
+
+jest.mock("../../network", () => ({ getLastBlockHeight: jest.fn() }));
+jest.mock("./getBlockInfo", () => ({ getBlockInfo: jest.fn() }));
+
+describe("lastBlock", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("resolves the current height then delegates to getBlockInfo", async () => {
+    jest.mocked(getLastBlockHeight).mockResolvedValueOnce(123);
+    const info = { height: 123, hash: "0xabc", time: new Date() };
+    jest.mocked(getBlockInfo).mockResolvedValueOnce(info);
+
+    const result = await lastBlock();
+
+    expect(getBlockInfo).toHaveBeenCalledWith(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");
+    expect(getBlockInfo).not.toHaveBeenCalled();
+  });
+});

package/src/logic/history/listOperations.ts

@@ -0,0 +1,64 @@
+import type {
+  AssetInfo,
+  ListOperationsOptions,
+  MemoNotSupported,
+  Operation,
+  Page,
+} from "@ledgerhq/coin-module-framework/api/index";
+import type { Operation as LegacyOperation } from "@ledgerhq/types-live";
+import { VTHO_ADDRESS } from "@vechain/sdk-core";
+import { getLastBlockHeight, getOperations, getTokenOperations } from "../../network";
+import { NATIVE_ASSET, vthoAsset } from "../account/getBalance";
+
+function toFrameworkOperation(op: LegacyOperation, asset: AssetInfo): Operation<MemoNotSupported> {
+  return {
+    id: op.id,
+    type: op.type,
+    senders: op.senders,
+    recipients: op.recipients,
+    value: BigInt(op.value.toFixed(0)),
+    asset,
+    details: { ledgerOpType: op.type },
+    tx: {
+      hash: op.hash,
+      block: { height: op.blockHeight ?? 0, hash: op.blockHash ?? "", time: op.date },
+      fees: asset.type === "native" ? 0n : BigInt((op.fee ?? 0).toFixed(0)),
+      date: op.date,
+      failed: op.hasFailed ?? false,
+    },
+  };
+}
+
+function parseCursor(options: ListOperationsOptions): number {
+  const parsed = options.cursor ? Number.parseInt(options.cursor, 10) : Number.NaN;
+  const fromCursor = !Number.isNaN(parsed) && parsed >= 1 ? parsed : 1;
+  return Math.max(fromCursor, options.minHeight || 0);
+}
+
+// Merged VET + VTHO operations; `next` is one block past the current head for incremental resume.
+export async function listOperations(
+  address: string,
+  options: ListOperationsOptions,
+): Promise<Page<Operation<MemoNotSupported>>> {
+  const startAt = parseCursor(options);
+  const stopAt = await getLastBlockHeight();
+
+  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),
+  ]);
+
+  const items = [
+    ...vetOps.map(op => toFrameworkOperation(op, NATIVE_ASSET)),
+    ...vthoOps.map(op => toFrameworkOperation(op, vthoAsset(address))),
+  ].sort((a, b) => b.tx.date.getTime() - a.tx.date.getTime());
+
+  return {
+    items,
+    next: String(stopAt + 1),
+  };
+}