@ledgerhq/coin-casper 1.7.3 → 2.0.0-next.0

package/src/bridge/deviceTransactionConfig.test.ts

@@ -0,0 +1,171 @@
+import { log } from "@ledgerhq/logs";
+import getDeviceTransactionConfig from "./deviceTransactionConfig";
+import { createMockAccount, createMockTransaction } from "../test/fixtures";
+import { CASPER_NETWORK } from "../consts";
+import { methodToString } from "../common-logic";
+import { TransactionStatus, Transaction } from "../types";
+import BigNumber from "bignumber.js";
+
+// Mock the log function to prevent console output during tests
+jest.mock("@ledgerhq/logs", () => ({
+  log: jest.fn(),
+}));
+
+/**
+ * Tests for the getDeviceTransactionConfig function
+ * Validates the correct display fields are generated for Ledger devices
+ */
+describe("getDeviceTransactionConfig", () => {
+  // Common test objects
+  const MOCK_AMOUNT = new BigNumber("1000000000"); // 1 CSPR
+  const TRANSFER_ID = "12345678";
+
+  /**
+   * Creates a mock transaction status for testing
+   * @returns A valid TransactionStatus object
+   */
+  const createMockStatus = (): TransactionStatus => ({
+    errors: {},
+    warnings: {},
+    estimatedFees: new BigNumber(0),
+    amount: new BigNumber(0),
+    totalSpent: new BigNumber(0),
+  });
+
+  /**
+   * Helper to get config fields
+   */
+  const getConfigFields = (transaction: Transaction, account = createMockAccount()) =>
+    getDeviceTransactionConfig({
+      account,
+      parentAccount: null,
+      transaction,
+      status: createMockStatus(),
+    });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should display chain ID, transaction type and amount fields for standard transactions", () => {
+    // Create mock transaction
+    const mockTransaction = createMockTransaction({
+      amount: MOCK_AMOUNT,
+    });
+
+    // Get display fields
+    const fields = getConfigFields(mockTransaction);
+
+    // Verify the results
+    expect(fields).toHaveLength(4);
+    // Check Type field
+    expect(fields[0]).toEqual({
+      type: "text",
+      label: "Type",
+      value: methodToString(0), // 0 = "transfer"
+    });
+
+    // Check Chain ID field
+    expect(fields[1]).toEqual({
+      type: "text",
+      label: "Chain ID",
+      value: CASPER_NETWORK,
+    });
+
+    // Check Fee field
+    expect(fields[2]).toEqual({
+      type: "casper.extendedAmount",
+      label: "Fee",
+      value: new BigNumber(100000000),
+    });
+
+    // Check Amount field
+    expect(fields[3]).toEqual({
+      type: "casper.extendedAmount",
+      label: "Amount",
+      value: MOCK_AMOUNT,
+    });
+
+    // Verify logging
+    expect(log).toHaveBeenCalledWith("debug", expect.stringContaining("Transaction config"));
+  });
+
+  test("should include transferId field when provided in transaction", () => {
+    // Create mock transaction with transferId
+    const mockTransaction = createMockTransaction({
+      amount: MOCK_AMOUNT,
+      transferId: TRANSFER_ID,
+    });
+
+    // Get display fields
+    const fields = getConfigFields(mockTransaction);
+
+    // Verify the results
+    expect(fields).toHaveLength(5); // Chain ID, Type, Amount, Transfer ID fields
+
+    // Check all fields are present
+    const fieldLabels = fields.map(field => field.label);
+    expect(fieldLabels).toEqual(["Type", "Chain ID", "Fee", "Amount", "Transfer ID"]);
+
+    // Check Transfer ID field specifically
+    expect(fields[4]).toEqual({
+      type: "text",
+      label: "Transfer ID",
+      value: TRANSFER_ID,
+    });
+  });
+
+  test("should not include transferId field when undefined in transaction", () => {
+    // Create mock transaction with explicitly undefined transferId
+    const mockTransaction = createMockTransaction({
+      amount: MOCK_AMOUNT,
+      transferId: undefined,
+    });
+
+    // Get display fields
+    const fields = getConfigFields(mockTransaction);
+
+    // Verify no transferId field is present
+    expect(fields).toHaveLength(4);
+    expect(fields.map(field => field.label)).not.toContain("Transfer ID");
+  });
+
+  test("should handle zero amount transactions correctly", () => {
+    // Create mock transaction with zero amount
+    const mockTransaction = createMockTransaction({
+      amount: new BigNumber(0),
+    });
+
+    // Get display fields
+    const fields = getConfigFields(mockTransaction);
+
+    // Verify amount field has zero value
+    const amountField = fields.find(field => field.label === "Amount");
+    expect(amountField).toBeDefined();
+    expect(amountField).toEqual({
+      type: "casper.extendedAmount",
+      label: "Amount",
+      value: new BigNumber(0),
+    });
+  });
+
+  test("should maintain consistent order of fields regardless of transaction properties", () => {
+    // Create two transactions - one with transferId, one without
+    const txWithTransferId = createMockTransaction({
+      amount: MOCK_AMOUNT,
+      transferId: TRANSFER_ID,
+    });
+
+    const txWithoutTransferId = createMockTransaction({
+      amount: MOCK_AMOUNT,
+    });
+
+    const fieldsWithId = getConfigFields(txWithTransferId);
+    const fieldsWithoutId = getConfigFields(txWithoutTransferId);
+
+    // Verify field order consistency for common fields
+    for (let i = 0; i < fieldsWithoutId.length; i++) {
+      expect(fieldsWithId[i].label).toEqual(fieldsWithoutId[i].label);
+    }
+  });
+});

package/src/bridge/deviceTransactionConfig.ts

@@ -4,6 +4,7 @@ import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/tran
 import { Transaction, TransactionStatus } from "../types";
 import { methodToString } from "../common-logic";
 import BigNumber from "bignumber.js";
+import { CASPER_NETWORK } from "../consts";
 
 export type ExtraDeviceTransactionField = {
   type: "casper.extendedAmount";
@@ -27,6 +28,11 @@ function getDeviceTransactionConfig({
     label: "Type",
     value: methodToString(0),
   });
+  fields.push({
+    type: "text",
+    label: "Chain ID",
+    value: CASPER_NETWORK,
+  });
   fields.push({
     type: "casper.extendedAmount",
     label: "Fee",
@@ -38,6 +44,14 @@ function getDeviceTransactionConfig({
     value: transaction.amount,
   });
 
+  if (transaction.transferId) {
+    fields.push({
+      type: "text",
+      label: "Transfer ID",
+      value: transaction.transferId,
+    });
+  }
+
   log("debug", `Transaction config ${JSON.stringify(fields)}`);
 
   return fields;

package/src/bridge/estimateMaxSpendable.test.ts

@@ -0,0 +1,155 @@
+import { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { Transaction } from "../types";
+import { createMockAccount } from "../test/fixtures";
+
+// Mock the fee helper
+jest.mock("./bridgeHelpers/fee", () => ({
+  getEstimatedFees: jest.fn().mockReturnValue(new BigNumber(1000000)),
+}));
+
+describe("estimateMaxSpendable", () => {
+  const mockAccount: Partial<Account> = {
+    id: "casper:0:testAccount",
+    type: "Account",
+    spendableBalance: new BigNumber(10000000),
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return zero when balance is zero", async () => {
+    const zeroBalanceAccount = {
+      ...mockAccount,
+      spendableBalance: new BigNumber(0),
+    };
+
+    const result = await estimateMaxSpendable({
+      account: zeroBalanceAccount as Account,
+      parentAccount: undefined,
+    });
+
+    expect(result.toNumber()).toBe(0);
+    expect(getEstimatedFees).not.toHaveBeenCalled();
+  });
+
+  test("should return balance minus fees when no transaction is provided", async () => {
+    const result = await estimateMaxSpendable({
+      account: mockAccount as Account,
+      parentAccount: undefined,
+    });
+
+    const expectedFees = new BigNumber(1000000);
+    const expectedMaxSpendable = mockAccount.spendableBalance!.minus(expectedFees);
+
+    expect(result.toString()).toBe(expectedMaxSpendable.toString());
+    expect(getEstimatedFees).toHaveBeenCalled();
+  });
+
+  test("should use transaction fees when transaction is provided", async () => {
+    const transactionFees = new BigNumber(500000);
+    const mockTransaction: Partial<Transaction> = {
+      fees: transactionFees,
+    };
+
+    const result = await estimateMaxSpendable({
+      account: mockAccount as Account,
+      parentAccount: undefined,
+      transaction: mockTransaction as Transaction,
+    });
+
+    const expectedMaxSpendable = mockAccount.spendableBalance!.minus(transactionFees);
+
+    expect(result.toString()).toBe(expectedMaxSpendable.toString());
+    expect(getEstimatedFees).not.toHaveBeenCalled();
+  });
+
+  test("should return zero when balance is less than fees", async () => {
+    const lowBalanceAccount = {
+      ...mockAccount,
+      spendableBalance: new BigNumber(500000), // Less than default fee of 1000000
+    };
+
+    const result = await estimateMaxSpendable({
+      account: lowBalanceAccount as Account,
+      parentAccount: undefined,
+    });
+
+    expect(result.toString()).toBe("0");
+  });
+
+  test("should use main account when parentAccount is provided", async () => {
+    const parentAccount = {
+      id: "casper:parent",
+      spendableBalance: new BigNumber(0),
+    };
+
+    const result = await estimateMaxSpendable({
+      account: mockAccount as Account,
+      parentAccount: parentAccount as Account,
+    });
+
+    const expectedFees = new BigNumber(1000000);
+    const expectedMaxSpendable = mockAccount.spendableBalance!.minus(expectedFees);
+
+    expect(result.toString()).toBe(expectedMaxSpendable.toString());
+  });
+});
+
+// Add test cases from fixtures
+describe("estimateMaxSpendable with standard test cases", () => {
+  const standardFees = new BigNumber("1000000");
+
+  beforeEach(() => {
+    (getEstimatedFees as jest.Mock).mockReturnValue(standardFees);
+  });
+
+  test.each([
+    {
+      name: "Standard account",
+      account: createMockAccount(),
+      expectedResult: new BigNumber("10000000000").minus(standardFees),
+    },
+    {
+      name: "Empty account",
+      account: createMockAccount({
+        balance: new BigNumber("0"),
+        spendableBalance: new BigNumber("0"),
+      }),
+      expectedResult: new BigNumber("0"),
+    },
+    {
+      name: "Account with balance less than fees",
+      account: createMockAccount({
+        balance: standardFees.div(2),
+        spendableBalance: standardFees.div(2),
+      }),
+      expectedResult: new BigNumber("0"),
+    },
+    {
+      name: "Account with balance equal to fees",
+      account: createMockAccount({
+        balance: standardFees,
+        spendableBalance: standardFees,
+      }),
+      expectedResult: new BigNumber("0"),
+    },
+    {
+      name: "Account with high balance",
+      account: createMockAccount({
+        balance: new BigNumber("100000000000000"),
+        spendableBalance: new BigNumber("100000000000000"),
+      }),
+      expectedResult: new BigNumber("100000000000000").minus(standardFees),
+    },
+  ])("should handle $name", async ({ account, expectedResult }) => {
+    const result = await estimateMaxSpendable({
+      account: account,
+      parentAccount: undefined,
+    });
+    expect(result.toString()).toBe(expectedResult.toString());
+  });
+});

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,264 @@
+import { BigNumber } from "bignumber.js";
+import { getTransactionStatus } from "./getTransactionStatus";
+import {
+  CASPER_MINIMUM_VALID_AMOUNT_MOTES,
+  MayBlockAccountError,
+  InvalidMinimumAmountError,
+} from "../consts";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { CasperInvalidTransferId } from "../errors";
+import { createMockAccount, createMockTransaction, TEST_ADDRESSES } from "../test/fixtures";
+
+describe("getTransactionStatus", () => {
+  // Create fixtures
+  const mockAccount = createMockAccount();
+  const validTransaction = createMockTransaction();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should validate a valid transaction", async () => {
+    const status = await getTransactionStatus(mockAccount, validTransaction);
+
+    expect(status.errors).toEqual({});
+    expect(status.warnings).toEqual({});
+    expect(status.estimatedFees).toEqual(validTransaction.fees);
+    expect(status.amount).toEqual(validTransaction.amount);
+    expect(status.totalSpent).toEqual(validTransaction.amount.plus(validTransaction.fees));
+  });
+
+  test("should return error when recipient is missing", async () => {
+    const txWithoutRecipient = {
+      ...validTransaction,
+      recipient: "",
+    };
+
+    const status = await getTransactionStatus(mockAccount, txWithoutRecipient);
+
+    expect(status.errors.recipient).toBeInstanceOf(RecipientRequired);
+  });
+
+  test("should return error when recipient is invalid", async () => {
+    const txWithInvalidRecipient = {
+      ...validTransaction,
+      recipient: TEST_ADDRESSES.INVALID,
+    };
+
+    const status = await getTransactionStatus(mockAccount, txWithInvalidRecipient);
+
+    expect(status.errors.recipient).toBeInstanceOf(InvalidAddress);
+  });
+
+  test("should return error when recipient is same as sender", async () => {
+    const txToSelf = {
+      ...validTransaction,
+      recipient: mockAccount.freshAddress,
+    };
+
+    const status = await getTransactionStatus(mockAccount, txToSelf);
+
+    expect(status.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+  });
+
+  test("should return error when transfer ID is invalid", async () => {
+    const txWithInvalidTransferId = {
+      ...validTransaction,
+      transferId: "invalid-id",
+    };
+
+    const status = await getTransactionStatus(mockAccount, txWithInvalidTransferId);
+
+    expect(status.errors.sender).toBeInstanceOf(CasperInvalidTransferId);
+  });
+
+  test("should handle useAllAmount correctly", async () => {
+    const useAllAmountTx = {
+      ...validTransaction,
+      useAllAmount: true,
+    };
+
+    const status = await getTransactionStatus(mockAccount, useAllAmountTx);
+
+    expect(status.amount).toEqual(mockAccount.spendableBalance.minus(useAllAmountTx.fees));
+    expect(status.totalSpent).toEqual(mockAccount.spendableBalance);
+    expect(status.errors).toEqual({});
+  });
+
+  test("should return error when useAllAmount but not enough balance for fees", async () => {
+    const lowBalanceAccount = createMockAccount({
+      spendableBalance: new BigNumber(500000), // Less than the fee
+    });
+
+    const useAllAmountTx = {
+      ...validTransaction,
+      useAllAmount: true,
+      fees: new BigNumber(1000000),
+    };
+
+    const status = await getTransactionStatus(lowBalanceAccount, useAllAmountTx);
+
+    expect(status.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  test("should return error when amount is zero", async () => {
+    const zeroAmountTx = {
+      ...validTransaction,
+      amount: new BigNumber(0),
+    };
+
+    const status = await getTransactionStatus(mockAccount, zeroAmountTx);
+
+    expect(status.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+
+  test("should return error when amount is below minimum", async () => {
+    const lowAmountTx = {
+      ...validTransaction,
+      amount: new BigNumber(CASPER_MINIMUM_VALID_AMOUNT_MOTES).minus(1),
+    };
+
+    const status = await getTransactionStatus(mockAccount, lowAmountTx);
+
+    expect(status.errors.amount).toBe(InvalidMinimumAmountError);
+  });
+
+  test("should return error when not enough balance for transaction", async () => {
+    const lowBalanceAccount = createMockAccount({
+      spendableBalance: new BigNumber(5000000),
+    });
+
+    const expensiveTx = {
+      ...validTransaction,
+      amount: new BigNumber(5000000),
+      fees: new BigNumber(1000000),
+    };
+
+    const status = await getTransactionStatus(lowBalanceAccount, expensiveTx);
+
+    expect(status.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  test("should return warning when spending more than 90% of balance", async () => {
+    const expensiveTx = {
+      ...validTransaction,
+      amount: mockAccount.spendableBalance.multipliedBy(0.95), // 95% of balance
+    };
+
+    const status = await getTransactionStatus(mockAccount, expensiveTx);
+
+    expect(status.warnings.amount).toBe(MayBlockAccountError);
+  });
+
+  // Test using the predefined test cases
+  describe("transaction status test cases", () => {
+    const testCases = [
+      {
+        name: "Valid transaction",
+        account: createMockAccount(),
+        transaction: createMockTransaction(),
+        expectedStatus: { errors: {}, warnings: {}, estimatedFees: createMockTransaction().fees },
+      },
+      {
+        name: "Invalid recipient",
+        account: createMockAccount(),
+        transaction: createMockTransaction({ recipient: TEST_ADDRESSES.INVALID }),
+        expectedStatus: {
+          errors: { recipient: new InvalidAddress() },
+          warnings: {},
+          estimatedFees: createMockTransaction().fees,
+        },
+      },
+      {
+        name: "Zero amount",
+        account: createMockAccount(),
+        transaction: createMockTransaction({ amount: new BigNumber("0") }),
+        expectedStatus: {
+          errors: { amount: new AmountRequired() },
+          warnings: {},
+        },
+      },
+      {
+        name: "High amount (warning)",
+        account: createMockAccount(),
+        transaction: createMockTransaction({
+          amount: new BigNumber(
+            createMockAccount().balance.minus(createMockTransaction().fees).toString(),
+          ),
+        }),
+        expectedStatus: {
+          errors: {},
+          warnings: { amount: MayBlockAccountError },
+        },
+      },
+      {
+        name: "Insufficient funds",
+        account: createMockAccount({
+          balance: new BigNumber("2000000"), // 0.002 CSPR
+          spendableBalance: new BigNumber("2000000"),
+        }),
+        transaction: createMockTransaction({
+          amount: new BigNumber("2000000"),
+        }),
+        expectedStatus: {
+          errors: { amount: new NotEnoughBalance() },
+          warnings: { amount: MayBlockAccountError },
+        },
+      },
+      {
+        name: "Empty account",
+        account: createMockAccount({
+          balance: new BigNumber("0"),
+          spendableBalance: new BigNumber("0"),
+        }),
+        transaction: createMockTransaction(),
+        expectedStatus: {
+          errors: { amount: new NotEnoughBalance() },
+          warnings: { amount: MayBlockAccountError },
+        },
+      },
+    ];
+
+    testCases.forEach(testCase => {
+      test(`should handle ${testCase.name}`, async () => {
+        const status = await getTransactionStatus(testCase.account, testCase.transaction);
+
+        // Check if errors match expected errors
+        if (Object.keys(testCase.expectedStatus.errors).length) {
+          // Simplified error checking
+          expect(Object.keys(status.errors).length).toBeGreaterThan(0);
+
+          // Check only specific known error keys
+          if ("recipient" in testCase.expectedStatus.errors) {
+            expect(status.errors.recipient).toBeTruthy();
+          }
+
+          if ("amount" in testCase.expectedStatus.errors) {
+            expect(status.errors.amount).toBeTruthy();
+          }
+        } else {
+          expect(Object.keys(status.errors).length).toBe(0);
+        }
+
+        // Check if warnings match expected warnings
+        if (Object.keys(testCase.expectedStatus.warnings).length) {
+          // Simplified warning checking
+          expect(Object.keys(status.warnings).length).toBeGreaterThan(0);
+
+          // Check only specific known warning keys
+          if ("amount" in testCase.expectedStatus.warnings) {
+            expect(status.warnings.amount).toBeTruthy();
+          }
+        } else {
+          expect(Object.keys(status.warnings).length).toBe(0);
+        }
+      });
+    });
+  });
+});

package/src/bridge/index.ts

@@ -17,6 +17,8 @@ import { createTransaction } from "./createTransaction";
 import { getAccountShape } from "./bridgeHelpers/accountShape";
 import { buildSignOperation } from "./signOperation";
 import { broadcast } from "./broadcast";
+import { CasperCoinConfig } from "../config";
+import { setCoinConfig } from "../config";
 
 function buildCurrencyBridge(signerContext: SignerContext<CasperSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);
@@ -57,7 +59,12 @@ function buildAccountBridge(
   };
 }
 
-export function createBridges(signerContext: SignerContext<CasperSigner>) {
+export function createBridges(
+  signerContext: SignerContext<CasperSigner>,
+  coinConfig: CasperCoinConfig,
+) {
+  setCoinConfig(coinConfig);
+
   return {
     currencyBridge: buildCurrencyBridge(signerContext),
     accountBridge: buildAccountBridge(signerContext),