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

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,174 @@
+import { BigNumber } from "bignumber.js";
+import { prepareTransaction } from "./prepareTransaction";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { createMockAccount, createMockTransaction } from "../test/fixtures";
+
+// Mock dependencies
+jest.mock("./bridgeHelpers/fee", () => ({
+  getEstimatedFees: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers", () => ({
+  updateTransaction: jest.fn((tx, updates) => ({ ...tx, ...updates })),
+}));
+
+describe("prepareTransaction", () => {
+  const mockAccount = createMockAccount({
+    id: "casper:0:testAccount",
+    spendableBalance: new BigNumber(10000000),
+  });
+
+  const mockTransaction = createMockTransaction({
+    recipient: "01fedcba0987654321",
+    amount: new BigNumber(5000000),
+    useAllAmount: false,
+    fees: new BigNumber(1000000),
+    transferId: "1",
+  });
+
+  const mockEstimatedFees = new BigNumber(1000000);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (getEstimatedFees as jest.Mock).mockReturnValue(mockEstimatedFees);
+  });
+
+  test("should prepare a regular transaction with estimated fees", async () => {
+    const result = await prepareTransaction(mockAccount, mockTransaction);
+
+    expect(getEstimatedFees).toHaveBeenCalled();
+    expect(updateTransaction).toHaveBeenCalledWith(mockTransaction, {
+      fees: mockEstimatedFees,
+      amount: mockTransaction.amount,
+    });
+
+    expect(result).toEqual({
+      ...mockTransaction,
+      fees: mockEstimatedFees,
+    });
+  });
+
+  test("should calculate correct amount for useAllAmount transactions", async () => {
+    const useAllAmountTx = createMockTransaction({
+      ...mockTransaction,
+      useAllAmount: true,
+    });
+
+    const result = await prepareTransaction(mockAccount, useAllAmountTx);
+
+    const expectedAmount = mockAccount.spendableBalance.minus(mockEstimatedFees);
+
+    expect(updateTransaction).toHaveBeenCalledWith(useAllAmountTx, {
+      fees: mockEstimatedFees,
+      amount: expectedAmount,
+    });
+
+    expect(result).toEqual({
+      ...useAllAmountTx,
+      fees: mockEstimatedFees,
+      amount: expectedAmount,
+    });
+  });
+
+  test("should recalculate amount for useAllAmount transactions after fee update", async () => {
+    const useAllAmountTx = createMockTransaction({
+      ...mockTransaction,
+      useAllAmount: true,
+    });
+
+    const result = await prepareTransaction(mockAccount, useAllAmountTx);
+
+    const expectedAmount = mockAccount.spendableBalance.minus(mockEstimatedFees);
+
+    expect(result.amount).toEqual(expectedAmount);
+  });
+
+  // Using parameterized testing with fixtures
+  describe("with test case fixtures", () => {
+    // Define test cases inline for controlled fee values
+    test.each([
+      {
+        name: "Standard transaction",
+        account: createMockAccount({
+          spendableBalance: new BigNumber("10000000000"),
+        }),
+        transaction: createMockTransaction({
+          amount: new BigNumber("1000000000"),
+          useAllAmount: false,
+        }),
+        expectedResult: {
+          fees: mockEstimatedFees,
+          amount: new BigNumber("1000000000"),
+        },
+      },
+      {
+        name: "Use all amount transaction",
+        account: createMockAccount({
+          spendableBalance: new BigNumber("10000000000"),
+        }),
+        transaction: createMockTransaction({
+          useAllAmount: true,
+        }),
+        expectedResult: {
+          fees: mockEstimatedFees,
+          amount: new BigNumber("10000000000").minus(mockEstimatedFees),
+        },
+      },
+      {
+        name: "Low balance account",
+        account: createMockAccount({
+          spendableBalance: new BigNumber(mockEstimatedFees.div(2)),
+        }),
+        transaction: createMockTransaction({
+          useAllAmount: true,
+        }),
+        expectedResult: {
+          fees: mockEstimatedFees,
+          // For low balance, amount should be negative (will be handled in the test)
+          amount: new BigNumber(mockEstimatedFees.div(2)).minus(mockEstimatedFees),
+        },
+      },
+      {
+        name: "Exactly enough for fees",
+        account: createMockAccount({
+          spendableBalance: mockEstimatedFees,
+        }),
+        transaction: createMockTransaction({
+          useAllAmount: true,
+        }),
+        expectedResult: {
+          fees: mockEstimatedFees,
+          // For exact fee balance, amount should be zero
+          amount: new BigNumber("0"),
+        },
+      },
+      {
+        name: "Custom fee override",
+        account: createMockAccount({
+          spendableBalance: new BigNumber("10000000000"),
+        }),
+        transaction: createMockTransaction({
+          fees: new BigNumber("2000000"),
+          useAllAmount: true,
+        }),
+        expectedResult: {
+          fees: mockEstimatedFees,
+          amount: new BigNumber("10000000000").minus(mockEstimatedFees),
+        },
+      },
+    ])("$name", async ({ account, transaction, expectedResult }) => {
+      const result = await prepareTransaction(account, transaction);
+      expect(result.fees).toEqual(expectedResult.fees);
+
+      // For negative balance scenarios, just check they're less than or equal to zero
+      if (account.spendableBalance.lt(mockEstimatedFees) && transaction.useAllAmount) {
+        expect(result.amount.lte(new BigNumber("0"))).toBe(true);
+      } else if (account.spendableBalance.eq(mockEstimatedFees) && transaction.useAllAmount) {
+        expect(result.amount.eq(new BigNumber("0"))).toBe(true);
+      } else {
+        expect(result.amount).toEqual(expectedResult.amount);
+      }
+    });
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -11,7 +11,7 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
   const fees = getEstimatedFees();
 
   const amount = transaction.useAllAmount
-    ? account.spendableBalance.minus(transaction.fees)
+    ? account.spendableBalance.minus(fees)
     : transaction.amount;
 
   // log("debug", "[prepareTransaction] finish fn");

package/src/bridge/signOperation.ts

@@ -1,13 +1,13 @@
 import { Observable } from "rxjs";
 import { log } from "@ledgerhq/logs";
-import { DeployUtil } from "casper-js-sdk";
 import { Account, AccountBridge } from "@ledgerhq/types-live";
-import { casperGetCLPublicKey, getAddress } from "../bridge/bridgeHelpers/addresses";
-import { createNewDeploy } from "../bridge/bridgeHelpers/txn";
+import { getAddress } from "../bridge/bridgeHelpers/addresses";
+import { createNewTransaction } from "../bridge/bridgeHelpers/txn";
 import { Transaction } from "../types";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { CasperSigner } from "../types";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { KeyAlgorithm } from "casper-js-sdk";
 
 export const buildSignOperation =
   (
@@ -18,26 +18,20 @@ export const buildSignOperation =
       async function main() {
         // log("debug", "[signOperation] start fn");
 
-        const { recipient } = transaction;
+        const { recipient, amount, fees, transferId } = transaction;
         const { address, derivationPath } = getAddress(account);
-        const deploy = createNewDeploy(
-          address,
-          recipient,
-          transaction.amount,
-          transaction.fees,
-          transaction.transferId,
-        );
+        const casperTx = await createNewTransaction(address, recipient, amount, fees, transferId);
 
         // Serialize tx
-        const deployBytes = DeployUtil.deployToBytes(deploy);
-        log("debug", `[signOperation] serialized deploy: [${deployBytes.toString()}]`);
+        const txBytes = casperTx.toBytes();
+        log("debug", `[signOperation] serialized transaction: [${txBytes.toString()}]`);
         o.next({
           type: "device-signature-requested",
         });
 
         // Sign by device
         const { r } = await signerContext(deviceId, async signer => {
-          const r = await signer.sign(derivationPath, Buffer.from(deployBytes));
+          const r = await signer.sign(derivationPath, Buffer.from(txBytes));
           return { r };
         });
 
@@ -46,23 +40,20 @@ export const buildSignOperation =
         });
 
         // signature verification
-        const deployHash = deploy.hash.toString();
-        const signature = r.signatureRS;
+        const txHash = casperTx.hash.getHash()?.toHex() ?? "";
+        const signature = Buffer.concat([Buffer.from([KeyAlgorithm.SECP256K1]), r.signatureRS]);
 
-        // sign deploy object
-        const signedDeploy = DeployUtil.setSignature(
-          deploy,
-          signature,
-          casperGetCLPublicKey(address),
-        );
-
-        const operation = buildOptimisticOperation(account, transaction, deployHash);
+        const operation = buildOptimisticOperation(account, transaction, txHash);
+        const txJson = casperTx.toJSON();
 
         o.next({
           type: "signed",
           signedOperation: {
             operation,
-            signature: JSON.stringify(DeployUtil.deployToJson(signedDeploy)),
+            signature: Buffer.from(signature).toString("hex"),
+            rawData: {
+              tx: JSON.stringify(txJson),
+            },
           },
         });
       }

package/src/bridge/transaction.test.ts

@@ -0,0 +1,182 @@
+import { BigNumber } from "bignumber.js";
+import transaction, { fromTransactionRaw, formatTransaction } from "./transaction";
+import { TransactionRaw } from "../types";
+import {
+  createMockAccount,
+  createMockTransaction,
+  TEST_ADDRESSES,
+  TEST_TRANSFER_IDS,
+} from "../test/fixtures";
+
+describe("transaction", () => {
+  // Using the createMockAccount function from fixtures
+  const account = createMockAccount({
+    id: "casper:0:testAccount",
+    balance: new BigNumber(100000000),
+    spendableBalance: new BigNumber(100000000),
+    blockHeight: 123456,
+    freshAddress: "0123456789",
+    freshAddressPath: "44'/506'/0'/0/0",
+    lastSyncDate: new Date(),
+  });
+
+  describe("formatTransaction", () => {
+    test("should format a transaction with amount", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: new BigNumber(50000000),
+        fees: new BigNumber(1000000),
+        transferId: "1",
+      });
+
+      const result = formatTransaction(tx, account);
+      expect(result).toContain("SEND");
+      expect(result).toContain("0.05");
+      expect(result).toContain("CSPR");
+      expect(result).toContain(`TO ${TEST_ADDRESSES.RECIPIENT_SECP256K1}`);
+    });
+
+    test("should format a transaction with useAllAmount", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: true,
+        amount: new BigNumber(0),
+        fees: new BigNumber(1000000),
+        transferId: "1",
+      });
+
+      const result = formatTransaction(tx, account);
+      expect(result).toContain("SEND MAX");
+      expect(result).toContain(`TO ${TEST_ADDRESSES.RECIPIENT_SECP256K1}`);
+    });
+
+    test("should format a transaction with zero amount", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: new BigNumber(0),
+        fees: new BigNumber(1000000),
+        transferId: "1",
+      });
+
+      const result = formatTransaction(tx, account);
+      expect(result).toContain("SEND");
+      expect(result).not.toContain("MAX");
+      expect(result).not.toContain("CSPR");
+      expect(result).toContain(`TO ${TEST_ADDRESSES.RECIPIENT_SECP256K1}`);
+    });
+
+    test("should format a transaction with different address formats", () => {
+      // Test with ED25519 address format
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_ED25519,
+        amount: new BigNumber(50000000),
+      });
+
+      const result = formatTransaction(tx, account);
+      expect(result).toContain(`TO ${TEST_ADDRESSES.RECIPIENT_ED25519}`);
+    });
+
+    test("should format a transaction with transfer ID", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        amount: new BigNumber(50000000),
+        transferId: TEST_TRANSFER_IDS.VALID,
+      });
+
+      const result = formatTransaction(tx, account);
+      expect(result).toContain("0.05");
+      expect(result).toContain("CSPR");
+      expect(result).toContain(`TO ${TEST_ADDRESSES.RECIPIENT_SECP256K1}`);
+    });
+  });
+
+  describe("fromTransactionRaw", () => {
+    test("should convert a transaction raw to a transaction", () => {
+      const raw: TransactionRaw = {
+        family: "casper",
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: "50000000",
+        fees: "1000000",
+        transferId: TEST_TRANSFER_IDS.VALID,
+      };
+
+      const result = fromTransactionRaw(raw);
+      expect(result.family).toBe("casper");
+      expect(result.recipient).toBe(TEST_ADDRESSES.RECIPIENT_SECP256K1);
+      expect(result.useAllAmount).toBe(false);
+      expect(result.amount).toEqual(new BigNumber(50000000));
+      expect(result.fees).toEqual(new BigNumber(1000000));
+      expect(result.transferId).toBe(TEST_TRANSFER_IDS.VALID);
+    });
+
+    test("should handle transaction raw without optional fields", () => {
+      const raw: TransactionRaw = {
+        family: "casper",
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: "50000000",
+        fees: "1000000",
+      };
+
+      const result = fromTransactionRaw(raw);
+      expect(result.family).toBe("casper");
+      expect(result.transferId).toBeUndefined();
+    });
+  });
+
+  describe("toTransactionRaw", () => {
+    test("should convert a transaction to a transaction raw", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: new BigNumber(50000000),
+        fees: new BigNumber(1000000),
+        transferId: TEST_TRANSFER_IDS.VALID,
+      });
+
+      const result = transaction.toTransactionRaw(tx);
+      expect(result.family).toBe("casper");
+      expect(result.recipient).toBe(TEST_ADDRESSES.RECIPIENT_SECP256K1);
+      expect(result.useAllAmount).toBe(false);
+      expect(result.amount).toBe("50000000");
+      expect(result.fees).toBe("1000000");
+      expect(result.transferId).toBe(TEST_TRANSFER_IDS.VALID);
+    });
+
+    test("should handle transaction without optional fields", () => {
+      const tx = createMockTransaction({
+        recipient: TEST_ADDRESSES.RECIPIENT_SECP256K1,
+        useAllAmount: false,
+        amount: new BigNumber(50000000),
+        fees: new BigNumber(1000000),
+        transferId: undefined,
+      });
+
+      const result = transaction.toTransactionRaw(tx);
+      expect(result.transferId).toBeUndefined();
+    });
+
+    test("should handle different transaction scenarios", () => {
+      // Test with useAllAmount = true
+      const maxTx = createMockTransaction({
+        useAllAmount: true,
+        amount: new BigNumber(0),
+      });
+
+      const maxResult = transaction.toTransactionRaw(maxTx);
+      expect(maxResult.useAllAmount).toBe(true);
+      expect(maxResult.amount).toBe("0");
+
+      // Test with very large amount
+      const largeTx = createMockTransaction({
+        amount: new BigNumber("9999000000000"), // 9,999 CSPR
+      });
+
+      const largeResult = transaction.toTransactionRaw(largeTx);
+      expect(largeResult.amount).toBe("9999000000000");
+    });
+  });
+});

package/src/common-logic/utils.additional.test.ts

@@ -0,0 +1,75 @@
+import {
+  isNoErrorReturnCode,
+  getPath,
+  isError,
+  methodToString,
+  getRandomTransferID,
+} from "./utils";
+
+describe("Casper utils", () => {
+  describe("isNoErrorReturnCode", () => {
+    test("should return true for code 0x9000", () => {
+      expect(isNoErrorReturnCode(0x9000)).toBe(true);
+    });
+
+    test("should return false for other codes", () => {
+      expect(isNoErrorReturnCode(0x6984)).toBe(false);
+      expect(isNoErrorReturnCode(0x6a80)).toBe(false);
+      expect(isNoErrorReturnCode(0)).toBe(false);
+    });
+  });
+
+  describe("getPath", () => {
+    test("should add m/ prefix if not present", () => {
+      expect(getPath("44'/506'/0'/0/0")).toBe("m/44'/506'/0'/0/0");
+    });
+
+    test("should not modify path if m/ prefix is already present", () => {
+      expect(getPath("m/44'/506'/0'/0/0")).toBe("m/44'/506'/0'/0/0");
+    });
+
+    test("should handle empty path", () => {
+      expect(getPath("")).toBe("");
+    });
+  });
+
+  describe("isError", () => {
+    test("should not throw for successful return code", () => {
+      expect(() => isError({ returnCode: 0x9000, errorMessage: "Success" })).not.toThrow();
+    });
+
+    test("should throw for error return codes", () => {
+      expect(() => isError({ returnCode: 0x6a80, errorMessage: "Bad data" })).toThrow(
+        "27264 - Bad data",
+      );
+    });
+  });
+
+  describe("methodToString", () => {
+    test("should return 'Token transfer' for method 0", () => {
+      expect(methodToString(0)).toBe("Token transfer");
+    });
+
+    test("should return 'Unknown' for other methods", () => {
+      expect(methodToString(1)).toBe("Unknown");
+      expect(methodToString(999)).toBe("Unknown");
+    });
+  });
+
+  describe("getRandomTransferID", () => {
+    test("should return a string containing a number", () => {
+      const result = getRandomTransferID();
+      expect(typeof result).toBe("string");
+      expect(Number.isNaN(parseInt(result, 10))).toBe(false);
+    });
+
+    test("should generate different IDs on multiple calls", () => {
+      const id1 = getRandomTransferID();
+      const id2 = getRandomTransferID();
+      const id3 = getRandomTransferID();
+
+      // There's a very small chance these could be the same, but it's extremely unlikely
+      expect(new Set([id1, id2, id3]).size).toBeGreaterThan(0);
+    });
+  });
+});

package/src/common-logic/utils.unit.test.ts

@@ -1,4 +1,4 @@
-import { CLPublicKeyTag } from "casper-js-sdk";
+import { KeyAlgorithm } from "casper-js-sdk";
 import { casperAddressFromPubKey, isAddressValid } from "../bridge/bridgeHelpers/addresses";
 
 describe("Casper addresses", () => {
@@ -20,6 +20,8 @@ describe("Casper addresses", () => {
   test("Check if valid addresses are valid", () => {
     expect(isAddressValid(pubKeys.validEd25519)).toBe(true);
     expect(isAddressValid(pubKeys.validSecp256k1)).toBe(true);
+    expect(isAddressValid(pubKeys.validSecp256k1Checksum)).toBe(true);
+    expect(isAddressValid(pubKeys.validEd25519Checksum)).toBe(true);
   });
 
   test("Check if invalid addresses are invalid", () => {
@@ -39,9 +41,9 @@ describe("Casper addresses", () => {
      */
     function casperPubKeyFromAddress(address: string): {
       pubkey: Buffer;
-      keySig: CLPublicKeyTag;
+      keySig: KeyAlgorithm;
     } {
-      const keySig = parseInt(address.slice(0, 2), 10) as CLPublicKeyTag;
+      const keySig = parseInt(address.slice(0, 2), 10) as KeyAlgorithm;
       const pubkeyHex = address.slice(2);
       const pubkey = Buffer.from(pubkeyHex, "hex");
       return { pubkey, keySig };
@@ -50,25 +52,25 @@ describe("Casper addresses", () => {
     expect(
       casperAddressFromPubKey(
         casperPubKeyFromAddress(pubKeys.validSecp256k1).pubkey,
-        CLPublicKeyTag.SECP256K1,
+        KeyAlgorithm.SECP256K1,
       ),
     ).toBe(pubKeys.validSecp256k1);
     expect(
       casperAddressFromPubKey(
         casperPubKeyFromAddress(pubKeys.validSecp256k1Checksum).pubkey,
-        CLPublicKeyTag.SECP256K1,
+        KeyAlgorithm.SECP256K1,
       ),
     ).toBe(pubKeys.validSecp256k1Checksum.toLowerCase());
     expect(
       casperAddressFromPubKey(
         casperPubKeyFromAddress(pubKeys.validEd25519).pubkey,
-        CLPublicKeyTag.ED25519,
+        KeyAlgorithm.ED25519,
       ),
     ).toBe(pubKeys.validEd25519);
     expect(
       casperAddressFromPubKey(
         casperPubKeyFromAddress(pubKeys.validEd25519Checksum).pubkey,
-        CLPublicKeyTag.ED25519,
+        KeyAlgorithm.ED25519,
       ),
     ).toBe(pubKeys.validEd25519Checksum.toLowerCase());
   });

package/src/config.ts

@@ -0,0 +1,22 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type CasperCoinConfig = () => CurrencyConfig & {
+  infra: {
+    API_CASPER_NODE_ENDPOINT: string;
+    API_CASPER_INDEXER: string;
+  };
+};
+
+let coinConfig: CasperCoinConfig | undefined;
+
+export const setCoinConfig = (config: CasperCoinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): ReturnType<CasperCoinConfig> => {
+  if (!coinConfig?.()) {
+    throw new Error("Casper module config not set");
+  }
+
+  return coinConfig();
+};

package/src/consts.ts

@@ -6,6 +6,7 @@ export const CASPER_MINIMUM_VALID_AMOUNT_MOTES = 2.5 * 1e9;
 export const CASPER_MINIMUM_VALID_AMOUNT_CSPR = 2.5;
 export const CASPER_NETWORK = "casper";
 export const CASPER_CHECKSUM_HEX_LEN = 32;
+export const CASPER_DEFAULT_TTL = 1800000;
 
 export const CASPER_MAX_TRANSFER_ID = "18446744073709551615";
 
@@ -16,3 +17,7 @@ export const MayBlockAccountError = new MayBlockAccount("", {
 export const InvalidMinimumAmountError = new InvalidMinimumAmount("", {
   minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR} CSPR`,
 });
+
+// Known Error Codes
+export const NodeErrorCodeAccountNotFound = -32009;
+export const NodeErrorCodeQueryFailed = -32003;