@ledgerhq/coin-canton 0.7.0 → 0.8.0-nightly.0

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,9 @@ export function createBridges(
     sync,
     receive,
     signOperation,
-    assignToAccountRaw,
-    assignFromAccountRaw,
+    signRawOperation: () => {
+      throw new Error("signRawOperation is not supported");
+    },
     getSerializedAddressParameters,
   };
 

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

@@ -1,23 +1,45 @@
+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 { buildOnboardAccount, isAccountOnboarded, buildAuthorizePreapproval } from "./onboard";
 import {
+  AuthorizeStatus,
   OnboardStatus,
-  PreApprovalStatus,
+  CantonAuthorizeProgress,
+  CantonAuthorizeResult,
   CantonOnboardProgress,
   CantonOnboardResult,
-  CantonPreApprovalProgress,
-  CantonPreApprovalResult,
 } from "../types/onboard";
 import coinConfig from "../config";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { buildOnboardAccount, isAccountOnboarded, buildAuthorizePreapproval } from "./onboard";
 
 describe("onboard (devnet)", () => {
   const mockDeviceId = "test-device-id";
-  const mockDerivationPath = "44'/6767'/0'/0'/0'";
   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: [],
+  };
 
   let onboardedAccount: {
     keyPair: ReturnType<typeof generateMockKeyPair>;
@@ -58,7 +80,7 @@ describe("onboard (devnet)", () => {
 
       const onboardObservable = buildOnboardAccount(mockSignerContext);
       const onboardValues = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        onboardObservable(mockCurrency, mockDeviceId, mockAccount).pipe(toArray()),
       );
       const onboardResult = onboardValues.find(
         (value): value is CantonOnboardResult => "partyId" in value,
@@ -82,10 +104,10 @@ describe("onboard (devnet)", () => {
       // THEN
       expect(result).not.toBe(false);
       if (typeof result === "object") {
-        expect(result.party_id).toBeDefined();
-        expect(result.party_id).toBe(onboardResult!.partyId);
+        expect(result.partyId).toBeDefined();
+        expect(result.partyId).toBe(onboardResult.partyId);
       }
-    }, 30000);
+    }, 40000);
 
     it("should return false for non-onboarded account with fresh keypair", async () => {
       // GIVEN
@@ -122,7 +144,7 @@ describe("onboard (devnet)", () => {
 
       // WHEN
       const allValues = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        onboardObservable(mockCurrency, mockDeviceId, mockAccount).pipe(toArray()),
       );
       const progressValues = allValues.filter(
         (value): value is CantonOnboardProgress => "status" in value && !("partyId" in value),
@@ -149,12 +171,12 @@ describe("onboard (devnet)", () => {
 
     it("should complete full onboarding flow with already onboarded account", async () => {
       // GIVEN
-      const { keyPair, mockSignerContext, onboardResult: firstResult } = getOnboardedAccount();
+      const { mockSignerContext, onboardResult: firstResult } = getOnboardedAccount();
       const secondOnboardObservable = buildOnboardAccount(mockSignerContext);
 
       // WHEN
       const secondOnboardValues = await firstValueFrom(
-        secondOnboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        secondOnboardObservable(mockCurrency, mockDeviceId, mockAccount).pipe(toArray()),
       );
       const secondResult = secondOnboardValues.find(
         (value): value is CantonOnboardResult => "partyId" in value,
@@ -175,27 +197,23 @@ describe("onboard (devnet)", () => {
 
       // WHEN
       const preapprovalValues = await firstValueFrom(
-        preapprovalObservable(
-          mockCurrency,
-          mockDeviceId,
-          mockDerivationPath,
-          onboardResult.partyId,
-        ).pipe(toArray()),
+        preapprovalObservable(mockCurrency, mockDeviceId, mockAccount, onboardResult.partyId).pipe(
+          toArray(),
+        ),
       );
 
       const progressValues = preapprovalValues.filter(
-        (value): value is CantonPreApprovalProgress =>
-          "status" in value && !("isApproved" in value),
+        (value): value is CantonAuthorizeProgress => "status" in value && !("isApproved" in value),
       );
       const resultValues = preapprovalValues.filter(
-        (value): value is CantonPreApprovalResult => "isApproved" in value,
+        (value): value is CantonAuthorizeResult => "isApproved" in value,
       );
 
       // THEN
       // Check expected status progression
-      expect(progressValues.some(p => p.status === PreApprovalStatus.PREPARE)).toBe(true);
-      expect(progressValues.some(p => p.status === PreApprovalStatus.SIGN)).toBe(true);
-      expect(progressValues.some(p => p.status === PreApprovalStatus.SUBMIT)).toBe(true);
+      expect(progressValues.some(p => p.status === AuthorizeStatus.PREPARE)).toBe(true);
+      expect(progressValues.some(p => p.status === AuthorizeStatus.SIGN)).toBe(true);
+      expect(progressValues.some(p => p.status === AuthorizeStatus.SUBMIT)).toBe(true);
 
       // Check final result (should be approved)
       expect(resultValues.length).toBeGreaterThan(0);
@@ -216,12 +234,7 @@ describe("onboard (devnet)", () => {
       // WHEN & THEN
       try {
         await firstValueFrom(
-          preapprovalObservable(
-            mockCurrency,
-            mockDeviceId,
-            mockDerivationPath,
-            "invalid-party-id-123",
-          ),
+          preapprovalObservable(mockCurrency, mockDeviceId, mockAccount, "invalid-party-id-123"),
         );
         expect(true).toBe(true);
       } catch (error) {