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

package/src/bridge/bridgeHelpers/txn.test.ts

@@ -0,0 +1,339 @@
+import BigNumber from "bignumber.js";
+import { getUnit, mapTxToOps } from "./txn";
+import { casperAccountHashFromPublicKey, isAddressValid } from "./addresses";
+import * as fixtures from "../../test/fixtures";
+import { ITxnHistoryData } from "../../api/types";
+import { createNewTransaction as testCreateNewTransaction } from "./txn";
+
+// Import Casper SDK mock for direct access to mocks
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const mockCasperSDK = require("casper-js-sdk");
+
+// Mock the entire Casper SDK
+jest.mock("casper-js-sdk", () => {
+  const mockTransaction = { id: "mock-transaction" };
+  const mockHelper = {
+    createTransferTransaction: jest.fn().mockReturnValue(mockTransaction),
+  };
+
+  return {
+    CasperNetwork: {
+      create: jest.fn().mockResolvedValue(mockHelper),
+    },
+    PublicKey: {
+      fromHex: jest.fn().mockReturnValue({ value: "mocked-public-key" }),
+    },
+    Transaction: jest.fn().mockImplementation(() => mockTransaction),
+  };
+});
+
+jest.mock("@ledgerhq/coin-framework/operation", () => ({
+  encodeOperationId: jest.fn(
+    (accountId: string, hash: string, type: string) => `${accountId}-${hash}-${type}`,
+  ),
+}));
+
+jest.mock("./addresses", () => ({
+  casperAccountHashFromPublicKey: jest.fn((key: string) => `account-hash-${key}`),
+  isAddressValid: jest.fn(),
+}));
+
+jest.mock("../../api", () => ({
+  getCasperNodeRpcClient: jest.fn(),
+}));
+
+describe("txn", () => {
+  // Reset mocks between tests
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("getUnit", () => {
+    test("should return the first unit of casper currency", () => {
+      const unit = getUnit();
+      expect(unit).toBeDefined();
+      expect(unit.name).toBe("CSPR");
+      expect(unit.code).toBe("CSPR");
+      expect(unit.magnitude).toBe(9);
+    });
+  });
+
+  describe("mapTxToOps", () => {
+    const { mockAccountId } = fixtures.createMockAccountShapeData();
+    const fees = new BigNumber("100000000");
+    const mockTimestamp = "2023-01-01T12:00:00Z";
+
+    beforeEach(() => {
+      (casperAccountHashFromPublicKey as jest.Mock).mockImplementation(
+        (key: string) => `account-hash-${key}`,
+      );
+    });
+
+    test("should map an outgoing transaction to operation", () => {
+      // Use a modified version of the fixture tx data
+      const fixtureData = fixtures.createMockAccountShapeData();
+      const txData: ITxnHistoryData = {
+        ...fixtureData.mockTxs[0],
+        timestamp: mockTimestamp,
+        caller_public_key: "owner-public-key",
+        args: {
+          target: {
+            cl_type: "PublicKey",
+            parsed: "recipient-public-key",
+          },
+          amount: {
+            parsed: "5000000000",
+            cl_type: "U512",
+          },
+          id: {
+            parsed: 12345,
+            cl_type: {
+              Option: "U64",
+            },
+          },
+        },
+        deploy_hash: "test-deploy-hash",
+        status: "success",
+        amount: "5000000000",
+      };
+
+      // Set up the owner address hash to match the from account hash
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-owner-public-key",
+      );
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-recipient-public-key",
+      );
+
+      const mapper = mapTxToOps(mockAccountId, "account-hash-owner-public-key", fees);
+      const operations = mapper(txData);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]).toEqual({
+        id: `${mockAccountId}-${txData.deploy_hash}-OUT`,
+        hash: txData.deploy_hash,
+        type: "OUT",
+        value: new BigNumber("5000000000").plus(fees),
+        fee: fees,
+        blockHeight: 1,
+        hasFailed: false,
+        blockHash: null,
+        accountId: mockAccountId,
+        senders: ["account-hash-owner-public-key"],
+        recipients: ["account-hash-recipient-public-key"],
+        date: new Date(mockTimestamp),
+        extra: {
+          transferId: "12345",
+        },
+      });
+    });
+
+    test("should map an incoming transaction to operation", () => {
+      const recipientAddressHash = "account-hash-owner-public-key";
+      // Use a modified version of the fixture tx data
+      const fixtureData = fixtures.createMockAccountShapeData();
+      const txData: ITxnHistoryData = {
+        ...fixtureData.mockTxs[0],
+        timestamp: mockTimestamp,
+        caller_public_key: "sender-public-key",
+        args: {
+          target: {
+            cl_type: "PublicKey",
+            parsed: "owner-public-key",
+          },
+          amount: {
+            parsed: "5000000000",
+            cl_type: "U512",
+          },
+          id: {
+            parsed: 12345,
+            cl_type: {
+              Option: "U64",
+            },
+          },
+        },
+        deploy_hash: "test-deploy-hash",
+        status: "success",
+        amount: "5000000000",
+      };
+
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-sender-public-key",
+      );
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(recipientAddressHash);
+
+      const mapper = mapTxToOps(mockAccountId, recipientAddressHash, fees);
+      const operations = mapper(txData);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]).toEqual({
+        id: `${mockAccountId}-${txData.deploy_hash}-IN`,
+        hash: txData.deploy_hash,
+        type: "IN",
+        value: new BigNumber("5000000000"),
+        fee: fees,
+        blockHeight: 1,
+        hasFailed: false,
+        blockHash: null,
+        accountId: mockAccountId,
+        senders: ["account-hash-sender-public-key"],
+        recipients: [recipientAddressHash],
+        date: new Date(mockTimestamp),
+        extra: {
+          transferId: "12345",
+        },
+      });
+    });
+
+    test("should map a failed transaction correctly", () => {
+      // Use a modified version of the fixture tx data
+      const fixtureData = fixtures.createMockAccountShapeData();
+      const txData: ITxnHistoryData = {
+        ...fixtureData.mockTxs[0],
+        timestamp: mockTimestamp,
+        caller_public_key: "owner-public-key",
+        args: {
+          target: {
+            cl_type: "PublicKey",
+            parsed: "recipient-public-key",
+          },
+          amount: {
+            parsed: "5000000000",
+            cl_type: "U512",
+          },
+          id: {
+            parsed: 12345,
+            cl_type: {
+              Option: "U64",
+            },
+          },
+        },
+        deploy_hash: "test-deploy-hash",
+        error_message: "Transaction failed due to insufficient funds",
+        status: "failure",
+        amount: "5000000000",
+      };
+
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-owner-public-key",
+      );
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-recipient-public-key",
+      );
+
+      const mapper = mapTxToOps(mockAccountId, "account-hash-owner-public-key", fees);
+      const operations = mapper(txData);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0].hasFailed).toBe(true);
+    });
+
+    test("should handle target as account hash string directly", () => {
+      // Use a modified version of the fixture tx data
+      const fixtureData = fixtures.createMockAccountShapeData();
+      const txData: ITxnHistoryData = {
+        ...fixtureData.mockTxs[0],
+        timestamp: mockTimestamp,
+        caller_public_key: "owner-public-key",
+        args: {
+          target: {
+            cl_type: {
+              ByteArray: 32,
+            },
+            parsed: "account-hash-direct-address",
+          },
+          amount: {
+            parsed: "5000000000",
+            cl_type: "U512",
+          },
+          id: {
+            parsed: 12345,
+            cl_type: {
+              Option: "U64",
+            },
+          },
+        },
+        deploy_hash: "test-deploy-hash",
+        status: "success",
+        amount: "5000000000",
+      };
+
+      (casperAccountHashFromPublicKey as jest.Mock).mockReturnValueOnce(
+        "account-hash-owner-public-key",
+      );
+
+      const mapper = mapTxToOps(mockAccountId, "account-hash-owner-public-key", fees);
+      const operations = mapper(txData);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0].recipients).toEqual(["account-hash-direct-address"]);
+    });
+
+    test("should catch and log errors when mapping fails", () => {
+      const txData = {
+        timestamp: mockTimestamp,
+        caller_public_key: "owner-public-key",
+        args: {
+          // Intentionally missing the target field to cause an error
+          amount: {
+            parsed: "5000000000",
+            cl_type: "U512",
+          },
+        },
+        deploy_hash: "test-deploy-hash",
+        block_hash: "block-hash-1",
+        execution_type_id: 1,
+        cost: "100000",
+        payment_amount: "100000000",
+        status: "success",
+        amount: "5000000000",
+      };
+
+      const mapper = mapTxToOps(mockAccountId, "account-hash-owner-public-key", fees);
+      const operations = mapper(txData as any);
+
+      expect(operations).toEqual([]);
+    });
+  });
+
+  describe("createNewTransaction", () => {
+    const { mockAddress: mockSender } = fixtures.createMockAccountShapeData();
+    const mockRecipient = fixtures.TEST_ADDRESSES.RECIPIENT_SECP256K1;
+    const mockAmount = new BigNumber("5000000000");
+    const mockFees = new BigNumber("100000000");
+    const mockTransferId = fixtures.TEST_TRANSFER_IDS.VALID;
+
+    // Direct access to the mocks from jest.mock
+    const mockCreateNetwork = mockCasperSDK.CasperNetwork.create;
+    const mockPublicKeyFromHex = mockCasperSDK.PublicKey.fromHex;
+
+    beforeEach(() => {
+      (isAddressValid as jest.Mock).mockReturnValue(true);
+    });
+
+    test("should throw error if recipient address is invalid", async () => {
+      (isAddressValid as jest.Mock).mockReturnValue(false);
+
+      await expect(
+        testCreateNewTransaction(mockSender, mockRecipient, mockAmount, mockFees),
+      ).rejects.toThrow();
+    });
+
+    test("should create a new transaction with valid parameters", async () => {
+      const expectedTransaction = { id: "mock-transaction" };
+
+      const result = await testCreateNewTransaction(
+        mockSender,
+        mockRecipient,
+        mockAmount,
+        mockFees,
+        mockTransferId,
+      );
+
+      expect(result).toEqual(expectedTransaction);
+      expect(mockCreateNetwork).toHaveBeenCalled();
+      expect(mockPublicKeyFromHex).toHaveBeenCalledWith(mockSender);
+      expect(mockPublicKeyFromHex).toHaveBeenCalledWith(mockRecipient);
+    });
+  });
+});

package/src/bridge/bridgeHelpers/txn.ts

@@ -3,14 +3,15 @@ import { InvalidAddress } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
 import { Unit } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
-import { DeployUtil } from "casper-js-sdk";
+import { CasperNetwork, PublicKey, Transaction } from "casper-js-sdk";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { CASPER_NETWORK } from "../../consts";
-import { casperAccountHashFromPublicKey, casperGetCLPublicKey, isAddressValid } from "./addresses";
+import { CASPER_DEFAULT_TTL, CASPER_NETWORK } from "../../consts";
+import { casperAccountHashFromPublicKey, isAddressValid } from "./addresses";
 import { ITxnHistoryData } from "../../api/types";
 import { getEstimatedFees } from "./fee";
 import { CasperOperation } from "../../types";
 import invariant from "invariant";
+import { getCasperNodeRpcClient } from "../../api";
 
 export const getUnit = (): Unit => getCryptoCurrencyById("casper").units[0];
 
@@ -89,33 +90,32 @@ export function mapTxToOps(
   };
 }
 
-export const createNewDeploy = (
+export const createNewTransaction = async (
   sender: string,
   recipient: string,
   amount: BigNumber,
   fees: BigNumber,
   transferId?: string,
   network = CASPER_NETWORK,
-): DeployUtil.Deploy => {
-  log("debug", `Creating new Deploy: ${sender}, ${recipient}, ${network}`);
+): Promise<Transaction> => {
+  log("debug", `Creating new Transaction: ${sender}, ${recipient}, ${network}`);
 
   if (recipient && !isAddressValid(recipient)) {
     throw InvalidAddress(`Invalid recipient Address ${recipient}`);
   }
 
-  const deployParams = new DeployUtil.DeployParams(casperGetCLPublicKey(sender), network);
+  const client = getCasperNodeRpcClient();
+  const helper = await CasperNetwork.create(client);
 
-  const session = DeployUtil.ExecutableDeployItem.newTransferWithOptionalTransferId(
-    amount?.toNumber() ?? 0,
-    casperGetCLPublicKey(recipient),
-    undefined,
-    transferId,
+  const tx = helper.createTransferTransaction(
+    PublicKey.fromHex(sender),
+    PublicKey.fromHex(recipient),
+    network,
+    amount.toString(),
+    fees.toNumber(),
+    CASPER_DEFAULT_TTL,
+    parseInt(transferId ?? "0"),
   );
 
-  const payment = DeployUtil.standardPayment(fees.toString());
-  const deploy = DeployUtil.makeDeploy(deployParams, session, payment);
-  const txnRaw = DeployUtil.deployToJson(deploy);
-  const txnFromRaw = DeployUtil.deployFromJson(txnRaw).unwrap();
-
-  return txnFromRaw;
+  return tx;
 };

package/src/bridge/broadcast.test.ts

@@ -0,0 +1,89 @@
+import { Transaction as CasperTransaction, PublicKey } from "casper-js-sdk";
+import { broadcast } from "./broadcast";
+import { broadcastTx } from "../api";
+import {
+  createMockAccount,
+  createMockTransaction,
+  createMockSignedOperation,
+} from "../test/fixtures";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/lib/operation";
+
+// Mock the dependencies
+jest.mock("casper-js-sdk", () => {
+  return {
+    Transaction: {
+      fromJSON: jest.fn().mockReturnValue({
+        setSignature: jest.fn(),
+      }),
+    },
+    PublicKey: {
+      fromHex: jest.fn().mockReturnValue("mockedPublicKey"),
+    },
+  };
+});
+
+jest.mock("../api", () => ({
+  broadcastTx: jest.fn().mockResolvedValue("mockedTxHash"),
+}));
+
+describe("broadcast", () => {
+  // Create test fixtures
+  const mockAccount = createMockAccount();
+  const mockTransaction = createMockTransaction();
+  const mockSignedOperation = createMockSignedOperation(mockAccount, mockTransaction, {
+    signature: "deadbeef",
+    rawTxJson: { hash: "mockTxHash" },
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should successfully broadcast a transaction", async () => {
+    const result = await broadcast({
+      account: mockAccount,
+      signedOperation: mockSignedOperation,
+    });
+
+    // Assert the transaction was constructed and signed correctly
+    expect(CasperTransaction.fromJSON).toHaveBeenCalledWith(mockSignedOperation.rawData.tx);
+    expect(PublicKey.fromHex).toHaveBeenCalledWith(mockAccount.freshAddress);
+
+    // Assert the transaction was broadcast
+    expect(broadcastTx).toHaveBeenCalled();
+
+    // Assert the operation was patched with the hash
+    expect(result.hash).toBe("mockedTxHash");
+    expect(result).toEqual({
+      ...patchOperationWithHash(mockSignedOperation.operation, "mockedTxHash"),
+      hash: "mockedTxHash",
+    });
+  });
+
+  test("should throw if rawData is missing", async () => {
+    // Create a type-safe but invalid signed operation for testing
+    const invalidSignedOperation = {
+      ...mockSignedOperation,
+      rawData: null as any, // Force type assertion for test
+    };
+
+    await expect(
+      broadcast({
+        account: mockAccount,
+        signedOperation: invalidSignedOperation,
+      }),
+    ).rejects.toThrow("casper: rawData is required");
+  });
+
+  test("should throw if broadcast fails to return a hash", async () => {
+    // Mock broadcastTx to return null (failed broadcast)
+    (broadcastTx as jest.Mock).mockResolvedValueOnce(null);
+
+    await expect(
+      broadcast({
+        account: mockAccount,
+        signedOperation: mockSignedOperation,
+      }),
+    ).rejects.toThrow("casper: failed to broadcast transaction and get transaction hash");
+  });
+});

package/src/bridge/broadcast.ts

@@ -1,4 +1,4 @@
-import { DeployUtil } from "casper-js-sdk";
+import { Transaction as CasperTransaction, PublicKey } from "casper-js-sdk";
 import { AccountBridge } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
 import { Transaction } from "../types";
@@ -6,15 +6,17 @@ import { broadcastTx } from "../api";
 import invariant from "invariant";
 
 export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
-  signedOperation: { signature, operation },
+  account,
+  signedOperation: { signature, operation, rawData },
 }) => {
-  const tx = DeployUtil.deployFromJson(JSON.parse(signature)).unwrap();
+  invariant(rawData, "casper: rawData is required");
+  const tx = CasperTransaction.fromJSON(rawData.tx);
+  tx.setSignature(Buffer.from(signature, "hex"), PublicKey.fromHex(account.freshAddress));
 
-  const resp = await broadcastTx(tx);
-  invariant(resp.deploy_hash, "casper: failed to broadcast transaction and get deploy hash");
-  const { deploy_hash } = resp;
+  const hash = await broadcastTx(tx);
+  invariant(hash, "casper: failed to broadcast transaction and get transaction hash");
 
-  const result = patchOperationWithHash(operation, deploy_hash);
+  const result = patchOperationWithHash(operation, hash);
 
   return result;
 };

package/src/bridge/buildOptimisticOperation.test.ts

@@ -0,0 +1,89 @@
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { getAddress } from "./bridgeHelpers/addresses";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { createMockAccount, createMockTransaction, TEST_TRANSFER_IDS } from "../test/fixtures";
+
+// Mock dependencies
+jest.mock("./bridgeHelpers/addresses", () => ({
+  getAddress: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-framework/operation", () => ({
+  encodeOperationId: jest.fn(),
+}));
+
+describe("buildOptimisticOperation", () => {
+  // Create test fixtures using helper functions
+  const mockAccount = createMockAccount();
+  const mockTransaction = createMockTransaction();
+
+  const mockHash = "mockedTransactionHash";
+  const mockAddress = "01abcdef1234567890";
+  const mockOperationId = "mockOperationId";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (getAddress as jest.Mock).mockReturnValue({ address: mockAddress });
+    (encodeOperationId as jest.Mock).mockReturnValue(mockOperationId);
+  });
+
+  test("should build an optimistic operation for an outgoing transaction", () => {
+    const operation = buildOptimisticOperation(mockAccount, mockTransaction, mockHash);
+
+    expect(getAddress).toHaveBeenCalledWith(mockAccount);
+    expect(encodeOperationId).toHaveBeenCalledWith(mockAccount.id, mockHash, "OUT");
+
+    expect(operation).toEqual({
+      id: mockOperationId,
+      hash: mockHash,
+      type: "OUT",
+      senders: [mockAddress],
+      recipients: [mockTransaction.recipient],
+      accountId: mockAccount.id,
+      value: mockTransaction.amount.plus(mockTransaction.fees),
+      fee: mockTransaction.fees,
+      blockHash: null,
+      blockHeight: null,
+      date: expect.any(Date),
+      extra: {
+        transferId: mockTransaction.transferId,
+      },
+      nftOperations: [],
+      subOperations: [],
+    });
+  });
+
+  test("should build an optimistic operation with a custom operation type", () => {
+    const customType = "IN";
+    const operation = buildOptimisticOperation(mockAccount, mockTransaction, mockHash, customType);
+
+    expect(encodeOperationId).toHaveBeenCalledWith(mockAccount.id, mockHash, customType);
+    expect(operation.type).toBe(customType);
+  });
+
+  test("should include transferId in the extra field when present", () => {
+    const txWithTransferId = {
+      ...mockTransaction,
+      transferId: TEST_TRANSFER_IDS.VALID,
+    };
+
+    const operation = buildOptimisticOperation(mockAccount, txWithTransferId, mockHash);
+
+    expect(operation.extra).toEqual({
+      transferId: TEST_TRANSFER_IDS.VALID,
+    });
+  });
+
+  test("should handle transaction without transferId", () => {
+    const txWithoutTransferId = {
+      ...mockTransaction,
+      transferId: undefined,
+    };
+
+    const operation = buildOptimisticOperation(mockAccount, txWithoutTransferId, mockHash);
+
+    expect(operation.extra).toEqual({
+      transferId: undefined,
+    });
+  });
+});

package/src/bridge/buildOptimisticOperation.ts

@@ -27,5 +27,7 @@ export const buildOptimisticOperation = (
     extra: {
       transferId: transaction.transferId,
     },
+    nftOperations: [],
+    subOperations: [],
   };
 };

package/src/bridge/createTransaction.test.ts

@@ -0,0 +1,43 @@
+import BigNumber from "bignumber.js";
+import { createTransaction } from "./createTransaction";
+import { Transaction } from "../types";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+
+describe("createTransaction", () => {
+  it("should create a transaction with default values", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    const expectedTransaction: Transaction = {
+      family: "casper",
+      amount: new BigNumber(0),
+      fees: new BigNumber(0),
+      recipient: "",
+      useAllAmount: false,
+    };
+    expect(transaction).toEqual(expectedTransaction);
+  });
+
+  it("should create a transaction with the correct family", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    expect(transaction.family).toBe("casper");
+  });
+
+  it("should create a transaction with default amount set to zero", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    expect(transaction.amount.isEqualTo(new BigNumber(0))).toBe(true);
+  });
+
+  it("should create a transaction with default fees set to zero", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    expect(transaction.fees.isEqualTo(new BigNumber(0))).toBe(true);
+  });
+
+  it("should create a transaction with empty recipient", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    expect(transaction.recipient).toBe("");
+  });
+
+  it("should create a transaction with useAllAmount set to false", () => {
+    const transaction = createTransaction({} as AccountLike<Account>);
+    expect(transaction.useAllAmount).toBe(false);
+  });
+});