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

package/src/bridge/getTransactionStatus.test.ts

@@ -1,446 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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);
-      });
-    });
-  });
-});