@libp2p/crypto 2.0.8-6b6ba9ab7 → 2.0.8-74e84bc29

package/src/keys/secp256k1-class.ts

@@ -2,10 +2,12 @@ import { CodeError } from '@libp2p/interface/errors'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { isPromise } from '../util.js'
 import { exporter } from './exporter.js'
 import * as keysProtobuf from './keys.js'
 import * as crypto from './secp256k1.js'
 import type { Multibase } from 'multiformats'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export class Secp256k1PublicKey {
   private readonly _key: Uint8Array
@@ -15,7 +17,7 @@ export class Secp256k1PublicKey {
     this._key = key
   }
 
-  async verify (data: Uint8Array, sig: Uint8Array): Promise<boolean> {
+  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean {
     return crypto.hashAndVerify(this._key, sig, data)
   }
 
@@ -35,7 +37,14 @@ export class Secp256k1PublicKey {
   }
 
   async hash (): Promise<Uint8Array> {
-    const { bytes } = await sha256.digest(this.bytes)
+    const p = sha256.digest(this.bytes)
+    let bytes: Uint8Array
+
+    if (isPromise(p)) {
+      ({ bytes } = await p)
+    } else {
+      bytes = p.bytes
+    }
 
     return bytes
   }
@@ -52,7 +61,7 @@ export class Secp256k1PrivateKey {
     crypto.validatePublicKey(this._publicKey)
   }
 
-  async sign (message: Uint8Array): Promise<Uint8Array> {
+  sign (message: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array> {
     return crypto.hashAndSign(this._key, message)
   }
 
@@ -75,10 +84,14 @@ export class Secp256k1PrivateKey {
     return uint8ArrayEquals(this.bytes, key.bytes)
   }
 
-  async hash (): Promise<Uint8Array> {
-    const { bytes } = await sha256.digest(this.bytes)
+  hash (): Uint8Array | Promise<Uint8Array> {
+    const p = sha256.digest(this.bytes)
 
-    return bytes
+    if (isPromise(p)) {
+      return p.then(({ bytes }) => bytes)
+    }
+
+    return p.bytes
   }
 
   /**

package/src/keys/secp256k1.ts

@@ -1,6 +1,7 @@
+import crypto from 'node:crypto'
 import { CodeError } from '@libp2p/interface/errors'
 import { secp256k1 as secp } from '@noble/curves/secp256k1'
-import { sha256 } from 'multiformats/hashes/sha2'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PRIVATE_KEY_BYTE_LENGTH = 32
 
@@ -13,8 +14,19 @@ export function generateKey (): Uint8Array {
 /**
  * Hash and sign message with private key
  */
-export async function hashAndSign (key: Uint8Array, msg: Uint8Array): Promise<Uint8Array> {
-  const { digest } = await sha256.digest(msg)
+export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList): Uint8Array {
+  const hash = crypto.createHash('sha256')
+
+  if (msg instanceof Uint8Array) {
+    hash.update(msg)
+  } else {
+    for (const buf of msg) {
+      hash.update(buf)
+    }
+  }
+
+  const digest = hash.digest()
+
   try {
     const signature = secp.sign(digest, key)
     return signature.toDERRawBytes()
@@ -26,9 +38,20 @@ export async function hashAndSign (key: Uint8Array, msg: Uint8Array): Promise<Ui
 /**
  * Hash message and verify signature with public key
  */
-export async function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array): Promise<boolean> {
+export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): boolean {
+  const hash = crypto.createHash('sha256')
+
+  if (msg instanceof Uint8Array) {
+    hash.update(msg)
+  } else {
+    for (const buf of msg) {
+      hash.update(buf)
+    }
+  }
+
+  const digest = hash.digest()
+
   try {
-    const { digest } = await sha256.digest(msg)
     return secp.verify(sig, digest, key)
   } catch (err) {
     throw new CodeError(String(err), 'ERR_INVALID_INPUT')

package/src/util.ts

@@ -40,3 +40,13 @@ export function base64urlToBuffer (str: string, len?: number): Uint8Array {
 
   return buf
 }
+
+export function isPromise <T = unknown> (thing: any): thing is Promise<T> {
+  if (thing == null) {
+    return false
+  }
+
+  return typeof thing.then === 'function' &&
+    typeof thing.catch === 'function' &&
+    typeof thing.finally === 'function'
+}