@peerbit/crypto 2.2.0 → 2.3.0-55cebfe

package/src/sepc256k1.ts

@@ -1,24 +1,26 @@
-import { field, fixedArray, variant, vec } from "@dao-xyz/borsh";
-import { Keypair, PrivateSignKey, PublicSignKey } from "./key.js";
-
+import { field, fixedArray, variant } from "@dao-xyz/borsh";
+import {
+	type SignatureLike,
+	arrayify,
+	joinSignature,
+	splitSignature,
+} from "@ethersproject/bytes";
 import { Wallet } from "@ethersproject/wallet";
-import { arrayify } from "@ethersproject/bytes";
-import { joinSignature } from "@ethersproject/bytes";
-import { SignatureLike, splitSignature } from "@ethersproject/bytes";
-import _ec from "elliptic";
-import EC = _ec.ec;
-let _curve: EC;
-
-import { equals } from "@peerbit/uint8arrays";
-import { toHexString } from "./utils.js";
-import { PeerId } from "@libp2p/interface";
-import { Identity } from "./signer.js";
-import { coerce } from "./bytes.js";
 import { generateKeyPair, supportedKeys } from "@libp2p/crypto/keys";
+import { type PeerId } from "@libp2p/interface";
+import { peerIdFromKeys } from "@libp2p/peer-id";
 import utf8 from "@protobufjs/utf8";
-import { SignatureWithKey } from "./signature.js";
+import _ec from "elliptic";
+import { equals } from "uint8arrays";
+import { coerce } from "./bytes.js";
+import { Keypair, PrivateSignKey, PublicSignKey } from "./key.js";
 import { PreHash, prehashFn } from "./prehash.js";
-import { peerIdFromKeys } from "@libp2p/peer-id";
+import { SignatureWithKey } from "./signature.js";
+import { type Identity } from "./signer.js";
+import { toHexString } from "./utils.js";
+
+import EC = _ec.ec;
+let _curve: EC;
 
 @variant(1)
 export class Secp256k1PublicKey extends PublicSignKey {
@@ -43,7 +45,7 @@ export class Secp256k1PublicKey extends PublicSignKey {
 		// So we can recover the public key
 		const publicKey = recoverPublicKeyFromSignature(
 			await prehashFn(toSign, PreHash.ETH_KECCAK_256),
-			signature
+			signature,
 		);
 
 		return new Secp256k1PublicKey({ publicKey });
@@ -62,7 +64,7 @@ export class Secp256k1PublicKey extends PublicSignKey {
 
 	toPeerId(): Promise<PeerId> {
 		return peerIdFromKeys(
-			new supportedKeys["secp256k1"].Secp256k1PublicKey(this.publicKey).bytes
+			new supportedKeys["secp256k1"].Secp256k1PublicKey(this.publicKey).bytes,
 		);
 	}
 
@@ -72,7 +74,7 @@ export class Secp256k1PublicKey extends PublicSignKey {
 		}
 		if (id.type === "secp256k1") {
 			return new Secp256k1PublicKey({
-				publicKey: id.publicKey.slice(4) // computeAddress(!.slice(4)),
+				publicKey: id.publicKey.slice(4), // computeAddress(!.slice(4)),
 			});
 		}
 		throw new Error("Unsupported key type: " + id.type);
@@ -110,7 +112,7 @@ export class Secp256k1PrivateKey extends PrivateSignKey {
 		}
 		if (id.type === "secp256k1") {
 			return new Secp256k1PrivateKey({
-				privateKey: coerce(id.privateKey!.slice(4))
+				privateKey: coerce(id.privateKey.slice(4)),
 			});
 		}
 		throw new Error("Unsupported key type: " + id.type);
@@ -125,7 +127,7 @@ export class Secp256k1Keypair extends Keypair implements Identity {
 	@field({ type: Secp256k1PrivateKey })
 	privateKey: Secp256k1PrivateKey;
 
-	_wallet: Wallet;
+	_wallet!: Wallet;
 	constructor(properties: {
 		publicKey: Secp256k1PublicKey;
 		privateKey: Secp256k1PrivateKey;
@@ -139,11 +141,11 @@ export class Secp256k1Keypair extends Keypair implements Identity {
 		const generated = await generateKeyPair("secp256k1");
 		const kp = new Secp256k1Keypair({
 			publicKey: new Secp256k1PublicKey({
-				publicKey: generated.public.marshal()
+				publicKey: generated.public.marshal(),
 			}),
 			privateKey: new Secp256k1PrivateKey({
-				privateKey: generated.marshal()
-			})
+				privateKey: generated.marshal(),
+			}),
 		});
 
 		return kp;
@@ -151,14 +153,14 @@ export class Secp256k1Keypair extends Keypair implements Identity {
 
 	async sign(
 		data: Uint8Array,
-		prehash: PreHash = PreHash.ETH_KECCAK_256
+		prehash: PreHash = PreHash.ETH_KECCAK_256,
 	): Promise<SignatureWithKey> {
 		const maybeHashed = await prehashFn(data, prehash);
 
 		const signature = joinSignature(
 			(this._wallet || (this._wallet = new Wallet(this.privateKey.privateKey)))
 				._signingKey()
-				.signDigest(maybeHashed)
+				.signDigest(maybeHashed),
 		);
 		const signatureBytes = new Uint8Array(utf8.length(signature)); // TODO utilize Buffer allocUnsafe
 		utf8.write(signature, signatureBytes, 0);
@@ -166,7 +168,7 @@ export class Secp256k1Keypair extends Keypair implements Identity {
 		return new SignatureWithKey({
 			prehash,
 			publicKey: this.publicKey,
-			signature: signatureBytes
+			signature: signatureBytes,
 		});
 	}
 
@@ -183,19 +185,19 @@ export class Secp256k1Keypair extends Keypair implements Identity {
 	static fromPeerId(peerId: PeerId) {
 		return new Secp256k1Keypair({
 			privateKey: Secp256k1PrivateKey.from(peerId),
-			publicKey: Secp256k1PublicKey.fromPeerId(peerId)
+			publicKey: Secp256k1PublicKey.fromPeerId(peerId),
 		});
 	}
 
 	toPeerId(): Promise<PeerId> {
 		return peerIdFromKeys(
 			new supportedKeys["secp256k1"].Secp256k1PublicKey(
-				this.publicKey.publicKey
+				this.publicKey.publicKey,
 			).bytes,
 			new supportedKeys["secp256k1"].Secp256k1PrivateKey(
 				this.privateKey.privateKey,
-				this.publicKey.publicKey
-			).bytes
+				this.publicKey.publicKey,
+			).bytes,
 		);
 	}
 }
@@ -211,28 +213,28 @@ function getCurve() {
 
 export const recoverPublicKeyFromSignature = (
 	digest: Uint8Array,
-	signature: SignatureLike
+	signature: SignatureLike,
 ): Uint8Array => {
 	const sig = splitSignature(signature);
 	const rs = { r: arrayify(sig.r), s: arrayify(sig.s) };
 	return new Uint8Array(
 		getCurve()
 			.recoverPubKey(arrayify(digest), rs, sig.recoveryParam)
-			.encodeCompressed()
+			.encodeCompressed(),
 	);
 };
 
 export const verifySignatureSecp256k1 = async (
 	signature: SignatureWithKey,
-	data: Uint8Array
+	data: Uint8Array,
 ): Promise<boolean> => {
 	const hashedData = await prehashFn(data, signature.prehash);
 	const signerKey = recoverPublicKeyFromSignature(
 		arrayify(hashedData),
-		decoder.decode(signature.signature)
+		decoder.decode(signature.signature),
 	);
 	return equals(
 		signerKey,
-		(signature.publicKey as Secp256k1PublicKey).publicKey
+		(signature.publicKey as Secp256k1PublicKey).publicKey,
 	);
 };

package/src/signature.ts

@@ -1,18 +1,18 @@
 import {
+	type AbstractType,
 	deserialize,
-	variant,
 	field,
 	option,
 	serialize,
-	AbstractType
+	variant,
 } from "@dao-xyz/borsh";
-import { equals } from "@peerbit/uint8arrays";
+import { compare, equals } from "uint8arrays";
 import { verifySignatureEd25519 } from "./ed25519-sign.js";
 import { Ed25519PublicKey } from "./ed25519.js";
 import { PublicSignKey } from "./key.js";
 import { PreHash } from "./prehash.js";
 import { Secp256k1PublicKey, verifySignatureSecp256k1 } from "./sepc256k1.js";
-import { SignWithKey } from "./signer.js";
+import { type SignWithKey } from "./signer.js";
 
 @variant(0)
 export class SignatureWithKey {
@@ -30,11 +30,9 @@ export class SignatureWithKey {
 		publicKey: PublicSignKey;
 		prehash: PreHash;
 	}) {
-		if (props) {
-			this.signature = props.signature;
-			this.publicKey = props.publicKey;
-			this.prehash = props.prehash;
-		}
+		this.signature = props.signature;
+		this.publicKey = props.publicKey;
+		this.prehash = props.prehash;
 	}
 
 	equals(other: SignatureWithKey): boolean {
@@ -42,8 +40,8 @@ export class SignatureWithKey {
 			return false;
 		}
 		return (
-			Buffer.compare(serialize(this.publicKey), serialize(other.publicKey)) ===
-				0 && this.prehash == other.prehash
+			compare(serialize(this.publicKey), serialize(other.publicKey)) === 0 &&
+			this.prehash === other.prehash
 		);
 	}
 }
@@ -56,16 +54,14 @@ export class MaybeSigned<T> {
 	@field({ type: option(SignatureWithKey) })
 	signature?: SignatureWithKey;
 
-	constructor(props?: {
+	constructor(props: {
 		data: Uint8Array;
 		value?: T;
 		signature?: SignatureWithKey;
 	}) {
-		if (props) {
-			this.data = props.data;
-			this.signature = props.signature;
-			this._value = props.value;
-		}
+		this.data = props.data;
+		this.signature = props.signature;
+		this._value = props.value;
 	}
 
 	_value?: T;
@@ -94,10 +90,9 @@ export class MaybeSigned<T> {
 		return true;
 	}
 
-	/**
-	 * In place
-	 * @param signer
-	 */
+	/*
+	 In place signing
+	*/
 	async sign(signer: SignWithKey): Promise<MaybeSigned<T>> {
 		const signatureResult = await signer(this.data);
 		this.signature = signatureResult;
@@ -113,172 +108,3 @@ export const verify = async (signature: SignatureWithKey, data: Uint8Array) => {
 	}
 	return false;
 };
-
-/* 
-
-@variant(0)
-export class SignatureWithKey {
-	@field({ type: Uint8Array })
-	signature: Uint8Array;
-
-	@field({ type: PublicSignKey })
-	publicKey: PublicSignKey;
-
-	constructor(props?: { signature: Uint8Array; publicKey: PublicSignKey }) {
-		if (props) {
-			this.signature = props.signature;
-			this.publicKey = props.publicKey;
-		}
-	}
-
-	equals(other: SignatureWithKey): boolean {
-		if (!equals(this.signature, other.signature)) {
-			return false;
-		}
-		return (
-			Buffer.compare(
-				serialize(this.publicKey),
-				serialize(other.publicKey)
-			) === 0
-		);
-	}
-}
-
-@variant(0)
-export abstract class MaybeSigned<T> {
-
-	@field({ type: Uint8Array })
-	data: Uint8Array;
-
-	constructor(props: {
-		data: Uint8Array;
-		value?: T;
-	}) {
-		this.data = props.data;
-		this._value = props.value;
-	}
-
-	_value?: T;
-
-	getValue(constructor: AbstractType<T>): T {
-		return deserialize(this.data, constructor);
-	}
-
-	abstract verify(): Promise<boolean>
-
-	equals(other: MaybeSigned<T>): boolean {
-		if (!equals(this.data, other.data)) {
-			return false;
-		}
-		return true;
-	}
-
-}
-
-@variant(0)
-export class Signed<T> extends MaybeSigned<T> {
-
-	@field({ type: option(SignatureWithKey) })
-	signature: SignatureWithKey;
-
-	constructor(props: {
-		data: Uint8Array;
-		value?: T;
-		signature: SignatureWithKey;
-	}) {
-		super(props)
-		this.signature = props.signature;
-
-	}
-
-	async verify(): Promise<boolean> {
-		return verify(
-			this.signature.signature,
-			this.signature.publicKey,
-			this.data
-		);
-	}
-
-	equals(other: MaybeSigned<T>): boolean {
-		if (other instanceof Signed<T>) {
-			if (!this.signature !== !other.signature) {
-				return false;
-			}
-			if (this.signature && other.signature) {
-				return this.signature.equals(other.signature);
-			}
-			return super.equals(other)
-		}
-		else {
-			return false;
-		}
-	}
-
-
-	async sign(signer: SignWithKey): Promise<MaybeSigned<T>> {
-		const signatureResult = await signer(this.data);
-		this.signature = new SignatureWithKey({
-			publicKey: signatureResult.publicKey,
-			signature: signatureResult.signature,
-		});
-		return this;
-	}
-}
-
-
-@variant(0)
-export class Unsigned<T> extends MaybeSigned<T> {
-
-
-	constructor(props: {
-		data: Uint8Array;
-		value?: T;
-	}) {
-		super(props)
-	}
-
-	equals(other: MaybeSigned<T>): boolean {
-		if (other instanceof Unsigned) {
-			return super.equals(other)
-		}
-		else {
-			return false;
-		}
-	}
-
-   
-	async sign(signer: SignWithKey): Promise<Signed<T>> {
-		const signatureResult = await signer(this.data);
-		return new Signed({
-			data: this.data,
-			signature: new SignatureWithKey({
-				publicKey: signatureResult.publicKey,
-				signature: signatureResult.signature,
-			}),
-			value: this._value
-		});
-	}
-
-	async verify(): Promise<boolean> {
-		return true;
-	}
-}
-
-
-export const verify = (
-	signature: Uint8Array,
-	publicKey: PublicSignKey,
-	data: Uint8Array
-) => {
-	if (!signature) {
-		return true;
-	}
-	if (publicKey instanceof Ed25519PublicKey) {
-		return verifySignatureEd25519(signature, publicKey, data);
-	} else if (publicKey instanceof Secp256k1PublicKey) {
-		return verifySignatureSecp256k1(signature, publicKey, data);
-	}
-	return false;
-};
-
-*/

package/src/signer.ts

@@ -1,16 +1,16 @@
-import { PublicSignKey } from "./key.js";
-import { PreHash } from "./prehash.js";
-import { SignatureWithKey } from "./signature.js";
+import type { PublicSignKey } from "./key.js";
+import type { PreHash } from "./prehash.js";
+import type { SignatureWithKey } from "./signature.js";
 
 export interface Signer {
 	sign: (
 		bytes: Uint8Array,
-		prehash?: PreHash
+		prehash?: PreHash,
 	) => Promise<SignatureWithKey> | SignatureWithKey;
 }
 
 export type SignWithKey = (
-	bytes: Uint8Array
+	bytes: Uint8Array,
 ) => Promise<SignatureWithKey> | SignatureWithKey;
 
 export type Identity<T extends PublicSignKey = PublicSignKey> = Signer & {

package/src/utils.ts

@@ -1,4 +1,6 @@
 import sodium from "libsodium-wrappers";
+import { base58btc } from "multiformats/bases/base58";
+
 export const fromHexString = (hexString: string) => sodium.from_hex(hexString);
 
 export const toHexString = (bytes: Uint8Array) => sodium.to_hex(bytes);
@@ -16,3 +18,7 @@ export const toBase64URL = (arr: Uint8Array) => {
 export const fromBase64URL = (base64: string) => {
 	return sodium.from_base64(base64, sodium.base64_variants.URLSAFE);
 };
+
+export const toBase58 = (arr: Uint8Array) => {
+	return base58btc.baseEncode(arr);
+};

package/src/x25519.ts

@@ -1,19 +1,17 @@
-export * from "./errors.js";
 import { field, fixedArray, variant } from "@dao-xyz/borsh";
-import { compare } from "@peerbit/uint8arrays";
+import { type PeerId } from "@libp2p/interface";
 import sodium from "libsodium-wrappers";
+import { compare } from "uint8arrays";
+import { Ed25519Keypair, Ed25519PublicKey } from "./ed25519.js";
 import {
 	Keypair,
 	PrivateEncryptionKey,
-	PublicKeyEncryptionKey
+	PublicKeyEncryptionKey,
 } from "./key.js";
-import {
-	Ed25519Keypair,
-	Ed25519PublicKey,
-	Ed25519PrivateKey
-} from "./ed25519.js";
 import { toHexString } from "./utils.js";
-import { PeerId } from "@libp2p/interface";
+
+export * from "./errors.js";
+
 @variant(0)
 export class X25519PublicKey extends PublicKeyEncryptionKey {
 	@field({ type: fixedArray("u8", 32) })
@@ -33,31 +31,32 @@ export class X25519PublicKey extends PublicKeyEncryptionKey {
 		}
 		return false;
 	}
+
 	toString(): string {
 		return "x25519p/" + toHexString(this.publicKey);
 	}
 
 	static async from(
-		ed25119PublicKey: Ed25519PublicKey
+		ed25119PublicKey: Ed25519PublicKey,
 	): Promise<X25519PublicKey> {
 		await sodium.ready;
 		return new X25519PublicKey({
 			publicKey: sodium.crypto_sign_ed25519_pk_to_curve25519(
-				ed25119PublicKey.publicKey
-			)
+				ed25119PublicKey.publicKey,
+			),
 		});
 	}
 
 	static async fromPeerId(peerId: PeerId): Promise<X25519PublicKey> {
 		await sodium.ready;
-		const ed = await Ed25519PublicKey.fromPeerId(peerId);
+		const ed = Ed25519PublicKey.fromPeerId(peerId);
 		return X25519PublicKey.from(ed);
 	}
 
 	static async create(): Promise<X25519PublicKey> {
 		await sodium.ready;
 		return new X25519PublicKey({
-			publicKey: sodium.crypto_box_keypair().publicKey
+			publicKey: sodium.crypto_box_keypair().publicKey,
 		});
 	}
 }
@@ -77,34 +76,34 @@ export class X25519SecretKey extends PrivateEncryptionKey {
 
 	equals(other: PublicKeyEncryptionKey): boolean {
 		if (other instanceof X25519SecretKey) {
-			return (
-				compare(this.secretKey, (other as X25519SecretKey).secretKey) === 0
-			);
+			return compare(this.secretKey, other.secretKey) === 0;
 		}
 		return false;
 	}
+
 	toString(): string {
 		return "x25519s" + toHexString(this.secretKey);
 	}
 
 	async publicKey(): Promise<X25519PublicKey> {
 		return new X25519PublicKey({
-			publicKey: sodium.crypto_scalarmult_base(this.secretKey)
+			publicKey: sodium.crypto_scalarmult_base(this.secretKey),
 		});
 	}
+
 	static async from(ed25119Keypair: Ed25519Keypair): Promise<X25519SecretKey> {
 		await sodium.ready;
 		return new X25519SecretKey({
 			secretKey: sodium.crypto_sign_ed25519_sk_to_curve25519(
-				ed25119Keypair.privateKeyPublicKey
-			)
+				ed25119Keypair.privateKeyPublicKey,
+			),
 		});
 	}
 
 	static async create(): Promise<X25519SecretKey> {
 		await sodium.ready;
 		return new X25519SecretKey({
-			secretKey: sodium.crypto_box_keypair().privateKey
+			secretKey: sodium.crypto_box_keypair().privateKey,
 		});
 	}
 }
@@ -131,11 +130,11 @@ export class X25519Keypair extends Keypair {
 		const generated = sodium.crypto_box_keypair();
 		const kp = new X25519Keypair({
 			publicKey: new X25519PublicKey({
-				publicKey: generated.publicKey
+				publicKey: generated.publicKey,
 			}),
 			secretKey: new X25519SecretKey({
-				secretKey: generated.privateKey
-			})
+				secretKey: generated.privateKey,
+			}),
 		});
 
 		return kp;
@@ -144,7 +143,7 @@ export class X25519Keypair extends Keypair {
 	static async from(ed25119Keypair: Ed25519Keypair): Promise<X25519Keypair> {
 		const kp = new X25519Keypair({
 			publicKey: await X25519PublicKey.from(ed25119Keypair.publicKey),
-			secretKey: await X25519SecretKey.from(ed25119Keypair)
+			secretKey: await X25519SecretKey.from(ed25119Keypair),
 		});
 		return kp;
 	}
@@ -153,13 +152,12 @@ export class X25519Keypair extends Keypair {
 		const ed = Ed25519Keypair.fromPeerId(peerId);
 		return X25519Keypair.from(ed);
 	}
+
 	equals(other: Keypair) {
 		if (other instanceof X25519Keypair) {
 			return (
 				this.publicKey.equals(other.publicKey) &&
-				this.secretKey.equals(
-					(other as X25519Keypair).secretKey as X25519SecretKey as any
-				)
+				this.secretKey.equals(other.secretKey)
 			);
 		}
 		return false;