@atproto/crypto 0.1.1 → 0.2.1

package/dist/multibase.d.ts

@@ -1 +1,3 @@
+import { SupportedEncodings } from 'uint8arrays/to-string';
 export declare const multibaseToBytes: (mb: string) => Uint8Array;
+export declare const bytesToMultibase: (mb: Uint8Array, encoding: SupportedEncodings) => string;

package/dist/p256/keypair.d.ts

@@ -1,20 +1,20 @@
 import { SupportedEncodings } from 'uint8arrays/util/bases';
 import { Keypair } from '../types';
-export declare type EcdsaKeypairOptions = {
+export declare type P256KeypairOptions = {
     exportable: boolean;
 };
-export declare class EcdsaKeypair implements Keypair {
+export declare class P256Keypair implements Keypair {
+    private privateKey;
+    private exportable;
     jwtAlg: string;
     private publicKey;
-    private keypair;
-    private exportable;
-    constructor(keypair: CryptoKeyPair, publicKey: Uint8Array, exportable: boolean);
-    static create(opts?: Partial<EcdsaKeypairOptions>): Promise<EcdsaKeypair>;
-    static import(jwk: JsonWebKey, opts?: Partial<EcdsaKeypairOptions>): Promise<EcdsaKeypair>;
+    constructor(privateKey: Uint8Array, exportable: boolean);
+    static create(opts?: Partial<P256KeypairOptions>): Promise<P256Keypair>;
+    static import(privKey: Uint8Array | string, opts?: Partial<P256KeypairOptions>): Promise<P256Keypair>;
     publicKeyBytes(): Uint8Array;
     publicKeyStr(encoding?: SupportedEncodings): string;
     did(): string;
     sign(msg: Uint8Array): Promise<Uint8Array>;
-    export(): Promise<JsonWebKey>;
+    export(): Promise<Uint8Array>;
 }
-export default EcdsaKeypair;
+export default P256Keypair;

package/dist/p256/operations.d.ts

@@ -1,4 +1,2 @@
-export declare const importKeypairJwk: (jwk: JsonWebKey, exportable?: boolean) => Promise<CryptoKeyPair>;
 export declare const verifyDidSig: (did: string, data: Uint8Array, sig: Uint8Array) => Promise<boolean>;
-export declare const verify: (publicKey: Uint8Array, data: Uint8Array, sig: Uint8Array) => Promise<boolean>;
-export declare const importEcdsaPublicKey: (keyBytes: Uint8Array) => Promise<CryptoKey>;
+export declare const verifySig: (publicKey: Uint8Array, data: Uint8Array, sig: Uint8Array) => Promise<boolean>;

package/dist/random.d.ts

@@ -1,4 +1,5 @@
+import * as noble from '@noble/hashes/utils';
 import { SupportedEncodings } from 'uint8arrays/to-string';
-export declare const randomBytes: (length: number) => Uint8Array;
-export declare const randomIV: () => Uint8Array;
+export declare const randomBytes: typeof noble.randomBytes;
 export declare const randomStr: (byteLength: number, encoding: SupportedEncodings) => string;
+export declare const randomIntFromSeed: (seed: string, high: number, low?: number) => Promise<number>;

package/dist/secp256k1/operations.d.ts

@@ -1 +1,2 @@
 export declare const verifyDidSig: (did: string, data: Uint8Array, sig: Uint8Array) => Promise<boolean>;
+export declare const verifySig: (publicKey: Uint8Array, data: Uint8Array, sig: Uint8Array) => Promise<boolean>;

package/dist/sha.d.ts

@@ -1,3 +1 @@
-import { Readable } from 'stream';
 export declare const sha256: (input: Uint8Array | string) => Promise<Uint8Array>;
-export declare const sha256Stream: (stream: Readable) => Promise<Uint8Array>;

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 export interface Signer {
+    jwtAlg: string;
     sign(msg: Uint8Array): Promise<Uint8Array>;
 }
 export interface Didable {

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@atproto/crypto",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto.git",
+    "directory": "packages/crypto"
+  },
   "scripts": {
     "test": "jest ",
-    "prettier": "prettier --check src/",
-    "prettier:fix": "prettier --write src/",
+    "prettier": "prettier --check src/ tests/",
+    "prettier:fix": "prettier --write src/ tests/",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "yarn lint --fix",
     "verify": "run-p prettier lint",
@@ -19,10 +24,8 @@
     "postpublish": "npm run update-main-to-src"
   },
   "dependencies": {
-    "@noble/secp256k1": "^1.7.0",
-    "big-integer": "^1.6.51",
-    "multiformats": "^9.6.4",
-    "one-webcrypto": "^1.0.3",
+    "@noble/curves": "^1.1.0",
+    "@noble/hashes": "^1.3.1",
     "uint8arrays": "3.0.0"
   }
 }

package/src/const.ts

@@ -1,6 +1,7 @@
 export const P256_DID_PREFIX = new Uint8Array([0x80, 0x24])
 export const SECP256K1_DID_PREFIX = new Uint8Array([0xe7, 0x01])
-export const BASE58_DID_PREFIX = 'did:key:z' // z is the multibase prefix for base58btc byte encoding
+export const BASE58_MULTIBASE_PREFIX = 'z'
+export const DID_KEY_PREFIX = 'did:key:'
 
 export const P256_JWT_ALG = 'ES256'
 export const SECP256K1_JWT_ALG = 'ES256K'

package/src/did.ts

@@ -2,21 +2,24 @@ import * as uint8arrays from 'uint8arrays'
 import * as p256 from './p256/encoding'
 import * as secp from './secp256k1/encoding'
 import plugins from './plugins'
-import { P256_JWT_ALG, SECP256K1_JWT_ALG } from './const'
+import {
+  BASE58_MULTIBASE_PREFIX,
+  DID_KEY_PREFIX,
+  P256_JWT_ALG,
+  SECP256K1_JWT_ALG,
+} from './const'
 
-export const DID_KEY_BASE58_PREFIX = 'did:key:z'
-
-export type ParsedDidKey = {
+export type ParsedMultikey = {
   jwtAlg: string
   keyBytes: Uint8Array
 }
 
-export const parseDidKey = (did: string): ParsedDidKey => {
-  if (!did.startsWith(DID_KEY_BASE58_PREFIX)) {
-    throw new Error(`Incorrect prefix for did:key: ${did}`)
+export const parseMultikey = (multikey: string): ParsedMultikey => {
+  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
+    throw new Error(`Incorrect prefix for multikey: ${multikey}`)
   }
   const prefixedBytes = uint8arrays.fromString(
-    did.slice(DID_KEY_BASE58_PREFIX.length),
+    multikey.slice(BASE58_MULTIBASE_PREFIX.length),
     'base58btc',
   )
   const plugin = plugins.find((p) => hasPrefix(prefixedBytes, p.prefix))
@@ -35,7 +38,10 @@ export const parseDidKey = (did: string): ParsedDidKey => {
   }
 }
 
-export const formatDidKey = (jwtAlg: string, keyBytes: Uint8Array): string => {
+export const formatMultikey = (
+  jwtAlg: string,
+  keyBytes: Uint8Array,
+): string => {
   const plugin = plugins.find((p) => p.jwtAlg === jwtAlg)
   if (!plugin) {
     throw new Error('Unsupported key type')
@@ -47,10 +53,21 @@ export const formatDidKey = (jwtAlg: string, keyBytes: Uint8Array): string => {
   }
   const prefixedBytes = uint8arrays.concat([plugin.prefix, keyBytes])
   return (
-    DID_KEY_BASE58_PREFIX + uint8arrays.toString(prefixedBytes, 'base58btc')
+    BASE58_MULTIBASE_PREFIX + uint8arrays.toString(prefixedBytes, 'base58btc')
   )
 }
 
+export const parseDidKey = (did: string): ParsedMultikey => {
+  if (!did.startsWith(DID_KEY_PREFIX)) {
+    throw new Error(`Incorrect prefix for did:key: ${did}`)
+  }
+  return parseMultikey(did.slice(DID_KEY_PREFIX.length))
+}
+
+export const formatDidKey = (jwtAlg: string, keyBytes: Uint8Array): string => {
+  return DID_KEY_PREFIX + formatMultikey(jwtAlg, keyBytes)
+}
+
 const hasPrefix = (bytes: Uint8Array, prefix: Uint8Array): boolean => {
   return uint8arrays.equals(prefix, bytes.subarray(0, prefix.byteLength))
 }

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from './aes'
 export * from './const'
 export * from './did'
 export * from './multibase'

package/src/multibase.ts

@@ -1,4 +1,5 @@
 import * as uint8arrays from 'uint8arrays'
+import { SupportedEncodings } from 'uint8arrays/to-string'
 
 export const multibaseToBytes = (mb: string): Uint8Array => {
   const base = mb[0]
@@ -24,3 +25,29 @@ export const multibaseToBytes = (mb: string): Uint8Array => {
       throw new Error(`Unsupported multibase: :${mb}`)
   }
 }
+
+export const bytesToMultibase = (
+  mb: Uint8Array,
+  encoding: SupportedEncodings,
+): string => {
+  switch (encoding) {
+    case 'base16':
+      return 'f' + uint8arrays.toString(mb, encoding)
+    case 'base16upper':
+      return 'F' + uint8arrays.toString(mb, encoding)
+    case 'base32':
+      return 'b' + uint8arrays.toString(mb, encoding)
+    case 'base32upper':
+      return 'B' + uint8arrays.toString(mb, encoding)
+    case 'base58btc':
+      return 'z' + uint8arrays.toString(mb, encoding)
+    case 'base64':
+      return 'm' + uint8arrays.toString(mb, encoding)
+    case 'base64url':
+      return 'u' + uint8arrays.toString(mb, encoding)
+    case 'base64urlpad':
+      return 'U' + uint8arrays.toString(mb, encoding)
+    default:
+      throw new Error(`Unsupported multibase: :${mb}`)
+  }
+}

package/src/p256/encoding.ts

@@ -1,81 +1,14 @@
-import bigInt from 'big-integer'
-import * as uint8arrays from 'uint8arrays'
+import { p256 } from '@noble/curves/p256'
 
-// PUBLIC KEY COMPRESSION
-// ------------------------
-
-// Compression & Decompression algos from:
-// https://stackoverflow.com/questions/48521840/biginteger-to-a-uint8array-of-bytes
-
-// Public key compression for NIST P-256
 export const compressPubkey = (pubkeyBytes: Uint8Array): Uint8Array => {
-  if (pubkeyBytes.length !== 65) {
-    throw new Error('Expected 65 byte pubkey')
-  } else if (pubkeyBytes[0] !== 0x04) {
-    throw new Error('Expected first byte to be 0x04')
-  }
-  // first byte is a prefix
-  const x = pubkeyBytes.slice(1, 33)
-  const y = pubkeyBytes.slice(33, 65)
-  const out = new Uint8Array(x.length + 1)
-
-  out[0] = 2 + (y[y.length - 1] & 1)
-  out.set(x, 1)
-
-  return out
+  const point = p256.ProjectivePoint.fromHex(pubkeyBytes)
+  return point.toRawBytes(true)
 }
 
-// Public key decompression for NIST P-256
 export const decompressPubkey = (compressed: Uint8Array): Uint8Array => {
   if (compressed.length !== 33) {
     throw new Error('Expected 33 byte compress pubkey')
-  } else if (compressed[0] !== 0x02 && compressed[0] !== 0x03) {
-    throw new Error('Expected first byte to be 0x02 or 0x03')
-  }
-  // Consts for P256 curve
-  const two = bigInt(2)
-  // 115792089210356248762697446949407573530086143415290314195533631308867097853951
-  const prime = two
-    .pow(256)
-    .subtract(two.pow(224))
-    .add(two.pow(192))
-    .add(two.pow(96))
-    .subtract(1)
-  const b = bigInt(
-    '41058363725152142129326129780047268409114441015993725554835256314039467401291',
-  )
-
-  // Pre-computed value, or literal
-  const pIdent = prime.add(1).divide(4) // 28948022302589062190674361737351893382521535853822578548883407827216774463488
-
-  // This value must be 2 or 3. 4 indicates an uncompressed key, and anything else is invalid.
-  const signY = bigInt(compressed[0] - 2)
-  const x = compressed.slice(1)
-  const xBig = bigInt(uint8arrays.toString(x, 'base10'))
-
-  // y^2 = x^3 - 3x + b
-  const maybeY = xBig
-    .pow(3)
-    .subtract(xBig.multiply(3))
-    .add(b)
-    .modPow(pIdent, prime)
-
-  let yBig
-  // If the parity matches, we found our root, otherwise it's the other root
-  if (maybeY.mod(2).equals(signY)) {
-    yBig = maybeY
-  } else {
-    // y = prime - y
-    yBig = prime.subtract(maybeY)
   }
-  const y = uint8arrays.fromString(yBig.toString(10), 'base10')
-
-  // left-pad for smaller than 32 byte y
-  const offset = 32 - y.length
-  const yPadded = new Uint8Array(32)
-  yPadded.set(y, offset)
-
-  // concat coords & prepend P-256 prefix
-  const publicKey = uint8arrays.concat([[0x04], x, yPadded])
-  return publicKey
+  const point = p256.ProjectivePoint.fromHex(compressed)
+  return point.toRawBytes(false)
 }

package/src/p256/keypair.ts

@@ -1,54 +1,41 @@
-import { webcrypto } from 'one-webcrypto'
+import { p256 } from '@noble/curves/p256'
+import { sha256 } from '@noble/hashes/sha256'
 import * as uint8arrays from 'uint8arrays'
 import { SupportedEncodings } from 'uint8arrays/util/bases'
 import * as did from '../did'
-import * as operations from './operations'
 import { P256_JWT_ALG } from '../const'
 import { Keypair } from '../types'
 
-export type EcdsaKeypairOptions = {
+export type P256KeypairOptions = {
   exportable: boolean
 }
 
-export class EcdsaKeypair implements Keypair {
+export class P256Keypair implements Keypair {
   jwtAlg = P256_JWT_ALG
   private publicKey: Uint8Array
-  private keypair: CryptoKeyPair
-  private exportable: boolean
 
-  constructor(
-    keypair: CryptoKeyPair,
-    publicKey: Uint8Array,
-    exportable: boolean,
-  ) {
-    this.keypair = keypair
-    this.publicKey = publicKey
-    this.exportable = exportable
+  constructor(private privateKey: Uint8Array, private exportable: boolean) {
+    this.publicKey = p256.getPublicKey(privateKey)
   }
 
   static async create(
-    opts?: Partial<EcdsaKeypairOptions>,
-  ): Promise<EcdsaKeypair> {
+    opts?: Partial<P256KeypairOptions>,
+  ): Promise<P256Keypair> {
     const { exportable = false } = opts || {}
-    const keypair = await webcrypto.subtle.generateKey(
-      { name: 'ECDSA', namedCurve: 'P-256' },
-      exportable,
-      ['sign', 'verify'],
-    )
-    const pubkeyBuf = await webcrypto.subtle.exportKey('raw', keypair.publicKey)
-    const pubkeyBytes = new Uint8Array(pubkeyBuf)
-    return new EcdsaKeypair(keypair, pubkeyBytes, exportable)
+    const privKey = p256.utils.randomPrivateKey()
+    return new P256Keypair(privKey, exportable)
   }
 
   static async import(
-    jwk: JsonWebKey,
-    opts?: Partial<EcdsaKeypairOptions>,
-  ): Promise<EcdsaKeypair> {
+    privKey: Uint8Array | string,
+    opts?: Partial<P256KeypairOptions>,
+  ): Promise<P256Keypair> {
     const { exportable = false } = opts || {}
-    const keypair = await operations.importKeypairJwk(jwk, exportable)
-    const pubkeyBuf = await webcrypto.subtle.exportKey('raw', keypair.publicKey)
-    const pubkeyBytes = new Uint8Array(pubkeyBuf)
-    return new EcdsaKeypair(keypair, pubkeyBytes, exportable)
+    const privKeyBytes =
+      typeof privKey === 'string'
+        ? uint8arrays.fromString(privKey, 'hex')
+        : privKey
+    return new P256Keypair(privKeyBytes, exportable)
   }
 
   publicKeyBytes(): Uint8Array {
@@ -64,21 +51,18 @@ export class EcdsaKeypair implements Keypair {
   }
 
   async sign(msg: Uint8Array): Promise<Uint8Array> {
-    const buf = await webcrypto.subtle.sign(
-      { name: 'ECDSA', hash: { name: 'SHA-256' } },
-      this.keypair.privateKey,
-      msg.buffer,
-    )
-    return new Uint8Array(buf)
+    const msgHash = await sha256(msg)
+    // return raw 64 byte sig not DER-encoded
+    const sig = await p256.sign(msgHash, this.privateKey, { lowS: true })
+    return sig.toCompactRawBytes()
   }
 
-  async export(): Promise<JsonWebKey> {
+  async export(): Promise<Uint8Array> {
     if (!this.exportable) {
       throw new Error('Private key is not exportable')
     }
-    const jwk = await webcrypto.subtle.exportKey('jwk', this.keypair.privateKey)
-    return jwk
+    return this.privateKey
   }
 }
 
-export default EcdsaKeypair
+export default P256Keypair

package/src/p256/operations.ts

@@ -1,30 +1,8 @@
-import { webcrypto } from 'one-webcrypto'
+import { p256 } from '@noble/curves/p256'
+import { sha256 } from '@noble/hashes/sha256'
 import { P256_JWT_ALG } from '../const'
 import { parseDidKey } from '../did'
 
-export const importKeypairJwk = async (
-  jwk: JsonWebKey,
-  exportable = false,
-): Promise<CryptoKeyPair> => {
-  const privateKey = await webcrypto.subtle.importKey(
-    'jwk',
-    jwk,
-    { name: 'ECDSA', namedCurve: 'P-256' },
-    exportable,
-    ['sign'],
-  )
-  const { kty, crv, x, y } = jwk
-  const pubKeyJwk = { kty, crv, x, y }
-  const publicKey = await webcrypto.subtle.importKey(
-    'jwk',
-    pubKeyJwk,
-    { name: 'ECDSA', namedCurve: 'P-256' },
-    true,
-    ['verify'],
-  )
-  return { privateKey, publicKey }
-}
-
 export const verifyDidSig = async (
   did: string,
   data: Uint8Array,
@@ -34,31 +12,14 @@ export const verifyDidSig = async (
   if (jwtAlg !== P256_JWT_ALG) {
     throw new Error(`Not a P-256 did:key: ${did}`)
   }
-  return verify(keyBytes, data, sig)
+  return verifySig(keyBytes, data, sig)
 }
 
-export const verify = async (
+export const verifySig = async (
   publicKey: Uint8Array,
   data: Uint8Array,
   sig: Uint8Array,
 ): Promise<boolean> => {
-  const importedKey = await importEcdsaPublicKey(publicKey)
-  return webcrypto.subtle.verify(
-    { name: 'ECDSA', hash: { name: 'SHA-256' } },
-    importedKey,
-    sig,
-    data,
-  )
-}
-
-export const importEcdsaPublicKey = async (
-  keyBytes: Uint8Array,
-): Promise<CryptoKey> => {
-  return webcrypto.subtle.importKey(
-    'raw',
-    keyBytes,
-    { name: 'ECDSA', namedCurve: 'P-256' },
-    true,
-    ['verify'],
-  )
+  const msgHash = await sha256(data)
+  return p256.verify(sig, msgHash, publicKey, { lowS: true })
 }

package/src/random.ts

@@ -1,14 +1,9 @@
+import * as noble from '@noble/hashes/utils'
 import * as uint8arrays from 'uint8arrays'
-import { webcrypto } from 'one-webcrypto'
 import { SupportedEncodings } from 'uint8arrays/to-string'
+import { sha256 } from './sha'
 
-export const randomBytes = (length: number): Uint8Array => {
-  return webcrypto.getRandomValues(new Uint8Array(length))
-}
-
-export const randomIV = (): Uint8Array => {
-  return randomBytes(12)
-}
+export const randomBytes = noble.randomBytes
 
 export const randomStr = (
   byteLength: number,
@@ -17,3 +12,15 @@ export const randomStr = (
   const bytes = randomBytes(byteLength)
   return uint8arrays.toString(bytes, encoding)
 }
+
+export const randomIntFromSeed = async (
+  seed: string,
+  high: number,
+  low = 0,
+): Promise<number> => {
+  const hash = await sha256(seed)
+  const number = Buffer.from(hash).readUintBE(0, 6)
+  const range = high - low
+  const normalized = number % range
+  return normalized + low
+}

package/src/secp256k1/encoding.ts

@@ -1,8 +1,7 @@
-import * as secp from '@noble/secp256k1'
+import { secp256k1 as k256 } from '@noble/curves/secp256k1'
 
 export const compressPubkey = (pubkeyBytes: Uint8Array): Uint8Array => {
-  const hex = secp.utils.bytesToHex(pubkeyBytes)
-  const point = secp.Point.fromHex(hex)
+  const point = k256.ProjectivePoint.fromHex(pubkeyBytes)
   return point.toRawBytes(true)
 }
 
@@ -10,7 +9,6 @@ export const decompressPubkey = (compressed: Uint8Array): Uint8Array => {
   if (compressed.length !== 33) {
     throw new Error('Expected 33 byte compress pubkey')
   }
-  const hex = secp.utils.bytesToHex(compressed)
-  const point = secp.Point.fromHex(hex)
+  const point = k256.ProjectivePoint.fromHex(compressed)
   return point.toRawBytes(false)
 }

package/src/secp256k1/keypair.ts

@@ -1,4 +1,5 @@
-import * as secp from '@noble/secp256k1'
+import { secp256k1 as k256 } from '@noble/curves/secp256k1'
+import { sha256 } from '@noble/hashes/sha256'
 import * as uint8arrays from 'uint8arrays'
 import { SupportedEncodings } from 'uint8arrays/util/bases'
 import * as did from '../did'
@@ -14,14 +15,14 @@ export class Secp256k1Keypair implements Keypair {
   private publicKey: Uint8Array
 
   constructor(private privateKey: Uint8Array, private exportable: boolean) {
-    this.publicKey = secp.getPublicKey(privateKey)
+    this.publicKey = k256.getPublicKey(privateKey)
   }
 
   static async create(
     opts?: Partial<Secp256k1KeypairOptions>,
   ): Promise<Secp256k1Keypair> {
     const { exportable = false } = opts || {}
-    const privKey = secp.utils.randomPrivateKey()
+    const privKey = k256.utils.randomPrivateKey()
     return new Secp256k1Keypair(privKey, exportable)
   }
 
@@ -50,9 +51,10 @@ export class Secp256k1Keypair implements Keypair {
   }
 
   async sign(msg: Uint8Array): Promise<Uint8Array> {
-    const msgHash = await secp.utils.sha256(msg)
+    const msgHash = await sha256(msg)
     // return raw 64 byte sig not DER-encoded
-    return secp.sign(msgHash, this.privateKey, { der: false })
+    const sig = await k256.sign(msgHash, this.privateKey, { lowS: true })
+    return sig.toCompactRawBytes()
   }
 
   async export(): Promise<Uint8Array> {

package/src/secp256k1/operations.ts

@@ -1,4 +1,5 @@
-import * as secp from '@noble/secp256k1'
+import { secp256k1 as k256 } from '@noble/curves/secp256k1'
+import { sha256 } from '@noble/hashes/sha256'
 import { SECP256K1_JWT_ALG } from '../const'
 import { parseDidKey } from '../did'
 
@@ -11,6 +12,14 @@ export const verifyDidSig = async (
   if (jwtAlg !== SECP256K1_JWT_ALG) {
     throw new Error(`Not a secp256k1 did:key: ${did}`)
   }
-  const msgHash = await secp.utils.sha256(data)
-  return secp.verify(sig, msgHash, keyBytes)
+  return verifySig(keyBytes, data, sig)
+}
+
+export const verifySig = async (
+  publicKey: Uint8Array,
+  data: Uint8Array,
+  sig: Uint8Array,
+): Promise<boolean> => {
+  const msgHash = await sha256(data)
+  return k256.verify(sig, msgHash, publicKey, { lowS: true })
 }

package/src/sha.ts

@@ -1,7 +1,5 @@
-import * as mf from 'multiformats/hashes/sha2'
+import * as noble from '@noble/hashes/sha256'
 import * as uint8arrays from 'uint8arrays'
-import crypto from 'crypto'
-import { Readable } from 'stream'
 
 // takes either bytes of utf8 input
 export const sha256 = async (
@@ -9,20 +7,5 @@ export const sha256 = async (
 ): Promise<Uint8Array> => {
   const bytes =
     typeof input === 'string' ? uint8arrays.fromString(input, 'utf8') : input
-  const hash = await mf.sha256.digest(bytes)
-  return hash.digest
-}
-
-export const sha256Stream = async (stream: Readable): Promise<Uint8Array> => {
-  const hash = crypto.createHash('sha256')
-  try {
-    for await (const chunk of stream) {
-      hash.write(chunk)
-    }
-  } catch (err) {
-    hash.end()
-    throw err
-  }
-  hash.end()
-  return hash.read()
+  return noble.sha256(bytes)
 }

package/src/types.ts

@@ -1,4 +1,5 @@
 export interface Signer {
+  jwtAlg: string
   sign(msg: Uint8Array): Promise<Uint8Array>
 }