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

package/src/bridge/buildSubAccounts.ts

@@ -0,0 +1,132 @@
+import BigNumber from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+import type { TokenAccount } from "@ledgerhq/types-live";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { encodeTokenAccountId, emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { type TransferProposal } from "../network/gateway";
+
+export type CantonTokenAccount = TokenAccount & {
+  cantonResources: { pendingTransferProposals: TransferProposal[] };
+};
+
+export function buildSubAccounts({
+  accountId,
+  tokenBalances,
+  existingSubAccounts,
+  allOperations,
+  pendingTransferProposals,
+  calTokens,
+}: {
+  accountId: string;
+  calTokens: Map<string, string>;
+  tokenBalances: Array<{
+    adminId: string;
+    totalBalance: bigint;
+    spendableBalance: bigint;
+    token: TokenCurrency;
+  }>;
+  existingSubAccounts: TokenAccount[];
+  allOperations: Operation[];
+  pendingTransferProposals: TransferProposal[];
+}): CantonTokenAccount[] {
+  if (tokenBalances.length === 0) return [];
+
+  const tokenAccounts: CantonTokenAccount[] = [];
+  const existingAccountByTicker: { [ticker: string]: TokenAccount } = {};
+  const existingAccountTickers: string[] = [];
+
+  for (const existingSubAccount of existingSubAccounts) {
+    if (existingSubAccount.type === "TokenAccount") {
+      const { ticker } = existingSubAccount.token;
+      existingAccountTickers.push(ticker);
+      existingAccountByTicker[ticker] = existingSubAccount;
+    }
+  }
+
+  for (const { totalBalance, spendableBalance, token, adminId } of tokenBalances) {
+    const initialTokenAccount = existingAccountByTicker[token.ticker];
+
+    const instrumentId = calTokens.get(token.id) || token.name;
+
+    // Filter operations for this specific instrument (both id and admin must match)
+    const tokenOperations = allOperations.filter(op => {
+      const extra = op.extra as { instrumentId?: string; instrumentAdmin?: string };
+      return extra?.instrumentId === instrumentId && extra?.instrumentAdmin === adminId;
+    });
+
+    // Filter pending transfer proposals for this specific instrument
+    const tokenPendingTransferProposals = pendingTransferProposals.filter(
+      proposal => proposal.instrument_id === instrumentId && proposal.instrument_admin === adminId,
+    );
+
+    const tokenAccount = buildSubAccount({
+      totalBalance: new BigNumber(totalBalance.toString()),
+      spendableBalance: new BigNumber(spendableBalance.toString()),
+      accountId,
+      initialTokenAccount,
+      parentAccountId: accountId,
+      token,
+      operations: tokenOperations,
+      pendingTransferProposals: tokenPendingTransferProposals,
+    });
+    if (tokenAccount) tokenAccounts.push(tokenAccount);
+  }
+
+  return tokenAccounts;
+}
+
+function buildSubAccount({
+  totalBalance,
+  spendableBalance,
+  accountId,
+  initialTokenAccount,
+  parentAccountId,
+  token,
+  operations,
+  pendingTransferProposals,
+}: {
+  totalBalance: BigNumber;
+  spendableBalance: BigNumber;
+  accountId: string;
+  initialTokenAccount: TokenAccount | undefined;
+  parentAccountId: string;
+  token: TokenCurrency;
+  operations: Operation[];
+  pendingTransferProposals: TransferProposal[];
+}): CantonTokenAccount {
+  const subAccountId = encodeTokenAccountId(accountId, token);
+
+  // Merge old operations with new ones and update accountId for sub-account
+  const oldOperations = initialTokenAccount?.operations || [];
+  const newOperations = operations.map(op => ({
+    ...op,
+    id: encodeOperationId(subAccountId, op.hash, op.type),
+    accountId: subAccountId,
+  }));
+  const mergedOperations = mergeOps(oldOperations, newOperations);
+
+  const creationDate =
+    mergedOperations.length > 0
+      ? new Date(Math.min(...mergedOperations.map(op => op.date.getTime())))
+      : new Date();
+
+  return {
+    type: "TokenAccount" as const,
+    id: subAccountId,
+    parentId: parentAccountId,
+    token,
+    balance: totalBalance,
+    spendableBalance,
+    operationsCount: mergedOperations.length,
+    operations: mergedOperations,
+    creationDate,
+    pendingOperations: initialTokenAccount?.pendingOperations || [],
+    balanceHistoryCache: initialTokenAccount?.balanceHistoryCache || emptyHistoryCache,
+    swapHistory: [],
+    cantonResources: {
+      pendingTransferProposals,
+    },
+  };
+}

package/src/bridge/getTransactionStatus.ts

@@ -3,7 +3,9 @@ import {
   FeeNotLoaded,
   FeeTooHigh,
   InvalidAddress,
+  NotEnoughBalance,
   NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughBalanceInParentAccount,
   NotEnoughSpendableBalance,
   RecipientRequired,
 } from "@ledgerhq/errors";
@@ -37,10 +39,22 @@ export const getTransactionStatus: AccountBridge<
   // reserveAmount is the minimum amount of currency that an account must hold in order to stay activated
   const reserveAmount = new BigNumber(coinConfig.getCoinConfig(account.currency).minReserve || 0);
   const estimatedFees = new BigNumber(transaction.fee || 0);
-  const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
   const amount = new BigNumber(transaction.amount);
 
-  if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+  const isTokenTransaction = !!transaction.subAccountId;
+  // For token transactions, fees are paid from parent account, so totalSpent is just amount
+  const totalSpent = isTokenTransaction ? amount : amount.plus(estimatedFees);
+
+  // Get the account balance to check against (subAccount for tokens, main account for native)
+  let accountBalance = account.spendableBalance;
+  if (isTokenTransaction && account.subAccounts) {
+    const subAccount = account.subAccounts.find(
+      sub => sub.type === "TokenAccount" && sub.id === transaction.subAccountId,
+    );
+    accountBalance = subAccount?.spendableBalance ?? new BigNumber(0);
+  }
+
+  if (amount.gt(0) && estimatedFees.times(10).gt(amount) && !isTokenTransaction) {
     // if the fee is more than 10 times the amount, we warn the user that fee is high compared to what he is sending
     warnings.feeTooHigh = new FeeTooHigh();
   }
@@ -48,24 +62,6 @@ export const getTransactionStatus: AccountBridge<
   if (transaction.fee === null || transaction.fee === undefined) {
     // if the fee is not loaded, we can't do much
     errors.fee = new FeeNotLoaded();
-  } else if (totalSpent.gt(account.balance.minus(reserveAmount))) {
-    // if the total spent is greater than the balance minus the reserve amount, tx is invalid
-    errors.amount = new NotEnoughSpendableBalance("", {
-      minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
-        disableRounding: true,
-        useGrouping: false,
-        showCode: true,
-      }),
-    });
-  } else if (transaction.recipient && transaction.amount.lt(reserveAmount)) {
-    // if we send an amount lower than reserve amount AND target account is new, we need to warn the user that the target account will not be activated
-    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
-      minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
-        disableRounding: true,
-        useGrouping: false,
-        showCode: true,
-      }),
-    });
   }
 
   if (!transaction.recipient) {
@@ -77,11 +73,43 @@ export const getTransactionStatus: AccountBridge<
     });
   }
 
-  if (!errors.amount && amount.eq(0)) {
+  if (amount.eq(0)) {
     // if the amount is 0, we prevent the user from sending the tx (even if it's technically feasible)
     errors.amount = new AmountRequired();
   }
 
+  // For token transactions, check that parent account has enough native balance to pay fees
+  if (isTokenTransaction && estimatedFees.gt(account.balance)) {
+    errors.amount = new NotEnoughBalanceInParentAccount();
+  }
+
+  // Check if total spent exceeds available balance
+  if (!errors.amount && totalSpent.gt(accountBalance)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  // For native coin transactions, check reserve amount constraints
+  if (!isTokenTransaction && !errors.amount) {
+    if (totalSpent.gt(account.balance.minus(reserveAmount))) {
+      errors.amount = new NotEnoughSpendableBalance("", {
+        minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+          disableRounding: true,
+          useGrouping: false,
+          showCode: true,
+        }),
+      });
+    } else if (transaction.recipient && amount.lt(reserveAmount)) {
+      // if we send an amount lower than reserve amount AND target account is new, we need to warn the user that the target account will not be activated
+      errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+        minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+          disableRounding: true,
+          useGrouping: false,
+          showCode: true,
+        }),
+      });
+    }
+  }
+
   const utxoWarning = validateUtxoCount(account, transaction);
   if (utxoWarning) {
     warnings.tooManyUtxos = utxoWarning;
@@ -120,7 +148,10 @@ function validateUtxoCount(account: CantonAccount, transaction: Transaction): Er
   }
 
   const { instrumentUtxoCounts } = account.cantonResources;
-  const instrumentUtxoCount = instrumentUtxoCounts[transaction.tokenId] || 0;
+  const instrumentKey = transaction.instrumentAdmin
+    ? `${transaction.tokenId}-${transaction.instrumentAdmin}`
+    : transaction.tokenId;
+  const instrumentUtxoCount = instrumentUtxoCounts[instrumentKey] || 0;
 
   if (instrumentUtxoCount > TO_MANY_UTXOS_CRITICAL_COUNT) {
     return new TooManyUtxosCritical();

package/src/bridge/index.ts

@@ -23,6 +23,7 @@ import { updateTransaction } from "./updateTransaction";
 import { buildOnboardAccount, buildAuthorizePreapproval } from "./onboard";
 import { buildTransferInstruction } from "./acceptOffer";
 import { assignToAccountRaw, assignFromAccountRaw } from "./serialization";
+import { validateAddress } from "./validateAddress";
 
 export function createBridges(
   signerContext: SignerContext<CantonSigner>,
@@ -70,6 +71,7 @@ export function createBridges(
     assignToAccountRaw,
     assignFromAccountRaw,
     getSerializedAddressParameters,
+    validateAddress,
   };
 
   return {

package/src/bridge/prepareTransaction.ts

@@ -1,9 +1,14 @@
-import { AccountBridge } from "@ledgerhq/types-live";
+import { AccountBridge, TokenAccount } from "@ledgerhq/types-live";
 import { Transaction } from "../types";
 import { estimateFees } from "../common-logic";
 import BigNumber from "bignumber.js";
 import { updateTransaction } from "./updateTransaction";
 import coinConfig from "../config";
+import { getCalTokensCached } from "../network/gateway";
+
+type CantonTokenAccount = TokenAccount & {
+  cantonResources: { instrumentAdmin: string };
+};
 
 export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
   account,
@@ -14,8 +19,28 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
     (await estimateFees(account.currency, BigInt(amount.toFixed()))).toString(),
   );
 
-  if (!transaction.tokenId) {
-    transaction.tokenId = coinConfig.getCoinConfig(account.currency).nativeInstrumentId;
+  let tokenId = transaction.tokenId;
+  let instrumentAdmin: string | undefined;
+  if (transaction.subAccountId && account.subAccounts) {
+    const subAccount = account.subAccounts.find(
+      (sub): sub is CantonTokenAccount =>
+        sub.type === "TokenAccount" && sub.id === transaction.subAccountId,
+    );
+    if (subAccount) {
+      const calTokens = await getCalTokensCached(account.currency);
+      tokenId = calTokens.get(subAccount.token.id) || subAccount.token.name;
+      instrumentAdmin = subAccount.token.contractAddress;
+    }
   }
-  return updateTransaction(transaction, { fee });
+
+  // Default to native instrument if no tokenId set
+  if (!tokenId) {
+    tokenId = coinConfig.getCoinConfig(account.currency).nativeInstrumentId;
+  }
+
+  return updateTransaction(transaction, {
+    fee,
+    tokenId,
+    ...(instrumentAdmin !== undefined && { instrumentAdmin }),
+  });
 };

package/src/bridge/signOperation.ts

@@ -32,12 +32,16 @@ export const buildSignOperation =
               tokenId: string;
               expireInSeconds: number;
               memo?: string;
+              instrumentAdmin?: string;
             } = {
               recipient: transaction.recipient,
               amount: transaction.amount,
               expireInSeconds: 60 * 60,
               tokenId: transaction.tokenId,
             };
+            if (transaction.instrumentAdmin) {
+              params.instrumentAdmin = transaction.instrumentAdmin;
+            }
             if (transaction.memo) {
               params.memo = transaction.memo;
             }