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

package/src/hw-signMessage.test.ts

@@ -0,0 +1,123 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Account } from "@ledgerhq/types-live";
+import { signMessage } from "./hw-signMessage";
+import { CasperSigner, CasperSignature } from "./types";
+
+describe("hw-signMessage", () => {
+  // Test fixtures
+  const mockDeviceId = "device_123";
+
+  // Only define the properties actually used by the signMessage function
+  const mockAccount = {
+    freshAddressPath: "44'/506'/0'/0/1",
+  } as unknown as Account;
+
+  // Mock signature response
+  const mockSignatureResponse: CasperSignature = {
+    errorMessage: "",
+    returnCode: 0x9000,
+    signatureRS: Buffer.from(
+      "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
+      "hex",
+    ),
+    signatureRSV: Buffer.from(
+      "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff01",
+      "hex",
+    ),
+    signature_compact: new Uint8Array(
+      Buffer.from("00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff01", "hex"),
+    ),
+  };
+
+  // Mock a successful signer
+  const mockSigner: CasperSigner = {
+    showAddressAndPubKey: jest.fn(),
+    getAddressAndPubKey: jest.fn(),
+    sign: jest.fn().mockResolvedValue(mockSignatureResponse),
+  };
+
+  // Mock signerContext function
+  const mockSignerContext: SignerContext<CasperSigner> = jest.fn((deviceId, callback) =>
+    callback(mockSigner),
+  );
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should sign a plain text message correctly", async () => {
+    const message = "Hello Casper Network";
+    const result = await signMessage(mockSignerContext)(mockDeviceId, mockAccount, { message });
+
+    // Verify the signer was called with correct parameters
+    expect(mockSignerContext).toHaveBeenCalledWith(mockDeviceId, expect.any(Function));
+    expect(mockSigner.sign).toHaveBeenCalledWith(mockAccount.freshAddressPath, expect.any(Buffer));
+
+    // Verify the correct signature format is returned
+    expect(result).toEqual({
+      rsv: {
+        r: "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
+        s: "01",
+        v: NaN,
+      },
+      signature: "0x00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff01",
+    });
+  });
+
+  test("should sign a hex message correctly", async () => {
+    const message = "0x123456789abcdef";
+    const result = await signMessage(mockSignerContext)(mockDeviceId, mockAccount, { message });
+
+    expect(mockSigner.sign).toHaveBeenCalledWith(mockAccount.freshAddressPath, expect.any(Buffer));
+    expect(result.signature).toBe(
+      "0x00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff01",
+    );
+  });
+
+  test("should sign a base64 message correctly", async () => {
+    const message = "SGVsbG8gQ2FzcGVyIE5ldHdvcms="; // "Hello Casper Network" in base64
+    const result = await signMessage(mockSignerContext)(mockDeviceId, mockAccount, { message });
+
+    expect(mockSigner.sign).toHaveBeenCalledWith(mockAccount.freshAddressPath, expect.any(Buffer));
+    expect(result.signature).toBe(
+      "0x00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff01",
+    );
+  });
+
+  test("should throw error if message is empty", async () => {
+    await expect(
+      signMessage(mockSignerContext)(mockDeviceId, mockAccount, { message: "" }),
+    ).rejects.toThrow("Message cannot be empty");
+  });
+
+  test("should throw error if message is undefined", async () => {
+    await expect(
+      signMessage(mockSignerContext)(mockDeviceId, mockAccount, { message: undefined as any }),
+    ).rejects.toThrow("Message cannot be empty");
+  });
+
+  test("should throw error if message is not a string", async () => {
+    await expect(
+      signMessage(mockSignerContext)(mockDeviceId, mockAccount, {
+        message: { type: "EIP712" } as any,
+      }),
+    ).rejects.toThrow("Signing EIP712Message not supported");
+  });
+
+  test("should propagate errors from the signer", async () => {
+    // Mock an error from the signer
+    const errorSigner: CasperSigner = {
+      showAddressAndPubKey: jest.fn(),
+      getAddressAndPubKey: jest.fn(),
+      sign: jest.fn().mockRejectedValue(new Error("Device disconnected")),
+    };
+
+    const errorSignerContext: SignerContext<CasperSigner> = jest.fn((deviceId, callback) =>
+      callback(errorSigner),
+    );
+
+    await expect(
+      signMessage(errorSignerContext)(mockDeviceId, mockAccount, { message: "test" }),
+    ).rejects.toThrow("Device disconnected");
+  });
+});

package/src/signer/getAddress.test.ts

@@ -0,0 +1,134 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { KeyAlgorithm } from "casper-js-sdk";
+import getAddressResolver from "./getAddress";
+import { CasperSigner, CasperGetAddrResponse } from "../types";
+import * as addressHelpers from "../bridge/bridgeHelpers/addresses";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+describe("getAddress resolver", () => {
+  // Test fixtures
+  const mockDeviceId = "device_123";
+  const mockPath = "44'/506'/0'/0/0";
+  const mockCurrency = getCryptoCurrencyById("casper");
+  const mockDerivationMode = "casper_wallet";
+  const mockPubKey = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+  const mockDerivedAddress = "02cafe0123456789abcdef";
+
+  let mockSigner: CasperSigner;
+  let mockSignerContext: SignerContext<CasperSigner>;
+
+  // Mock responses
+  const createAddressResponse = (includeAddress: boolean): CasperGetAddrResponse => ({
+    errorMessage: "",
+    returnCode: 0x9000,
+    publicKey: Buffer.from(mockPubKey, "hex"),
+    Address: {
+      toString: jest.fn().mockReturnValue(includeAddress ? "02CAFE0123456789ABCDEF" : ""),
+      length: includeAddress ? 1 : 0,
+    },
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Set up mocks
+    mockSigner = {
+      showAddressAndPubKey: jest.fn(),
+      getAddressAndPubKey: jest.fn(),
+      sign: jest.fn(),
+    };
+
+    mockSignerContext = jest.fn((deviceId, callback) => callback(mockSigner));
+
+    // Mock address derivation function
+    jest.spyOn(addressHelpers, "casperAddressFromPubKey").mockReturnValue(mockDerivedAddress);
+  });
+
+  const setupTest = (verify: boolean, includeAddress: boolean) => {
+    const response = createAddressResponse(includeAddress);
+
+    if (verify) {
+      mockSigner.showAddressAndPubKey = jest.fn().mockResolvedValue(response);
+    } else {
+      mockSigner.getAddressAndPubKey = jest.fn().mockResolvedValue(response);
+    }
+
+    return getAddressResolver(mockSignerContext);
+  };
+
+  test("should return address from device when verify=false", async () => {
+    const getAddressFn = setupTest(false, true);
+
+    const result = await getAddressFn(mockDeviceId, {
+      path: mockPath,
+      verify: false,
+      currency: mockCurrency,
+      derivationMode: mockDerivationMode,
+    });
+
+    expect(mockSigner.getAddressAndPubKey).toHaveBeenCalledWith(mockPath);
+    expect(mockSigner.showAddressAndPubKey).not.toHaveBeenCalled();
+
+    expect(result).toEqual({
+      path: mockPath,
+      address: mockDerivedAddress,
+      publicKey: mockPubKey,
+    });
+  });
+
+  test("should return address from device when verify=true", async () => {
+    const getAddressFn = setupTest(true, true);
+
+    const result = await getAddressFn(mockDeviceId, {
+      path: mockPath,
+      verify: true,
+      currency: mockCurrency,
+      derivationMode: mockDerivationMode,
+    });
+
+    expect(mockSigner.showAddressAndPubKey).toHaveBeenCalledWith(mockPath);
+    expect(mockSigner.getAddressAndPubKey).not.toHaveBeenCalled();
+
+    expect(result).toEqual({
+      path: mockPath,
+      address: mockDerivedAddress,
+      publicKey: mockPubKey,
+    });
+  });
+
+  test("should derive address when not provided by device", async () => {
+    const getAddressFn = setupTest(false, false);
+
+    const result = await getAddressFn(mockDeviceId, {
+      path: mockPath,
+      verify: false,
+      currency: mockCurrency,
+      derivationMode: mockDerivationMode,
+    });
+
+    expect(addressHelpers.casperAddressFromPubKey).toHaveBeenCalledWith(
+      expect.any(Buffer),
+      KeyAlgorithm.SECP256K1,
+    );
+
+    expect(result).toEqual({
+      path: mockPath,
+      address: mockDerivedAddress,
+      publicKey: mockPubKey,
+    });
+  });
+
+  test("should propagate errors from the signer", async () => {
+    mockSigner.getAddressAndPubKey = jest.fn().mockRejectedValue(new Error("Device disconnected"));
+    const getAddressFn = getAddressResolver(mockSignerContext);
+
+    await expect(
+      getAddressFn(mockDeviceId, {
+        path: mockPath,
+        verify: false,
+        currency: mockCurrency,
+        derivationMode: mockDerivationMode,
+      }),
+    ).rejects.toThrow("Device disconnected");
+  });
+});

package/src/signer/getAddress.ts

@@ -2,7 +2,7 @@ import { log } from "@ledgerhq/logs";
 import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { CLPublicKeyTag } from "casper-js-sdk";
+import { KeyAlgorithm } from "casper-js-sdk";
 import { casperAddressFromPubKey } from "../bridge/bridgeHelpers/addresses";
 import { CasperSigner } from "../types";
 
@@ -22,7 +22,7 @@ function resolver(signerContext: SignerContext<CasperSigner>): GetAddressFn {
       path,
       address: r.Address.length
         ? r.Address.toString().toLowerCase()
-        : casperAddressFromPubKey(r.publicKey, CLPublicKeyTag.SECP256K1),
+        : casperAddressFromPubKey(r.publicKey, KeyAlgorithm.SECP256K1),
       publicKey: r.publicKey.toString("hex"),
     };
   };

package/src/test/bot-specs.ts

@@ -19,6 +19,7 @@ const casperSpecs: AppSpec<Transaction> = {
   appQuery: {
     model: DeviceModelId.nanoSP,
     appName: "Casper",
+    appVersion: "3.0.7",
   },
   genericDeviceAction: acceptTransaction,
   testTimeout: 6 * 60 * 1000,