@owlmeans/did 0.1.18-rc.9 → 0.1.18

package/src/utils.ts

@@ -1,34 +1,40 @@
 import { ENTITY_PREFIX, KP_SEP, PREFIX_SEP, PROFILE_PREFIX, SERVICE_PREFIX } from './consts.js'
 import type { KeyMeta } from './types.js'
+import { skipFields } from './consts.local.js'
+import type { KeyPathUtils } from './utils/types.js'
 
-export const toPath = (...args: (string | string[])[]) => args.map(
-  arg => Array.isArray(arg) ? arg.join(PREFIX_SEP) : arg
-).join(KP_SEP)
+export const createKeyPathUtils = (): KeyPathUtils => {
+  const toPath = (...args: (string | string[])[]): string => args.map(
+    arg => Array.isArray(arg) ? arg.join(PREFIX_SEP) : arg
+  ).join(KP_SEP)
 
-export const mataToPath = (meta: Partial<KeyMeta>): string => {
-  const { scopes, id, entityId } = meta
-  const items: (string | string[])[] = []
-  if (scopes != null && scopes.length === 1) {
-    items.push([SERVICE_PREFIX, scopes[0]])
-  }
-  if (entityId != null) {
-    items.push([ENTITY_PREFIX, entityId])
-  }
-  if (id != null) {
-    items.push([PROFILE_PREFIX, id])
+  const mataToPath = (meta: Partial<KeyMeta>): string => {
+    const { scopes, id, entityId } = meta
+    const items: (string | string[])[] = []
+    if (scopes != null && scopes.length === 1) {
+      items.push([SERVICE_PREFIX, scopes[0]])
+    }
+    if (entityId != null) {
+      items.push([ENTITY_PREFIX, entityId])
+    }
+    if (id != null) {
+      items.push([PROFILE_PREFIX, id])
+    }
+
+    return toPath(...items)
   }
 
-  return toPath(...items)
-}
+  const matchMeta = (haystack: KeyMeta, needle: Partial<KeyMeta>): boolean =>
+    Object.entries(needle).every(([key, value]) =>
+      skipFields.includes(key)
+      || (haystack[key as keyof typeof haystack] != null
+        && (Array.isArray(value)
+          ? Array.isArray(haystack[key as keyof typeof haystack])
+          && value.every(value => (haystack[key as keyof typeof haystack] as unknown[]).includes(value))
+          : haystack[key as keyof typeof haystack] === value)
+      ))
 
-const skipFields = ['name']
+  return { toPath, mataToPath, matchMeta }
+}
 
-export const matchMeta = (haystack: KeyMeta, needle: Partial<KeyMeta>): boolean =>
-  Object.entries(needle).every(([key, value]) =>
-    skipFields.includes(key)
-    || (haystack[key as keyof typeof haystack] != null
-      && (Array.isArray(value)
-        ? Array.isArray(haystack[key as keyof typeof haystack])
-        && value.every(value => (haystack[key as keyof typeof haystack] as unknown[]).includes(value))
-        : haystack[key as keyof typeof haystack] === value)
-    ))
+export const keyPathUtils = createKeyPathUtils()

package/src/wallet.ts

@@ -1,14 +1,15 @@
 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 type { Criteria } from '@owlmeans/resource'
+import type { DIDKeyModel, DIDStore, DIDWallet, KeyMeta, KeyMetaRecord, KeyPairRecord, MakeDIDWalletOptions } from './types.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'
+import { keyPathUtils } from './utils.js'
+import { mnemonicHelper } from './utils/mnemonic.js'
 
-export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) => {
+export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions): Promise<DIDWallet> => {
   if (await store.master.load(MASTER) == null) {
     if (!opts?.force && !opts?.allowEmpty) {
       throw new DIDInitializationError('master')
@@ -26,11 +27,11 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
     store, 
 
     generate: async opts => {
-      const mnemonic = generateMnemonic(opts)
+      const mnemonic = mnemonicHelper.generateMnemonic(opts)
 
       const seed = {
-        entropy: toEntropy(mnemonic),
-        seed: toSeed(mnemonic)
+        entropy: mnemonicHelper.toEntropy(mnemonic),
+        seed: mnemonicHelper.toSeed(mnemonic)
       }
 
       const master = produceKey(seed.seed, type)
@@ -46,7 +47,7 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
         return false
       }
 
-      return toMnemonic(master.seed)
+      return mnemonicHelper.toMnemonic(master.seed)
     },
 
     master: async () => makeDidKeyModel(await store.master.get(MASTER)),
@@ -94,11 +95,12 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
     },
 
     find: async meta => {
-      const result = await store.meta.list(
-        Object.fromEntries(Object.entries(meta).filter(([_, v]) => typeof v !== 'boolean'))
+      const where: Criteria<KeyMetaRecord> = Object.fromEntries(
+        Object.entries(meta).filter(([_, v]) => typeof v !== 'boolean')
       )
+      const result = await store.meta.list(where)
 
-      const keys = await Promise.all(result.items.filter(item => matchMeta(item, meta))
+      const keys = await Promise.all(result.items.filter(item => keyPathUtils.matchMeta(item, meta))
         .map(async meta => store.keys.get(meta.id)))
 
       return keys.map(key => makeDidKeyModel(key))
@@ -107,7 +109,7 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
     provide: async meta => {
       const found = await wallet.find(meta)
       if (found.length === 0) {
-        const path = mataToPath(meta)
+        const path = keyPathUtils.mataToPath(meta)
         const master = await wallet.master()
         const key = master.derive(path)
         if (meta.name == null) {
@@ -142,7 +144,7 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
       if (key == null) {
         throw new DIDWalletError('no:key')
       }
-      await store.keys.delete(key)
+      await store.keys.delete(did)
       const model = makeDidKeyModel(key)
       await store.meta.delete(model.exportAddress())
 
@@ -153,9 +155,9 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
       const result: KeyPairRecord[] = []
       let more = false
       do {
-        const found = await store.keys.list({ pager: { page: Math.floor(result.length / 100), size: 100 } })
+        const found = await store.keys.list(undefined, { page: Math.floor(result.length / 100), size: 100 })
         result.push(...found.items)
-        more = found.pager?.total != null && found.pager.total > result.length
+        more = found.items.length > 0 && found.total > result.length
       } while (more)
 
       return result.map(key => makeDidKeyModel(key))
@@ -165,10 +167,9 @@ export const makeWallet = async (store: DIDStore, opts?: MakeDIDWalletOptions) =
       const result: KeyMeta[] = []
       let more = false
       do {
-        // const found = await store.keys.list({ pager: { page: Math.floor(result.length / 100), size: 100 } })
-        const found = await store.meta.list({ pager: { page: Math.floor(result.length / 100), size: 100 } })
+        const found = await store.meta.list(undefined, { page: Math.floor(result.length / 100), size: 100 })
         result.push(...found.items)
-        more = found.pager?.total != null && found.pager.total > result.length
+        more = found.items.length > 0 && found.total > result.length
       } while (more)
 
       return result

package/tests/mnemonic.spec.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'bun:test'
+import { wordlist } from '@scure/bip39/wordlists/english.js'
+import { mnemonicHelper } from '../src/utils/mnemonic.js'
+
+/**
+ * Answers computed with @scure/bip39 1.6 before the v2 line: the seed of the all-`abandon` test mnemonic is
+ * the published BIP-39 vector, so a changed derivation fails here rather than as a different DID.
+ */
+const MNEMONIC = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
+const SEED_HEX = '5eb00bbddcf069084889a8ab9155568165f5c453ccb85e70811aaed6f6da5fc19a5ac40b389cd370d086206dec8aa6c43daea6690f20ad3d8d48b2d2ce9e38e4'
+
+describe('@owlmeans/did — mnemonic derivation', () => {
+  test('the seed of the BIP-39 test mnemonic is the published vector', () => {
+    expect(mnemonicHelper.toEntropy(MNEMONIC)).toBe(SEED_HEX)
+    expect(Buffer.from(mnemonicHelper.toSeed(MNEMONIC), 'base64').toString('hex')).toBe(SEED_HEX)
+  })
+
+  test('entropy turns back into the mnemonic it came from', () => {
+    expect(mnemonicHelper.toMnemonic('00000000000000000000000000000000')).toBe(MNEMONIC)
+  })
+
+  test('a generated mnemonic is a valid BIP-39 length and made of words of the list', () => {
+    const words = mnemonicHelper.generateMnemonic({ size: 12 }).split(' ')
+    expect([12, 15, 18, 21, 24]).toContain(words.length)
+    expect(words.every(word => wordlist.includes(word))).toBe(true)
+  })
+
+  test('sizes outside 12–24 are refused', () => {
+    expect(() => mnemonicHelper.generateMnemonic({ size: 8 })).toThrow()
+  })
+})

package/tsconfig.json

@@ -7,5 +7,5 @@
     "rootDir": "./src/",
     "outDir": "./build/"
   },
-  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
+  "exclude": ["./dist/**/*", "./build/**/*", "./tests/**/*", "./*.ts"]
 }