@ledgerhq/coin-canton 0.7.0-nightly.1 → 0.7.0-nightly.3

package/lib-es/types/onboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onboard.d.ts","sourceRoot":"","sources":["../../src/types/onboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,oBAAY,aAAa;IACvB,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,OAAO,IAAA;IACP,KAAK,IAAA;CACN;AAED,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,OAAO,IAAA;IACP,KAAK,IAAA;CACN;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,iBAAiB,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;GAGG;AAEH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,gCAAgC,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,GAAG,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB"}
+{"version":3,"file":"onboard.d.ts","sourceRoot":"","sources":["../../src/types/onboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,oBAAY,aAAa;IACvB,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,OAAO,IAAA;IACP,KAAK,IAAA;CACN;AAED,oBAAY,eAAe;IACzB,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,OAAO,IAAA;IACP,KAAK,IAAA;CACN;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;GAGG;AAEH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,gCAAgC,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,GAAG,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/lib-es/types/onboard.js

@@ -7,13 +7,13 @@ export var OnboardStatus;
     OnboardStatus[OnboardStatus["SUCCESS"] = 4] = "SUCCESS";
     OnboardStatus[OnboardStatus["ERROR"] = 5] = "ERROR";
 })(OnboardStatus || (OnboardStatus = {}));
-export var PreApprovalStatus;
-(function (PreApprovalStatus) {
-    PreApprovalStatus[PreApprovalStatus["INIT"] = 0] = "INIT";
-    PreApprovalStatus[PreApprovalStatus["PREPARE"] = 1] = "PREPARE";
-    PreApprovalStatus[PreApprovalStatus["SIGN"] = 2] = "SIGN";
-    PreApprovalStatus[PreApprovalStatus["SUBMIT"] = 3] = "SUBMIT";
-    PreApprovalStatus[PreApprovalStatus["SUCCESS"] = 4] = "SUCCESS";
-    PreApprovalStatus[PreApprovalStatus["ERROR"] = 5] = "ERROR";
-})(PreApprovalStatus || (PreApprovalStatus = {}));
+export var AuthorizeStatus;
+(function (AuthorizeStatus) {
+    AuthorizeStatus[AuthorizeStatus["INIT"] = 0] = "INIT";
+    AuthorizeStatus[AuthorizeStatus["PREPARE"] = 1] = "PREPARE";
+    AuthorizeStatus[AuthorizeStatus["SIGN"] = 2] = "SIGN";
+    AuthorizeStatus[AuthorizeStatus["SUBMIT"] = 3] = "SUBMIT";
+    AuthorizeStatus[AuthorizeStatus["SUCCESS"] = 4] = "SUCCESS";
+    AuthorizeStatus[AuthorizeStatus["ERROR"] = 5] = "ERROR";
+})(AuthorizeStatus || (AuthorizeStatus = {}));
 //# sourceMappingURL=onboard.js.map

package/lib-es/types/onboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"onboard.js","sourceRoot":"","sources":["../../src/types/onboard.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,iDAAI,CAAA;IACJ,uDAAO,CAAA;IACP,iDAAI,CAAA;IACJ,qDAAM,CAAA;IACN,uDAAO,CAAA;IACP,mDAAK,CAAA;AACP,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB;AAED,MAAM,CAAN,IAAY,iBAOX;AAPD,WAAY,iBAAiB;IAC3B,yDAAI,CAAA;IACJ,+DAAO,CAAA;IACP,yDAAI,CAAA;IACJ,6DAAM,CAAA;IACN,+DAAO,CAAA;IACP,2DAAK,CAAA;AACP,CAAC,EAPW,iBAAiB,KAAjB,iBAAiB,QAO5B"}
+{"version":3,"file":"onboard.js","sourceRoot":"","sources":["../../src/types/onboard.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,iDAAI,CAAA;IACJ,uDAAO,CAAA;IACP,iDAAI,CAAA;IACJ,qDAAM,CAAA;IACN,uDAAO,CAAA;IACP,mDAAK,CAAA;AACP,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB;AAED,MAAM,CAAN,IAAY,eAOX;AAPD,WAAY,eAAe;IACzB,qDAAI,CAAA;IACJ,2DAAO,CAAA;IACP,qDAAI,CAAA;IACJ,yDAAM,CAAA;IACN,2DAAO,CAAA;IACP,uDAAK,CAAA;AACP,CAAC,EAPW,eAAe,KAAf,eAAe,QAO1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-canton",
-  "version": "0.7.0-nightly.1",
+  "version": "0.7.0-nightly.3",
   "description": "Canton coin integration",
   "keywords": [
     "Ledger",
@@ -101,12 +101,13 @@
     "bignumber.js": "^9.1.2",
     "invariant": "^2.2.4",
     "rxjs": "^7.8.1",
-    "@ledgerhq/coin-framework": "^6.6.0-nightly.1",
-    "@ledgerhq/cryptoassets": "^13.30.0-nightly.0",
+    "@ledgerhq/coin-framework": "^6.6.0-nightly.2",
+    "@ledgerhq/cryptoassets": "^13.30.0-nightly.1",
     "@ledgerhq/devices": "8.6.0",
     "@ledgerhq/errors": "^6.26.0-nightly.0",
     "@ledgerhq/live-env": "^2.17.0",
     "@ledgerhq/live-network": "^2.0.18",
+    "@ledgerhq/logs": "^6.13.0",
     "@ledgerhq/types-live": "^6.86.0-nightly.0"
   },
   "devDependencies": {
@@ -117,7 +118,7 @@
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
     "typescript": "^5.4.5",
-    "@ledgerhq/types-cryptoassets": "^7.28.0-nightly.0",
+    "@ledgerhq/types-cryptoassets": "^7.28.0-nightly.1",
     "@ledgerhq/disable-network-setup": "^0.0.0"
   },
   "scripts": {

package/src/api/lastBlock.integ.test.ts

@@ -1,26 +1,8 @@
 import { AlpacaApi } from "@ledgerhq/coin-framework/lib/api/types";
 import { createApi } from ".";
-import { CantonCoinConfig } from "../config";
 
 let api: AlpacaApi;
 
-describe.skip("localnet", () => {
-  beforeAll(() => {
-    api = createApi({
-      nodeUrl: "http://localhost:2975/v2",
-      nativeInstrumentId: "Amulet",
-      networkType: "localnet",
-    } satisfies Partial<CantonCoinConfig>);
-  });
-
-  describe("lastBlock", () => {
-    it("should return ledger end", async () => {
-      const lastBlock = await api.lastBlock();
-      expect(lastBlock.height).toBeGreaterThan(0);
-    });
-  });
-});
-
 describe.skip("devnet", () => {
   beforeAll(() => {
     api = createApi({

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,446 @@
+import BigNumber from "bignumber.js";
+import { Account } from "@ledgerhq/types-live";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  FeeRequired,
+  FeeTooHigh,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughSpendableBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { Transaction } from "../types";
+import coinConfig from "../config";
+
+// Mock the coin config
+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,
+      },
+    ],
+    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
+      networkType: "mainnet",
+      status: { type: "active" },
+      nativeInstrumentId: "Amulet",
+    });
+  });
+
+  describe("fee validation", () => {
+    it("should return FeeNotLoaded error when fee is not provided", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: null,
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.fee).toBeInstanceOf(FeeNotLoaded);
+      expect(result.warnings).toEqual({});
+    });
+
+    it("should return FeeRequired error when fee is zero", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: new BigNumber(0),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.fee).toBeInstanceOf(FeeRequired);
+      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
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.warnings.feeTooHigh).toBeInstanceOf(FeeTooHigh);
+      // Don't check for empty errors since there might be balance issues
+    });
+
+    it("should not add FeeTooHigh warning when fee is reasonable", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: new BigNumber(10), // 0.1x the amount
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.warnings).toEqual({});
+      expect(result.errors).toEqual({});
+    });
+  });
+
+  describe("balance validation", () => {
+    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",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughSpendableBalance);
+    });
+
+    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",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalanceBecauseDestinationNotCreated);
+    });
+
+    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",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.amount).toBeUndefined();
+    });
+  });
+
+  describe("recipient validation", () => {
+    it("should return RecipientRequired error when recipient is missing", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
+    });
+
+    it("should return InvalidAddressBecauseDestinationIsAlsoSource error when sending to self", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "test::123", // Same as account.freshAddress
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+    });
+
+    it("should return InvalidAddress error when recipient is invalid", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "invalid-address",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.recipient).toBeInstanceOf(InvalidAddress);
+    });
+
+    it("should pass recipient validation when recipient is valid", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::456",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.recipient).toBeUndefined();
+    });
+  });
+
+  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
+        networkType: "mainnet",
+        status: { type: "active" },
+        nativeInstrumentId: "Amulet",
+      });
+
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(0),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(accountWithHighBalance, transaction);
+
+      expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+    });
+
+    it("should not return AmountRequired error when amount is positive", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.amount).toBeUndefined();
+    });
+  });
+
+  describe("return values", () => {
+    it("should return correct estimatedFees, amount, and totalSpent", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.estimatedFees).toEqual(new BigNumber(10));
+      expect(result.amount).toEqual(new BigNumber(100));
+      expect(result.totalSpent).toEqual(new BigNumber(110));
+    });
+
+    it("should return empty errors and warnings when transaction is valid", async () => {
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(100),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors).toEqual({});
+      expect(result.warnings).toEqual({});
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle account with zero balance", async () => {
+      const accountWithZeroBalance = {
+        ...mockAccount,
+        balance: new BigNumber(0),
+      };
+
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(50),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(accountWithZeroBalance, transaction);
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughSpendableBalance);
+    });
+
+    it("should handle account with balance exactly equal to reserve", async () => {
+      const accountWithReserveBalance = {
+        ...mockAccount,
+        balance: new BigNumber(100), // Exactly equal to reserve
+      };
+
+      const transaction: Transaction = {
+        family: "canton",
+        amount: new BigNumber(50),
+        recipient: "valid::123",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(accountWithReserveBalance, transaction);
+
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughSpendableBalance);
+    });
+
+    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: "",
+      };
+
+      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",
+        fee: new BigNumber(10),
+        tokenId: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.errors.amount).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: "",
+      };
+
+      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: "",
+      };
+
+      const result = await getTransactionStatus(mockAccount, transaction);
+
+      expect(result.warnings.feeTooHigh).toBeInstanceOf(FeeTooHigh);
+      expect(result.errors.amount).toBeInstanceOf(NotEnoughBalanceBecauseDestinationNotCreated);
+    });
+  });
+});

package/src/bridge/index.ts

@@ -18,10 +18,9 @@ import { estimateMaxSpendable } from "./estimateMaxSpendable";
 import { getTransactionStatus } from "./getTransactionStatus";
 import { prepareTransaction } from "./prepareTransaction";
 import { buildSignOperation } from "./signOperation";
-import { getAccountShape } from "./sync";
+import { makeGetAccountShape } from "./sync";
 import { updateTransaction } from "./updateTransaction";
 import { buildOnboardAccount, buildAuthorizePreapproval } from "./onboard";
-import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
 
 export function createBridges(
   signerContext: SignerContext<CantonSigner>,
@@ -33,7 +32,7 @@ export function createBridges(
   const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
 
   const scanAccounts = makeScanAccounts({
-    getAccountShape: getAccountShape,
+    getAccountShape: makeGetAccountShape(signerContext),
     getAddressFn: getAddress,
   });
 
@@ -49,7 +48,7 @@ export function createBridges(
   };
 
   const signOperation = buildSignOperation(signerContext);
-  const sync = makeSync({ getAccountShape });
+  const sync = makeSync({ getAccountShape: makeGetAccountShape(signerContext) });
   // we want one method per file
   const accountBridge: AccountBridge<Transaction> = {
     broadcast,
@@ -63,8 +62,6 @@ export function createBridges(
     sync,
     receive,
     signOperation,
-    assignToAccountRaw,
-    assignFromAccountRaw,
     getSerializedAddressParameters,
   };