@owlmeans/did 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,552 @@
+# @owlmeans/did
+
+A comprehensive Decentralized Identity (DID) and cryptographic wallet management library for OwlMeans Common applications. This package provides secure key generation, hierarchical deterministic wallets, and decentralized identity management with mnemonic seed support.
+
+## Overview
+
+The `@owlmeans/did` package is the core decentralized identity library in the OwlMeans Common ecosystem, providing:
+
+- **DID Wallet Management**: Hierarchical deterministic wallet creation and management
+- **Mnemonic Key Generation**: BIP39-compatible mnemonic phrase generation and recovery
+- **Cryptographic Key Derivation**: Secure key derivation with configurable depth
+- **Identity Management**: Profile and entity-based identity organization
+- **Secure Storage**: Resource-based secure storage for keys and metadata
+- **Plugin Architecture**: Extensible cryptographic algorithm support
+- **Cross-Platform Support**: Works across server, web, and mobile environments
+
+## Installation
+
+```bash
+npm install @owlmeans/did
+```
+
+## Core Concepts
+
+### DID Wallet
+
+A `DIDWallet` is a hierarchical deterministic wallet that manages cryptographic keys and associated metadata. It supports key derivation, profile management, and secure storage.
+
+### DID Key Model
+
+A `DIDKeyModel` extends the basic key pair model with DID-specific functionality, including path-based key derivation and parent-child key relationships.
+
+### Key Metadata
+
+Key metadata associates human-readable information with cryptographic keys, including names, entity IDs, and profile information.
+
+### Mnemonic Seeds
+
+Mnemonic phrases provide a human-readable way to backup and restore wallets, following BIP39 standards.
+
+## API Reference
+
+### Types
+
+#### `DIDWallet`
+Core wallet interface for managing decentralized identities.
+
+```typescript
+interface DIDWallet {
+  store: DIDStore                                                    // Storage backend
+  generate: (opts?: MnemonicOptions) => Promise<void>               // Generate new wallet
+  mnemonic: (crash?: boolean) => Promise<string | false>            // Get mnemonic phrase
+  master: () => Promise<DIDKeyModel>                                // Get master key
+  add: (key: DIDKeyModel, meta: KeyMeta) => Promise<void>           // Add key with metadata
+  meta: (key: string | DIDKeyModel) => Promise<KeyMeta>             // Get key metadata
+  update: (key: DIDKeyModel, meta: KeyMeta) => Promise<[DIDKeyModel, KeyMeta]>  // Update key metadata
+  get: (did: string) => Promise<DIDKeyModel | null>                 // Get key by DID
+  find: (meta: Partial<KeyMeta>) => Promise<DIDKeyModel[]>          // Find keys by metadata
+  provide: (meta: Partial<KeyMeta>) => Promise<DIDKeyModel[]>       // Provide keys matching criteria
+  remove: (did: string | KeyMeta | DIDKeyModel) => Promise<DIDKeyModel>  // Remove key
+  all: () => Promise<DIDKeyModel[]>                                 // Get all keys
+  allMeta: () => Promise<KeyMeta[]>                                 // Get all metadata
+}
+```
+
+#### `DIDKeyModel`
+Extended key model with DID capabilities.
+
+```typescript
+interface DIDKeyModel extends KeyPairModel {
+  keyPair?: DIDKeyPair                        // Underlying key pair
+  derive: (path: string) => DIDKeyModel       // Derive child keys
+}
+```
+
+#### `KeyMeta`
+Metadata associated with keys.
+
+```typescript
+interface KeyMeta extends Partial<Profile> {
+  id: string          // Unique identifier
+  name: string        // Human-readable name
+  entityId?: string   // Associated entity ID
+}
+```
+
+#### `DIDStore`
+Storage interface for wallet data.
+
+```typescript
+interface DIDStore {
+  master: MasterResource      // Master key storage
+  keys: KeyPairResource       // Key pair storage
+  meta: KeyMetaResource       // Metadata storage
+}
+```
+
+### Factory Functions
+
+#### `makeWallet(store: DIDStore, opts?: MakeDIDWalletOptions): Promise<DIDWallet>`
+Creates a new DID wallet instance.
+
+**Parameters:**
+- `store`: Storage backend for wallet data
+- `opts`: Optional wallet creation options
+
+**Options:**
+```typescript
+interface MakeDIDWalletOptions {
+  force?: boolean           // Force creation even if master exists
+  allowEmpty?: boolean      // Allow empty wallet creation
+  mnemonic?: MnemonicOptions  // Mnemonic generation options
+  type?: string            // Key type (default: 'owlmk')
+  allowCustomType?: boolean // Allow custom key types
+}
+```
+
+#### `makeDidKeyModel(input?: KeyPair | string): DIDKeyModel`
+Creates a DID key model from key pair or type string.
+
+### Wallet Operations
+
+#### `generate(opts?: MnemonicOptions): Promise<void>`
+Generates a new wallet with mnemonic seed.
+
+```typescript
+// Generate with default options
+await wallet.generate()
+
+// Generate with custom entropy
+await wallet.generate({ size: 256 })
+```
+
+#### `mnemonic(crash?: boolean): Promise<string | false>`
+Retrieves the wallet's mnemonic phrase.
+
+```typescript
+// Get mnemonic (safe, returns false if not available)
+const mnemonic = await wallet.mnemonic()
+
+// Get mnemonic (throws error if not available)
+const mnemonic = await wallet.mnemonic(true)
+```
+
+#### `master(): Promise<DIDKeyModel>`
+Gets the master key for the wallet.
+
+```typescript
+const masterKey = await wallet.master()
+console.log('Master DID:', masterKey.did)
+```
+
+### Key Management
+
+#### `add(key: DIDKeyModel, meta: KeyMeta): Promise<void>`
+Adds a key with metadata to the wallet.
+
+```typescript
+const childKey = masterKey.derive('profile/user')
+await wallet.add(childKey, {
+  id: 'user-profile',
+  name: 'User Profile Key',
+  entityId: 'user-123'
+})
+```
+
+#### `get(did: string): Promise<DIDKeyModel | null>`
+Retrieves a key by its DID.
+
+```typescript
+const key = await wallet.get('did:owlmeans:key:...')
+if (key) {
+  console.log('Found key:', key.did)
+}
+```
+
+#### `find(meta: Partial<KeyMeta>): Promise<DIDKeyModel[]>`
+Finds keys matching metadata criteria.
+
+```typescript
+// Find all profile keys
+const profileKeys = await wallet.find({ entityId: 'user-123' })
+
+// Find keys by name pattern
+const namedKeys = await wallet.find({ name: 'Service Key' })
+```
+
+### Key Derivation
+
+#### `derive(path: string): DIDKeyModel`
+Derives child keys from parent keys using hierarchical paths.
+
+```typescript
+const masterKey = await wallet.master()
+
+// Derive profile key
+const profileKey = masterKey.derive('profile/user')
+
+// Derive service key
+const serviceKey = masterKey.derive('service/api')
+
+// Derive entity-specific key
+const entityKey = masterKey.derive('entity/org/dept')
+```
+
+### Constants
+
+```typescript
+const KEY_OWL = 'owlmk'              // Default key type
+const MAX_DEPTH = 6                 // Maximum derivation depth
+const PROFILE_PREFIX = 'profile'    // Profile key prefix
+const ENTITY_PREFIX = 'entity'      // Entity key prefix  
+const SERVICE_PREFIX = 'service'    // Service key prefix
+const MASTER = '_master_key'        // Master key identifier
+```
+
+## Usage Examples
+
+### Basic Wallet Creation
+
+```typescript
+import { makeWallet } from '@owlmeans/did'
+import { createDIDStore } from './storage'
+
+// Create storage backend
+const store = createDIDStore()
+
+// Create new wallet
+const wallet = await makeWallet(store, {
+  allowEmpty: true
+})
+
+// Generate master key
+await wallet.generate()
+
+// Get mnemonic for backup
+const mnemonic = await wallet.mnemonic()
+console.log('Backup phrase:', mnemonic)
+```
+
+### Key Derivation and Management
+
+```typescript
+// Get master key
+const master = await wallet.master()
+
+// Derive keys for different purposes
+const profileKey = master.derive('profile/personal')
+const workKey = master.derive('profile/work')
+const apiKey = master.derive('service/api/v1')
+
+// Add keys with metadata
+await wallet.add(profileKey, {
+  id: 'personal-profile',
+  name: 'Personal Profile',
+  entityId: 'user-123'
+})
+
+await wallet.add(workKey, {
+  id: 'work-profile', 
+  name: 'Work Profile',
+  entityId: 'org-456'
+})
+
+await wallet.add(apiKey, {
+  id: 'api-service',
+  name: 'API Service Key',
+  entityId: 'service-789'
+})
+```
+
+### Identity Management
+
+```typescript
+// Create identity for a user
+const createUserIdentity = async (userId: string, name: string) => {
+  const master = await wallet.master()
+  const userKey = master.derive(`profile/${userId}`)
+  
+  await wallet.add(userKey, {
+    id: `user-${userId}`,
+    name: `${name}'s Identity`,
+    entityId: userId,
+    scopes: ['user:profile', 'user:data']
+  })
+  
+  return userKey
+}
+
+// Create identity for a service
+const createServiceIdentity = async (serviceName: string) => {
+  const master = await wallet.master()
+  const serviceKey = master.derive(`service/${serviceName}`)
+  
+  await wallet.add(serviceKey, {
+    id: `service-${serviceName}`,
+    name: `${serviceName} Service`,
+    entityId: serviceName,
+    scopes: ['service:*']
+  })
+  
+  return serviceKey
+}
+```
+
+### Signature and Verification
+
+```typescript
+// Sign data with a specific key
+const signWithProfile = async (data: string, profileId: string) => {
+  const keys = await wallet.find({ id: profileId })
+  if (keys.length === 0) {
+    throw new Error('Profile key not found')
+  }
+  
+  const key = keys[0]
+  const signature = await key.sign(Buffer.from(data, 'utf8'))
+  
+  return {
+    data,
+    signature: signature.toString('base64'),
+    did: key.did,
+    publicKey: key.publicKey?.toString('base64')
+  }
+}
+
+// Verify signature
+const verifySignature = async (signedData: any) => {
+  const key = await wallet.get(signedData.did)
+  if (!key) {
+    throw new Error('Key not found')
+  }
+  
+  const signature = Buffer.from(signedData.signature, 'base64')
+  const data = Buffer.from(signedData.data, 'utf8')
+  
+  return await key.verify(data, signature)
+}
+```
+
+### Multi-Entity Wallet
+
+```typescript
+// Organization with multiple departments
+const setupOrganizationWallet = async () => {
+  const master = await wallet.master()
+  
+  // Organization master key
+  const orgKey = master.derive('entity/acme-corp')
+  await wallet.add(orgKey, {
+    id: 'acme-corp',
+    name: 'ACME Corporation',
+    entityId: 'org-acme'
+  })
+  
+  // Department keys
+  const departments = ['hr', 'engineering', 'sales']
+  
+  for (const dept of departments) {
+    const deptKey = orgKey.derive(`dept/${dept}`)
+    await wallet.add(deptKey, {
+      id: `acme-${dept}`,
+      name: `ACME ${dept.toUpperCase()} Department`,
+      entityId: `org-acme-${dept}`
+    })
+  }
+  
+  // Employee keys within departments
+  const engineeringKey = await wallet.get('acme-engineering')
+  const employeeKey = engineeringKey!.derive('employee/john-doe')
+  
+  await wallet.add(employeeKey, {
+    id: 'john-doe-work',
+    name: 'John Doe Work Identity',
+    entityId: 'user-john-doe',
+    groups: ['engineering', 'senior-dev']
+  })
+}
+```
+
+### Wallet Recovery
+
+```typescript
+// Recover wallet from mnemonic
+const recoverWallet = async (mnemonic: string, store: DIDStore) => {
+  // Create wallet allowing empty state
+  const wallet = await makeWallet(store, { allowEmpty: true })
+  
+  // Import from mnemonic
+  await wallet.generate({ mnemonic })
+  
+  // Verify master key was restored
+  const master = await wallet.master()
+  console.log('Recovered master DID:', master.did)
+  
+  // List all recovered keys
+  const allKeys = await wallet.all()
+  console.log(`Recovered ${allKeys.length} keys`)
+  
+  return wallet
+}
+```
+
+### Key Export and Import
+
+```typescript
+// Export key for external use
+const exportKey = async (keyId: string) => {
+  const keys = await wallet.find({ id: keyId })
+  if (keys.length === 0) {
+    throw new Error('Key not found')
+  }
+  
+  const key = keys[0]
+  const meta = await wallet.meta(key)
+  
+  return {
+    did: key.did,
+    publicKey: key.publicKey?.toString('base64'),
+    privateKey: key.privateKey?.toString('base64'), // Only if needed
+    meta: {
+      id: meta.id,
+      name: meta.name,
+      entityId: meta.entityId
+    }
+  }
+}
+
+// Import external key
+const importKey = async (keyData: any) => {
+  const keyModel = makeDidKeyModel({
+    type: 'ed25519',
+    publicKey: Buffer.from(keyData.publicKey, 'base64'),
+    privateKey: keyData.privateKey ? Buffer.from(keyData.privateKey, 'base64') : undefined
+  })
+  
+  await wallet.add(keyModel, keyData.meta)
+}
+```
+
+## Advanced Features
+
+### Custom Key Types
+
+```typescript
+// Register custom key type
+const customKeyType = 'custom-ed25519'
+
+const wallet = await makeWallet(store, {
+  type: customKeyType,
+  allowCustomType: true
+})
+```
+
+### Hierarchical Path Management
+
+```typescript
+// Standardized path structure
+const createStandardPath = (type: 'profile' | 'entity' | 'service', identifier: string, subpath?: string) => {
+  const basePath = `${type}/${identifier}`
+  return subpath ? `${basePath}/${subpath}` : basePath
+}
+
+// Usage
+const userProfilePath = createStandardPath('profile', 'user123')
+const serviceApiPath = createStandardPath('service', 'api', 'v1')
+const entityDeptPath = createStandardPath('entity', 'corp', 'dept/engineering')
+```
+
+### Batch Operations
+
+```typescript
+// Batch key creation
+const createBatchKeys = async (specifications: Array<{path: string, meta: Omit<KeyMeta, 'id'>}>) => {
+  const master = await wallet.master()
+  const keys: DIDKeyModel[] = []
+  
+  for (const spec of specifications) {
+    const key = master.derive(spec.path)
+    await wallet.add(key, {
+      ...spec.meta,
+      id: `${spec.meta.name.toLowerCase().replace(/\s+/g, '-')}`
+    })
+    keys.push(key)
+  }
+  
+  return keys
+}
+```
+
+## Error Handling
+
+The package provides specialized error types:
+
+```typescript
+import { DIDWalletError, DIDKeyError, DIDInitializationError } from '@owlmeans/did'
+
+try {
+  const wallet = await makeWallet(store)
+  await wallet.generate()
+} catch (error) {
+  if (error instanceof DIDInitializationError) {
+    console.error('Wallet initialization failed:', error.message)
+  } else if (error instanceof DIDKeyError) {
+    console.error('Key operation failed:', error.message)
+  } else if (error instanceof DIDWalletError) {
+    console.error('Wallet operation failed:', error.message)
+  }
+}
+```
+
+## Integration with OwlMeans Ecosystem
+
+The `@owlmeans/did` package integrates with:
+
+- **@owlmeans/basic-keys**: Core cryptographic operations and key management
+- **@owlmeans/auth**: Authentication and authorization with DID-based identities
+- **@owlmeans/resource**: Storage backend for wallet data persistence
+- **@owlmeans/client-did**: Client-side DID wallet implementations
+- **@owlmeans/server-auth**: Server-side DID authentication
+- **@owlmeans/context**: Service registration and dependency injection
+
+## Security Considerations
+
+- Store mnemonic phrases securely and never expose them in logs
+- Use appropriate key derivation paths to prevent key correlation
+- Implement proper access controls for wallet operations
+- Regular backup of wallet data and mnemonic phrases
+- Use secure random number generation for key creation
+- Validate all imported keys and metadata
+
+## Best Practices
+
+### Key Management
+- Use descriptive names and metadata for all keys
+- Implement consistent path naming conventions
+- Regular audit of stored keys and remove unused ones
+- Use different keys for different purposes (signing, encryption, etc.)
+
+### Security
+- Never store private keys in plain text
+- Use hardware security modules where possible
+- Implement proper key rotation policies
+- Monitor for unauthorized key access
+
+### Performance
+- Cache frequently used keys in memory
+- Use batch operations for multiple key operations
+- Implement proper indexing for key searches
+- Consider key compression for storage efficiency
+
+Fixes #32.

package/build/consts.d.ts

@@ -0,0 +1,9 @@
+export declare const KEY_OWL = "owlmk";
+export declare const KP_SEP = "/";
+export declare const MAX_DEPTH = 6;
+export declare const PROFILE_PREFIX = "profile";
+export declare const ENTITY_PREFIX = "entity";
+export declare const SERVICE_PREFIX = "service";
+export declare const PREFIX_SEP = ".";
+export declare const MASTER = "_master_key";
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,UAAU,CAAA;AAE9B,eAAO,MAAM,MAAM,MAAM,CAAA;AAEzB,eAAO,MAAM,SAAS,IAAI,CAAA;AAE1B,eAAO,MAAM,cAAc,YAAY,CAAA;AAEvC,eAAO,MAAM,aAAa,WAAW,CAAA;AAErC,eAAO,MAAM,cAAc,YAAY,CAAA;AAEvC,eAAO,MAAM,UAAU,MAAM,CAAA;AAE7B,eAAO,MAAM,MAAM,gBAAgB,CAAA"}

package/build/consts.js

@@ -0,0 +1,9 @@
+export const KEY_OWL = 'owlmk';
+export const KP_SEP = '/';
+export const MAX_DEPTH = 6;
+export const PROFILE_PREFIX = 'profile';
+export const ENTITY_PREFIX = 'entity';
+export const SERVICE_PREFIX = 'service';
+export const PREFIX_SEP = '.';
+export const MASTER = '_master_key';
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAA;AAE9B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;AAEzB,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAA;AAE1B,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAA;AAEvC,MAAM,CAAC,MAAM,aAAa,GAAG,QAAQ,CAAA;AAErC,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAA;AAEvC,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAA;AAE7B,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAA"}

package/build/errors.d.ts

@@ -0,0 +1,22 @@
+import { ResilientError } from '@owlmeans/error';
+export declare class DIDError extends ResilientError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class DIDKeyError extends DIDError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class DIDWalletError extends DIDError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class DIDWalletPermissionError extends DIDWalletError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class DIDInitializationError extends DIDWalletError {
+    static typeName: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,qBAAa,QAAS,SAAQ,cAAc;IAC1C,OAAuB,QAAQ,SAAa;gBAEhC,OAAO,GAAE,MAAgB;CAGtC;AAED,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAuB,QAAQ,SAA6B;gBAEhD,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,cAAe,SAAQ,QAAQ;IAC1C,OAAuB,QAAQ,SAAgC;gBAEnD,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,wBAAyB,SAAQ,cAAc;IAC1D,OAAuB,QAAQ,SAA0C;gBAE7D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,sBAAuB,SAAQ,cAAc;IACxD,OAAuB,QAAQ,SAA8C;gBAEjE,OAAO,GAAE,MAAgB;CAItC"}

package/build/errors.js

@@ -0,0 +1,41 @@
+import { ResilientError } from '@owlmeans/error';
+export class DIDError extends ResilientError {
+    static typeName = 'DIDError';
+    constructor(message = 'error') {
+        super(DIDError.typeName, `did:${message}`);
+    }
+}
+export class DIDKeyError extends DIDError {
+    static typeName = `${DIDError.typeName}:Key`;
+    constructor(message = 'error') {
+        super(`wallet:${message}`);
+        this.type = DIDKeyError.typeName;
+    }
+}
+export class DIDWalletError extends DIDError {
+    static typeName = `${DIDError.typeName}:Wallet`;
+    constructor(message = 'error') {
+        super(`wallet:${message}`);
+        this.type = DIDWalletError.typeName;
+    }
+}
+export class DIDWalletPermissionError extends DIDWalletError {
+    static typeName = `${DIDWalletError.typeName}:Permission`;
+    constructor(message = 'error') {
+        super(`permission:${message}`);
+        this.type = DIDWalletPermissionError.typeName;
+    }
+}
+export class DIDInitializationError extends DIDWalletError {
+    static typeName = `${DIDWalletError.typeName}:Initialization`;
+    constructor(message = 'error') {
+        super(`init:${message}`);
+        this.type = DIDInitializationError.typeName;
+    }
+}
+ResilientError.registerErrorClass(DIDError);
+ResilientError.registerErrorClass(DIDKeyError);
+ResilientError.registerErrorClass(DIDWalletError);
+ResilientError.registerErrorClass(DIDWalletPermissionError);
+ResilientError.registerErrorClass(DIDInitializationError);
+//# sourceMappingURL=errors.js.map

package/build/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,MAAM,OAAO,QAAS,SAAQ,cAAc;IACnC,MAAM,CAAU,QAAQ,GAAG,UAAU,CAAA;IAE5C,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,OAAO,EAAE,CAAC,CAAA;IAC5C,CAAC;;AAGH,MAAM,OAAO,WAAY,SAAQ,QAAQ;IAChC,MAAM,CAAU,QAAQ,GAAG,GAAG,QAAQ,CAAC,QAAQ,MAAM,CAAA;IAE5D,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,UAAU,OAAO,EAAE,CAAC,CAAA;QAC1B,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAA;IAClC,CAAC;;AAGH,MAAM,OAAO,cAAe,SAAQ,QAAQ;IACnC,MAAM,CAAU,QAAQ,GAAG,GAAG,QAAQ,CAAC,QAAQ,SAAS,CAAA;IAE/D,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,UAAU,OAAO,EAAE,CAAC,CAAA;QAC1B,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,QAAQ,CAAA;IACrC,CAAC;;AAGH,MAAM,OAAO,wBAAyB,SAAQ,cAAc;IACnD,MAAM,CAAU,QAAQ,GAAG,GAAG,cAAc,CAAC,QAAQ,aAAa,CAAA;IAEzE,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,cAAc,OAAO,EAAE,CAAC,CAAA;QAC9B,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC,QAAQ,CAAA;IAC/C,CAAC;;AAGH,MAAM,OAAO,sBAAuB,SAAQ,cAAc;IACjD,MAAM,CAAU,QAAQ,GAAG,GAAG,cAAc,CAAC,QAAQ,iBAAiB,CAAA;IAE7E,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,QAAQ,OAAO,EAAE,CAAC,CAAA;QACxB,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC,QAAQ,CAAA;IAC7C,CAAC;;AAGH,cAAc,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAA;AAC3C,cAAc,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAA;AAC9C,cAAc,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAA;AACjD,cAAc,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,CAAA;AAC3D,cAAc,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAA"}

package/build/i18n/en.json

@@ -0,0 +1,8 @@
+{
+    "address": {
+        "hint": "DID address"
+    },
+    "master": {
+        "title": "Master key"
+    }
+}