@owlmeans/did 0.1.0

package/src/utils.ts

@@ -0,0 +1,34 @@
+import { ENTITY_PREFIX, KP_SEP, PREFIX_SEP, PROFILE_PREFIX, SERVICE_PREFIX } from './consts.js'
+import type { KeyMeta } from './types.js'
+
+export const toPath = (...args: (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])
+  }
+
+  return toPath(...items)
+}
+
+const skipFields = ['name']
+
+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)
+    ))

package/src/wallet/index.ts

@@ -0,0 +1,2 @@
+
+export type * from './types.js'

package/src/wallet/types.ts

@@ -0,0 +1,43 @@
+import { DIDKeyPair, KeyMeta } from '../types.js'
+
+export interface WalletFacade {
+  sign: (entityId: string | null, payload: Uint8Array, opts?: WalletOptions) => Promise<Uint8Array>
+
+  createKey: (entityId: string, opts?: NewKeyOptions) => Promise<string>
+
+  getEntityKey: (entityId: string, opts?: WalletOptions) => Promise<WalletKey>
+
+  // TODO: This operation is maximum unsecure. It needs to be double checked by user
+  // and probably limited by the client to only OwlMeans services
+  getMasterDid: (opts?: RequestReason) => Promise<string>
+
+  selectKey: (opts?: WalletOptions) => Promise<WalletKey>
+
+  getPublicDetails: (did: string, opts?: RequestReason) => Promise<WalletKey>
+
+  requestPermissions: (methods: string[], opts?: WalletOptions) => Promise<boolean>
+
+  close: () => Promise<void>
+}
+
+export interface WalletKey {
+  key: Partial<DIDKeyPair>
+  meta: KeyMeta
+}
+
+export interface RequestReason {
+  intro?: string
+  reason?: string
+  timestamp?: number
+}
+
+export interface WalletOptions extends RequestReason {
+  purpose?: string
+  type?: string
+  profileId?: string
+  service?: string
+}
+
+export interface NewKeyOptions extends WalletOptions {
+  name: string
+}

package/src/wallet.ts

@@ -0,0 +1,183 @@
+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('mnemonic')
+        }
+        return false
+      }
+
+      return toMnemonic(master.seed)
+    },
+
+    master: async () => makeDidKeyModel(await store.master.get(MASTER)),
+
+    add: async (key, meta) => {
+      if (key.keyPair == null || key.keyPair.privateKey == null) {
+        throw new DIDWalletError('key:non-managable')
+      }
+      const stored = await store.keys.load(key.exportAddress())
+      if (stored != null) {
+        throw new DIDWalletError('key:exists')
+      }
+      await store.keys.create({ id: key.exportAddress(), ...key.keyPair })
+      await store.meta.create({ ...meta, id: key.exportAddress() })
+    },
+
+    meta: async key => {
+      if (typeof key === 'string') {
+        if (null == await store.keys.load(key)) {
+          throw new DIDWalletError('no:key')
+        }
+
+        return store.meta.get(key)
+      }
+
+      return wallet.meta(key.exportAddress())
+    },
+
+    update: async (key, meta) => {
+      if (key.keyPair == null) {
+        throw new DIDWalletError('key:non-managable')
+      }
+      const did = key.exportAddress()
+      const returnKey = await store.keys.save({ id: did, ...key.keyPair })
+      const returnMeta = await store.meta.save({ ...meta, id: did })
+
+      return [makeDidKeyModel(returnKey), returnMeta]
+    },
+
+    get: async did => {
+      if (await store.keys.load(did) == null) {
+        throw new DIDWalletError('no:key')
+      }
+      return makeDidKeyModel(await store.keys.get(did))
+    },
+
+    find: async meta => {
+      const result = await store.meta.list(
+        Object.fromEntries(Object.entries(meta).filter(([_, v]) => typeof v !== 'boolean'))
+      )
+
+      const keys = await Promise.all(result.items.filter(item => matchMeta(item, meta))
+        .map(async meta => store.keys.get(meta.id)))
+
+      return keys.map(key => makeDidKeyModel(key))
+    },
+
+    provide: async meta => {
+      const found = await wallet.find(meta)
+      if (found.length === 0) {
+        const path = mataToPath(meta)
+        const master = await wallet.master()
+        const key = master.derive(path)
+        if (meta.name == null) {
+          throw new DIDKeyError('no:name')
+        }
+        const metaToSave: KeyMeta = {
+          ...meta, id: meta.id ?? key.exportAddress(), name: meta.name
+        }
+        await wallet.add(key, metaToSave)
+
+        return [key]
+      }
+
+      return found
+    },
+
+    remove: async did => {
+      if (typeof did === 'object') {
+        if ("keyPair" in did) {
+          return wallet.remove(did.exportAddress())
+        }
+        const keys = await wallet.find(did as KeyMeta)
+        const key = await keys.reduce<Promise<DIDKeyModel | null>>(async (_, key) => {
+          return wallet.remove(key)
+        }, Promise.resolve(null))
+        if (key == null) {
+          throw new DIDWalletError('no:key')
+        }
+        return key
+      }
+      const key = await store.keys.load(did)
+      if (key == null) {
+        throw new DIDWalletError('no:key')
+      }
+      await store.keys.delete(key)
+      const model = makeDidKeyModel(key)
+      await store.meta.delete(model.exportAddress())
+
+      return model
+    },
+
+    all: async () => {
+      const result: KeyPairRecord[] = []
+      let more = false
+      do {
+        const found = await store.keys.list({ pager: { page: Math.floor(result.length / 100), size: 100 } })
+        result.push(...found.items)
+        more = found.pager?.total != null && found.pager.total > result.length
+      } while (more)
+
+      return result.map(key => makeDidKeyModel(key))
+    },
+
+    allMeta: async () => {
+      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 } })
+        result.push(...found.items)
+        more = found.pager?.total != null && found.pager.total > result.length
+      } while (more)
+
+      return result
+    }
+  }
+
+  if (opts?.force) {
+    await wallet.generate(opts.mnemonic)
+  }
+
+  return wallet
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+    "../tsconfig.react.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+    "moduleResolution": "Bundler"
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/errors.ts","./src/i18n.ts","./src/index.ts","./src/model.ts","./src/types.ts","./src/utils.ts","./src/wallet.ts","./src/plugins/ed25519owl.ts","./src/plugins/exports.ts","./src/plugins/index.ts","./src/utils/index.ts","./src/utils/key.ts","./src/utils/mnemonic.ts","./src/wallet/index.ts","./src/wallet/types.ts"],"version":"5.6.3"}