@ledgerhq/coin-canton 0.9.0-nightly.1 → 0.9.0-nightly.20251030160608

package/src/bridge/getTransactionStatus.test.ts

@@ -1,6 +1,3 @@
-import BigNumber from "bignumber.js";
-import { Account } from "@ledgerhq/types-live";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   AmountRequired,
   FeeNotLoaded,
@@ -12,76 +9,37 @@ import {
   NotEnoughSpendableBalance,
   RecipientRequired,
 } from "@ledgerhq/errors";
-import { getTransactionStatus } from "./getTransactionStatus";
-import { Transaction } from "../types";
+import BigNumber from "bignumber.js";
 import coinConfig from "../config";
+import { createMockAccount } from "../test/fixtures";
+import { CantonAccount, TooManyUtxosCritical, TooManyUtxosWarning, Transaction } from "../types";
+import {
+  getTransactionStatus,
+  TO_MANY_UTXOS_CRITICAL_COUNT,
+  TO_MANY_UTXOS_WARNING_COUNT,
+} from "./getTransactionStatus";
 
-// Mock the coin config
-jest.mock("../config", () => ({
-  getCoinConfig: jest.fn(),
-}));
-
+jest.mock("../config", () => ({ getCoinConfig: jest.fn() }));
 const mockCoinConfig = jest.mocked(coinConfig);
 
 describe("getTransactionStatus", () => {
-  const mockCurrency: CryptoCurrency = {
-    id: "canton_network",
-    name: "Canton Network",
-    family: "canton",
-    units: [
-      {
-        name: "Canton",
-        code: "CANTON",
-        magnitude: 8,
+  const mockAccount: CantonAccount = {
+    ...createMockAccount({
+      balance: new BigNumber(1000),
+      spendableBalance: new BigNumber(1000),
+      freshAddress: "test::33333333333333333333333333333333333333333333333333333333333333333333",
+    }),
+    cantonResources: {
+      instrumentUtxoCounts: {
+        Amulet: 5,
       },
-    ],
-    ticker: "CANTON",
-    scheme: "canton",
-    color: "#000000",
-    type: "CryptoCurrency",
-    managerAppName: "Canton",
-    coinType: 0,
-    disableCountervalue: false,
-    delisted: false,
-    keywords: ["canton"],
-    explorerViews: [],
-    terminated: {
-      link: "",
     },
   };
 
-  const mockAccount: Account = {
-    id: "test-account-id",
-    seedIdentifier: "test-seed-identifier",
-    currency: mockCurrency,
-    balance: new BigNumber(1000), // 1000 units
-    spendableBalance: new BigNumber(1000),
-    freshAddress: "test::123",
-    freshAddressPath: "44'/60'/0'/0/0",
-    index: 0,
-    derivationMode: "canton",
-    used: true,
-    operations: [],
-    pendingOperations: [],
-    lastSyncDate: new Date(),
-    creationDate: new Date(),
-    operationsCount: 0,
-    blockHeight: 100,
-    balanceHistoryCache: {
-      HOUR: { latestDate: null, balances: [] },
-      DAY: { latestDate: null, balances: [] },
-      WEEK: { latestDate: null, balances: [] },
-    },
-    swapHistory: [],
-    nfts: [],
-    subAccounts: [],
-    type: "Account",
-  };
-
   beforeEach(() => {
     jest.clearAllMocks();
     mockCoinConfig.getCoinConfig.mockReturnValue({
-      minReserve: 100, // 100 units minimum reserve
+      minReserve: 100,
       networkType: "mainnet",
       status: { type: "active" },
       nativeInstrumentId: "Amulet",
@@ -89,11 +47,11 @@ describe("getTransactionStatus", () => {
   });
 
   describe("fee validation", () => {
-    it("should return FeeNotLoaded error when fee is not provided", async () => {
+    it("should return FeeNotLoaded error when fee is null", async () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: null,
         tokenId: "",
       };
@@ -104,27 +62,27 @@ describe("getTransactionStatus", () => {
       expect(result.warnings).toEqual({});
     });
 
-    it("should return FeeRequired error when fee is zero", async () => {
+    it("should return FeeNotLoaded error when fee is undefined", async () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
-        fee: new BigNumber(0),
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
+        fee: undefined,
         tokenId: "",
       };
 
       const result = await getTransactionStatus(mockAccount, transaction);
 
-      expect(result.errors.fee).toBeInstanceOf(FeeRequired);
+      expect(result.errors.fee).toBeInstanceOf(FeeNotLoaded);
       expect(result.warnings).toEqual({});
     });
 
     it("should add FeeTooHigh warning when fee is more than 10 times the amount", async () => {
       const transaction: Transaction = {
         family: "canton",
-        amount: new BigNumber(100), // Use larger amount to avoid balance issues
-        recipient: "valid::123",
-        fee: new BigNumber(1500), // 15x the amount
+        amount: new BigNumber(100),
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
+        fee: new BigNumber(1500),
         tokenId: "",
       };
 
@@ -138,8 +96,8 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
-        fee: new BigNumber(10), // 0.1x the amount
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
+        fee: new BigNumber(10),
         tokenId: "",
       };
 
@@ -154,8 +112,10 @@ describe("getTransactionStatus", () => {
     it("should return NotEnoughSpendableBalance error when total spent exceeds balance minus reserve", async () => {
       const transaction: Transaction = {
         family: "canton",
-        amount: new BigNumber(950), // 950 + 10 fee = 960, but balance is 1000 and reserve is 100
-        recipient: "valid::123",
+        amount: mockAccount.balance
+          .minus(new BigNumber(mockCoinConfig.getCoinConfig().minReserve))
+          .plus(1),
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -168,8 +128,8 @@ describe("getTransactionStatus", () => {
     it("should return NotEnoughBalanceBecauseDestinationNotCreated error when amount is below reserve", async () => {
       const transaction: Transaction = {
         family: "canton",
-        amount: new BigNumber(50), // Below reserve amount of 100
-        recipient: "valid::123",
+        amount: new BigNumber(mockCoinConfig.getCoinConfig().minReserve).minus(1),
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -182,8 +142,8 @@ describe("getTransactionStatus", () => {
     it("should pass balance validation when transaction is within limits", async () => {
       const transaction: Transaction = {
         family: "canton",
-        amount: new BigNumber(800), // 800 + 10 fee = 810, balance is 1000, reserve is 100, so 900 available
-        recipient: "valid::123",
+        amount: mockAccount.balance.multipliedBy(0.5),
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -209,18 +169,18 @@ describe("getTransactionStatus", () => {
       expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
     });
 
-    it("should return InvalidAddressBecauseDestinationIsAlsoSource error when sending to self", async () => {
+    it("should not return error when sending to self", async () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "test::123", // Same as account.freshAddress
+        recipient: mockAccount.freshAddress,
         fee: new BigNumber(10),
         tokenId: "",
       };
 
       const result = await getTransactionStatus(mockAccount, transaction);
 
-      expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+      expect(result.errors.recipient).toBeUndefined();
     });
 
     it("should return InvalidAddress error when recipient is invalid", async () => {
@@ -241,7 +201,7 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::456",
+        recipient: "valid::22222222222222222222222222222222222222222222222222222222222222222222",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -254,16 +214,8 @@ describe("getTransactionStatus", () => {
 
   describe("amount validation", () => {
     it("should return AmountRequired error when amount is zero", async () => {
-      // Create a scenario where there are no other amount errors
-      // Use a high balance and amount above reserve to avoid other amount errors
-      const accountWithHighBalance = {
-        ...mockAccount,
-        balance: new BigNumber(10000), // High balance to avoid balance errors
-      };
-
-      // Set a high reserve to avoid the NotEnoughBalanceBecauseDestinationNotCreated error
       mockCoinConfig.getCoinConfig.mockReturnValue({
-        minReserve: 0, // Set reserve to 0 to avoid reserve-related errors
+        minReserve: 0,
         networkType: "mainnet",
         status: { type: "active" },
         nativeInstrumentId: "Amulet",
@@ -272,12 +224,12 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(0),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
 
-      const result = await getTransactionStatus(accountWithHighBalance, transaction);
+      const result = await getTransactionStatus(mockAccount, transaction);
 
       expect(result.errors.amount).toBeInstanceOf(AmountRequired);
     });
@@ -286,7 +238,7 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -302,7 +254,7 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -318,7 +270,7 @@ describe("getTransactionStatus", () => {
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(100),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
       };
@@ -330,117 +282,103 @@ describe("getTransactionStatus", () => {
     });
   });
 
-  describe("edge cases", () => {
-    it("should handle account with zero balance", async () => {
-      const accountWithZeroBalance = {
+  describe("UTXO count validation", () => {
+    it("should show critical warning when UTXO count exceeds TO_MANY_UTXOS_CRITICAL_COUNT", async () => {
+      const accountWithTooManyUtxos = {
         ...mockAccount,
-        balance: new BigNumber(0),
+        cantonResources: {
+          instrumentUtxoCounts: {
+            Amulet: TO_MANY_UTXOS_CRITICAL_COUNT + 1,
+          },
+        },
       };
 
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(50),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
-        tokenId: "",
+        tokenId: "Amulet",
       };
 
-      const result = await getTransactionStatus(accountWithZeroBalance, transaction);
+      const result = await getTransactionStatus(accountWithTooManyUtxos, transaction);
 
-      expect(result.errors.amount).toBeInstanceOf(NotEnoughSpendableBalance);
+      expect(result.warnings.tooManyUtxos).toBeDefined();
+      expect(result.warnings.tooManyUtxos).toBeInstanceOf(TooManyUtxosCritical);
     });
 
-    it("should handle account with balance exactly equal to reserve", async () => {
-      const accountWithReserveBalance = {
+    it("should show warning when UTXO count exceeds TO_MANY_UTXOS_WARNING_COUNT", async () => {
+      const accountWithManyUtxos = {
         ...mockAccount,
-        balance: new BigNumber(100), // Exactly equal to reserve
+        cantonResources: {
+          instrumentUtxoCounts: {
+            Amulet: TO_MANY_UTXOS_WARNING_COUNT + 1,
+          },
+        },
       };
 
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(50),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
-        tokenId: "",
+        tokenId: "Amulet",
       };
 
-      const result = await getTransactionStatus(accountWithReserveBalance, transaction);
+      const result = await getTransactionStatus(accountWithManyUtxos, transaction);
 
-      expect(result.errors.amount).toBeInstanceOf(NotEnoughSpendableBalance);
+      expect(result.warnings.tooManyUtxos).toBeDefined();
+      expect(result.warnings.tooManyUtxos).toBeInstanceOf(TooManyUtxosWarning);
+      expect(result.warnings.tooManyUtxos?.message).toContain(
+        "families.canton.tooManyUtxos.warning",
+      );
     });
 
-    it("should handle zero reserve amount", async () => {
-      mockCoinConfig.getCoinConfig.mockReturnValue({
-        minReserve: 0,
-        networkType: "mainnet",
-        status: { type: "active" },
-        nativeInstrumentId: "Amulet",
-      });
-
-      const transaction: Transaction = {
-        family: "canton",
-        amount: new BigNumber(50),
-        recipient: "valid::123",
-        fee: new BigNumber(10),
-        tokenId: "",
+    it("should not show warning or error when UTXO count is less than TO_MANY_UTXOS_WARNING_COUNT", async () => {
+      const accountWithFewUtxos = {
+        ...mockAccount,
+        cantonResources: {
+          instrumentUtxoCounts: {
+            Amulet: TO_MANY_UTXOS_WARNING_COUNT - 1,
+          },
+        },
       };
 
-      const result = await getTransactionStatus(mockAccount, transaction);
-
-      expect(result.errors.amount).toBeUndefined();
-    });
-
-    it("should handle undefined reserve amount", async () => {
-      mockCoinConfig.getCoinConfig.mockReturnValue({
-        networkType: "mainnet",
-        status: { type: "active" },
-        nativeInstrumentId: "Amulet",
-      });
-
       const transaction: Transaction = {
         family: "canton",
         amount: new BigNumber(50),
-        recipient: "valid::123",
+        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
-        tokenId: "",
+        tokenId: "Amulet", // Use the same tokenId as in cantonResources
       };
 
-      const result = await getTransactionStatus(mockAccount, transaction);
+      const result = await getTransactionStatus(accountWithFewUtxos, transaction);
 
-      expect(result.errors.amount).toBeUndefined();
+      expect(result.warnings.tooManyUtxos).toBeUndefined();
     });
-  });
 
-  describe("multiple validation errors", () => {
-    it("should return multiple errors when multiple validations fail", async () => {
-      const transaction: Transaction = {
-        family: "canton",
-        amount: new BigNumber(0), // AmountRequired
-        recipient: "", // RecipientRequired
-        fee: null, // FeeNotLoaded
-        tokenId: "",
+    it("should not show warning or error for abandon seed address transactions", async () => {
+      const accountWithManyUtxos = {
+        ...mockAccount,
+        cantonResources: {
+          instrumentUtxoCounts: {
+            Amulet: 25,
+          },
+        },
       };
 
-      const result = await getTransactionStatus(mockAccount, transaction);
-
-      expect(result.errors.amount).toBeInstanceOf(AmountRequired);
-      expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
-      expect(result.errors.fee).toBeInstanceOf(FeeNotLoaded);
-    });
-
-    it("should return both errors and warnings", async () => {
       const transaction: Transaction = {
         family: "canton",
-        amount: new BigNumber(5), // Small amount
-        recipient: "valid::123",
-        fee: new BigNumber(100), // High fee relative to amount
-        tokenId: "",
+        amount: new BigNumber(50),
+        recipient: "abandon::ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        fee: new BigNumber(10),
+        tokenId: "Amulet",
       };
 
-      const result = await getTransactionStatus(mockAccount, transaction);
+      const result = await getTransactionStatus(accountWithManyUtxos, transaction);
 
-      expect(result.warnings.feeTooHigh).toBeInstanceOf(FeeTooHigh);
-      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalanceBecauseDestinationNotCreated);
+      expect(result.warnings.tooManyUtxos).toBeUndefined();
+      expect(result.errors.utxoCount).toBeUndefined();
     });
   });
 });

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>;
@@ -221,25 +198,5 @@ describe("onboard (devnet)", () => {
       expect(finalResult.isApproved).toBe(true);
       expect(typeof finalResult.isApproved).toBe("boolean");
     }, 30000);
-
-    it("should handle invalid party ID gracefully", async () => {
-      // GIVEN
-      const keyPair = generateMockKeyPair();
-      const mockSigner = createMockSigner(keyPair);
-      const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
-        return callback(mockSigner);
-      });
-      const preapprovalObservable = buildAuthorizePreapproval(mockSignerContext);
-
-      // WHEN & THEN
-      try {
-        await firstValueFrom(
-          preapprovalObservable(mockCurrency, mockDeviceId, mockAccount, "invalid-party-id-123"),
-        );
-        expect(true).toBe(true);
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
-    }, 30000);
   });
 });