@ledgerhq/coin-canton 0.9.0-nightly.2 → 0.9.0-nightly.20251031023756

package/src/bridge/getTransactionStatus.ts

@@ -4,21 +4,30 @@ import {
   FeeRequired,
   FeeTooHigh,
   InvalidAddress,
-  InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalanceBecauseDestinationNotCreated,
   NotEnoughSpendableBalance,
   RecipientRequired,
 } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
-import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { AccountBridge } from "@ledgerhq/types-live";
 import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
-import { Transaction, TransactionStatus } from "../types";
+import {
+  Transaction,
+  TransactionStatus,
+  CantonAccount,
+  TooManyUtxosCritical,
+  TooManyUtxosWarning,
+} from "../types";
 import { isRecipientValid } from "../common-logic/utils";
 import coinConfig from "../config";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
+
+export const TO_MANY_UTXOS_CRITICAL_COUNT = 24;
+export const TO_MANY_UTXOS_WARNING_COUNT = 10;
 
 export const getTransactionStatus: AccountBridge<
   Transaction,
-  Account,
+  CantonAccount,
   TransactionStatus
 >["getTransactionStatus"] = async (account, transaction) => {
   const errors: Record<string, Error> = {};
@@ -35,12 +44,9 @@ export const getTransactionStatus: AccountBridge<
     warnings.feeTooHigh = new FeeTooHigh();
   }
 
-  if (!transaction.fee) {
+  if (transaction.fee === null || transaction.fee === undefined) {
     // if the fee is not loaded, we can't do much
     errors.fee = new FeeNotLoaded();
-  } else if (transaction.fee.eq(0)) {
-    // On some chains, 0 fee could still work so this is optional
-    errors.fee = new FeeRequired();
   } 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("", {
@@ -63,9 +69,6 @@ export const getTransactionStatus: AccountBridge<
 
   if (!transaction.recipient) {
     errors.recipient = new RecipientRequired("");
-  } else if (account.freshAddress === transaction.recipient) {
-    // we want to prevent user from sending to themselves (even if it's technically feasible)
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
   } else if (!isRecipientValid(transaction.recipient)) {
     // We want to prevent user from sending to an invalid address
     errors.recipient = new InvalidAddress("", {
@@ -78,6 +81,8 @@ export const getTransactionStatus: AccountBridge<
     errors.amount = new AmountRequired();
   }
 
+  validateUtxoCount(account, transaction, warnings);
+
   return {
     errors,
     warnings,
@@ -86,3 +91,30 @@ export const getTransactionStatus: AccountBridge<
     totalSpent,
   };
 };
+
+function validateUtxoCount(
+  account: CantonAccount,
+  transaction: Transaction,
+  warnings: Record<string, Error>,
+): void {
+  const abandonSeedAddress = getAbandonSeedAddress(account.currency.id);
+  const isAbandonSeedAddress = transaction.recipient?.includes(abandonSeedAddress);
+
+  // UTXO count validation - only validate if recipient is valid and not equal to sender
+  // Skip validation for abandon seed addresses
+  if (
+    account?.cantonResources?.instrumentUtxoCounts &&
+    transaction.recipient &&
+    isRecipientValid(transaction.recipient) &&
+    account.xpub !== transaction.recipient &&
+    !isAbandonSeedAddress
+  ) {
+    const { instrumentUtxoCounts } = account.cantonResources;
+    const instrumentUtxoCount = instrumentUtxoCounts[transaction.tokenId] || 0;
+    if (instrumentUtxoCount > TO_MANY_UTXOS_CRITICAL_COUNT) {
+      warnings.tooManyUtxos = new TooManyUtxosCritical();
+    } else if (instrumentUtxoCount > TO_MANY_UTXOS_WARNING_COUNT) {
+      warnings.tooManyUtxos = new TooManyUtxosWarning("families.canton.tooManyUtxos.warning");
+    }
+  }
+}

package/src/bridge/index.ts

@@ -10,7 +10,7 @@ import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { AccountBridge } from "@ledgerhq/types-live";
 import cantonCoinConfig, { type CantonCoinConfig } from "../config";
 import resolver from "../signer";
-import { CantonCurrencyBridge, CantonSigner } from "../types";
+import { CantonCurrencyBridge, CantonSigner, CantonAccount } from "../types";
 import type { Transaction } from "../types";
 import { broadcast } from "./broadcast";
 import { createTransaction } from "./createTransaction";
@@ -21,6 +21,7 @@ import { buildSignOperation } from "./signOperation";
 import { makeGetAccountShape } from "./sync";
 import { updateTransaction } from "./updateTransaction";
 import { buildOnboardAccount, buildAuthorizePreapproval } from "./onboard";
+import { assignToAccountRaw, assignFromAccountRaw } from "./serialization";
 
 export function createBridges(
   signerContext: SignerContext<CantonSigner>,
@@ -49,13 +50,11 @@ export function createBridges(
 
   const signOperation = buildSignOperation(signerContext);
   const sync = makeSync({ getAccountShape: makeGetAccountShape(signerContext) });
-  // we want one method per file
-  const accountBridge: AccountBridge<Transaction> = {
+
+  const accountBridge: AccountBridge<Transaction, CantonAccount> = {
     broadcast,
     createTransaction,
     updateTransaction,
-    // NOTE: use updateTransaction: defaultUpdateTransaction<Transaction>,
-    // if you don't need to update the transaction patch object
     prepareTransaction,
     getTransactionStatus,
     estimateMaxSpendable,
@@ -65,6 +64,8 @@ export function createBridges(
     signRawOperation: () => {
       throw new Error("signRawOperation is not supported");
     },
+    assignToAccountRaw,
+    assignFromAccountRaw,
     getSerializedAddressParameters,
   };
 

package/src/bridge/onboard.integ.test.ts

@@ -1,45 +1,22 @@
-import BigNumber from "bignumber.js";
-import { firstValueFrom, toArray } from "rxjs";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
-import { generateMockKeyPair, createMockSigner } from "../test/cantonTestUtils";
+import { firstValueFrom, toArray } from "rxjs";
+import coinConfig from "../config";
+import { createMockSigner, generateMockKeyPair } from "../test/cantonTestUtils";
+import { createMockAccount, createMockCantonCurrency } from "../test/fixtures";
 import {
   AuthorizeStatus,
-  OnboardStatus,
   CantonAuthorizeProgress,
   CantonAuthorizeResult,
   CantonOnboardProgress,
   CantonOnboardResult,
+  OnboardStatus,
 } from "../types/onboard";
-import coinConfig from "../config";
-import { buildOnboardAccount, isAccountOnboarded, buildAuthorizePreapproval } from "./onboard";
+import { buildAuthorizePreapproval, buildOnboardAccount, isAccountOnboarded } from "./onboard";
 
 describe("onboard (devnet)", () => {
   const mockDeviceId = "test-device-id";
-  const mockCurrency = {
-    id: "canton_network",
-  } as unknown as CryptoCurrency;
-  const mockAccount = {
-    type: "Account" as const,
-    id: "js:2:canton_network:canton_3f5c9d9a:canton",
-    seedIdentifier: "canton_3f5c9d9a",
-    derivationMode: "canton" as const,
-    index: 0,
-    freshAddress: "canton_3f5c9d9a",
-    freshAddressPath: "44'/6767'/0'/0'/0'",
-    used: false,
-    balance: BigNumber(10000),
-    spendableBalance: BigNumber(10000),
-    creationDate: new Date(),
-    blockHeight: 1,
-    currency: mockCurrency,
-    operationsCount: 0,
-    operations: [],
-    pendingOperations: [],
-    lastSyncDate: new Date(),
-    balanceHistoryCache: emptyHistoryCache,
-    swapHistory: [],
-  };
+  const mockCurrency = createMockCantonCurrency();
+  const mockAccount = createMockAccount();
 
   let onboardedAccount: {
     keyPair: ReturnType<typeof generateMockKeyPair>;

package/src/bridge/onboard.ts

@@ -89,6 +89,7 @@ export const buildOnboardAccount =
         o.next({ status: OnboardStatus.PREPARE });
 
         let { partyId } = await isAccountOnboarded(currency, publicKey);
+
         if (partyId) {
           const onboardedAccount = createOnboardedAccount(account, partyId, currency);
           o.next({ partyId, account: onboardedAccount }); // success
@@ -144,7 +145,7 @@ export const buildAuthorizePreapproval =
 
           o.next({ status: AuthorizeStatus.SIGN });
 
-          const signature = await signerContext(deviceId, async signer => {
+          const { signature } = await signerContext(deviceId, async signer => {
             return await signTransaction(signer, account.freshAddressPath, preparedTransaction);
           });
           o.next({ status: AuthorizeStatus.SUBMIT });
@@ -162,7 +163,7 @@ export const buildAuthorizePreapproval =
               if (serialized && hash) {
                 o.next({ status: AuthorizeStatus.SIGN });
 
-                const signature = await signerContext(deviceId, signer =>
+                const { signature } = await signerContext(deviceId, signer =>
                   signer.signTransaction(account.freshAddressPath, hash),
                 );
 

package/src/bridge/prepareTransaction.ts

@@ -11,7 +11,7 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
 ) => {
   const amount = transaction.amount || BigNumber(0);
   const fee = BigNumber(
-    (await estimateFees(account.currency, BigInt(amount.toString()))).toString(),
+    (await estimateFees(account.currency, BigInt(amount.toFixed()))).toString(),
   );
 
   if (!transaction.tokenId) {

package/src/bridge/serialization.ts

@@ -0,0 +1,44 @@
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import {
+  type CantonAccount,
+  type CantonAccountRaw,
+  type CantonResources,
+  type CantonResourcesRaw,
+} from "../types";
+
+function isCantonAccount(account: Account): account is CantonAccount {
+  return "cantonResources" in account;
+}
+
+function isCantonAccountRaw(accountRaw: AccountRaw): accountRaw is CantonAccountRaw {
+  return "cantonResources" in accountRaw;
+}
+
+function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
+  const { instrumentUtxoCounts } = r;
+  return {
+    instrumentUtxoCounts,
+  };
+}
+
+function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
+  return {
+    instrumentUtxoCounts: r.instrumentUtxoCounts,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  if (isCantonAccount(account) && isCantonAccountRaw(accountRaw)) {
+    if (account.cantonResources) {
+      accountRaw.cantonResources = toResourcesRaw(account.cantonResources);
+    }
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account): void {
+  if (isCantonAccountRaw(accountRaw) && isCantonAccount(account)) {
+    if (accountRaw.cantonResources) {
+      account.cantonResources = fromResourcesRaw(accountRaw.cantonResources);
+    }
+  }
+}

package/src/bridge/signOperation.test.ts

@@ -1,9 +1,15 @@
 import { BigNumber } from "bignumber.js";
-import { CantonSigner, CantonPreparedTransaction } from "../types";
+import {
+  CantonSigner,
+  CantonPreparedTransaction,
+  CantonSignature,
+  CantonUntypedVersionedMessage,
+} from "../types";
 import { Transaction } from "../types";
 import { craftTransaction } from "../common-logic";
 import prepareTransferMock from "../test/prepare-transfer.json";
 import { buildSignOperation } from "./signOperation";
+import { createMockAccount } from "../test/fixtures";
 
 jest.mock("../common-logic", () => {
   const actual = jest.requireActual("../common-logic");
@@ -26,12 +32,22 @@ class MockCantonSigner implements CantonSigner {
 
   async signTransaction(
     path: string,
-    data: CantonPreparedTransaction | { transactions: string[] },
-  ) {
-    if ("transactions" in data) {
-      return `untyped-signature-${data.transactions.length}`;
+    data: CantonPreparedTransaction | CantonUntypedVersionedMessage | string,
+  ): Promise<CantonSignature> {
+    if (typeof data === "string") {
+      return { signature: `txhash-signature-${data}` };
+    } else if ("transactions" in data) {
+      const result: CantonSignature = {
+        signature: `untyped-signature-${data.transactions.length}`,
+      };
+      if (data.challenge) {
+        result.applicationSignature = `challenge-signature-${data.challenge}`;
+      }
+      return result;
     } else {
-      return `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`;
+      return {
+        signature: `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`,
+      };
     }
   }
 }
@@ -39,25 +55,18 @@ class MockCantonSigner implements CantonSigner {
 describe("buildSignOperation", () => {
   const mockDeviceId = "test-device-id";
   const mockDerivationPath = "44'/6767'/0'/0'/0'";
-  const mockPartyId = "alice::1220d466a5d96a3509736c821e25fe81fc8a73f226d92e57e94a65170e58b07fc08e";
 
   beforeEach(() => {
     jest.clearAllMocks();
     mockCraftTransaction.mockReset();
   });
 
-  const mockAccount = {
+  const mockAccount = createMockAccount({
     id: "js:2:canton_network:test-party-id:",
     freshAddress: "test-address",
     freshAddressPath: mockDerivationPath,
     xpub: "test-party-id",
-    currency: {
-      id: "canton_network",
-    },
-    cantonResources: {
-      partyId: mockPartyId,
-    },
-  } as any;
+  });
 
   const mockTransaction: Transaction = {
     family: "canton",

package/src/bridge/signOperation.ts

@@ -50,13 +50,13 @@ export const buildSignOperation =
               params,
             );
 
-            const transactionSignature = await signTransaction(signer, derivationPath, {
+            const { signature } = await signTransaction(signer, derivationPath, {
               json: nativeTransaction,
               serialized: serializedTransaction,
               hash: hash,
             });
 
-            return combine(serializedTransaction, `${transactionSignature}__PARTY__${address}`);
+            return combine(serializedTransaction, `${signature}__PARTY__${address}`);
           });
 
           o.next({

package/src/bridge/sync.test.ts

@@ -52,6 +52,7 @@ describe("makeGetAccountShape", () => {
     mockedCoinConfig.mockReturnValue({
       nativeInstrumentId: "Native",
       minReserve: "0",
+      useGateway: true,
     });
 
     mockedIsAuthorized.mockResolvedValue(true);
@@ -64,6 +65,7 @@ describe("makeGetAccountShape", () => {
         instrument_id: "Native",
         amount: "1000",
         locked: false,
+        utxo_count: 1,
       },
     ]);
     mockedGetOperations.mockResolvedValue({
@@ -113,11 +115,13 @@ describe("makeGetAccountShape", () => {
         instrument_id: "LockedNative",
         amount: "1000",
         locked: true,
+        utxo_count: 1,
       },
       {
         instrument_id: "Native",
         amount: "10",
         locked: false,
+        utxo_count: 1,
       },
     ]);
 
@@ -128,7 +132,7 @@ describe("makeGetAccountShape", () => {
 
     expect(shape).toBeDefined();
     expect(shape.balance).toEqual(BigNumber(1010));
-    expect(shape.spendableBalance).toEqual(BigNumber(10));
+    expect(shape.spendableBalance).toEqual(BigNumber(1010));
   });
 
   it("should handle empty balances correctly", async () => {

package/src/bridge/sync.ts

@@ -4,7 +4,8 @@ import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
+import { getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
+import { getBalance, type CantonBalance } from "../common-logic/account/getBalance";
 import coinConfig from "../config";
 import resolver from "../signer";
 import { CantonAccount, CantonSigner } from "../types";
@@ -108,18 +109,25 @@ export function makeGetAccountShape(
     const balances = xpubOrAddress ? await getBalance(currency, xpubOrAddress) : [];
 
     const balancesData = (balances || []).reduce(
-      (acc, { amount, instrument_id, locked }) => {
-        acc[instrument_id] = { amount, locked };
+      (acc, balance) => {
+        acc[balance.instrumentId] = balance;
         return acc;
       },
-      {} as Record<string, { amount: string; locked: boolean }>,
+      {} as Record<string, CantonBalance>,
     );
 
-    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.amount || "0");
-    const lockedAmount = new BigNumber(balancesData[`Locked${nativeInstrumentId}`]?.amount || "0");
+    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.value.toString() || "0");
+    const lockedAmount = new BigNumber(
+      balancesData[`Locked${nativeInstrumentId}`]?.value.toString() || "0",
+    );
     const totalBalance = unlockedAmount.plus(lockedAmount);
     const reserveMin = new BigNumber(coinConfig.getCoinConfig(currency).minReserve || 0);
-    const spendableBalance = BigNumber.max(0, unlockedAmount.minus(reserveMin));
+    const spendableBalance = BigNumber.max(0, totalBalance.minus(reserveMin));
+
+    const instrumentUtxoCounts: Record<string, number> = {};
+    for (const [instrumentId, balance] of Object.entries(balancesData)) {
+      instrumentUtxoCounts[instrumentId] = balance.utxoCount;
+    }
 
     let operations: Operation[] = [];
     if (xpubOrAddress) {
@@ -159,6 +167,9 @@ export function makeGetAccountShape(
       spendableBalance,
       xpub: xpubOrAddress,
       used,
+      cantonResources: {
+        instrumentUtxoCounts,
+      },
     };
 
     return shape;

package/src/bridge/transaction.ts

@@ -48,7 +48,7 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
   return {
     ...common,
     family: t.family,
-    fee: t.fee ? t.fee.toString() : null,
+    fee: t.fee ? t.fee.toFixed() : null,
     tokenId: t.tokenId,
   };
 };

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

@@ -3,12 +3,17 @@ import { getBalance as gatewayGetBalance, type InstrumentBalance } from "../../n
 import coinConfig from "../../config";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
+export type CantonBalance = Balance & {
+  utxoCount: number;
+  instrumentId: string;
+};
+
 const useGateway = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).useGateway === true;
 const getNativeId = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).nativeInstrumentId;
 
-function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): Balance {
+function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): CantonBalance {
   return {
     value: BigInt(instrument.amount),
     locked: instrument.locked === true ? BigInt(instrument.amount) : BigInt(0),
@@ -16,10 +21,15 @@ function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance
       getNativeId(currency) === instrument.instrument_id
         ? { type: "native" }
         : { type: "token", assetReference: instrument.instrument_id },
+    utxoCount: instrument.utxo_count,
+    instrumentId: instrument.instrument_id,
   };
 }
 
-export async function getBalance(currency: CryptoCurrency, partyId: string): Promise<Balance[]> {
+export async function getBalance(
+  currency: CryptoCurrency,
+  partyId: string,
+): Promise<CantonBalance[]> {
   if (useGateway(currency))
     return (await gatewayGetBalance(currency, partyId)).map(instrument =>
       adaptInstrument(currency, instrument),

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

@@ -29,11 +29,13 @@ describe("getBalance", () => {
       {
         instrument_id: "native-id",
         amount: "1000",
+        utxo_count: 1,
         locked: false,
       },
       {
         instrument_id: "token-123",
         amount: "5000",
+        utxo_count: 1,
         locked: true,
       },
     ];
@@ -43,16 +45,20 @@ describe("getBalance", () => {
     const result = await getBalance(mockCurrency, "party-id");
 
     expect(getBalanceFromNetwork).toHaveBeenCalledWith(mockCurrency, "party-id");
-    expect(result).toEqual<Balance[]>([
+    expect(result).toEqual([
       {
         value: BigInt(1000),
         locked: BigInt(0),
         asset: { type: "native" },
+        utxoCount: 1,
+        instrumentId: "native-id",
       },
       {
         value: BigInt(5000),
         locked: BigInt(5000),
         asset: { type: "token", assetReference: "token-123" },
+        utxoCount: 1,
+        instrumentId: "token-123",
       },
     ]);
   });

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

@@ -27,7 +27,7 @@ export async function craftTransaction(
 }> {
   const params: PrepareTransferRequest = {
     recipient: transaction.recipient || "",
-    amount: transaction.amount.toString(),
+    amount: transaction.amount.toFixed(),
     type: "token-transfer-request" as const,
     execute_before_secs: transaction.expireInSeconds,
     instrument_id: transaction.tokenId,

package/src/common-logic/transaction/estimateFees.test.ts

@@ -47,4 +47,14 @@ describe("estimateFees", () => {
     // 3 CC
     expect(result).toEqual(3n * magnitude);
   });
+
+  it("returns forced fees when 0 is setup in config", async () => {
+    mockGetCoinConfig.mockReturnValue({
+      fee: 0,
+    } as unknown as coinConfigModule.CantonCoinConfig);
+
+    const result = await estimateFees(mockCurrency, 1000n * magnitude);
+
+    expect(result).toEqual(0n);
+  });
 });

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

@@ -21,7 +21,7 @@ const feeValue = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency
 
 export async function estimateFees(currency: CryptoCurrency, amount: bigint): Promise<bigint> {
   const forcedValue = feeValue(currency);
-  if (forcedValue) {
+  if (forcedValue !== undefined) {
     return Promise.resolve(BigInt(forcedValue) * magnitude);
   } else {
     return Promise.resolve(