};

}

function expectThrowsError(run: () => unknown): void {

let error: unknown;

try {

run();

} catch (caught) {

error = caught;

}

expect(error).toBeInstanceOf(Error);

}

// ============================================================================

// Fuzz Tests for validatePrivateKey

// ============================================================================

describe("validatePrivateKey type confusion", () => {

it("rejects non-string input", () => {

for (const value of [null, undefined, 123, true, {}, [], () => {}]) {

expect(() => validatePrivateKey(value as unknown as string)).toThrow();

expectThrowsError(() => validatePrivateKey(value as unknown as string));

}

});

});

];

for (const key of invalidKeys) {

expect(() => validatePrivateKey(key)).toThrow();

expectThrowsError(() => validatePrivateKey(key));

}

});

});

describe("edge cases", () => {

it("rejects very long string", () => {

const veryLong = "a".repeat(10000);

expect(() => validatePrivateKey(veryLong)).toThrow();

expectThrowsError(() => validatePrivateKey(veryLong));

});

it("rejects string of spaces matching length", () => {

const spaces = " ".repeat(64);

expect(() => validatePrivateKey(spaces)).toThrow();

expectThrowsError(() => validatePrivateKey(spaces));

});

it("rejects hex with spaces between characters", () => {

const withSpaces =

"01 23 45 67 89 ab cd ef 01 23 45 67 89 ab cd ef 01 23 45 67 89 ab cd ef 01 23 45 67 89 ab cd ef";

expect(() => validatePrivateKey(withSpaces)).toThrow();

expectThrowsError(() => validatePrivateKey(withSpaces));

});

});

describe("nsec format edge cases", () => {

it("rejects nsec with invalid bech32 characters", () => {

// 'b', 'i', 'o' are not valid bech32 characters

const invalidBech32 = "nsec1qypqxpq9qtpqscx7peytbfwtdjmcv0mrz5rjpej8vjppfkqfqy8skqfv3l";

expect(() => validatePrivateKey(invalidBech32)).toThrow();

expectThrowsError(() => validatePrivateKey(invalidBech32));

});

it("rejects nsec with wrong prefix", () => {

expect(() => validatePrivateKey("nsec0aaaa")).toThrow();

expectThrowsError(() => validatePrivateKey("nsec0aaaa"));

});

it("rejects partial nsec", () => {

expect(() => validatePrivateKey("nsec1")).toThrow();

expectThrowsError(() => validatePrivateKey("nsec1"));

});

});

});

describe("prototype pollution attempts", () => {

it("throws for prototype property names", () => {

for (const value of ["__proto__", "constructor", "prototype"]) {

expect(() => normalizePubkey(value)).toThrow();

expectThrowsError(() => normalizePubkey(value));

}

});

});