@prosopo/keyring 2.10.0 → 2.10.2

package/src/keyring/testing.test.ts

@@ -1,146 +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 { u8aToHex } from "@polkadot/util";
-import { describe, expect, it } from "vitest";
-import { PAIRSSR25519, createTestKeyring } from "./testing.js";
-import { createTestPairs } from "./testingPairs.js";
-
-// Key derivation runs scrypt/pbkdf2 with production parameters and takes
-// seconds per call, so these suites need more than the 10s default.
-const SLOW = { timeout: 60000 };
-
-describe("createTestKeyring", SLOW, () => {
-	it("adds a pair for every well-known dev account", () => {
-		expect(createTestKeyring().getPairs()).toHaveLength(PAIRSSR25519.length);
-	});
-
-	it("names each pair after its seed, lowercased with the path flattened", () => {
-		// `Alice//stash` becomes `alice_stash`, which is the name the rest of
-		// the stack looks pairs up by.
-		const names = createTestKeyring()
-			.getPairs()
-			.map((pair) => pair.meta.name);
-		expect(names).toEqual([
-			"alice",
-			"alice_stash",
-			"bob",
-			"bob_stash",
-			"charlie",
-			"dave",
-			"eve",
-			"ferdie",
-		]);
-	});
-
-	it("marks every pair as a testing pair", () => {
-		for (const pair of createTestKeyring().getPairs()) {
-			expect(pair.meta.isTesting).toBe(true);
-		}
-	});
-
-	it("uses the hard-coded public keys, not derivation, by default", () => {
-		const keyring = createTestKeyring();
-		for (const { p } of PAIRSSR25519) {
-			expect(u8aToHex(keyring.getPair(p).publicKey)).toBe(p);
-		}
-	});
-
-	it("replaces lock with a no-op so the fixtures stay usable", () => {
-		// The pairs carry their secret in the clear; locking them would make
-		// every downstream test fail to sign.
-		const pair = createTestKeyring().getPairs()[0];
-		expect(pair).toBeDefined();
-		if (!pair) return;
-		expect(() => pair.lock()).not.toThrow();
-		expect(pair.isLocked).toBe(false);
-	});
-
-	it("produces signable pairs", () => {
-		const pair = createTestKeyring().getPair(PAIRSSR25519[0]?.p ?? "0x");
-		const message = new TextEncoder().encode("hello");
-		expect(pair.verify(message, pair.sign(message), pair.publicKey)).toBe(true);
-	});
-
-	it("honours a requested ss58 format", () => {
-		const alice = PAIRSSR25519[0]?.p ?? "0x";
-		expect(
-			createTestKeyring({ ss58Format: 42 }).getPair(alice).address,
-		).not.toBe(createTestKeyring({ ss58Format: 2 }).getPair(alice).address);
-	});
-
-	it("derives different keys when asked to, because the seeds are bare names", () => {
-		// The `isDerived = false` branch feeds the seed straight to
-		// `addFromUri`, and the seeds are names like "Alice" rather than
-		// "//Alice". They are therefore padded raw phrases, not dev-phrase
-		// derivations, so the pairs are NOT the well-known dev accounts.
-		// Anything relying on Alice's address must use the default mode.
-		const derived = createTestKeyring({}, false);
-		expect(derived.getPairs()).toHaveLength(PAIRSSR25519.length);
-		for (const { p } of PAIRSSR25519) {
-			expect(() => derived.getPair(p)).toThrow("Unable to retrieve keypair");
-		}
-	});
-
-	it("rejects a keyring type it cannot support", () => {
-		expect(() => createTestKeyring({ type: "ed25519" })).toThrow(
-			"Expected a keyring type of either 'sr25519'",
-		);
-	});
-});
-
-describe("createTestPairs", SLOW, () => {
-	it("exposes every named pair plus nobody", () => {
-		const pairs = createTestPairs();
-		for (const name of [
-			"nobody",
-			"alice",
-			"alice_stash",
-			"bob",
-			"bob_stash",
-			"charlie",
-			"dave",
-			"eve",
-			"ferdie",
-		]) {
-			expect(pairs[name], name).toBeDefined();
-		}
-	});
-
-	it("maps alice to the well-known Alice public key", () => {
-		expect(
-			u8aToHex(createTestPairs().alice?.publicKey ?? new Uint8Array()),
-		).toBe(PAIRSSR25519[0]?.p);
-	});
-
-	it("includes nobody, which cannot verify anything", () => {
-		const nobodyPair = createTestPairs().nobody;
-		expect(nobodyPair).toBeDefined();
-		expect(nobodyPair?.isLocked).toBe(true);
-		expect(
-			nobodyPair?.verify(
-				new Uint8Array(1),
-				new Uint8Array(64),
-				nobodyPair.publicKey,
-			),
-		).toBe(false);
-	});
-
-	it("returns independent maps so one test cannot poison another", () => {
-		const first = createTestPairs();
-		const second = createTestPairs();
-		expect(first).not.toBe(second);
-		expect(first.alice).not.toBe(second.alice);
-	});
-});

package/src/keyring/testing.ts

@@ -1,119 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from "@polkadot/util/types";
-import type { KeyringInstance, KeyringOptions } from "@prosopo/types";
-
-import { hexToU8a } from "@polkadot/util";
-
-import type { KeypairType } from "@prosopo/util-crypto";
-import { createPair } from "../pair/index.js";
-import { Keyring } from "./keyring.js";
-
-interface PairDef {
-	name?: string;
-	p: HexString;
-	s: HexString;
-	seed?: string;
-	type: KeypairType;
-}
-
-// NOTE This is not great since we have the secretKey here explicitly, but a testing
-// keyring is for testing - what happens is that in most cases the keyring is initialises
-// before anything else. Since the sr25519 crypto is async, this creates problems with
-// adding the keys when only the keyring is used.
-export const PAIRSSR25519: PairDef[] = [
-	{
-		p: "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
-		s: "0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011", // nosemgrep
-		seed: "Alice",
-		type: "sr25519",
-	},
-	{
-		p: "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
-		s: "0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd", // nosemgrep
-		seed: "Alice//stash",
-		type: "sr25519",
-	},
-	{
-		p: "0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
-		s: "0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325", // nosemgrep
-		seed: "Bob",
-		type: "sr25519",
-	},
-	{
-		p: "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
-		s: "0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde", // nosemgrep
-		seed: "Bob//stash",
-		type: "sr25519",
-	},
-	{
-		p: "0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22",
-		s: "0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c", // nosemgrep
-		seed: "Charlie",
-		type: "sr25519",
-	},
-	{
-		p: "0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20",
-		s: "0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568", // nosemgrep
-		seed: "Dave",
-		type: "sr25519",
-	},
-	{
-		p: "0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e",
-		s: "0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587", // nosemgrep
-		seed: "Eve",
-		type: "sr25519",
-	},
-	{
-		p: "0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
-		s: "0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426", // nosemgrep
-		seed: "Ferdie",
-		type: "sr25519",
-	},
-];
-
-function createMeta(name?: string, seed?: string) {
-	if (!name && !seed) {
-		throw new Error("Testing pair should have either a name or a seed");
-	}
-
-	return {
-		isTesting: true,
-		name: name || seed?.replace("//", "_").toLowerCase(),
-	};
-}
-
-/**
- * @name testKeyring
- * @summary Create an instance of Keyring pre-populated with locked test accounts
- * @description The test accounts (i.e. alice, bob, dave, eve, ferdie)
- * are available on the dev chain and each test account is initialized with DOT funds.
- */
-export function createTestKeyring(
-	options: KeyringOptions = {},
-	isDerived = true,
-): KeyringInstance {
-	const keyring = new Keyring(options);
-	const pairs = PAIRSSR25519;
-
-	for (const { name, p, s, seed, type } of pairs) {
-		const meta = createMeta(name, seed);
-		const pair =
-			!isDerived && !name && seed
-				? keyring.addFromUri(seed, meta, options.type)
-				: keyring.addPair(
-						createPair(
-							{ toSS58: keyring.encodeAddress, type },
-							{ publicKey: hexToU8a(p), secretKey: hexToU8a(s) },
-							meta,
-						),
-					);
-
-		pair.lock = (): void => {
-			// we don't have lock/unlock functionality here
-		};
-	}
-
-	return keyring;
-}

package/src/keyring/testingPairs.ts

@@ -1,61 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { KeyringOptions, KeyringPair } from "@prosopo/types";
-import type { KeypairType } from "@prosopo/util-crypto";
-
-import { nobody } from "../pair/nobody.js";
-import { createTestKeyring } from "./testing.js";
-
-export interface TestKeyringMap {
-	nobody: KeyringPair;
-
-	[index: string]: KeyringPair;
-}
-
-export interface TestKeyringMapSubstrate extends TestKeyringMap {
-	alice: KeyringPair;
-	bob: KeyringPair;
-	charlie: KeyringPair;
-	dave: KeyringPair;
-	eve: KeyringPair;
-	ferdie: KeyringPair;
-}
-
-export interface TestKeyringMapEthereum extends TestKeyringMap {
-	Alith: KeyringPair;
-	Baltathar: KeyringPair;
-	Charleth: KeyringPair;
-	Dorothy: KeyringPair;
-	Ethan: KeyringPair;
-	Faith: KeyringPair;
-}
-
-export type DetectMap<O extends KeyringOptions | undefined> =
-	DetectPairType<O> extends "ethereum"
-		? TestKeyringMapEthereum
-		: TestKeyringMapSubstrate;
-
-export type DetectPairType<O extends KeyringOptions | undefined> =
-	O extends KeyringOptions
-		? O["type"] extends KeypairType
-			? O["type"]
-			: "sr25519"
-		: "sr25519";
-
-export function createTestPairs<O extends KeyringOptions, M = DetectMap<O>>(
-	options?: O,
-	isDerived = true,
-): M {
-	const keyring = createTestKeyring(options, isDerived);
-	const pairs = keyring.getPairs();
-	const map: TestKeyringMap = { nobody: nobody() };
-
-	for (const p of pairs) {
-		if (p.meta.name) {
-			map[p.meta.name] = p;
-		}
-	}
-
-	return map as M;
-}

package/src/keyring.test-d.ts

@@ -1,134 +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 type {
-	IProviderAccount,
-	ISite,
-	KeyringInstance,
-	KeyringPair,
-	KeyringPair$Json,
-} from "@prosopo/types";
-import { assertType, describe, expectTypeOf, it } from "vitest";
-import {
-	Keyring,
-	generateMiniSecret,
-	generateMnemonic,
-	getDefaultProviders,
-	getDefaultSiteKeys,
-	getPair,
-} from "./index.js";
-// The testing helpers and `nobody` are deliberately not re-exported from the
-// package barrel, so they are imported from their modules directly.
-import type {
-	DetectMap,
-	DetectPairType,
-	TestKeyringMapEthereum,
-	TestKeyringMapSubstrate,
-} from "./keyring/testingPairs.js";
-import { nobody } from "./pair/nobody.js";
-
-describe("Keyring types", () => {
-	it("implements the shared KeyringInstance contract", () => {
-		expectTypeOf<Keyring>().toExtend<KeyringInstance>();
-	});
-
-	it("returns KeyringPair from every add and create method", () => {
-		const keyring = new Keyring();
-		expectTypeOf(keyring.addFromUri("//Alice")).toEqualTypeOf<KeyringPair>();
-		expectTypeOf(keyring.addFromMnemonic("x")).toEqualTypeOf<KeyringPair>();
-		expectTypeOf(
-			keyring.addFromSeed(new Uint8Array()),
-		).toEqualTypeOf<KeyringPair>();
-		expectTypeOf(keyring.addFromAddress("x")).toEqualTypeOf<KeyringPair>();
-		expectTypeOf(keyring.getPair("x")).toEqualTypeOf<KeyringPair>();
-		expectTypeOf(keyring.getPairs()).toEqualTypeOf<KeyringPair[]>();
-		expectTypeOf(keyring.publicKeys).toEqualTypeOf<Uint8Array[]>();
-		expectTypeOf(keyring.toJson("x")).toEqualTypeOf<KeyringPair$Json>();
-	});
-
-	it("accepts an address as either a string or raw bytes", () => {
-		const keyring = new Keyring();
-		assertType(keyring.getPair("5abc"));
-		assertType(keyring.getPair(new Uint8Array(32)));
-		// @ts-expect-error a number is not an address
-		assertType(keyring.getPair(1));
-	});
-
-	it("rejects a keyring option object with an unknown key", () => {
-		// @ts-expect-error `curve` is not an option
-		new Keyring({ curve: "sr25519" });
-	});
-
-	it("has a readonly type", () => {
-		expectTypeOf<Keyring["type"]>().toEqualTypeOf<
-			import("@prosopo/util-crypto").KeypairType
-		>();
-	});
-});
-
-describe("account helper types", () => {
-	it("returns a pair from getPair with every argument optional", () => {
-		expectTypeOf(getPair).returns.toEqualTypeOf<KeyringPair>();
-		assertType(getPair());
-		assertType(getPair("secret", "account", "sr25519", 42));
-	});
-
-	it("returns the mnemonic and address as a tuple", () => {
-		expectTypeOf(generateMnemonic).returns.resolves.toEqualTypeOf<
-			[string, string]
-		>();
-	});
-
-	it("returns the mini secret as bytes paired with an address", () => {
-		expectTypeOf(generateMiniSecret).returns.resolves.toEqualTypeOf<
-			[Uint8Array, string]
-		>();
-	});
-
-	it("describes the dev fixtures with the shared account types", () => {
-		expectTypeOf(getDefaultSiteKeys()).toEqualTypeOf<ISite[]>();
-		expectTypeOf(getDefaultProviders()).toEqualTypeOf<IProviderAccount[]>();
-	});
-
-	it("returns a real KeyringPair for nobody", () => {
-		expectTypeOf(nobody()).toEqualTypeOf<KeyringPair>();
-	});
-});
-
-describe("test keyring map inference", () => {
-	it("defaults to the substrate map when no options are given", () => {
-		expectTypeOf<DetectPairType<undefined>>().toEqualTypeOf<"sr25519">();
-		expectTypeOf<
-			DetectMap<undefined>
-		>().toEqualTypeOf<TestKeyringMapSubstrate>();
-	});
-
-	it("selects the ethereum map only for an ethereum keyring", () => {
-		expectTypeOf<
-			DetectMap<{ type: "ethereum" }>
-		>().toEqualTypeOf<TestKeyringMapEthereum>();
-		expectTypeOf<
-			DetectMap<{ type: "sr25519" }>
-		>().toEqualTypeOf<TestKeyringMapSubstrate>();
-	});
-
-	it("indexes the map by arbitrary names, always yielding a pair", () => {
-		expectTypeOf<
-			TestKeyringMapSubstrate["alice"]
-		>().toEqualTypeOf<KeyringPair>();
-		expectTypeOf<
-			TestKeyringMapSubstrate["anything-else"]
-		>().toEqualTypeOf<KeyringPair>();
-	});
-});

package/src/pair/decode.spec.ts

@@ -1,25 +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("decode", (): void => {
-	it("fails when no data provided", (): void => {
-		expect((): void => keyring.alice.decodePkcs8()).toThrow(
-			/(No encrypted data available|Password required)/,
-		);
-	});
-
-	// scrypt with the production parameters takes several seconds, which
-	// overruns the 10s default on a loaded CI runner.
-	it("returns correct publicKey from encoded", { timeout: 60000 }, (): void => {
-		const PASS = "testing";
-
-		expect((): void =>
-			keyring.alice.decodePkcs8(PASS, keyring.alice.encodePkcs8(PASS)),
-		).not.toThrow();
-	});
-});

package/src/pair/decode.ts

@@ -1,64 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aEq } from "@polkadot/util";
-import type { EncryptedJsonEncoding } from "@prosopo/util-crypto";
-import { jsonDecryptData } from "@prosopo/util-crypto";
-
-import {
-	PAIR_DIV,
-	PAIR_HDR,
-	PUB_LENGTH,
-	SEC_LENGTH,
-	SEED_LENGTH,
-} from "./defaults.js";
-
-const SEED_OFFSET = PAIR_HDR.length;
-
-/**
- * Decode a pair, taking into account the generation-specific formats and headers
- *
- * For divisor/headers, don't rely on the magic being static. These will
- * change between generations, aka with the long-awaited 4th generation
- * of the format. The external decode interface is the only way to use and decode these.
- **/
-export function decodePair(
-	passphrase?: string,
-	encrypted?: Uint8Array | null,
-	_encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[],
-): { publicKey: Uint8Array; secretKey: Uint8Array } {
-	const encType =
-		Array.isArray(_encType) || _encType === undefined ? _encType : [_encType];
-	const decrypted = jsonDecryptData(encrypted, passphrase, encType);
-	const header = decrypted.subarray(0, PAIR_HDR.length);
-
-	// check the start header (generations 1-3)
-	if (!u8aEq(header, PAIR_HDR)) {
-		throw new Error("Invalid encoding header found in body");
-	}
-
-	// setup for generation 3 format
-	let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
-	let divOffset = SEED_OFFSET + SEC_LENGTH;
-	let divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-
-	// old-style (generation 1 & 2), we have the seed here
-	if (!u8aEq(divider, PAIR_DIV)) {
-		divOffset = SEED_OFFSET + SEED_LENGTH;
-		secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
-		divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-
-		// check the divisior at this point (already checked for generation 3)
-		if (!u8aEq(divider, PAIR_DIV)) {
-			throw new Error("Invalid encoding divider found in body");
-		}
-	}
-
-	const pubOffset = divOffset + PAIR_DIV.length;
-	const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
-
-	return {
-		publicKey,
-		secretKey,
-	};
-}

package/src/pair/defaults.ts

@@ -1,22 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/** public/secret section divider (generation 1-3, will change in 4, don't rely on value) */
-export const PAIR_DIV = new Uint8Array([161, 35, 3, 33, 0]);
-
-/** public/secret start block (generation 1-3, will change in 4, don't rely on value) */
-export const PAIR_HDR = new Uint8Array([
-	48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32,
-]);
-
-/** length of a public key */
-export const PUB_LENGTH = 32;
-
-/** length of a salt */
-export const SALT_LENGTH = 32;
-
-/** length of a secret key */
-export const SEC_LENGTH = 64;
-
-/** length of a user-input seed */
-export const SEED_LENGTH = 32;

package/src/pair/encode.spec.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { NONCE_LENGTH, SCRYPT_LENGTH } from "@prosopo/util-crypto";
-import { describe, expect, it } from "vitest";
-
-import { createTestPairs } from "../keyring/testingPairs.js";
-import { PAIR_DIV, PAIR_HDR, PUB_LENGTH, SEC_LENGTH } from "./defaults.js";
-
-const DECODED_LENGTH =
-	PAIR_DIV.length + PAIR_HDR.length + PUB_LENGTH + SEC_LENGTH;
-const ENCODED_LENGTH = 16 + DECODED_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;
-
-const keyring = createTestPairs({ type: "sr25519" }, false);
-
-describe("encode", (): void => {
-	it("returns PKCS8 when no passphrase supplied", (): void => {
-		expect(keyring.alice.encodePkcs8()).toHaveLength(DECODED_LENGTH);
-	});
-
-	// scrypt with the production parameters takes several seconds, which
-	// overruns the 10s default on a loaded CI runner.
-	it(
-		"returns encoded PKCS8 when passphrase supplied",
-		{ timeout: 60000 },
-		(): void => {
-			expect(keyring.alice.encodePkcs8("testing")).toHaveLength(ENCODED_LENGTH);
-		},
-	);
-});

package/src/pair/encode.ts

@@ -1,32 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aConcat } from "@polkadot/util";
-import type { PairInfo } from "@prosopo/types";
-import { naclEncrypt, scryptEncode, scryptToU8a } from "@prosopo/util-crypto";
-
-import { PAIR_DIV, PAIR_HDR } from "./defaults.js";
-
-/**
- * Encode a pair with the latest generation format (generation 3)
- **/
-export function encodePair(
-	{ publicKey, secretKey }: PairInfo,
-	passphrase?: string,
-): Uint8Array {
-	if (!secretKey) {
-		throw new Error("Expected a valid secretKey to be passed to encode");
-	}
-
-	const encoded = u8aConcat(PAIR_HDR, secretKey, PAIR_DIV, publicKey);
-
-	if (!passphrase) {
-		return encoded;
-	}
-
-	// this is only for generation 3 (previous generations are only handled in decoding)
-	const { params, password, salt } = scryptEncode(passphrase);
-	const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-
-	return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
-}