@atproto/crypto 0.0.1

package/dist/p256/keypair.d.ts

@@ -0,0 +1,19 @@
+import * as ucan from '@ucans/core';
+export declare type EcdsaKeypairOptions = {
+    exportable: boolean;
+};
+export declare class EcdsaKeypair implements ucan.DidableKey {
+    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>;
+    publicKeyBytes(): Uint8Array;
+    publicKeyStr(encoding?: ucan.Encodings): string;
+    did(): string;
+    sign(msg: Uint8Array): Promise<Uint8Array>;
+    export(): Promise<JsonWebKey>;
+}
+export default EcdsaKeypair;

package/dist/p256/operations.d.ts

@@ -0,0 +1,4 @@
+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>;

package/dist/p256/plugin.d.ts

@@ -0,0 +1,3 @@
+import { DidKeyPlugin } from '@ucans/core';
+export declare const p256Plugin: DidKeyPlugin;
+export default p256Plugin;

package/dist/plugins.d.ts

@@ -0,0 +1,2 @@
+export declare const plugins: import("@ucans/core").DidKeyPlugin[];
+export default plugins;

package/dist/random.d.ts

@@ -0,0 +1,4 @@
+import { SupportedEncodings } from 'uint8arrays/to-string';
+export declare const randomBytes: (length: number) => Uint8Array;
+export declare const randomIV: () => Uint8Array;
+export declare const randomStr: (byteLength: number, encoding: SupportedEncodings) => string;

package/dist/secp256k1/encoding.d.ts

@@ -0,0 +1,2 @@
+export declare const compressPubkey: (pubkeyBytes: Uint8Array) => Uint8Array;
+export declare const decompressPubkey: (compressed: Uint8Array) => Uint8Array;

package/dist/secp256k1/keypair.d.ts

@@ -0,0 +1,19 @@
+import * as ucan from '@ucans/core';
+export declare type Secp256k1KeypairOptions = {
+    exportable: boolean;
+};
+export declare class Secp256k1Keypair implements ucan.DidableKey {
+    private privateKey;
+    private exportable;
+    jwtAlg: string;
+    private publicKey;
+    constructor(privateKey: Uint8Array, exportable: boolean);
+    static create(opts?: Partial<Secp256k1KeypairOptions>): Promise<Secp256k1Keypair>;
+    static import(privKey: Uint8Array | string, opts?: Partial<Secp256k1KeypairOptions>): Promise<Secp256k1Keypair>;
+    publicKeyBytes(): Uint8Array;
+    publicKeyStr(encoding?: ucan.Encodings): string;
+    did(): string;
+    sign(msg: Uint8Array): Promise<Uint8Array>;
+    export(): Promise<Uint8Array>;
+}
+export default Secp256k1Keypair;

package/dist/secp256k1/operations.d.ts

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

package/dist/secp256k1/plugin.d.ts

@@ -0,0 +1,3 @@
+import { DidKeyPlugin } from '@ucans/core';
+export declare const secp256k1Plugin: DidKeyPlugin;
+export default secp256k1Plugin;

package/dist/sha.d.ts

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

package/dist/verify.d.ts

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

package/jest.config.js

@@ -0,0 +1,6 @@
+const base = require('../../jest.config.base.js')
+
+module.exports = {
+  ...base,
+  displayName: 'Crypto'
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@atproto/crypto",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "scripts": {
+    "test": "jest ",
+    "prettier": "prettier --check src/",
+    "prettier:fix": "prettier --write src/",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "yarn lint --fix",
+    "verify": "run-p prettier lint",
+    "verify:fix": "yarn prettier:fix && yarn lint:fix",
+    "build": "node ./build.js",
+    "postbuild": "tsc --build tsconfig.build.json",
+    "update-main-to-dist": "node ./update-pkg.js --update-main-to-dist",
+    "update-main-to-src": "node ./update-pkg.js --update-main-to-src",
+    "prepublish": "npm run update-main-to-dist",
+    "postpublish": "npm run update-main-to-src"
+  },
+  "dependencies": {
+    "@noble/secp256k1": "^1.7.0",
+    "@ucans/core": "0.11.0",
+    "big-integer": "^1.6.51",
+    "multiformats": "^9.6.4",
+    "one-webcrypto": "^1.0.3",
+    "uint8arrays": "3.0.0"
+  }
+}

package/src/aes.ts

@@ -0,0 +1,64 @@
+import { webcrypto } from 'one-webcrypto'
+import * as uint8arrays from 'uint8arrays'
+
+import * as random from './random'
+
+export class AesKey {
+  private key: CryptoKey
+  constructor(key: CryptoKey) {
+    this.key = key
+  }
+
+  static async create(): Promise<AesKey> {
+    const key = await webcrypto.subtle.generateKey(
+      {
+        name: 'AES-GCM',
+        length: 256,
+      },
+      true,
+      ['encrypt', 'decrypt'],
+    )
+    return new AesKey(key)
+  }
+
+  // utf8 data -> base64pad cipher
+  // returns base64 encrypted data with iv prepended
+  async encrypt(data: string): Promise<string> {
+    const iv = random.randomIV()
+    const dataBytes = uint8arrays.fromString(data, 'utf8')
+    const buf = await webcrypto.subtle.encrypt(
+      {
+        name: 'AES-GCM',
+        iv,
+      },
+      this.key,
+      dataBytes,
+    )
+    const encryptedBytes = new Uint8Array(buf)
+    const encrypted = uint8arrays.toString(
+      uint8arrays.concat([iv, encryptedBytes]),
+      'base64pad',
+    )
+    return encrypted
+  }
+
+  // base64pad cipher -> utf8 data
+  // expects base64 encrypted data with iv prepended
+  async decrypt(data: string): Promise<string> {
+    const dataBytes = uint8arrays.fromString(data, 'base64pad')
+    const iv = dataBytes.slice(0, 12)
+    const encrypted = dataBytes.slice(12)
+    const buf = await webcrypto.subtle.decrypt(
+      {
+        name: 'AES-GCM',
+        iv,
+      },
+      this.key,
+      encrypted,
+    )
+    const decryptedBytes = new Uint8Array(buf)
+    return uint8arrays.toString(decryptedBytes, 'utf8')
+  }
+}
+
+export default AesKey

package/src/const.ts

@@ -0,0 +1,6 @@
+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 P256_JWT_ALG = 'ES256'
+export const SECP256K1_JWT_ALG = 'ES256K'

package/src/did.ts

@@ -0,0 +1,56 @@
+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'
+
+export const DID_KEY_BASE58_PREFIX = 'did:key:z'
+
+export type ParsedDidKey = {
+  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}`)
+  }
+  const prefixedBytes = uint8arrays.fromString(
+    did.slice(DID_KEY_BASE58_PREFIX.length),
+    'base58btc',
+  )
+  const plugin = plugins.find((p) => hasPrefix(prefixedBytes, p.prefix))
+  if (!plugin) {
+    throw new Error('Unsupported key type')
+  }
+  let keyBytes = prefixedBytes.slice(plugin.prefix.length)
+  if (plugin.jwtAlg === P256_JWT_ALG) {
+    keyBytes = p256.decompressPubkey(keyBytes)
+  } else if (plugin.jwtAlg === SECP256K1_JWT_ALG) {
+    keyBytes = secp.decompressPubkey(keyBytes)
+  }
+  return {
+    jwtAlg: plugin.jwtAlg,
+    keyBytes,
+  }
+}
+
+export const formatDidKey = (jwtAlg: string, keyBytes: Uint8Array): string => {
+  const plugin = plugins.find((p) => p.jwtAlg === jwtAlg)
+  if (!plugin) {
+    throw new Error('Unsupported key type')
+  }
+  if (jwtAlg === P256_JWT_ALG) {
+    keyBytes = p256.compressPubkey(keyBytes)
+  } else if (jwtAlg === SECP256K1_JWT_ALG) {
+    keyBytes = secp.compressPubkey(keyBytes)
+  }
+  const prefixedBytes = uint8arrays.concat([plugin.prefix, keyBytes])
+  return (
+    DID_KEY_BASE58_PREFIX + uint8arrays.toString(prefixedBytes, 'base58btc')
+  )
+}
+
+const hasPrefix = (bytes: Uint8Array, prefix: Uint8Array): boolean => {
+  return uint8arrays.equals(prefix, bytes.subarray(0, prefix.byteLength))
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './aes'
+export * from './const'
+export * from './did'
+export * from './multibase'
+export * from './random'
+export * from './sha'
+export * from './verify'
+
+export * from './p256/keypair'
+export * from './p256/plugin'
+
+export * from './secp256k1/keypair'
+export * from './secp256k1/plugin'
+
+export type { DidableKey } from '@ucans/core'

package/src/multibase.ts

@@ -0,0 +1,26 @@
+import * as uint8arrays from 'uint8arrays'
+
+export const multibaseToBytes = (mb: string): Uint8Array => {
+  const base = mb[0]
+  const key = mb.slice(1)
+  switch (base) {
+    case 'f':
+      return uint8arrays.fromString(key, 'base16')
+    case 'F':
+      return uint8arrays.fromString(key, 'base16upper')
+    case 'b':
+      return uint8arrays.fromString(key, 'base32')
+    case 'B':
+      return uint8arrays.fromString(key, 'base32upper')
+    case 'z':
+      return uint8arrays.fromString(key, 'base58btc')
+    case 'm':
+      return uint8arrays.fromString(key, 'base64')
+    case 'u':
+      return uint8arrays.fromString(key, 'base64url')
+    case 'U':
+      return uint8arrays.fromString(key, 'base64urlpad')
+    default:
+      throw new Error(`Unsupported multibase: :${mb}`)
+  }
+}

package/src/p256/encoding.ts

@@ -0,0 +1,81 @@
+import bigInt from 'big-integer'
+import * as uint8arrays from 'uint8arrays'
+
+// 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
+}
+
+// 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
+}

package/src/p256/keypair.ts

@@ -0,0 +1,85 @@
+import { webcrypto } from 'one-webcrypto'
+import * as uint8arrays from 'uint8arrays'
+
+import * as ucan from '@ucans/core'
+
+import * as did from '../did'
+import * as operations from './operations'
+import { P256_JWT_ALG } from '../const'
+
+export type EcdsaKeypairOptions = {
+  exportable: boolean
+}
+
+export class EcdsaKeypair implements ucan.DidableKey {
+  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
+  }
+
+  static async create(
+    opts?: Partial<EcdsaKeypairOptions>,
+  ): Promise<EcdsaKeypair> {
+    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)
+  }
+
+  static async import(
+    jwk: JsonWebKey,
+    opts?: Partial<EcdsaKeypairOptions>,
+  ): Promise<EcdsaKeypair> {
+    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)
+  }
+
+  publicKeyBytes(): Uint8Array {
+    return this.publicKey
+  }
+
+  publicKeyStr(encoding: ucan.Encodings = 'base64pad'): string {
+    return uint8arrays.toString(this.publicKey, encoding)
+  }
+
+  did(): string {
+    return did.formatDidKey(this.jwtAlg, this.publicKey)
+  }
+
+  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)
+  }
+
+  async export(): Promise<JsonWebKey> {
+    if (!this.exportable) {
+      throw new Error('Private key is not exportable')
+    }
+    const jwk = await webcrypto.subtle.exportKey('jwk', this.keypair.privateKey)
+    return jwk
+  }
+}
+
+export default EcdsaKeypair

package/src/p256/operations.ts

@@ -0,0 +1,64 @@
+import { webcrypto } from 'one-webcrypto'
+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,
+  sig: Uint8Array,
+): Promise<boolean> => {
+  const { jwtAlg, keyBytes } = parseDidKey(did)
+  if (jwtAlg !== P256_JWT_ALG) {
+    throw new Error(`Not a P-256 did:key: ${did}`)
+  }
+  return verify(keyBytes, data, sig)
+}
+
+export const verify = 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'],
+  )
+}

package/src/p256/plugin.ts

@@ -0,0 +1,13 @@
+import { DidKeyPlugin } from '@ucans/core'
+
+import { P256_DID_PREFIX, P256_JWT_ALG } from '../const'
+
+import * as operations from './operations'
+
+export const p256Plugin: DidKeyPlugin = {
+  prefix: P256_DID_PREFIX,
+  jwtAlg: P256_JWT_ALG,
+  verifySignature: operations.verifyDidSig,
+}
+
+export default p256Plugin

package/src/plugins.ts

@@ -0,0 +1,6 @@
+import p256Plugin from './p256/plugin'
+import secp256k1Plugin from './secp256k1/plugin'
+
+export const plugins = [p256Plugin, secp256k1Plugin]
+
+export default plugins

package/src/random.ts

@@ -0,0 +1,19 @@
+import * as uint8arrays from 'uint8arrays'
+import { webcrypto } from 'one-webcrypto'
+import { SupportedEncodings } from 'uint8arrays/to-string'
+
+export const randomBytes = (length: number): Uint8Array => {
+  return webcrypto.getRandomValues(new Uint8Array(length))
+}
+
+export const randomIV = (): Uint8Array => {
+  return randomBytes(12)
+}
+
+export const randomStr = (
+  byteLength: number,
+  encoding: SupportedEncodings,
+): string => {
+  const bytes = randomBytes(byteLength)
+  return uint8arrays.toString(bytes, encoding)
+}

package/src/secp256k1/encoding.ts

@@ -0,0 +1,16 @@
+import * as secp from '@noble/secp256k1'
+
+export const compressPubkey = (pubkeyBytes: Uint8Array): Uint8Array => {
+  const hex = secp.utils.bytesToHex(pubkeyBytes)
+  const point = secp.Point.fromHex(hex)
+  return point.toRawBytes(true)
+}
+
+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)
+  return point.toRawBytes(false)
+}

package/src/secp256k1/keypair.ts

@@ -0,0 +1,65 @@
+import * as ucan from '@ucans/core'
+import * as secp from '@noble/secp256k1'
+import * as uint8arrays from 'uint8arrays'
+import * as did from '../did'
+import { SECP256K1_JWT_ALG } from '../const'
+
+export type Secp256k1KeypairOptions = {
+  exportable: boolean
+}
+
+export class Secp256k1Keypair implements ucan.DidableKey {
+  jwtAlg = SECP256K1_JWT_ALG
+  private publicKey: Uint8Array
+
+  constructor(private privateKey: Uint8Array, private exportable: boolean) {
+    this.publicKey = secp.getPublicKey(privateKey)
+  }
+
+  static async create(
+    opts?: Partial<Secp256k1KeypairOptions>,
+  ): Promise<Secp256k1Keypair> {
+    const { exportable = false } = opts || {}
+    const privKey = secp.utils.randomPrivateKey()
+    return new Secp256k1Keypair(privKey, exportable)
+  }
+
+  static async import(
+    privKey: Uint8Array | string,
+    opts?: Partial<Secp256k1KeypairOptions>,
+  ): Promise<Secp256k1Keypair> {
+    const { exportable = false } = opts || {}
+    const privKeyBytes =
+      typeof privKey === 'string'
+        ? uint8arrays.fromString(privKey, 'hex')
+        : privKey
+    return new Secp256k1Keypair(privKeyBytes, exportable)
+  }
+
+  publicKeyBytes(): Uint8Array {
+    return this.publicKey
+  }
+
+  publicKeyStr(encoding: ucan.Encodings = 'base64pad'): string {
+    return uint8arrays.toString(this.publicKey, encoding)
+  }
+
+  did(): string {
+    return did.formatDidKey(this.jwtAlg, this.publicKey)
+  }
+
+  async sign(msg: Uint8Array): Promise<Uint8Array> {
+    const msgHash = await secp.utils.sha256(msg)
+    // return raw 64 byte sig not DER-encoded
+    return secp.sign(msgHash, this.privateKey, { der: false })
+  }
+
+  async export(): Promise<Uint8Array> {
+    if (!this.exportable) {
+      throw new Error('Private key is not exportable')
+    }
+    return this.privateKey
+  }
+}
+
+export default Secp256k1Keypair

package/src/secp256k1/operations.ts

@@ -0,0 +1,16 @@
+import * as secp from '@noble/secp256k1'
+import { SECP256K1_JWT_ALG } from '../const'
+import { parseDidKey } from '../did'
+
+export const verifyDidSig = async (
+  did: string,
+  data: Uint8Array,
+  sig: Uint8Array,
+): Promise<boolean> => {
+  const { jwtAlg, keyBytes } = parseDidKey(did)
+  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)
+}