@ledgerhq/live-common 34.48.0-nightly.1 → 34.48.0-nightly.10

package/src/notifications/ServiceStatusProvider/index.test.ts

@@ -0,0 +1,102 @@
+import { filterServiceStatusIncidents } from "./index";
+import { LEDGER_COMPONENTS } from "./ledger-components";
+import type { Incident } from "./types";
+
+const makeIncident = (overrides: Partial<Incident> = {}): Incident => ({
+  created_at: "2025-01-01T00:00:00Z",
+  id: Math.random().toString(16).slice(2),
+  impact: "minor",
+  incident_updates: [],
+  monitoring_at: null,
+  name: "Test incident",
+  page_id: null,
+  resolved_at: null,
+  shortlink: null,
+  status: "investigating",
+  updated_at: null,
+  ...overrides,
+});
+
+describe("filterServiceStatusIncidents", () => {
+  it("returns empty when no tickers or no incidents", () => {
+    expect(filterServiceStatusIncidents([], ["BTC"]).length).toBe(0);
+    expect(filterServiceStatusIncidents([makeIncident()], []).length).toBe(0);
+  });
+
+  it("matches incidents with known Ledger components (case-insensitive)", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "Ledger Application Store" }] }),
+      makeIncident({ components: [{ id: "2", name: "ledger appliCAtion store" }] }),
+      makeIncident({ components: [{ id: "3", name: "Unknown Component" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"]);
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "2"]);
+  });
+
+  it("matches incidents if a component contains a tracked ticker as a whole word (case-insensitive)", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "BTC Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "eth Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "TETHER Service" }] }),
+      makeIncident({ components: [{ id: "4", name: "NOTBTCService" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC", "ETH"]);
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "2"]);
+  });
+
+  it("includes incidents with no components array or empty array", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: undefined }),
+      makeIncident({ components: [] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"]);
+    expect(result.length).toBe(2);
+  });
+
+  it("escapes tickers so special regex characters do not break matching", () => {
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "USDT Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "US.DT Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "(USDT) Node" }] }),
+      makeIncident({ components: [{ id: "4", name: "Ethereum  Node" }] }),
+      makeIncident({ components: [{ id: "5", name: "Ethereum (ETH) swap issue" }] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, ["USDT", "ETH"]);
+    expect(result.map(i => i.components?.[0].id)).toEqual(["1", "3", "5"]);
+    expect(result.length).toBe(3);
+  });
+
+  it("matches incidents for all known Ledger components", () => {
+    const incidents: Incident[] = LEDGER_COMPONENTS.map((name, index) =>
+      makeIncident({ components: [{ id: `${index + 1}`, name }] }),
+    );
+
+    const result = filterServiceStatusIncidents(incidents, ["BTC"]);
+    expect(result.length).toBe(LEDGER_COMPONENTS.length);
+  });
+
+  it("filters correctly with common tickers", () => {
+    const tickers = ["XRP", "SOL", "ETH", "BTC", "ADA", "USDC", "USDT"];
+    const incidents: Incident[] = [
+      makeIncident({ components: [{ id: "1", name: "BTC Node" }] }),
+      makeIncident({ components: [{ id: "2", name: "eth Node" }] }),
+      makeIncident({ components: [{ id: "3", name: "ADA-Service" }] }),
+      makeIncident({ components: [{ id: "4", name: "usdc gateway" }] }),
+      makeIncident({ components: [{ id: "5", name: "NOTUSDTService" }] }),
+      makeIncident({ components: [{ id: "6", name: "USDT" }] }),
+      makeIncident({ components: [{ id: "7", name: "xrp relayer" }] }),
+      makeIncident({ components: [{ id: "8", name: "SOL Node" }] }),
+      makeIncident({ components: [{ id: "9", name: "SOLANA Node" }] }),
+      makeIncident({ components: [{ id: "10", name: "Random Service" }] }),
+      makeIncident({ components: [] }),
+    ];
+
+    const result = filterServiceStatusIncidents(incidents, tickers);
+    expect(result.map(i => i.components?.[0]?.id)).toEqual(["1", "2", "3", "4", "6", "7", "8"]);
+    expect(result.length).toBe(8);
+  });
+});

package/src/notifications/ServiceStatusProvider/index.tsx

@@ -4,6 +4,7 @@ import defaultNetworkApi from "./api";
 import { fromPromise } from "xstate";
 import { useMachine } from "@xstate/react";
 import { serviceStatusMachine } from "./machine";
+import { LEDGER_COMPONENTS } from "./ledger-components";
 type Props = {
   children: React.ReactNode;
   autoUpdateDelay: number;
@@ -33,27 +34,51 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()[\]\\]/g, "\\$&"); // $& means the whole matched string
 }
 
+function sanitizeName(name: string): string {
+  return name.toLowerCase().trim().replace(/\s+/g, " "); // collapse multiple spaces
+}
+
+/**
+ * Filters service status incidents based on related tickers or Ledger components.
+ *
+ * ## Behavior:
+ * - If there are no `tickers` or no `incidents`, returns an empty list.
+ * - For each incident:
+ *   1. ✅ If the incident has no components → keep it (always relevant).
+ *   2. ✅ If at least one component name matches a known **Ledger component** → keep it.
+ *   3. ✅ If at least one component name contains a **currency ticker** → keep it.
+ *   4. ❌ Otherwise, the incident is discarded.
+ *
+ * @param {Incident[]} [incidents=[]] - List of incidents to filter.
+ * @param {string[]} [tickers=[]] - List of currency tickers to match against incident components.
+ * @returns {Incident[]} The list of incidents relevant to the provided tickers or Ledger components.
+ */
+
 export function filterServiceStatusIncidents(
-  incidents: Incident[],
+  incidents: Incident[] = [],
   tickers: string[] = [],
 ): Incident[] {
-  if (!tickers || tickers.length === 0 || !incidents || incidents.length === 0) {
-    return [];
-  }
-
-  const tickersRegex = new RegExp(escapeRegExp(tickers.join("|")), "i");
-  return incidents.filter(
-    ({ components }) =>
-      !components || // dont filter out if no components
-      components.length === 0 ||
-      components.some(({ name }) => tickersRegex.test(name)), // component name should hold currency ticker
-  );
+  if (!tickers.length || !incidents.length) return [];
+
+  const tickerRegex = new RegExp(`\\b(${tickers.map(escapeRegExp).join("|")})\\b`, "i");
+
+  const ledgerComponentsSet = new Set(LEDGER_COMPONENTS.map(component => sanitizeName(component)));
+
+  return incidents.filter(({ components }) => {
+    if (!components?.length) return true;
+
+    return components.some(({ name }) => {
+      const sanitizedName = sanitizeName(name);
+      return ledgerComponentsSet.has(sanitizedName) || tickerRegex.test(sanitizedName);
+    });
+  });
 }
 
 // filter out service status incidents by given currencies or fallback on context currencies
 export function useFilteredServiceStatus(filters?: ServiceStatusUserSettings): StatusContextType {
   const stateData = useContext(ServiceStatusContext);
   const { incidents, context } = stateData;
+
   const filteredIncidents = useMemo(() => {
     return filterServiceStatusIncidents(incidents, filters?.tickers || context?.tickers);
   }, [incidents, context, filters?.tickers]);

package/src/notifications/ServiceStatusProvider/ledger-components.ts

@@ -0,0 +1,12 @@
+export const LEDGER_COMPONENTS = [
+  "Ledger Application Store",
+  "Ledger Live Security Services",
+  "Swap API",
+  "Buy",
+  "Earn Dashboard",
+  "Crypto Assets Service",
+  "Cloud Sync",
+  "Trustchain",
+  "Loyalty Program",
+  "Card Program",
+] as const;

package/src/wallet-api/ACRE/server.test.ts

@@ -0,0 +1,470 @@
+import { handlers } from "./server";
+import { Account } from "@ledgerhq/types-live";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { AppPlatform, AppBranch, Visibility } from "../types";
+
+// Mock dependencies
+jest.mock("@ledgerhq/wallet-api-server", () => ({
+  RPCHandler: jest.fn(),
+  customWrapper: jest.fn(handler => handler),
+}));
+
+jest.mock("@ledgerhq/cryptoassets", () => ({
+  findTokenById: jest.fn(),
+  findTokenByAddressInCurrency: jest.fn(),
+  getCryptoCurrencyById: jest.fn(),
+}));
+
+jest.mock("../converters", () => ({
+  getAccountIdFromWalletAccountId: jest.fn(),
+  getWalletAPITransactionSignFlowInfos: jest.fn(),
+}));
+
+jest.mock("../../bridge", () => ({
+  getAccountBridge: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/live-env", () => ({
+  getEnv: jest.fn(),
+}));
+
+// Mock types
+const mockTracking = {
+  signMessageRequested: jest.fn(),
+  signMessageSuccess: jest.fn(),
+  signMessageFail: jest.fn(),
+  signMessageNoParams: jest.fn(),
+  signMessageUserRefused: jest.fn(),
+  signTransactionRequested: jest.fn(),
+  signTransactionSuccess: jest.fn(),
+  signTransactionFail: jest.fn(),
+  signTransactionNoParams: jest.fn(),
+  signTransactionAndBroadcastNoParams: jest.fn(),
+  broadcastSuccess: jest.fn(),
+  broadcastFail: jest.fn(),
+  broadcastOperationDetailsClick: jest.fn(),
+};
+
+const mockManifest = {
+  id: "test-manifest",
+  name: "Test App",
+  url: "https://test.app",
+  homepageUrl: "https://test.app",
+  icon: "data:image/png;base64,test",
+  apiVersion: "1.0.0",
+  permissions: [],
+  domains: [],
+  categories: [],
+  platforms: ["desktop", "ios"] as AppPlatform[],
+  manifestVersion: "1.0.0",
+  branch: "stable" as AppBranch,
+  currencies: [],
+  visibility: "complete" as Visibility,
+  content: {
+    shortDescription: { en: "Test app" },
+    description: { en: "Test app description" },
+  },
+};
+
+const mockEthereumCurrency: CryptoCurrency = {
+  type: "CryptoCurrency",
+  id: "ethereum",
+  coinType: 60,
+  name: "Ethereum",
+  managerAppName: "Ethereum",
+  ticker: "ETH",
+  scheme: "ethereum",
+  color: "#0ebdcd",
+  symbol: "Ξ",
+  family: "evm",
+  blockAvgTime: 15,
+  units: [
+    {
+      name: "ether",
+      code: "ETH",
+      magnitude: 18,
+    },
+  ],
+  keywords: ["eth", "ethereum"],
+  explorerViews: [],
+  explorerId: "eth",
+};
+
+const mockTokenCurrency: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/acre_btc",
+  contractAddress: "0x1234567890123456789012345678901234567890",
+  parentCurrency: mockEthereumCurrency,
+  tokenType: "erc20",
+  name: "ACRE Bitcoin",
+  ticker: "acreBTC",
+  units: [
+    {
+      name: "ACRE Bitcoin",
+      code: "acreBTC",
+      magnitude: 8,
+    },
+  ],
+};
+
+const mockAccount: Account = {
+  type: "Account",
+  id: "js:2:ethereum:0x1234567890123456789012345678901234567890:ethereum",
+  seedIdentifier: "0x1234567890123456789012345678901234567890",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0x1234567890123456789012345678901234567890",
+  freshAddressPath: "44'/60'/0'/0/0",
+  used: false,
+  blockHeight: 0,
+  creationDate: new Date(),
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+  operationsCount: 0,
+  operations: [],
+  pendingOperations: [],
+  currency: mockEthereumCurrency,
+  lastSyncDate: new Date(),
+  swapHistory: [],
+  balanceHistoryCache: {
+    HOUR: { latestDate: null, balances: [] },
+    DAY: { latestDate: null, balances: [] },
+    WEEK: { latestDate: null, balances: [] },
+  },
+  syncHash: "0x00000000",
+  subAccounts: [],
+  nfts: [],
+};
+
+jest.mock("@ledgerhq/coin-framework/account/index", () => ({
+  getParentAccount: jest.fn(),
+  getMainAccount: jest.fn(),
+  makeEmptyTokenAccount: jest.fn(),
+  isTokenAccount: jest.fn(),
+}));
+
+describe("ACRE Server Handlers", () => {
+  let mockUiHooks: any;
+  let serverHandlers: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUiHooks = {
+      "custom.acre.messageSign": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess("0x1234567890abcdef");
+      }),
+      "custom.acre.transactionSign": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess({
+          operation: { hash: "0x1234567890abcdef" },
+          signature: "0xabcdef1234567890",
+        });
+      }),
+      "custom.acre.transactionBroadcast": jest.fn(),
+      "custom.acre.registerAccount": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess();
+      }),
+    };
+
+    // Mock the cryptoassets functions globally
+    const { findTokenByAddressInCurrency, getCryptoCurrencyById } =
+      jest.requireMock("@ledgerhq/cryptoassets");
+    findTokenByAddressInCurrency.mockReturnValue(mockTokenCurrency);
+    getCryptoCurrencyById.mockReturnValue(mockEthereumCurrency);
+
+    // Mock the account functions
+    const { makeEmptyTokenAccount, getMainAccount, getParentAccount } = jest.requireMock(
+      "@ledgerhq/coin-framework/account/index",
+    );
+    makeEmptyTokenAccount.mockReturnValue({
+      type: "TokenAccount",
+      id: "mock-token-account-id",
+      parentId: "mock-parent-id",
+      token: mockTokenCurrency,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      creationDate: new Date(),
+      operationsCount: 0,
+      operations: [],
+      pendingOperations: [],
+      balanceHistoryCache: {
+        HOUR: { latestDate: null, balances: [] },
+        DAY: { latestDate: null, balances: [] },
+        WEEK: { latestDate: null, balances: [] },
+      },
+      swapHistory: [],
+    });
+    getMainAccount.mockReturnValue(mockAccount);
+    getParentAccount.mockReturnValue(undefined);
+
+    // Mock the converter functions
+    const { getAccountIdFromWalletAccountId, getWalletAPITransactionSignFlowInfos } =
+      jest.requireMock("../converters");
+    getAccountIdFromWalletAccountId.mockReturnValue(
+      "js:2:ethereum:0x1234567890123456789012345678901234567890:ethereum",
+    );
+    getWalletAPITransactionSignFlowInfos.mockReturnValue({
+      canEditFees: true,
+      liveTx: { family: "evm" },
+      hasFeesProvided: true,
+    });
+
+    // Mock the bridge
+    const { getAccountBridge } = jest.requireMock("../../bridge");
+    getAccountBridge.mockReturnValue({
+      broadcast: jest.fn().mockResolvedValue({ hash: "0x1234567890abcdef" }),
+    });
+
+    serverHandlers = handlers({
+      accounts: [mockAccount],
+      tracking: mockTracking,
+      manifest: mockManifest,
+      uiHooks: mockUiHooks,
+    });
+  });
+
+  describe("custom.acre.messageSign", () => {
+    it("should handle message signing request successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        message: { type: "SignIn", message: "test" },
+        derivationPath: "0/0",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+      };
+
+      const mockSignature = "0x1234567890abcdef";
+      mockUiHooks["custom.acre.messageSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignature);
+      });
+
+      const result = await serverHandlers["custom.acre.messageSign"](mockParams);
+
+      expect(result).toEqual({
+        hexSignedMessage: "1234567890abcdef",
+      });
+      expect(mockTracking.signMessageRequested).toHaveBeenCalledWith(mockManifest);
+      expect(mockTracking.signMessageSuccess).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.messageSign"](null);
+
+      expect(result).toEqual({
+        hexSignedMessage: "",
+      });
+      expect(mockTracking.signMessageNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle account not found", async () => {
+      const mockParams = {
+        accountId: "non-existent-account",
+        message: { type: "SignIn", message: "test" },
+        derivationPath: "0/0",
+        options: {},
+        meta: {},
+      };
+
+      // Mock getAccountIdFromWalletAccountId to return null for non-existent account
+      const { getAccountIdFromWalletAccountId } = jest.requireMock("../converters");
+      getAccountIdFromWalletAccountId.mockReturnValueOnce(null);
+
+      await expect(serverHandlers["custom.acre.messageSign"](mockParams)).rejects.toThrow(
+        "accountId non-existent-account unknown",
+      );
+    });
+  });
+
+  describe("custom.acre.transactionSign", () => {
+    it("should handle transaction signing request successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        rawTransaction: "0x1234567890abcdef",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+        tokenCurrency: "ethereum/erc20/test",
+      };
+
+      const mockSignedOperation = {
+        operation: { hash: "0x1234567890abcdef" },
+        signature: "0xabcdef1234567890",
+      };
+
+      mockUiHooks["custom.acre.transactionSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignedOperation);
+      });
+
+      const result = await serverHandlers["custom.acre.transactionSign"](mockParams);
+
+      expect(result).toEqual({
+        signedTransactionHex: "307861626364656631323334353637383930",
+      });
+      expect(mockTracking.signTransactionRequested).toHaveBeenCalledWith(mockManifest);
+      expect(mockTracking.signTransactionSuccess).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.transactionSign"](null);
+
+      expect(result).toEqual({
+        signedTransactionHex: "",
+      });
+      expect(mockTracking.signTransactionNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+  });
+
+  describe("custom.acre.transactionSignAndBroadcast", () => {
+    it("should handle transaction sign and broadcast successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        rawTransaction: "0x1234567890abcdef",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+        tokenCurrency: "ethereum/erc20/test",
+      };
+
+      const mockSignedOperation = {
+        operation: { hash: "0x1234567890abcdef" },
+        signature: "0xabcdef1234567890",
+      };
+
+      mockUiHooks["custom.acre.transactionSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignedOperation);
+      });
+
+      const result = await serverHandlers["custom.acre.transactionSignAndBroadcast"](mockParams);
+
+      expect(result).toEqual({
+        transactionHash: "0x1234567890abcdef",
+      });
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.transactionSignAndBroadcast"](null);
+
+      expect(result).toEqual({
+        transactionHash: "",
+      });
+      expect(mockTracking.signTransactionAndBroadcastNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+  });
+
+  describe("custom.acre.registerYieldBearingEthereumAddress", () => {
+    const mockParams = {
+      ethereumAddress: "0x9876543210987654321098765432109876543210",
+      tokenContractAddress: "0x1234567890123456789012345678901234567890",
+      meta: { test: "data" },
+    };
+
+    it("should register new yield-bearing Ethereum address successfully on mobile", async () => {
+      const result =
+        await serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](mockParams);
+
+      expect(result.success).toBe(true);
+      expect(result.accountName).toBe("Yield-bearing BTC on ACRE");
+      expect(result.ethereumAddress).toBe(mockParams.ethereumAddress);
+      expect(result.tokenContractAddress).toBe(mockParams.tokenContractAddress);
+
+      // Verify UI hook was called with correct parameters
+      expect(mockUiHooks["custom.acre.registerAccount"]).toHaveBeenCalledWith({
+        parentAccount: expect.objectContaining({
+          type: "Account",
+          id: expect.stringContaining("0x9876543210987654321098765432109876543210"),
+        }),
+        accountName: "Yield-bearing BTC on ACRE",
+        existingAccounts: [mockAccount],
+        onSuccess: expect.any(Function),
+        onError: expect.any(Function),
+      });
+    });
+
+    it("should register new yield-bearing Ethereum address successfully on desktop", async () => {
+      const desktopServerHandlers = handlers({
+        accounts: [mockAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: mockUiHooks,
+      });
+
+      const result = await (
+        desktopServerHandlers["custom.acre.registerYieldBearingEthereumAddress"] as any
+      )(mockParams);
+
+      expect(result.success).toBe(true);
+
+      expect(mockUiHooks["custom.acre.registerAccount"]).toHaveBeenCalledWith({
+        parentAccount: expect.objectContaining({
+          type: "Account",
+          id: expect.stringContaining("0x9876543210987654321098765432109876543210"),
+        }),
+        accountName: "Yield-bearing BTC on ACRE",
+        existingAccounts: [mockAccount],
+        onSuccess: expect.any(Function),
+        onError: expect.any(Function),
+      });
+    });
+
+    it("should handle existing account gracefully", async () => {
+      const existingAccount = {
+        ...mockAccount,
+        freshAddress: mockParams.ethereumAddress,
+      };
+
+      const serverHandlersWithExisting = handlers({
+        accounts: [existingAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: mockUiHooks,
+      });
+
+      const result = await (
+        serverHandlersWithExisting["custom.acre.registerYieldBearingEthereumAddress"] as any
+      )(mockParams);
+
+      expect(result.success).toBe(true);
+      expect(result.parentAccountId).toBe(existingAccount.id);
+      expect(result.tokenAccountId).toBe(existingAccount.id);
+      expect(mockUiHooks["custom.acre.registerAccount"]).not.toHaveBeenCalled();
+    });
+
+    it("should handle missing UI hook", async () => {
+      const serverHandlersWithoutHook = handlers({
+        accounts: [mockAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: {
+          ...mockUiHooks,
+          "custom.acre.registerAccount": undefined,
+        },
+      });
+
+      await expect(
+        (serverHandlersWithoutHook["custom.acre.registerYieldBearingEthereumAddress"] as any)(
+          mockParams,
+        ),
+      ).rejects.toThrow("No account registration UI hook available");
+    });
+
+    it("should validate Ethereum address format", async () => {
+      const invalidParams = {
+        ...mockParams,
+        ethereumAddress: "invalid-address",
+      };
+
+      await expect(
+        serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](invalidParams),
+      ).rejects.toThrow("Invalid Ethereum address format");
+    });
+
+    it("should require either tokenContractAddress or tokenTicker", async () => {
+      const invalidParams = {
+        ethereumAddress: mockParams.ethereumAddress,
+        meta: mockParams.meta,
+      };
+
+      await expect(
+        serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](invalidParams),
+      ).rejects.toThrow("Either tokenContractAddress or tokenTicker must be provided");
+    });
+  });
+});