@ledgerhq/coin-canton 0.12.0-nightly.20251211024123 → 0.12.0-nightly.20251212024049

package/src/bridge/sync.test.ts

@@ -1,11 +1,12 @@
-import { makeGetAccountShape } from "./sync";
-import { OperationInfo, type InstrumentBalance } from "../network/gateway";
+import { makeGetAccountShape, filterDisabledTokenAccounts } from "./sync";
+import { OperationInfo } from "../network/gateway";
 import * as gateway from "../network/gateway";
 import * as onboard from "./onboard";
 import * as config from "../config";
+import * as accountBalance from "../common-logic/account/getBalance";
 import resolver from "../signer";
 import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { Account } from "@ledgerhq/types-live";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { CantonAccount } from "../types";
 import { createMockCantonCurrency } from "../test/fixtures";
@@ -14,34 +15,76 @@ jest.mock("../network/gateway");
 jest.mock("../signer");
 jest.mock("../config");
 jest.mock("./onboard");
+jest.mock("../common-logic/account/getBalance");
+jest.mock("@ledgerhq/cryptoassets/state", () => {
+  const store = {
+    findTokenByAddressInCurrency: jest.fn().mockResolvedValue(undefined),
+  };
+  return {
+    getCryptoAssetsStore: jest.fn(() => store),
+  };
+});
 
-const mockedGetBalance = gateway.getBalance as jest.Mock;
+const mockedGetBalance = accountBalance.getBalance as jest.Mock;
 const mockedGetLedgerEnd = gateway.getLedgerEnd as jest.Mock;
 const mockedGetOperations = gateway.getOperations as jest.Mock;
+const mockedGetPendingTransferProposals = gateway.getPendingTransferProposals as jest.Mock;
+const mockedGetCalTokensCached = gateway.getCalTokensCached as unknown as jest.Mock;
+const mockedGetEnabledInstrumentsCached =
+  gateway.getEnabledInstrumentsCached as unknown as jest.Mock;
 const mockedResolver = resolver as jest.Mock;
 const mockedIsOnboarded = onboard.isAccountOnboarded as jest.Mock;
 const mockedIsAuthorized = onboard.isCantonCoinPreapproved as jest.Mock;
 const mockedCoinConfig = config.default.getCoinConfig as jest.Mock;
 
-const sampleCurrency = {
-  id: "testcoin",
+const sampleCurrency = createMockCantonCurrency();
+
+type CantonBalance = {
+  value: bigint;
+  locked: bigint;
+  asset: { type: "native" } | { type: "token"; assetReference: string };
+  utxoCount: number;
+  instrumentId: string;
+  adminId: string;
 };
 
-const createMockInstrumentBalances = (): InstrumentBalance[] => [
-  {
-    instrument_id: "Native",
-    amount: "1000",
-    locked: false,
-    utxo_count: 1,
-    admin_id: "admin1",
-  },
-];
-
-const createMockOperationView = (): OperationInfo =>
+const createMockNativeBalance = (amount: string, locked = false): CantonBalance => ({
+  value: BigInt(amount),
+  locked: locked ? BigInt(amount) : BigInt(0),
+  asset: { type: "native" },
+  utxoCount: 1,
+  instrumentId: "Amulet",
+  adminId: "native-admin",
+});
+
+const createMockTokenBalance = (
+  instrumentId: string,
+  amount: string,
+  locked = false,
+): CantonBalance => ({
+  value: BigInt(amount),
+  locked: locked ? BigInt(amount) : BigInt(0),
+  asset: { type: "token", assetReference: instrumentId },
+  utxoCount: 1,
+  instrumentId,
+  adminId: `admin-${instrumentId}`,
+});
+
+const createMockOperationView = (
+  overrides: {
+    instrumentId?: string;
+    instrumentAdmin?: string | null;
+    txHash?: string;
+    uid?: string;
+    type?: string;
+    value?: string;
+    operationType?: string;
+  } = {},
+): OperationInfo =>
   ({
-    transaction_hash: "tx-test",
-    uid: "uid-test",
-    type: "Send",
+    transaction_hash: overrides.txHash ?? "tx-test",
+    uid: overrides.uid ?? "uid-test",
+    type: overrides.type ?? "Send",
     status: "Success",
     fee: {
       value: "5",
@@ -57,10 +100,10 @@ const createMockOperationView = (): OperationInfo =>
       {
         address: "party123",
         type: "Send",
-        value: "100",
-        asset: "Native",
+        value: overrides.value ?? "100",
+        asset: overrides.instrumentId ?? "Amulet",
         details: {
-          operationType: "transfer",
+          operationType: overrides.operationType ?? "transfer",
           metadata: {
             reason: "test transfer",
           },
@@ -76,11 +119,11 @@ const createMockOperationView = (): OperationInfo =>
       hash: "blockhash1",
     },
     asset: {
-      type: "native",
-      issuer: null,
+      instrumentId: overrides.instrumentId ?? "Amulet",
+      instrumentAdmin: overrides.instrumentAdmin ?? null,
     },
     details: {
-      operationType: "transfer",
+      operationType: overrides.operationType ?? "transfer",
     },
   }) as OperationInfo;
 
@@ -125,49 +168,27 @@ describe("makeGetAccountShape", () => {
     });
 
     mockedCoinConfig.mockReturnValue({
-      nativeInstrumentId: "Native",
+      nativeInstrumentId: "Amulet",
       minReserve: "0",
       useGateway: true,
     });
 
     mockedIsAuthorized.mockResolvedValue(true);
     mockedGetLedgerEnd.mockResolvedValue(12345);
+    mockedGetPendingTransferProposals.mockResolvedValue([]);
+    mockedGetCalTokensCached.mockResolvedValue(new Map());
   });
 
   it("should return a valid account shape with correct balances and operations", async () => {
-    mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: false,
-        utxo_count: 1,
-      },
-    ]);
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [
-        {
-          transaction_hash: "tx1",
+        createMockOperationView({
+          txHash: "tx1",
           uid: "uid1",
           type: "Send",
-          fee: { value: "5" },
-          transfers: [
-            {
-              value: "100",
-              details: {
-                metadata: {
-                  reason: "test transfer",
-                },
-              },
-            },
-          ],
-          transaction_timestamp: new Date().toISOString(),
-          senders: ["party123"],
-          recipients: ["party456"],
-          block: {
-            height: 1,
-            hash: "blockhash1",
-          },
-        } as OperationInfo,
+          value: "100",
+        }),
       ],
     });
     const getAccountShape = makeGetAccountShape(fakeSignerContext);
@@ -186,18 +207,8 @@ describe("makeGetAccountShape", () => {
 
   it("should handle locked balances correctly", async () => {
     mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: true,
-        utxo_count: 1,
-      },
-      {
-        instrument_id: "Native",
-        amount: "10",
-        locked: false,
-        utxo_count: 1,
-      },
+      createMockNativeBalance("1000", true),
+      createMockNativeBalance("10", false),
     ]);
 
     const getAccountShape = makeGetAccountShape(fakeSignerContext);
@@ -207,7 +218,7 @@ describe("makeGetAccountShape", () => {
 
     expect(shape).toBeDefined();
     expect(shape.balance).toEqual(BigNumber(1010));
-    expect(shape.spendableBalance).toEqual(BigNumber(1010));
+    expect(shape.spendableBalance).toEqual(BigNumber(10));
   });
 
   it("should handle empty balances correctly", async () => {
@@ -224,39 +235,15 @@ describe("makeGetAccountShape", () => {
   });
 
   it("should default to FEES operation type when transferValue is 0", async () => {
-    mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: false,
-        utxo_count: 1,
-      },
-    ]);
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [
-        {
-          transaction_hash: "tx2",
+        createMockOperationView({
+          txHash: "tx2",
           uid: "uid2",
           type: "Send",
-          fee: { value: "3" },
-          transfers: [
-            {
-              value: "0",
-              details: {
-                metadata: {
-                  reason: "fee only",
-                },
-              },
-            },
-          ],
-          transaction_timestamp: new Date().toISOString(),
-          senders: ["party123"],
-          recipients: ["party456"],
-          block: {
-            height: 2,
-            hash: "blockhash2",
-          },
-        } as OperationInfo,
+          value: "0",
+        }),
       ],
     });
 
@@ -267,44 +254,20 @@ describe("makeGetAccountShape", () => {
     expect(shape).toBeDefined();
     expect(shape.operations[0].type).toBe("FEES");
     // In this case, value should equal the fee
-    expect(shape.operations[0].value).toEqual(BigNumber(3));
+    expect(shape.operations[0].value).toEqual(BigNumber(5)); // fee is 5 in createMockOperationView
   });
 
   it("should set operation type to TRANSFER_PROPOSAL when operationType is transfer-proposal", async () => {
-    mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: false,
-        utxo_count: 1,
-      },
-    ]);
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [
-        {
-          transaction_hash: "tx3",
+        createMockOperationView({
+          txHash: "tx3",
           uid: "uid3",
           type: "Send",
-          fee: { value: "5" },
-          transfers: [
-            {
-              value: "200",
-              details: {
-                operationType: "transfer-proposal",
-                metadata: {
-                  reason: "transfer proposal",
-                },
-              },
-            },
-          ],
-          transaction_timestamp: new Date().toISOString(),
-          senders: ["party123"],
-          recipients: ["party456"],
-          block: {
-            height: 3,
-            hash: "blockhash3",
-          },
-        } as OperationInfo,
+          value: "200",
+          operationType: "transfer-proposal",
+        }),
       ],
     });
 
@@ -318,40 +281,16 @@ describe("makeGetAccountShape", () => {
   });
 
   it("should set operation type to TRANSFER_REJECTED when operationType is transfer-rejected", async () => {
-    mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: false,
-        utxo_count: 1,
-      },
-    ]);
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [
-        {
-          transaction_hash: "tx4",
+        createMockOperationView({
+          txHash: "tx4",
           uid: "uid4",
           type: "Send",
-          fee: { value: "2" },
-          transfers: [
-            {
-              value: "150",
-              details: {
-                operationType: "transfer-rejected",
-                metadata: {
-                  reason: "transfer rejected",
-                },
-              },
-            },
-          ],
-          transaction_timestamp: new Date().toISOString(),
-          senders: ["party123"],
-          recipients: ["party456"],
-          block: {
-            height: 4,
-            hash: "blockhash4",
-          },
-        } as OperationInfo,
+          value: "150",
+          operationType: "transfer-rejected",
+        }),
       ],
     });
 
@@ -365,40 +304,16 @@ describe("makeGetAccountShape", () => {
   });
 
   it("should set operation type to TRANSFER_WITHDRAWN when operationType is transfer-withdrawn", async () => {
-    mockedGetBalance.mockResolvedValue([
-      {
-        instrument_id: "Native",
-        amount: "1000",
-        locked: false,
-        utxo_count: 1,
-      },
-    ]);
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [
-        {
-          transaction_hash: "tx5",
+        createMockOperationView({
+          txHash: "tx5",
           uid: "uid5",
           type: "Send",
-          fee: { value: "1" },
-          transfers: [
-            {
-              value: "50",
-              details: {
-                operationType: "transfer-withdrawn",
-                metadata: {
-                  reason: "transfer withdrawn",
-                },
-              },
-            },
-          ],
-          transaction_timestamp: new Date().toISOString(),
-          senders: ["party123"],
-          recipients: ["party456"],
-          block: {
-            height: 5,
-            hash: "blockhash5",
-          },
-        } as OperationInfo,
+          value: "50",
+          operationType: "transfer-withdrawn",
+        }),
       ],
     });
 
@@ -412,7 +327,7 @@ describe("makeGetAccountShape", () => {
   });
 
   it("should sync without device when account has xpub but no publicKey", async () => {
-    mockedGetBalance.mockResolvedValue(createMockInstrumentBalances());
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [createMockOperationView()],
     });
@@ -465,7 +380,7 @@ describe("makeGetAccountShape", () => {
   });
 
   it("should sync without device when account has both xpub and publicKey", async () => {
-    mockedGetBalance.mockResolvedValue(createMockInstrumentBalances());
+    mockedGetBalance.mockResolvedValue([createMockNativeBalance("1000")]);
     mockedGetOperations.mockResolvedValue({
       operations: [createMockOperationView()],
     });
@@ -491,3 +406,134 @@ describe("makeGetAccountShape", () => {
     expect(mockedResolver).not.toHaveBeenCalled();
   });
 });
+
+describe("filterDisabledTokenAccounts", () => {
+  const currency = createMockCantonCurrency();
+
+  const createMockTokenAccount = (contractAddress: string): TokenAccount => ({
+    type: "TokenAccount",
+    id: `token-account-${contractAddress}`,
+    parentId: "parent-account-id",
+    token: {
+      type: "TokenCurrency",
+      id: `token-id-${contractAddress}`,
+      contractAddress,
+      name: "Test Token",
+      ticker: "TEST",
+      decimals: 18,
+      parentCurrency: currency,
+    } as any,
+    balance: new BigNumber(100),
+    spendableBalance: new BigNumber(100),
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+    creationDate: new Date(),
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return empty array when subAccounts is undefined", async () => {
+    const result = await filterDisabledTokenAccounts(currency, undefined);
+    expect(result).toEqual([]);
+    expect(mockedGetEnabledInstrumentsCached).not.toHaveBeenCalled();
+  });
+
+  it("should return empty array when subAccounts is empty", async () => {
+    const result = await filterDisabledTokenAccounts(currency, []);
+    expect(result).toEqual([]);
+    expect(mockedGetEnabledInstrumentsCached).not.toHaveBeenCalled();
+  });
+
+  it("should filter out disabled token accounts", async () => {
+    const enabledTokenId = "0xenabled";
+    const disabledTokenId = "0xdisabled";
+    const enabledTokenAccount = createMockTokenAccount(enabledTokenId);
+    const disabledTokenAccount = createMockTokenAccount(disabledTokenId);
+
+    mockedGetEnabledInstrumentsCached.mockResolvedValue([enabledTokenId]);
+
+    const result = await filterDisabledTokenAccounts(currency, [
+      enabledTokenAccount,
+      disabledTokenAccount,
+    ]);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBe(enabledTokenAccount);
+    expect(mockedGetEnabledInstrumentsCached).toHaveBeenCalledWith(currency);
+  });
+
+  it("should keep enabled token accounts", async () => {
+    const enabledTokenId1 = "0xenabled1";
+    const enabledTokenId2 = "0xenabled2";
+    const enabledTokenAccount1 = createMockTokenAccount(enabledTokenId1);
+    const enabledTokenAccount2 = createMockTokenAccount(enabledTokenId2);
+
+    mockedGetEnabledInstrumentsCached.mockResolvedValue([enabledTokenId1, enabledTokenId2]);
+
+    const result = await filterDisabledTokenAccounts(currency, [
+      enabledTokenAccount1,
+      enabledTokenAccount2,
+    ]);
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain(enabledTokenAccount1);
+    expect(result).toContain(enabledTokenAccount2);
+  });
+
+  it("should not keep token accounts without contractAddress", async () => {
+    const tokenAccountWithoutAddress = {
+      ...createMockTokenAccount("0xtest"),
+      token: {
+        ...createMockTokenAccount("0xtest").token,
+        contractAddress: "",
+      },
+    };
+    const enabledTokenAccount = createMockTokenAccount("0xenabled");
+
+    mockedGetEnabledInstrumentsCached.mockResolvedValue(["0xenabled"]);
+
+    const result = await filterDisabledTokenAccounts(currency, [
+      tokenAccountWithoutAddress,
+      enabledTokenAccount,
+    ]);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBe(enabledTokenAccount);
+    expect(result).not.toContain(tokenAccountWithoutAddress);
+  });
+
+  it("should return empty array when API fails", async () => {
+    const enabledTokenAccount = createMockTokenAccount("0xenabled");
+    const disabledTokenAccount = createMockTokenAccount("0xdisabled");
+
+    mockedGetEnabledInstrumentsCached.mockRejectedValue(new Error("Network error"));
+
+    const result = await filterDisabledTokenAccounts(currency, [
+      enabledTokenAccount,
+      disabledTokenAccount,
+    ]);
+
+    expect(result).toEqual([]);
+    expect(mockedGetEnabledInstrumentsCached).toHaveBeenCalledWith(currency);
+  });
+
+  it("should handle empty enabled instruments list", async () => {
+    const tokenAccount1 = createMockTokenAccount("0xtoken1");
+    const tokenAccount2 = createMockTokenAccount("0xtoken2");
+
+    mockedGetEnabledInstrumentsCached.mockResolvedValue([]);
+
+    const result = await filterDisabledTokenAccounts(currency, [tokenAccount1, tokenAccount2]);
+
+    expect(result).toEqual([]);
+  });
+});