@ledgerhq/coin-casper/lib/signer/getAddress.test.js

Ledger Casper integration

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const casper_js_sdk_1 = require("casper-js-sdk");
const getAddress_1 = __importDefault(require("./getAddress"));
const addressHelpers = __importStar(require("../bridge/bridgeHelpers/addresses"));
const cryptoassets_1 = require("@ledgerhq/cryptoassets");
describe("getAddress resolver", () => {
    // Test fixtures
    const mockDeviceId = "device_123";
    const mockPath = "44'/506'/0'/0/0";
    const mockCurrency = (0, cryptoassets_1.getCryptoCurrencyById)("casper");
    const mockDerivationMode = "casper_wallet";
    const mockPubKey = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
    const mockDerivedAddress = "02cafe0123456789abcdef";
    let mockSigner;
    let mockSignerContext;
    // Mock responses
    const createAddressResponse = (includeAddress) => ({
        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, includeAddress) => {
        const response = createAddressResponse(includeAddress);
        if (verify) {
            mockSigner.showAddressAndPubKey = jest.fn().mockResolvedValue(response);
        }
        else {
            mockSigner.getAddressAndPubKey = jest.fn().mockResolvedValue(response);
        }
        return (0, getAddress_1.default)(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), casper_js_sdk_1.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 = (0, getAddress_1.default)(mockSignerContext);
        await expect(getAddressFn(mockDeviceId, {
            path: mockPath,
            verify: false,
            currency: mockCurrency,
            derivationMode: mockDerivationMode,
        })).rejects.toThrow("Device disconnected");
    });
});
//# sourceMappingURL=getAddress.test.js.map