@ledgerhq/coin-canton 0.9.0-nightly.3 → 0.9.0-nightly.5

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::33333333333333333333333333333333333333333333333333333333333333333333",
-    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",
@@ -122,9 +80,9 @@ describe("getTransactionStatus", () => {
     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
+        amount: new BigNumber(100),
         recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
-        fee: new BigNumber(1500), // 15x the amount
+        fee: new BigNumber(1500),
         tokenId: "",
       };
 
@@ -139,7 +97,7 @@ describe("getTransactionStatus", () => {
         family: "canton",
         amount: new BigNumber(100),
         recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
-        fee: new BigNumber(10), // 0.1x the amount
+        fee: new BigNumber(10),
         tokenId: "",
       };
 
@@ -154,7 +112,9 @@ 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
+        amount: mockAccount.balance
+          .minus(new BigNumber(mockCoinConfig.getCoinConfig().minReserve))
+          .plus(1),
         recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
@@ -168,7 +128,7 @@ 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
+        amount: new BigNumber(mockCoinConfig.getCoinConfig().minReserve).minus(1),
         recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
         fee: new BigNumber(10),
         tokenId: "",
@@ -182,7 +142,7 @@ 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
+        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::33333333333333333333333333333333333333333333333333333333333333333333", // 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 () => {
@@ -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",
@@ -277,7 +229,7 @@ describe("getTransactionStatus", () => {
         tokenId: "",
       };
 
-      const result = await getTransactionStatus(accountWithHighBalance, transaction);
+      const result = await getTransactionStatus(mockAccount, transaction);
 
       expect(result.errors.amount).toBeInstanceOf(AmountRequired);
     });
@@ -330,11 +282,15 @@ 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 = {
@@ -342,18 +298,23 @@ describe("getTransactionStatus", () => {
         amount: new BigNumber(50),
         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 = {
@@ -361,86 +322,63 @@ describe("getTransactionStatus", () => {
         amount: new BigNumber(50),
         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::11111111111111111111111111111111111111111111111111111111111111111111",
-        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::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::11111111111111111111111111111111111111111111111111111111111111111111",
-        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> = {};
@@ -63,9 +72,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 +84,8 @@ export const getTransactionStatus: AccountBridge<
     errors.amount = new AmountRequired();
   }
 
+  validateUtxoCount(account, transaction, warnings);
+
   return {
     errors,
     warnings,
@@ -86,3 +94,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/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

@@ -9,6 +9,7 @@ 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");
@@ -54,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/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,
       },
     ]);