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

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/common-logic/utils.test.ts

@@ -0,0 +1,93 @@
+import { isRecipientValid, validateTag } from "./utils";
+import BigNumber from "bignumber.js";
+
+describe("utils", () => {
+  describe("isRecipientValid", () => {
+    it("should return true for valid Canton addresses", () => {
+      const validAddresses = [
+        "abc::123",
+        "hello::1",
+        "test123::456",
+        "a::0",
+        "party::999",
+        "user123::42",
+        "canton_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z::123",
+        "test::123456789",
+      ];
+
+      validAddresses.forEach(address => {
+        expect(isRecipientValid(address)).toBe(true);
+      });
+    });
+
+    it("should return false for invalid Canton addresses", () => {
+      const invalidAddresses = [
+        "", // empty string
+        "::123", // no characters before ::
+        "abc::", // no numbers after ::
+        "abc:123", // single colon instead of double
+        "abc::abc", // letters instead of numbers after ::
+        "abc::", // empty after ::
+        "::", // only colons
+        "abc", // no colons
+        "123", // no colons
+        "abc::123abc", // mixed letters and numbers after ::
+        "abc::123.456", // decimal numbers
+        "abc::-123", // negative numbers
+        "abc::+123", // positive sign
+        "abc:: 123", // space before number
+        "abc::123 ", // space after number
+        "abc:: 123", // space after ::
+      ];
+
+      invalidAddresses.forEach(address => {
+        expect(isRecipientValid(address)).toBe(false);
+      });
+    });
+
+    it("should handle edge cases", () => {
+      expect(isRecipientValid("a::1")).toBe(true); // minimum valid case
+      expect(isRecipientValid("1::1")).toBe(true); // number before ::
+      expect(isRecipientValid("_::1")).toBe(true); // underscore before ::
+      expect(isRecipientValid("-::1")).toBe(true); // dash before ::
+      expect(isRecipientValid(".::1")).toBe(true); // dot before ::
+    });
+
+    it("should handle addresses with spaces and multiple colons", () => {
+      // These are valid according to our regex but might not be ideal Canton addresses
+      expect(isRecipientValid(" abc::123")).toBe(true); // space before address
+      expect(isRecipientValid("abc ::123")).toBe(true); // space before ::
+      expect(isRecipientValid("abc::123::456")).toBe(true); // multiple ::
+    });
+  });
+
+  describe("validateTag", () => {
+    it("should return true for valid tags", () => {
+      const validTags = [
+        new BigNumber(1),
+        new BigNumber(42),
+        new BigNumber(4294967295), // UINT32_MAX
+        new BigNumber(0),
+      ];
+
+      validTags.forEach(tag => {
+        expect(validateTag(tag)).toBe(true);
+      });
+    });
+
+    it("should return false for invalid tags", () => {
+      const invalidTags = [
+        new BigNumber(-1), // negative
+        new BigNumber(4294967296), // greater than UINT32_MAX
+        new BigNumber(1.5), // decimal
+        new BigNumber(NaN), // NaN
+        new BigNumber(Infinity), // Infinity
+        new BigNumber(-Infinity), // -Infinity
+      ];
+
+      invalidTags.forEach(tag => {
+        expect(validateTag(tag)).toBe(false);
+      });
+    });
+  });
+});

package/src/common-logic/utils.ts

@@ -8,6 +8,9 @@ export const validateTag = (tag: BigNumber) => {
   );
 };
 
+const CANTON_ADDRESS_REGEX = /^.+::\d+$/;
+
 export function isRecipientValid(recipient: string): boolean {
-  return recipient.length > 0;
+  // Canton address format: at least 1 character :: at least 1 number
+  return CANTON_ADDRESS_REGEX.test(recipient);
 }