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

package/src/bridge/sync.ts

@@ -1,5 +1,6 @@
 import BigNumber from "bignumber.js";
-import { Operation, OperationType } from "@ledgerhq/types-live";
+import { Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
@@ -9,18 +10,27 @@ import {
   getOperations,
   type OperationInfo,
   getPendingTransferProposals,
+  getEnabledInstrumentsCached,
+  getCalTokensCached,
 } from "../network/gateway";
-import { getBalance, type CantonBalance } from "../common-logic/account/getBalance";
+import { getBalance } from "../common-logic/account/getBalance";
 import coinConfig from "../config";
 import resolver from "../signer";
 import { CantonAccount, CantonResources, CantonSigner } from "../types";
 import { isAccountOnboarded } from "./onboard";
 import { isCantonAccountEmpty } from "../helpers";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
+import { buildSubAccounts } from "./buildSubAccounts";
+
+const SEPARATOR = "____";
+
+const getKey = (id: string, adminId: string) => `${id}${SEPARATOR}${adminId}`;
 
 const txInfoToOperationAdapter =
   (accountId: string, partyId: string) =>
   (txInfo: OperationInfo): Operation => {
     const {
+      asset: { instrumentId, instrumentAdmin },
       transaction_hash,
       uid,
       block: { height, hash },
@@ -73,6 +83,8 @@ const txInfoToOperationAdapter =
       extra: {
         uid,
         memo,
+        instrumentId,
+        instrumentAdmin,
       },
     };
 
@@ -87,6 +99,35 @@ const filterOperations = (
   return transactions.map(txInfoToOperationAdapter(accountId, partyId));
 };
 
+export async function filterDisabledTokenAccounts(
+  currency: CryptoCurrency,
+  subAccounts: TokenAccount[] | undefined,
+): Promise<TokenAccount[]> {
+  if (!subAccounts || subAccounts.length === 0) {
+    return [];
+  }
+
+  let enabledInstruments: Set<string>;
+
+  try {
+    const enabledList = await getEnabledInstrumentsCached(currency);
+    enabledInstruments = new Set(enabledList);
+  } catch (error) {
+    // If API fails, hide all token accounts
+    return [];
+  }
+
+  return subAccounts.filter(subAccount => {
+    const instrumentId = subAccount.token.contractAddress;
+
+    if (!instrumentId) {
+      return false;
+    }
+
+    return enabledInstruments.has(instrumentId);
+  });
+}
+
 export function makeGetAccountShape(
   signerContext: SignerContext<CantonSigner>,
 ): GetAccountShape<CantonAccount> {
@@ -129,31 +170,96 @@ export function makeGetAccountShape(
       ? await getPendingTransferProposals(currency, xpubOrAddress)
       : [];
 
-    const balancesData = (balances || []).reduce(
-      (acc, balance) => {
+    // Aggregate all balances by instrument (unlocked + locked)
+    const aggregatedBalances = new Map<
+      string,
+      {
+        unlockedBalance: bigint;
+        lockedBalance: bigint;
+        utxoCount: number;
+        token: TokenCurrency | null;
+        adminId: string;
+      }
+    >();
+
+    const proposalInstrumentKeys = new Set(
+      pendingTransferProposals.map(proposal =>
+        getKey(proposal.instrument_id, proposal.instrument_admin),
+      ),
+    );
+    for (const key of proposalInstrumentKeys) {
+      if (aggregatedBalances.has(key)) continue;
+
+      const [instrumentId, adminId] = key.split(SEPARATOR);
+      balances.push({
+        value: 0n,
+        locked: 0n,
+        utxoCount: 0,
+        instrumentId,
+        adminId,
+        asset: { type: "token", assetReference: instrumentId },
+      });
+    }
+
+    const tokensByKey = new Map<string, TokenCurrency>();
+    for await (const balance of balances) {
+      const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+        balance.adminId,
+        currency.id,
+      );
+      if (!token) continue;
+      tokensByKey.set(getKey(balance.instrumentId, balance.adminId), token);
+    }
+
+    for await (const balance of balances) {
+      const isNative = balance.instrumentId === nativeInstrumentId;
+      // Use just instrumentId for native (no admin), composite key for tokens
+      const balanceKey = isNative
+        ? nativeInstrumentId
+        : getKey(balance.instrumentId, balance.adminId);
+      const token: TokenCurrency | null = isNative ? null : tokensByKey.get(balanceKey) ?? null;
+
+      const existing = aggregatedBalances.get(balanceKey);
+      if (existing) {
         if (balance.locked) {
-          acc[`Locked${balance.instrumentId}`] = balance;
+          existing.lockedBalance += balance.value;
         } else {
-          acc[balance.instrumentId] = balance;
+          existing.unlockedBalance += balance.value;
         }
-        return acc;
-      },
-      {} as Record<string, CantonBalance>,
-    );
+        existing.utxoCount += balance.utxoCount;
+      } else {
+        aggregatedBalances.set(balanceKey, {
+          unlockedBalance: balance.locked ? 0n : balance.value,
+          lockedBalance: balance.locked ? balance.value : 0n,
+          utxoCount: balance.utxoCount,
+          token,
+          adminId: balance.adminId,
+        });
+      }
+    }
 
-    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.value.toString() || "0");
-    const lockedAmount = new BigNumber(
-      balancesData[`Locked${nativeInstrumentId}`]?.value.toString() || "0",
-    );
+    // Find native balance (token is null for native)
+    const nativeBalance = Array.from(aggregatedBalances.values()).find(data => data.token === null);
+    const unlockedAmount = new BigNumber((nativeBalance?.unlockedBalance ?? 0n).toString());
+    const lockedAmount = new BigNumber((nativeBalance?.lockedBalance ?? 0n).toString());
     const totalBalance = unlockedAmount.plus(lockedAmount);
     const reserveMin = new BigNumber(coinConfig.getCoinConfig(currency).minReserve || 0);
-    const spendableBalance = BigNumber.max(0, totalBalance.minus(reserveMin));
+    const spendableBalance = BigNumber.max(0, unlockedAmount.minus(reserveMin));
 
     const instrumentUtxoCounts: Record<string, number> = {};
-    for (const [instrumentId, balance] of Object.entries(balancesData)) {
-      instrumentUtxoCounts[instrumentId] = balance.utxoCount;
+    for (const [key, data] of aggregatedBalances) {
+      instrumentUtxoCounts[key] = data.utxoCount;
     }
 
+    const tokenBalances = Array.from(aggregatedBalances.entries())
+      .filter(([, data]) => data.token !== null)
+      .map(([, { unlockedBalance, lockedBalance, token, adminId }]) => ({
+        totalBalance: unlockedBalance + lockedBalance,
+        spendableBalance: unlockedBalance,
+        token: token!,
+        adminId,
+      }));
+
     let operations: Operation[] = [];
     if (xpubOrAddress) {
       const oldOperations = initialAccount?.operations || [];
@@ -166,26 +272,49 @@ export function makeGetAccountShape(
       operations = mergeOps(oldOperations, newOperations);
     }
 
+    // Filter main account operations (native instrument only)
+    const mainAccountOperations = operations.filter(op => {
+      const extra = op.extra as { instrumentId?: string };
+      return extra?.instrumentId === nativeInstrumentId;
+    });
+
+    // Build sub-accounts for tokens with their filtered operations
+
+    const calTokens = await getCalTokensCached(currency);
+
+    const subAccounts = buildSubAccounts({
+      accountId,
+      tokenBalances,
+      existingSubAccounts: initialAccount?.subAccounts ?? [],
+      allOperations: operations,
+      pendingTransferProposals,
+      calTokens,
+    });
+
     const cantonResources: CantonResources = {
       isOnboarded,
       instrumentUtxoCounts,
-      pendingTransferProposals,
+      pendingTransferProposals: pendingTransferProposals.filter(
+        proposal => proposal.instrument_id === nativeInstrumentId,
+      ),
       ...(publicKey && { publicKey }),
       xpub: xpubOrAddress,
     };
 
+    const filteredSubAccounts = await filterDisabledTokenAccounts(currency, subAccounts);
+
     const used = !isCantonAccountEmpty({
-      operationsCount: operations.length,
+      operationsCount: mainAccountOperations.length,
       balance: totalBalance,
-      subAccounts: initialAccount?.subAccounts ?? [],
+      subAccounts: filteredSubAccounts,
       cantonResources,
     });
 
     const blockHeight = await getLedgerEnd(currency);
 
     const creationDate =
-      operations.length > 0
-        ? new Date(Math.min(...operations.map(op => op.date.getTime())))
+      mainAccountOperations.length > 0
+        ? new Date(Math.min(...mainAccountOperations.map(op => op.date.getTime())))
         : new Date();
 
     const shape = {
@@ -197,9 +326,10 @@ export function makeGetAccountShape(
       lastSyncDate: new Date(),
       freshAddress: address,
       seedIdentifier: address,
-      operations,
-      operationsCount: operations.length,
+      operations: mainAccountOperations,
+      operationsCount: mainAccountOperations.length,
       spendableBalance,
+      subAccounts: filteredSubAccounts,
       xpub: xpubOrAddress,
       used,
       cantonResources,

package/src/bridge/validateAddress.test.ts

@@ -0,0 +1,25 @@
+import { isRecipientValid } from "../common-logic";
+import { validateAddress } from "./validateAddress";
+
+jest.mock("../common-logic");
+
+describe("validateAddress", () => {
+  const mockedIsRecipientValid = jest.mocked(isRecipientValid);
+
+  beforeEach(() => {
+    mockedIsRecipientValid.mockClear();
+  });
+
+  it.each([true, false])(
+    "should call correctly isRecipientValid and return the correct value",
+    async (expectedValue: boolean) => {
+      mockedIsRecipientValid.mockReturnValueOnce(expectedValue);
+
+      const result = await validateAddress("some random address", {});
+      expect(result).toEqual(expectedValue);
+
+      expect(mockedIsRecipientValid).toHaveBeenCalledTimes(1);
+      expect(mockedIsRecipientValid).toHaveBeenCalledWith("some random address");
+    },
+  );
+});

package/src/bridge/validateAddress.ts

@@ -0,0 +1,9 @@
+import { isRecipientValid } from "../common-logic";
+import { AddressValidationCurrencyParameters } from "@ledgerhq/types-live";
+
+export async function validateAddress(
+  address: string,
+  _parameters: Partial<AddressValidationCurrencyParameters>,
+): Promise<boolean> {
+  return isRecipientValid(address);
+}

package/src/common-logic/account/getBalance.ts

@@ -6,6 +6,7 @@ import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 export type CantonBalance = Balance & {
   utxoCount: number;
   instrumentId: string;
+  adminId: string;
 };
 
 const useGateway = (currency: CryptoCurrency) =>
@@ -23,6 +24,7 @@ function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance
         : { type: "token", assetReference: instrument.instrument_id },
     utxoCount: instrument.utxo_count,
     instrumentId: instrument.instrument_id,
+    adminId: instrument.admin_id,
   };
 }
 

package/src/common-logic/transaction/craftTransaction.ts

@@ -15,6 +15,7 @@ export async function craftTransaction(
   },
   transaction: {
     recipient?: string;
+    instrumentAdmin?: string;
     amount: BigNumber;
     tokenId: string;
     expireInSeconds: number;
@@ -33,6 +34,10 @@ export async function craftTransaction(
     instrument_id: transaction.tokenId,
   };
 
+  if (transaction.instrumentAdmin) {
+    params.instrument_admin = transaction.instrumentAdmin;
+  }
+
   if (transaction.memo) {
     params.reason = transaction.memo;
   }

package/src/network/gateway.test.ts

@@ -2,8 +2,12 @@ import {
   getBalance,
   isPartyAlreadyExists,
   submitOnboarding,
+  getEnabledInstruments,
+  getEnabledInstrumentsCached,
+  clearEnabledInstrumentsCache,
   type GetBalanceResponse,
   type InstrumentBalance,
+  type InstrumentsResponse,
   type OnboardingPrepareResponse,
 } from "./gateway";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
@@ -126,3 +130,168 @@ describe("getBalance", () => {
     await expect(getBalance(mockCurrency, "test-party-id")).rejects.toThrow(TopologyChangeError);
   });
 });
+
+describe("getEnabledInstruments", () => {
+  const mockCurrency = {
+    id: "canton_network",
+  } as unknown as CryptoCurrency;
+
+  const mockNetwork = network as jest.MockedFunction<typeof network>;
+
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
+      nodeId: "test-node-id",
+      useGateway: true,
+      networkType: "devnet",
+      nativeInstrumentId: "Amulet",
+      status: {
+        type: "active",
+      },
+    }));
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should fetch and return enabled instruments from API", async () => {
+    const mockInstrumentsResponse: InstrumentsResponse = {
+      instruments: [
+        { instrument_id: "Amulet", display_name: "Canton Coin" },
+        { instrument_id: "0x1234567890abcdef", display_name: "Test Token 1" },
+        { instrument_id: "0xabcdef1234567890", display_name: "Test Token 2" },
+      ],
+    };
+
+    mockNetwork.mockResolvedValue({ data: mockInstrumentsResponse, status: 200 });
+
+    const result = await getEnabledInstruments(mockCurrency);
+
+    expect(result).toEqual(["Amulet", "0x1234567890abcdef", "0xabcdef1234567890"]);
+    expect(mockNetwork).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: "GET",
+        url: expect.stringContaining("/v1/node/test-node-id/instruments"),
+      }),
+    );
+  });
+
+  it("should return empty array on API failure (fail-safe)", async () => {
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+    mockNetwork.mockRejectedValue(new Error("Network error"));
+
+    const result = await getEnabledInstruments(mockCurrency);
+
+    expect(result).toEqual([]);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Failed to fetch enabled instruments:",
+      expect.any(Error),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it("should return empty array when API returns empty instruments list", async () => {
+    const mockEmptyResponse: InstrumentsResponse = {
+      instruments: [],
+    };
+
+    mockNetwork.mockResolvedValue({ data: mockEmptyResponse, status: 200 });
+
+    const result = await getEnabledInstruments(mockCurrency);
+
+    expect(result).toEqual([]);
+  });
+
+  it("should handle malformed API response gracefully", async () => {
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+    // API returns data without instruments property
+    mockNetwork.mockResolvedValue({ data: { invalid: "response" }, status: 200 });
+
+    const result = await getEnabledInstruments(mockCurrency);
+
+    expect(result).toEqual([]);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+
+    consoleErrorSpy.mockRestore();
+  });
+});
+
+describe("getEnabledInstrumentsCached", () => {
+  const mockCurrency = {
+    id: "canton_network",
+  } as unknown as CryptoCurrency;
+
+  const mockNetwork = network as jest.MockedFunction<typeof network>;
+
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
+      nodeId: "test-node-id",
+      useGateway: true,
+      networkType: "devnet",
+      nativeInstrumentId: "Amulet",
+      status: {
+        type: "active",
+      },
+    }));
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Clear cache before each test
+    clearEnabledInstrumentsCache(mockCurrency);
+  });
+
+  it("should cache results and return cached value on subsequent calls", async () => {
+    const mockInstrumentsResponse: InstrumentsResponse = {
+      instruments: [{ instrument_id: "Amulet" }, { instrument_id: "0x1234567890abcdef" }],
+    };
+
+    mockNetwork.mockResolvedValue({ data: mockInstrumentsResponse, status: 200 });
+
+    // First call - should fetch from API
+    const result1 = await getEnabledInstrumentsCached(mockCurrency);
+    expect(result1).toEqual(["Amulet", "0x1234567890abcdef"]);
+    expect(mockNetwork).toHaveBeenCalledTimes(1);
+
+    // Second call - should return cached value
+    const result2 = await getEnabledInstrumentsCached(mockCurrency);
+    expect(result2).toEqual(["Amulet", "0x1234567890abcdef"]);
+    expect(mockNetwork).toHaveBeenCalledTimes(1); // Still only 1 call
+
+    // Third call - should still return cached value
+    const result3 = await getEnabledInstrumentsCached(mockCurrency);
+    expect(result3).toEqual(["Amulet", "0x1234567890abcdef"]);
+    expect(mockNetwork).toHaveBeenCalledTimes(1); // Still only 1 call
+  });
+
+  it("should fetch fresh data after cache is cleared", async () => {
+    const mockResponse1: InstrumentsResponse = {
+      instruments: [{ instrument_id: "Amulet" }],
+    };
+
+    const mockResponse2: InstrumentsResponse = {
+      instruments: [{ instrument_id: "Amulet" }, { instrument_id: "0xnewtoken" }],
+    };
+
+    mockNetwork.mockResolvedValueOnce({ data: mockResponse1, status: 200 });
+
+    // First call
+    const result1 = await getEnabledInstrumentsCached(mockCurrency);
+    expect(result1).toEqual(["Amulet"]);
+    expect(mockNetwork).toHaveBeenCalledTimes(1);
+
+    // Clear cache
+    clearEnabledInstrumentsCache(mockCurrency);
+
+    // Set up new response
+    mockNetwork.mockResolvedValueOnce({ data: mockResponse2, status: 200 });
+
+    // Second call after clear - should fetch fresh data
+    const result2 = await getEnabledInstrumentsCached(mockCurrency);
+    expect(result2).toEqual(["Amulet", "0xnewtoken"]);
+    expect(mockNetwork).toHaveBeenCalledTimes(2);
+  });
+});

package/src/network/gateway.ts

@@ -69,6 +69,7 @@ export type PrepareTransferRequest = {
   recipient: string;
   execute_before_secs: number;
   instrument_id: string;
+  instrument_admin?: string;
   reason?: string;
 };
 
@@ -87,6 +88,7 @@ export type TransferProposal = {
   receiver: string;
   amount: string;
   instrument_id: string;
+  instrument_admin: string;
   memo: string;
   expires_at_micros: number;
 };
@@ -112,6 +114,13 @@ type TransactionSubmitRequest = {
 
 type TransactionSubmitResponse = { update_id: string };
 
+type Asset = {
+  instrumentAdmin: string;
+  instrumentId: string;
+  issuer: string | null;
+  type: "token" | "native";
+};
+
 export type GetBalanceResponse =
   | {
       at_round: number;
@@ -228,10 +237,7 @@ export type OperationInfo =
           type: string;
         };
       };
-      asset: {
-        type: "token";
-        issuer: string;
-      };
+      asset: Asset;
       details: {
         operationType: OperationType;
       };
@@ -273,10 +279,7 @@ export type OperationInfo =
           type: string;
         };
       };
-      asset: {
-        type: "native";
-        issuer: null;
-      };
+      asset: Asset;
       details: {
         operationType: OperationType;
       };
@@ -318,10 +321,7 @@ export type OperationInfo =
           type: string;
         };
       };
-      asset: {
-        type: "native";
-        issuer: null;
-      };
+      asset: Asset;
       details: {
         operationType: OperationType;
       };
@@ -426,6 +426,45 @@ export function clearIsTopologyChangeRequiredCache(currency: CryptoCurrency, pub
   isTopologyChangeRequiredCached.clear(cacheKey);
 }
 
+export type InstrumentInfo = {
+  instrument_id: string;
+  display_name?: string;
+};
+
+export type InstrumentsResponse = {
+  instruments: InstrumentInfo[];
+};
+
+export async function getEnabledInstruments(currency: CryptoCurrency): Promise<string[]> {
+  try {
+    const { data } = await gatewayNetwork<InstrumentsResponse>({
+      method: "GET",
+      url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/instruments`,
+    });
+    return data.instruments.map(instrument => instrument.instrument_id);
+  } catch (error) {
+    // If API fails, return empty array (fail-safe: only native instrument will work)
+    console.error("Failed to fetch enabled instruments:", error);
+    return [];
+  }
+}
+
+const getEnabledInstrumentsCacheKey = (currency: CryptoCurrency): string => {
+  const nodeId = getNodeId(currency);
+  return `instruments_${nodeId}`;
+};
+
+export const getEnabledInstrumentsCached = makeLRUCache(
+  getEnabledInstruments,
+  getEnabledInstrumentsCacheKey,
+  minutes(15),
+);
+
+export function clearEnabledInstrumentsCache(currency: CryptoCurrency): void {
+  const cacheKey = getEnabledInstrumentsCacheKey(currency);
+  getEnabledInstrumentsCached.clear(cacheKey);
+}
+
 export async function submitOnboarding(
   currency: CryptoCurrency,
   publicKey: string,
@@ -704,3 +743,35 @@ export async function getPendingTransferProposals(currency: CryptoCurrency, part
   });
   return data;
 }
+
+// CAL API types
+export type CalToken = {
+  id: string;
+  name: string;
+  ticker: string;
+  network: string;
+  contract_address: string;
+  token_identifier: string;
+};
+
+/**
+ * Fetch Canton tokens from CAL service and create a map of id -> token_identifier
+ */
+async function getCalTokens(currency: CryptoCurrency): Promise<Map<string, string>> {
+  const calUrl = getEnv("CAL_SERVICE_URL");
+  const { data: calTokens } = await gatewayNetwork<CalToken[]>({
+    method: "GET",
+    url: `${calUrl}/v1/tokens?network=${currency.id}&output=id,name,ticker,network,contract_address,token_identifier,units,standard`,
+  });
+
+  // Map id -> token_identifier
+  const tokenIdentifierMap = new Map<string, string>();
+  for (const token of calTokens) {
+    tokenIdentifierMap.set(token.id, token.token_identifier);
+  }
+  return tokenIdentifierMap;
+}
+
+const getCalTokensCacheKey = (currency: CryptoCurrency): string => currency.id;
+
+export const getCalTokensCached = makeLRUCache(getCalTokens, getCalTokensCacheKey, minutes(30));

package/src/types/bridge.ts

@@ -62,6 +62,7 @@ export type Transaction = TransactionCommon & {
   memo?: string;
   tokenId: string;
   expireInSeconds?: number;
+  instrumentAdmin?: string;
 };
 
 export type TransactionRaw = TransactionCommonRaw & {
@@ -70,6 +71,7 @@ export type TransactionRaw = TransactionCommonRaw & {
   memo?: string;
   tokenId: string;
   expireInSeconds?: number;
+  instrumentAdmin?: string;
 };
 
 export type TransactionStatus = TransactionStatusCommon;

package/tsconfig.json

@@ -4,9 +4,14 @@
     "declaration": true,
     "declarationMap": true,
     "downlevelIteration": true,
-    "lib": ["es2020", "dom"],
+    "lib": [
+      "es2020",
+      "dom"
+    ],
     "outDir": "lib",
     "exactOptionalPropertyTypes": true
   },
-  "include": ["src/**/*"]
+  "include": [
+    "src/**/*"
+  ]
 }