@waku/enr 0.0.27-f599932.0 → 0.0.28-b6339f7.0

package/src/decoder.ts

@@ -37,7 +37,7 @@ async function fromValues(values: Uint8Array[]): Promise<ENR> {
   }
   const _seq = decodeSeq(seq);
 
-  const enr = await ENR.create(obj, _seq, signature);
+  const enr = ENR.create(obj, _seq, signature);
   checkSignature(seq, kvs, enr, signature);
   return enr;
 }

package/src/enr.ts

@@ -34,16 +34,16 @@ export class ENR extends RawEnr implements IEnr {
   public static readonly RECORD_PREFIX = "enr:";
   public peerId?: PeerId;
 
-  public static async create(
+  public static create(
     kvs: Record<ENRKey, ENRValue> = {},
     seq: SequenceNumber = BigInt(1),
     signature?: Uint8Array
-  ): Promise<ENR> {
+  ): ENR {
     const enr = new ENR(kvs, seq, signature);
     try {
       const publicKey = enr.publicKey;
       if (publicKey) {
-        enr.peerId = await createPeerIdFromPublicKey(publicKey);
+        enr.peerId = createPeerIdFromPublicKey(publicKey);
       }
     } catch (e) {
       log.error("Could not calculate peer id for ENR", e);

package/src/peer_id.ts

@@ -1,38 +1,13 @@
-import { unmarshalPrivateKey, unmarshalPublicKey } from "@libp2p/crypto/keys";
-import { supportedKeys } from "@libp2p/crypto/keys";
-import type { PeerId } from "@libp2p/interface";
-import { peerIdFromKeys } from "@libp2p/peer-id";
+import { publicKeyFromRaw } from "@libp2p/crypto/keys";
+import { type PeerId } from "@libp2p/interface";
+import { peerIdFromPublicKey } from "@libp2p/peer-id";
 
-export function createPeerIdFromPublicKey(
-  publicKey: Uint8Array
-): Promise<PeerId> {
-  const _publicKey = new supportedKeys.secp256k1.Secp256k1PublicKey(publicKey);
-  return peerIdFromKeys(_publicKey.bytes, undefined);
-}
-
-export function getPublicKeyFromPeerId(peerId: PeerId): Uint8Array {
-  if (peerId.type !== "secp256k1") {
-    throw new Error("Unsupported peer id type");
-  }
+export const ERR_TYPE_NOT_IMPLEMENTED = "Keypair type not implemented";
 
-  if (!peerId.publicKey) {
-    throw new Error("Public key not present on peer id");
+export function createPeerIdFromPublicKey(publicKey: Uint8Array): PeerId {
+  const pubKey = publicKeyFromRaw(publicKey);
+  if (pubKey.type !== "secp256k1") {
+    throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
   }
-
-  return unmarshalPublicKey(peerId.publicKey).marshal();
-}
-
-// Only used in tests
-export async function getPrivateKeyFromPeerId(
-  peerId: PeerId
-): Promise<Uint8Array> {
-  if (peerId.type !== "secp256k1") {
-    throw new Error("Unsupported peer id type");
-  }
-  if (!peerId.privateKey) {
-    throw new Error("Private key not present on peer id");
-  }
-
-  const privateKey = await unmarshalPrivateKey(peerId.privateKey);
-  return privateKey.marshal();
+  return peerIdFromPublicKey(pubKey);
 }