@waku/enr 0.0.4 → 0.0.6

package/src/raw_enr.ts

@@ -0,0 +1,204 @@
+import type { Multiaddr } from "@multiformats/multiaddr";
+import {
+  convertToBytes,
+  convertToString,
+} from "@multiformats/multiaddr/convert";
+import type { ENRKey, ENRValue, SequenceNumber, Waku2 } from "@waku/interfaces";
+import { bytesToUtf8 } from "@waku/utils/bytes";
+
+import { ERR_INVALID_ID } from "./constants.js";
+import { decodeMultiaddrs, encodeMultiaddrs } from "./multiaddrs_codec.js";
+import { decodeWaku2, encodeWaku2 } from "./waku2_codec.js";
+
+export class RawEnr extends Map<ENRKey, ENRValue> {
+  public seq: SequenceNumber;
+  public signature?: Uint8Array;
+
+  protected constructor(
+    kvs: Record<ENRKey, ENRValue> = {},
+    seq: SequenceNumber = BigInt(1),
+    signature?: Uint8Array
+  ) {
+    super(Object.entries(kvs));
+    this.seq = seq;
+    this.signature = signature;
+  }
+
+  set(k: ENRKey, v: ENRValue): this {
+    this.signature = undefined;
+    this.seq++;
+    return super.set(k, v);
+  }
+
+  get id(): string {
+    const id = this.get("id");
+    if (!id) throw new Error("id not found.");
+    return bytesToUtf8(id);
+  }
+
+  get publicKey(): Uint8Array | undefined {
+    switch (this.id) {
+      case "v4":
+        return this.get("secp256k1");
+      default:
+        throw new Error(ERR_INVALID_ID);
+    }
+  }
+
+  get ip(): string | undefined {
+    return getStringValue(this, "ip", "ip4");
+  }
+
+  set ip(ip: string | undefined) {
+    setStringValue(this, "ip", "ip4", ip);
+  }
+
+  get tcp(): number | undefined {
+    return getNumberAsStringValue(this, "tcp", "tcp");
+  }
+
+  set tcp(port: number | undefined) {
+    setNumberAsStringValue(this, "tcp", "tcp", port);
+  }
+
+  get udp(): number | undefined {
+    return getNumberAsStringValue(this, "udp", "udp");
+  }
+
+  set udp(port: number | undefined) {
+    setNumberAsStringValue(this, "udp", "udp", port);
+  }
+
+  get ip6(): string | undefined {
+    return getStringValue(this, "ip6", "ip6");
+  }
+
+  set ip6(ip: string | undefined) {
+    setStringValue(this, "ip6", "ip6", ip);
+  }
+
+  get tcp6(): number | undefined {
+    return getNumberAsStringValue(this, "tcp6", "tcp");
+  }
+
+  set tcp6(port: number | undefined) {
+    setNumberAsStringValue(this, "tcp6", "tcp", port);
+  }
+
+  get udp6(): number | undefined {
+    return getNumberAsStringValue(this, "udp6", "udp");
+  }
+
+  set udp6(port: number | undefined) {
+    setNumberAsStringValue(this, "udp6", "udp", port);
+  }
+
+  /**
+   * Get the `multiaddrs` field from ENR.
+   *
+   * This field is used to store multiaddresses that cannot be stored with the current ENR pre-defined keys.
+   * These can be a multiaddresses that include encapsulation (e.g. wss) or do not use `ip4` nor `ip6` for the host
+   * address (e.g. `dns4`, `dnsaddr`, etc)..
+   *
+   * If the peer information only contains information that can be represented with the ENR pre-defined keys
+   * (ip, tcp, etc) then the usage of { @link ENR.getLocationMultiaddr } should be preferred.
+   *
+   * The multiaddresses stored in this field are expected to be location multiaddresses, ie, peer id less.
+   */
+  get multiaddrs(): Multiaddr[] | undefined {
+    const raw = this.get("multiaddrs");
+
+    if (raw) return decodeMultiaddrs(raw);
+
+    return;
+  }
+
+  /**
+   * Set the `multiaddrs` field on the ENR.
+   *
+   * This field is used to store multiaddresses that cannot be stored with the current ENR pre-defined keys.
+   * These can be a multiaddresses that include encapsulation (e.g. wss) or do not use `ip4` nor `ip6` for the host
+   * address (e.g. `dns4`, `dnsaddr`, etc)..
+   *
+   * If the peer information only contains information that can be represented with the ENR pre-defined keys
+   * (ip, tcp, etc) then the usage of { @link ENR.setLocationMultiaddr } should be preferred.
+   * The multiaddresses stored in this field must be location multiaddresses,
+   * ie, without a peer id.
+   */
+  set multiaddrs(multiaddrs: Multiaddr[] | undefined) {
+    deleteUndefined(this, "multiaddrs", multiaddrs, encodeMultiaddrs);
+  }
+
+  /**
+   * Get the `waku2` field from ENR.
+   */
+  get waku2(): Waku2 | undefined {
+    const raw = this.get("waku2");
+    if (raw) return decodeWaku2(raw[0]);
+
+    return;
+  }
+
+  /**
+   * Set the `waku2` field on the ENR.
+   */
+  set waku2(waku2: Waku2 | undefined) {
+    deleteUndefined(
+      this,
+      "waku2",
+      waku2,
+      (w) => new Uint8Array([encodeWaku2(w)])
+    );
+  }
+}
+
+function getStringValue(
+  map: Map<ENRKey, ENRValue>,
+  key: ENRKey,
+  proto: string
+): string | undefined {
+  const raw = map.get(key);
+  if (!raw) return;
+  return convertToString(proto, raw);
+}
+
+function getNumberAsStringValue(
+  map: Map<ENRKey, ENRValue>,
+  key: ENRKey,
+  proto: string
+): number | undefined {
+  const raw = map.get(key);
+  if (!raw) return;
+  return Number(convertToString(proto, raw));
+}
+
+function setStringValue(
+  map: Map<ENRKey, ENRValue>,
+  key: ENRKey,
+  proto: string,
+  value: string | undefined
+): void {
+  deleteUndefined(map, key, value, convertToBytes.bind({}, proto));
+}
+
+function setNumberAsStringValue(
+  map: Map<ENRKey, ENRValue>,
+  key: ENRKey,
+  proto: string,
+  value: number | undefined
+): void {
+  setStringValue(map, key, proto, value?.toString(10));
+}
+
+function deleteUndefined<K, V, W>(
+  map: Map<K, W>,
+  key: K,
+  value: V | undefined,
+  transform: (v: V) => W
+): void {
+  if (value !== undefined) {
+    map.set(key, transform(value));
+  } else {
+    map.delete(key);
+  }
+}

package/src/v4.ts

@@ -1,9 +1,8 @@
 import * as secp from "@noble/secp256k1";
-import { bytesToHex } from "@waku/byte-utils";
 import type { NodeId } from "@waku/interfaces";
+import { bytesToHex } from "@waku/utils/bytes";
 
 import { keccak256 } from "./crypto.js";
-
 export async function sign(
   privKey: Uint8Array,
   msg: Uint8Array

package/dist/keypair/index.d.ts

@@ -1,8 +0,0 @@
-import type { PeerId } from "@libp2p/interface-peer-id";
-import { IKeypair, KeypairType } from "./types.js";
-export declare const ERR_TYPE_NOT_IMPLEMENTED = "Keypair type not implemented";
-export * from "./types.js";
-export * from "./secp256k1.js";
-export declare function createKeypair(type: KeypairType, privateKey?: Uint8Array, publicKey?: Uint8Array): IKeypair;
-export declare function createPeerIdFromKeypair(keypair: IKeypair): Promise<PeerId>;
-export declare function createKeypairFromPeerId(peerId: PeerId): Promise<IKeypair>;

package/dist/keypair/index.js

@@ -1,53 +0,0 @@
-import { unmarshalPrivateKey, unmarshalPublicKey } from "@libp2p/crypto/keys";
-import { supportedKeys } from "@libp2p/crypto/keys";
-import { peerIdFromKeys } from "@libp2p/peer-id";
-import { Secp256k1Keypair } from "./secp256k1.js";
-import { KeypairType } from "./types.js";
-export const ERR_TYPE_NOT_IMPLEMENTED = "Keypair type not implemented";
-export * from "./types.js";
-export * from "./secp256k1.js";
-export function createKeypair(type, privateKey, publicKey) {
-    switch (type) {
-        case KeypairType.secp256k1:
-            return new Secp256k1Keypair(privateKey, publicKey);
-        default:
-            throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
-    }
-}
-export async function createPeerIdFromKeypair(keypair) {
-    switch (keypair.type) {
-        case KeypairType.secp256k1: {
-            const publicKey = new supportedKeys.secp256k1.Secp256k1PublicKey(keypair.publicKey);
-            const privateKey = keypair.hasPrivateKey()
-                ? new supportedKeys.secp256k1.Secp256k1PrivateKey(keypair.privateKey)
-                : undefined;
-            return peerIdFromKeys(publicKey.bytes, privateKey?.bytes);
-        }
-        default:
-            throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
-    }
-}
-export async function createKeypairFromPeerId(peerId) {
-    let keypairType;
-    switch (peerId.type) {
-        case "RSA":
-            keypairType = KeypairType.rsa;
-            break;
-        case "Ed25519":
-            keypairType = KeypairType.ed25519;
-            break;
-        case "secp256k1":
-            keypairType = KeypairType.secp256k1;
-            break;
-        default:
-            throw new Error("Unsupported peer id type");
-    }
-    const publicKey = peerId.publicKey
-        ? unmarshalPublicKey(peerId.publicKey)
-        : undefined;
-    const privateKey = peerId.privateKey
-        ? await unmarshalPrivateKey(peerId.privateKey)
-        : undefined;
-    return createKeypair(keypairType, privateKey?.marshal(), publicKey?.marshal());
-}
-//# sourceMappingURL=index.js.map

package/dist/keypair/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keypair/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAY,WAAW,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,CAAC,MAAM,wBAAwB,GAAG,8BAA8B,CAAC;AACvE,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAE/B,MAAM,UAAU,aAAa,CAC3B,IAAiB,EACjB,UAAuB,EACvB,SAAsB;IAEtB,QAAQ,IAAI,EAAE;QACZ,KAAK,WAAW,CAAC,SAAS;YACxB,OAAO,IAAI,gBAAgB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACrD;YACE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;KAC7C;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,OAAiB;IAEjB,QAAQ,OAAO,CAAC,IAAI,EAAE;QACpB,KAAK,WAAW,CAAC,SAAS,CAAC,CAAC;YAC1B,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,kBAAkB,CAC9D,OAAO,CAAC,SAAS,CAClB,CAAC;YAEF,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,EAAE;gBACxC,CAAC,CAAC,IAAI,aAAa,CAAC,SAAS,CAAC,mBAAmB,CAAC,OAAO,CAAC,UAAU,CAAC;gBACrE,CAAC,CAAC,SAAS,CAAC;YAEd,OAAO,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;SAC3D;QACD;YACE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;KAC7C;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,MAAc;IAEd,IAAI,WAAW,CAAC;IAChB,QAAQ,MAAM,CAAC,IAAI,EAAE;QACnB,KAAK,KAAK;YACR,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC;YAC9B,MAAM;QACR,KAAK,SAAS;YACZ,WAAW,GAAG,WAAW,CAAC,OAAO,CAAC;YAClC,MAAM;QACR,KAAK,WAAW;YACd,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC;YACpC,MAAM;QACR;YACE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;KAC/C;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS;QAChC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC;QACtC,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU;QAClC,CAAC,CAAC,MAAM,mBAAmB,CAAC,MAAM,CAAC,UAAU,CAAC;QAC9C,CAAC,CAAC,SAAS,CAAC;IAEd,OAAO,aAAa,CAClB,WAAW,EACX,UAAU,EAAE,OAAO,EAAE,EACrB,SAAS,EAAE,OAAO,EAAE,CACrB,CAAC;AACJ,CAAC"}

package/dist/keypair/secp256k1.d.ts

@@ -1,13 +0,0 @@
-import { IKeypair, KeypairType } from "./types.js";
-export declare class Secp256k1Keypair implements IKeypair {
-    readonly type: KeypairType;
-    _privateKey?: Uint8Array;
-    readonly _publicKey?: Uint8Array;
-    constructor(privateKey?: Uint8Array, publicKey?: Uint8Array);
-    static generate(): Promise<Secp256k1Keypair>;
-    privateKeyVerify(key?: Uint8Array | undefined): boolean;
-    publicKeyVerify(key?: Uint8Array | undefined): boolean;
-    get privateKey(): Uint8Array;
-    get publicKey(): Uint8Array;
-    hasPrivateKey(): boolean;
-}

package/dist/keypair/secp256k1.js

@@ -1,57 +0,0 @@
-import * as secp from "@noble/secp256k1";
-import { compressPublicKey, randomBytes } from "../crypto.js";
-import { KeypairType } from "./types.js";
-export class Secp256k1Keypair {
-    constructor(privateKey, publicKey) {
-        let pub = publicKey;
-        if (pub) {
-            pub = compressPublicKey(pub);
-        }
-        if ((this._privateKey = privateKey) && !this.privateKeyVerify()) {
-            throw new Error("Invalid private key");
-        }
-        if ((this._publicKey = pub) && !this.publicKeyVerify()) {
-            throw new Error("Invalid public key");
-        }
-        this.type = KeypairType.secp256k1;
-    }
-    static async generate() {
-        const privateKey = randomBytes(32);
-        const publicKey = secp.getPublicKey(privateKey);
-        return new Secp256k1Keypair(privateKey, publicKey);
-    }
-    privateKeyVerify(key = this._privateKey) {
-        if (key) {
-            return secp.utils.isValidPrivateKey(key);
-        }
-        return true;
-    }
-    publicKeyVerify(key = this._publicKey) {
-        if (key) {
-            try {
-                secp.Point.fromHex(key);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        return true;
-    }
-    get privateKey() {
-        if (!this._privateKey) {
-            throw new Error();
-        }
-        return this._privateKey;
-    }
-    get publicKey() {
-        if (!this._publicKey) {
-            throw new Error();
-        }
-        return this._publicKey;
-    }
-    hasPrivateKey() {
-        return !!this._privateKey;
-    }
-}
-//# sourceMappingURL=secp256k1.js.map

package/dist/keypair/secp256k1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["../../src/keypair/secp256k1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE9D,OAAO,EAAY,WAAW,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,OAAO,gBAAgB;IAK3B,YAAY,UAAuB,EAAE,SAAsB;QACzD,IAAI,GAAG,GAAG,SAAS,CAAC;QACpB,IAAI,GAAG,EAAE;YACP,GAAG,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;SAC9B;QACD,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE;YAC/D,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SACxC;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE;YACtD,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;SACvC;QAED,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,SAAS,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,QAAQ;QACnB,MAAM,UAAU,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QACnC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAChD,OAAO,IAAI,gBAAgB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACrD,CAAC;IAED,gBAAgB,CAAC,GAAG,GAAG,IAAI,CAAC,WAAW;QACrC,IAAI,GAAG,EAAE;YACP,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;SAC1C;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,eAAe,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU;QACnC,IAAI,GAAG,EAAE;YACP,IAAI;gBACF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACxB,OAAO,IAAI,CAAC;aACb;YAAC,MAAM;gBACN,OAAO,KAAK,CAAC;aACd;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,UAAU;QACZ,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,MAAM,IAAI,KAAK,EAAE,CAAC;SACnB;QACD,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,IAAI,SAAS;QACX,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,MAAM,IAAI,KAAK,EAAE,CAAC;SACnB;QACD,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,aAAa;QACX,OAAO,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;CACF"}

package/dist/keypair/types.d.ts

@@ -1,13 +0,0 @@
-export declare enum KeypairType {
-    rsa = 0,
-    ed25519 = 1,
-    secp256k1 = 2
-}
-export interface IKeypair {
-    type: KeypairType;
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
-    privateKeyVerify(): boolean;
-    publicKeyVerify(): boolean;
-    hasPrivateKey(): boolean;
-}

package/dist/keypair/types.js

@@ -1,7 +0,0 @@
-export var KeypairType;
-(function (KeypairType) {
-    KeypairType[KeypairType["rsa"] = 0] = "rsa";
-    KeypairType[KeypairType["ed25519"] = 1] = "ed25519";
-    KeypairType[KeypairType["secp256k1"] = 2] = "secp256k1";
-})(KeypairType || (KeypairType = {}));
-//# sourceMappingURL=types.js.map

package/dist/keypair/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/keypair/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,2CAAO,CAAA;IACP,mDAAW,CAAA;IACX,uDAAa,CAAA;AACf,CAAC,EAJW,WAAW,KAAX,WAAW,QAItB"}

package/src/keypair/index.ts

@@ -1,76 +0,0 @@
-import { unmarshalPrivateKey, unmarshalPublicKey } from "@libp2p/crypto/keys";
-import { supportedKeys } from "@libp2p/crypto/keys";
-import type { PeerId } from "@libp2p/interface-peer-id";
-import { peerIdFromKeys } from "@libp2p/peer-id";
-
-import { Secp256k1Keypair } from "./secp256k1.js";
-import { IKeypair, KeypairType } from "./types.js";
-
-export const ERR_TYPE_NOT_IMPLEMENTED = "Keypair type not implemented";
-export * from "./types.js";
-export * from "./secp256k1.js";
-
-export function createKeypair(
-  type: KeypairType,
-  privateKey?: Uint8Array,
-  publicKey?: Uint8Array
-): IKeypair {
-  switch (type) {
-    case KeypairType.secp256k1:
-      return new Secp256k1Keypair(privateKey, publicKey);
-    default:
-      throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
-  }
-}
-
-export async function createPeerIdFromKeypair(
-  keypair: IKeypair
-): Promise<PeerId> {
-  switch (keypair.type) {
-    case KeypairType.secp256k1: {
-      const publicKey = new supportedKeys.secp256k1.Secp256k1PublicKey(
-        keypair.publicKey
-      );
-
-      const privateKey = keypair.hasPrivateKey()
-        ? new supportedKeys.secp256k1.Secp256k1PrivateKey(keypair.privateKey)
-        : undefined;
-
-      return peerIdFromKeys(publicKey.bytes, privateKey?.bytes);
-    }
-    default:
-      throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
-  }
-}
-
-export async function createKeypairFromPeerId(
-  peerId: PeerId
-): Promise<IKeypair> {
-  let keypairType;
-  switch (peerId.type) {
-    case "RSA":
-      keypairType = KeypairType.rsa;
-      break;
-    case "Ed25519":
-      keypairType = KeypairType.ed25519;
-      break;
-    case "secp256k1":
-      keypairType = KeypairType.secp256k1;
-      break;
-    default:
-      throw new Error("Unsupported peer id type");
-  }
-
-  const publicKey = peerId.publicKey
-    ? unmarshalPublicKey(peerId.publicKey)
-    : undefined;
-  const privateKey = peerId.privateKey
-    ? await unmarshalPrivateKey(peerId.privateKey)
-    : undefined;
-
-  return createKeypair(
-    keypairType,
-    privateKey?.marshal(),
-    publicKey?.marshal()
-  );
-}

package/src/keypair/secp256k1.ts

@@ -1,69 +0,0 @@
-import * as secp from "@noble/secp256k1";
-
-import { compressPublicKey, randomBytes } from "../crypto.js";
-
-import { IKeypair, KeypairType } from "./types.js";
-
-export class Secp256k1Keypair implements IKeypair {
-  readonly type: KeypairType;
-  _privateKey?: Uint8Array;
-  readonly _publicKey?: Uint8Array;
-
-  constructor(privateKey?: Uint8Array, publicKey?: Uint8Array) {
-    let pub = publicKey;
-    if (pub) {
-      pub = compressPublicKey(pub);
-    }
-    if ((this._privateKey = privateKey) && !this.privateKeyVerify()) {
-      throw new Error("Invalid private key");
-    }
-    if ((this._publicKey = pub) && !this.publicKeyVerify()) {
-      throw new Error("Invalid public key");
-    }
-
-    this.type = KeypairType.secp256k1;
-  }
-
-  static async generate(): Promise<Secp256k1Keypair> {
-    const privateKey = randomBytes(32);
-    const publicKey = secp.getPublicKey(privateKey);
-    return new Secp256k1Keypair(privateKey, publicKey);
-  }
-
-  privateKeyVerify(key = this._privateKey): boolean {
-    if (key) {
-      return secp.utils.isValidPrivateKey(key);
-    }
-    return true;
-  }
-
-  publicKeyVerify(key = this._publicKey): boolean {
-    if (key) {
-      try {
-        secp.Point.fromHex(key);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  get privateKey(): Uint8Array {
-    if (!this._privateKey) {
-      throw new Error();
-    }
-    return this._privateKey;
-  }
-
-  get publicKey(): Uint8Array {
-    if (!this._publicKey) {
-      throw new Error();
-    }
-    return this._publicKey;
-  }
-
-  hasPrivateKey(): boolean {
-    return !!this._privateKey;
-  }
-}

package/src/keypair/types.ts

@@ -1,14 +0,0 @@
-export enum KeypairType {
-  rsa = 0,
-  ed25519 = 1,
-  secp256k1 = 2,
-}
-
-export interface IKeypair {
-  type: KeypairType;
-  privateKey: Uint8Array;
-  publicKey: Uint8Array;
-  privateKeyVerify(): boolean;
-  publicKeyVerify(): boolean;
-  hasPrivateKey(): boolean;
-}