@owlmeans/did

--- package/src/types.ts (excerpt) ---
import type { Profile } from '@owlmeans/auth'
import type { KeyPair, KeyPairModel } from '@owlmeans/basic-keys'
import type { Resource, ResourceRecord } from '@owlmeans/resource'

export interface DIDWallet {
  store: DIDStore
  
  generate: (opts?: MnemonicOptions) => Promise<void>
  
  mnemonic: (crash?: boolean) => Promise<string | false>

  master: () => Promise<DIDKeyModel>

  add: (key: DIDKeyModel, meta: KeyMeta) => Promise<void>

  meta: (key: string | DIDKeyModel) => Promise<KeyMeta>

  update: (key: DIDKeyModel, meta: KeyMeta) => Promise<[DIDKeyModel, KeyMeta]>

  get: (did: string) => Promise<DIDKeyModel | null>

  find: (meta: Partial<KeyMeta>) => Promise<DIDKeyModel[]>

  provide: (mate: Partial<KeyMeta>) => Promise<DIDKeyModel[]>

  remove: (did: string | KeyMeta | DIDKeyModel) => Promise<DIDKeyModel>

  all: () => Promise<DIDKeyModel[]>
  
  allMeta: () => Promise<KeyMeta[]>
}

export interface MakeDIDWalletOptions {
  force?: boolean
  allowEmpty?: boolean
  mnemonic?: MnemonicOptions
  type?: string
  allowCustomType?: boolean
}

export interface DIDStore {
  master: MasterResource
  keys: KeyPairResource
  meta: KeyMetaResource
}

export interface MasterResource extends Resource<KeySeedRecord> {
}

export interface KeyPairResource extends Resource<KeyPairRecord> {
}

export interface KeyMetaResource extends Resource<KeyMetaRecord> {
}

export interface KeyPairRecord extends ResourceRecord, DIDKeyPair {
}

export interface KeySeedRecord extends ResourceRecord

--- package/src/wallet.ts (excerpt) ---
import { DIDInitializationError, DIDKeyError, DIDWalletError } from './errors.js'
import type { DIDKeyModel, DIDStore, DIDWallet, KeyMeta, KeyPairRecord, MakeDIDWalletOptions } from './types.js'
import { generateMnemonic, toEntropy, toMnemonic, toSeed } from './utils/mnemonic.js'
import { KEY_OWL, MASTER } from './consts.js'
import { plugins } from './plugins/index.js'
import { ed25519owlPluginBuilder } from './plugins/ed25519owl.js'
import { produceKey } from './utils/key.js'
import { makeDidKeyModel } from './model.js'
import { mataToPath, matchMeta } from './utils.js'

export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) => {
  if (await store.master.load(MASTER) == null) {
    if (!opts?.force && !opts?.allowEmpty) {
      throw new DIDInitializationError('master')
    }
  }
  
  const type = opts?.type ?? KEY_OWL
  if (plugins[type] == null) {
    if (opts?.allowCustomType) {
      plugins[type] = ed25519owlPluginBuilder(type)
    }
  }

  const wallet: DIDWallet = {
    store, 

    generate: async opts => {
      const mnemonic = generateMnemonic(opts)

      const seed = {
        entropy: toEntropy(mnemonic),
        seed: toSeed(mnemonic)
      }

      const master = produceKey(seed.seed, type)
      await store.master.save({ id: MASTER, ...master, ...seed })
    },

    mnemonic: async crash => {
      const master = await store.master.get(MASTER)
      if (master.seed == null) {
        if (crash) {
          throw new DIDWalletError('mn

--- package/src/utils/index.ts (excerpt) ---

export * from './mnemonic.js'
export * from './key.js'
export * from '../utils.js'


--- package/src/utils/mnemonic.ts (excerpt) ---
import type { MnemonicOptions } from '../types.js'
import { generateMnemonic as generate, mnemonicToSeedSync, entropyToMnemonic } from '@scure/bip39'
import { hex, base64 } from '@scure/base'
import { wordlist } from '@scure/bip39/wordlists/english'

export const generateMnemonic = (opts?: MnemonicOptions): string => {
  const size = opts?.size ?? 18

  if (size < 12 || size > 24) {
    throw new SyntaxError('Mnemonic size should be between 12 and 24')
  }

  const strength = Math.round(256 * size / 24)
  return generate(wordlist as any, strength + (32 - strength % 32))
}

export const toSeed = (mnemonic: string): string =>
  base64.encode(mnemonicToSeedSync(mnemonic))

export const toEntropy = (mnemonic: string): string =>
  hex.encode(mnemonicToSeedSync(mnemonic))

export const toMnemonic = (seed: string): string =>
  entropyToMnemonic(hex.decode(seed), wordlist as any)