@prosopo/keyring 2.10.0 → 2.10.2

package/src/pair/index.ts

@@ -1,304 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type {
-	KeyringPair,
-	KeyringPair$Json,
-	KeyringPair$Meta,
-	SignOptions,
-} from "@prosopo/types";
-import type { PairInfo } from "@prosopo/types";
-
-import {
-	objectSpread,
-	u8aConcat,
-	u8aEmpty,
-	u8aToHex,
-	u8aToU8a,
-} from "@polkadot/util";
-
-import {
-	type JWT,
-	blake2AsU8a,
-	jwtVerify,
-	sr25519jwtIssue,
-} from "@prosopo/util-crypto";
-import type { EncryptedJsonEncoding } from "@prosopo/util-crypto";
-import { keyExtractPath, keyFromPath } from "@prosopo/util-crypto";
-import { secp256k1Compress } from "@prosopo/util-crypto";
-import { signatureVerify } from "@prosopo/util-crypto";
-import { sr25519FromSeed, sr25519Sign } from "@prosopo/util-crypto";
-import { sr25519VrfSign, sr25519VrfVerify } from "@prosopo/util-crypto";
-import type { JWTVerifyOptions, JWTVerifyResult } from "@prosopo/util-crypto";
-import { decodePair } from "./decode.js";
-import { encodePair } from "./encode.js";
-import { pairToJson } from "./toJson.js";
-
-type KeypairType = "sr25519" | "ed25519" | "ecdsa" | "ethereum";
-
-interface Setup {
-	toSS58: (publicKey: Uint8Array) => string;
-	type: KeypairType;
-}
-
-const SIG_TYPE_NONE = new Uint8Array([]);
-
-const TYPE_FROM_SEED = {
-	sr25519: sr25519FromSeed,
-	ed25519: () => {
-		throw new Error("Not Implemented");
-	},
-	ecdsa: () => {
-		throw new Error("Not Implemented");
-	},
-	ethereum: () => {
-		throw new Error("Not Implemented");
-	},
-};
-
-const TYPE_PREFIX = {
-	ecdsa: new Uint8Array([2]),
-	ed25519: new Uint8Array([0]),
-	ethereum: new Uint8Array([2]),
-	sr25519: new Uint8Array([1]),
-};
-
-const TYPE_SIGNATURE = {
-	sr25519: sr25519Sign,
-	ed25519: () => {
-		throw new Error("Not Implemented");
-	},
-	ecdsa: () => {
-		throw new Error("Not Implemented");
-	},
-	ethereum: () => {
-		throw new Error("Not Implemented");
-	},
-};
-
-const TYPE_JWT_ISSUE = {
-	sr25519: sr25519jwtIssue,
-	ed25519: () => {
-		throw new Error("Not Implemented");
-	},
-	ecdsa: () => {
-		throw new Error("Not Implemented");
-	},
-	ethereum: () => {
-		throw new Error("Not Implemented");
-	},
-};
-
-const TYPE_ADDRESS = {
-	sr25519: (p: Uint8Array) => p,
-	ed25519: () => {
-		throw new Error("Not Implemented");
-	},
-	ecdsa: () => {
-		throw new Error("Not Implemented");
-	},
-	ethereum: () => {
-		throw new Error("Not Implemented");
-	},
-};
-
-function isLocked(secretKey?: Uint8Array): secretKey is undefined {
-	return !secretKey || u8aEmpty(secretKey);
-}
-
-function vrfHash(
-	proof: Uint8Array,
-	context?: string | Uint8Array,
-	extra?: string | Uint8Array,
-): Uint8Array {
-	return blake2AsU8a(u8aConcat(context || "", extra || "", proof));
-}
-
-/**
- * @name createPair
- * @summary Creates a keyring pair object
- * @description Creates a keyring pair object with provided account public key, metadata, and encoded arguments.
- * The keyring pair stores the account state including the encoded address and associated metadata.
- *
- * It has properties whose values are functions that may be called to perform account actions:
- *
- * - `address` function retrieves the address associated with the account.
- * - `decodedPkcs8` function is called with the account passphrase and account encoded public key.
- * It decodes the encoded public key using the passphrase provided to obtain the decoded account public key
- * and associated secret key that are then available in memory, and changes the account address stored in the
- * state of the pair to correspond to the address of the decoded public key.
- * - `encodePkcs8` function when provided with the correct passphrase associated with the account pair
- * and when the secret key is in memory (when the account pair is not locked) it returns an encoded
- * public key of the account.
- * - `meta` is the metadata that is stored in the state of the pair, either when it was originally
- * created or set via `setMeta`.
- * - `publicKey` returns the public key stored in memory for the pair.
- * - `sign` may be used to return a signature by signing a provided message with the secret
- * key (if it is in memory) using Nacl.
- * - `toJson` calls another `toJson` function and provides the state of the pair,
- * it generates arguments to be passed to the other `toJson` function including an encoded public key of the account
- * that it generates using the secret key from memory (if it has been made available in memory)
- * and the optionally provided passphrase argument. It passes a third boolean argument to `toJson`
- * indicating whether the public key has been encoded or not (if a passphrase argument was provided then it is encoded).
- * The `toJson` function that it calls returns a JSON object with properties including the `address`
- * and `meta` that are assigned with the values stored in the corresponding state variables of the account pair,
- * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
- * property that indicates whether the public key value of the `encoded` property is encoded or not.
- */
-export function createPair(
-	{ toSS58, type }: Setup,
-	{ publicKey, secretKey }: PairInfo,
-	meta: KeyringPair$Meta = {},
-	encoded: Uint8Array | null = null,
-	encTypes?: EncryptedJsonEncoding[],
-): KeyringPair {
-	const decodePkcs8 = (
-		passphrase?: string,
-		userEncoded?: Uint8Array | null,
-	): void => {
-		const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
-
-		if (decoded.secretKey.length === 64) {
-			publicKey = decoded.publicKey;
-			secretKey = decoded.secretKey;
-		} else {
-			const pair = TYPE_FROM_SEED[type](decoded.secretKey);
-
-			publicKey = pair.publicKey;
-			secretKey = pair.secretKey;
-		}
-	};
-
-	const recode = (passphrase?: string): Uint8Array => {
-		isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
-
-		encoded = encodePair({ publicKey, secretKey }, passphrase); // re-encode, latest version
-		encTypes = undefined; // swap to defaults, latest version follows
-
-		return encoded;
-	};
-
-	const encodeAddress = (): string => {
-		const raw = TYPE_ADDRESS[type](publicKey);
-
-		return toSS58(raw);
-	};
-
-	return {
-		get address(): string {
-			return encodeAddress();
-		},
-		get addressRaw(): Uint8Array {
-			return TYPE_ADDRESS[type](publicKey);
-		},
-		get isLocked(): boolean {
-			return isLocked(secretKey);
-		},
-		get meta(): KeyringPair$Meta {
-			return meta;
-		},
-		get publicKey(): Uint8Array {
-			return publicKey;
-		},
-		get type(): KeypairType {
-			return type;
-		},
-		// eslint-disable-next-line sort-keys
-		decodePkcs8,
-		derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
-			if (isLocked(secretKey)) {
-				throw new Error("Cannot derive on a locked keypair");
-			}
-
-			const { path } = keyExtractPath(suri);
-			const derived = keyFromPath({ publicKey, secretKey }, path, type);
-
-			return createPair({ toSS58, type }, derived, meta, null);
-		},
-		encodePkcs8: (passphrase?: string): Uint8Array => {
-			return recode(passphrase);
-		},
-		jwtIssue: (
-			options?: { expiresIn?: number; notBefore?: number },
-			message?: { [key: string]: string },
-		): JWT => {
-			if (isLocked(secretKey)) {
-				throw new Error("Cannot sign with a locked key pair");
-			}
-			return TYPE_JWT_ISSUE[type]({ publicKey, secretKey }, options, message);
-		},
-		jwtVerify: (jwt: JWT, options?: JWTVerifyOptions): JWTVerifyResult => {
-			return jwtVerify(jwt, publicKey, options);
-		},
-		lock: (): void => {
-			secretKey = new Uint8Array([]);
-		},
-		setMeta: (additional: KeyringPair$Meta): void => {
-			meta = objectSpread({}, meta, additional);
-		},
-		sign: (
-			message: string | Uint8Array,
-			options: SignOptions = {},
-		): Uint8Array => {
-			if (isLocked(secretKey)) {
-				throw new Error("Cannot sign with a locked key pair");
-			}
-
-			return u8aConcat(
-				options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE,
-				TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey }),
-			);
-		},
-		toJson: (passphrase?: string): KeyringPair$Json => {
-			// NOTE: For ecdsa and ethereum, the publicKey cannot be extracted from the address. For these
-			// pass the hex-encoded publicKey through to the address portion of the JSON (before decoding)
-			// unless the publicKey is already an address
-			const address = ["ecdsa", "ethereum"].includes(type)
-				? publicKey.length === 20
-					? u8aToHex(publicKey)
-					: u8aToHex(secp256k1Compress(publicKey))
-				: encodeAddress();
-
-			return pairToJson(
-				type,
-				{ address, meta },
-				recode(passphrase),
-				!!passphrase,
-			);
-		},
-		unlock: (passphrase?: string): void => {
-			decodePkcs8(passphrase);
-		},
-		verify: (
-			message: string | Uint8Array,
-			signature: string | Uint8Array,
-			signerPublic: string | Uint8Array,
-		): boolean => {
-			return signatureVerify(
-				message,
-				signature,
-				TYPE_ADDRESS[type](u8aToU8a(signerPublic)),
-			).isValid;
-		},
-		vrfSign: (
-			message: string | Uint8Array,
-			context?: string | Uint8Array,
-			extra?: string | Uint8Array,
-		): Uint8Array => {
-			if (isLocked(secretKey)) {
-				throw new Error("Cannot sign with a locked key pair");
-			}
-
-			return sr25519VrfSign(message, { secretKey }, context, extra);
-		},
-		vrfVerify: (
-			message: string | Uint8Array,
-			vrfResult: Uint8Array,
-			signerPublic: Uint8Array | string,
-			context?: string | Uint8Array,
-			extra?: string | Uint8Array,
-		): boolean => {
-			return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
-		},
-	};
-}

package/src/pair/nobody.test.ts

@@ -1,127 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { encodeAddress } from "@prosopo/util-crypto";
-import { describe, expect, it } from "vitest";
-import {
-	PAIR_DIV,
-	PAIR_HDR,
-	PUB_LENGTH,
-	SALT_LENGTH,
-	SEC_LENGTH,
-	SEED_LENGTH,
-} from "./defaults.js";
-import { nobody } from "./nobody.js";
-
-describe("nobody", () => {
-	it("is the all-zero public key, encoded as the well-known address", () => {
-		const pair = nobody();
-		expect(pair.publicKey).toEqual(new Uint8Array(32));
-		expect(pair.address).toBe(
-			"5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM",
-		);
-		// The address is a pre-computed constant in the source; if the encoding
-		// ever changed, the constant would silently be wrong.
-		expect(pair.address).toBe(encodeAddress(pair.publicKey, 42));
-	});
-
-	it("is permanently locked", () => {
-		const pair = nobody();
-		expect(pair.isLocked).toBe(true);
-		pair.unlock("anything");
-		expect(pair.isLocked).toBe(true);
-		pair.lock();
-		expect(pair.isLocked).toBe(true);
-	});
-
-	it("never verifies a signature, whatever it is given", () => {
-		// This is the whole point of the pair: it stands in for "no account"
-		// and must never authenticate anyone.
-		const pair = nobody();
-		expect(
-			pair.verify(new Uint8Array(1), new Uint8Array(64), pair.publicKey),
-		).toBe(false);
-		expect(
-			pair.verify(
-				new Uint8Array(0),
-				pair.sign(new Uint8Array(1)),
-				pair.publicKey,
-			),
-		).toBe(false);
-		expect(
-			pair.vrfVerify(new Uint8Array(1), new Uint8Array(96), pair.publicKey),
-		).toBe(false);
-	});
-
-	it("never reports a JWT as valid", () => {
-		const result = nobody().jwtVerify(nobody().jwtIssue());
-		expect(result.isValid).toBe(false);
-		expect(result.error).toBe("JWT verification failed");
-		expect(result.publicKey).toEqual(new Uint8Array(32));
-	});
-
-	it("returns correctly sized but empty signatures", () => {
-		const pair = nobody();
-		expect(pair.sign(new Uint8Array(1))).toEqual(new Uint8Array(64));
-		expect(pair.vrfSign(new Uint8Array(1))).toEqual(new Uint8Array(96));
-		expect(pair.encodePkcs8()).toEqual(new Uint8Array(0));
-	});
-
-	it("derives to itself, so no chain of derivation can escape it", () => {
-		const pair = nobody();
-		expect(pair.derive("//anything")).toBe(pair);
-		expect(pair.derive("//a").derive("//b")).toBe(pair);
-	});
-
-	it("ignores attempts to change its meta", () => {
-		const pair = nobody();
-		pair.setMeta({ name: "somebody" });
-		expect(pair.meta.name).toBe("nobody");
-		expect(pair.meta.isTesting).toBe(true);
-	});
-
-	it("serialises to an unencrypted v0 json blob", () => {
-		const json = nobody().toJson();
-		expect(json.address).toBe(nobody().address);
-		expect(json.encoded).toBe("");
-		expect(json.encoding.version).toBe("0");
-		expect(json.encoding.type).toBe("none");
-	});
-
-	it("returns the same shared instance each call", () => {
-		expect(nobody()).toBe(nobody());
-	});
-
-	it("accepts pkcs8 decoding without throwing", () => {
-		expect(() => nobody().decodePkcs8("pass", new Uint8Array(1))).not.toThrow();
-	});
-});
-
-describe("pair defaults", () => {
-	it("declares the sr25519 key and seed lengths", () => {
-		expect(PUB_LENGTH).toBe(32);
-		expect(SEED_LENGTH).toBe(32);
-		expect(SALT_LENGTH).toBe(32);
-		expect(SEC_LENGTH).toBe(64);
-	});
-
-	it("declares the pkcs8 header and divider used by the encoder", () => {
-		// These framing bytes are what makes an exported key readable by
-		// polkadot-js; a change here silently breaks every existing backup.
-		expect(Array.from(PAIR_DIV)).toEqual([161, 35, 3, 33, 0]);
-		expect(Array.from(PAIR_HDR)).toEqual([
-			48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32,
-		]);
-	});
-});

package/src/pair/nobody.ts

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type {
-	KeyringPair,
-	KeyringPair$Json,
-	KeyringPair$Meta,
-} from "@prosopo/types";
-import type {
-	JWT,
-	JWTVerifyOptions,
-	JWTVerifyResult,
-} from "@prosopo/util-crypto";
-
-// empty publicKey
-const publicKey = new Uint8Array(32);
-
-// pre-computed via encodeAddress(publicKey)
-const address = "5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM";
-
-const meta = {
-	isTesting: true,
-	name: "nobody",
-};
-
-const json: KeyringPair$Json = {
-	address,
-	encoded: "",
-	encoding: {
-		content: ["pkcs8", "ed25519"],
-		type: "none",
-		version: "0",
-	},
-	meta,
-};
-
-const pair: KeyringPair = {
-	address,
-	addressRaw: publicKey,
-	decodePkcs8: (_passphrase?: string, _encoded?: Uint8Array): void => undefined,
-	derive: (_suri: string, _meta?: KeyringPair$Meta): KeyringPair => pair,
-	encodePkcs8: (_passphrase?: string): Uint8Array => new Uint8Array(0),
-	isLocked: true,
-	jwtIssue: (_options?: { expiresIn?: number; notBefore?: number }): JWT =>
-		"jwt.dummy.token",
-	jwtVerify: (_jwt: JWT, _options?: JWTVerifyOptions): JWTVerifyResult => ({
-		isValid: false,
-		error: "JWT verification failed",
-		crypto: "sr25519",
-		publicKey,
-		isWrapped: false,
-	}),
-	lock: (): void => {
-		// no locking, it is always locked
-	},
-	meta,
-	publicKey,
-	setMeta: (_meta: KeyringPair$Meta): void => undefined,
-	sign: (_message: Uint8Array): Uint8Array => new Uint8Array(64),
-	toJson: (_passphrase?: string): KeyringPair$Json => json,
-	type: "sr25519",
-	unlock: (_passphrase?: string): void => undefined,
-	verify: (_message: Uint8Array, _signature: Uint8Array): boolean => false,
-	vrfSign: (
-		_message: Uint8Array,
-		_context?: string | Uint8Array,
-		_extra?: string | Uint8Array,
-	): Uint8Array => new Uint8Array(96),
-	vrfVerify: (
-		_message: Uint8Array,
-		_vrfResult: Uint8Array,
-		_context?: string | Uint8Array,
-		_extra?: string | Uint8Array,
-	): boolean => false,
-};
-
-export function nobody(): KeyringPair {
-	return pair;
-}

package/src/pair/toJson.spec.ts

@@ -1,46 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { describe, expect, it } from "vitest";
-import { createTestPairs } from "../keyring/testingPairs.js";
-
-const keyring = createTestPairs({ type: "sr25519" }, false);
-
-describe("toJson", (): void => {
-	it("creates an unencoded output with no passphrase", (): void => {
-		expect(keyring.alice.toJson()).toMatchObject({
-			address: "5Engs9f8Gk6JqvVWz3kFyJ8Kqkgx7pLi8C1UTcr7EZ855qBQ",
-			encoded:
-				"MFMCAQEwBQYDK2VwBCIEIHipoQ68w1cHP0Tju+ym3lzqc2fma5FCMXgDqwBDqTtU2pOQGFg2vA+4oVIIZMphcnOugCZhNuyAfxQ4r1OyWsahIwMhAHh9b36VcuIWVvYdPYl8NDyAyBt3Sx125cjHJVK3zLwl",
-			encoding: {
-				content: ["pkcs8", "sr25519"],
-				type: ["none"],
-				version: "3",
-			},
-			meta: {
-				isTesting: true,
-				name: "alice",
-			},
-		});
-	});
-
-	// scrypt with the production parameters takes several seconds, which
-	// overruns the 10s default on a loaded CI runner.
-	it(
-		"creates an encoded output with passphrase",
-		{ timeout: 60000 },
-		(): void => {
-			const json = keyring.alice.toJson("testing");
-
-			expect(json.encoded).toHaveLength(268);
-			expect(json).toMatchObject({
-				address: "5Engs9f8Gk6JqvVWz3kFyJ8Kqkgx7pLi8C1UTcr7EZ855qBQ",
-				encoding: {
-					content: ["pkcs8", "sr25519"],
-					type: ["scrypt", "xsalsa20-poly1305"],
-					version: "3",
-				},
-			});
-		},
-	);
-});

package/src/pair/toJson.ts

@@ -1,28 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { KeyringPair$Json, KeyringPair$Meta } from "@prosopo/types";
-import type { KeypairType } from "@prosopo/util-crypto";
-
-import { objectSpread } from "@polkadot/util";
-import { jsonEncryptFormat } from "@prosopo/util-crypto";
-
-interface PairStateJson {
-	address: string;
-	meta: KeyringPair$Meta;
-}
-
-export function pairToJson(
-	type: KeypairType,
-	{ address, meta }: PairStateJson,
-	encoded: Uint8Array,
-	isEncrypted: boolean,
-): KeyringPair$Json {
-	return objectSpread(
-		jsonEncryptFormat(encoded, ["pkcs8", type], isEncrypted),
-		{
-			address,
-			meta,
-		},
-	);
-}

package/tsconfig.cjs.json

@@ -1,30 +0,0 @@
-{
-	"extends": "../../tsconfig.cjs.json",
-	"compilerOptions": {
-		"rootDir": "./src",
-		"outDir": "./dist/cjs"
-	},
-	"include": [
-		"./src/**/*.ts",
-		"./src/**/*.json",
-		"./src/**/*.d.ts",
-		"./src/**/*.tsx"
-	],
-	"references": [
-		{
-			"path": "../../dev/config/tsconfig.cjs.json"
-		},
-		{
-			"path": "../common/tsconfig.cjs.json"
-		},
-		{
-			"path": "../types/tsconfig.cjs.json"
-		},
-		{
-			"path": "../util-crypto/tsconfig.cjs.json"
-		},
-		{
-			"path": "../util/tsconfig.cjs.json"
-		}
-	]
-}

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-	"extends": "../../tsconfig.esm.json",
-	"compilerOptions": {
-		"rootDir": "./src",
-		"outDir": "./dist",
-		"lib": ["es6", "dom"],
-		"allowJs": true
-	},
-	"include": [
-		"src",
-		"src/**/*.json",
-		"src/**/*.ts",
-		"src/**/*.tsx",
-		"src/**/*.d.ts"
-	],
-	"references": [
-		{
-			"path": "../../dev/config/tsconfig.json"
-		},
-		{
-			"path": "../common"
-		},
-		{
-			"path": "../types"
-		},
-		{
-			"path": "../util-crypto"
-		},
-		{
-			"path": "../util"
-		}
-	]
-}