@didcid/keymaster 0.3.4 → 0.3.6

package/README.md

@@ -198,14 +198,14 @@ keymaster list-ids
 | `create-response <challenge>` | Respond to a challenge |
 | `verify-response <response>` | Verify a response |
 
-##### Names (Aliases)
+##### Aliases
 
 | Command | Description |
 |---------|-------------|
-| `add-name <name> <did>` | Add alias for DID |
-| `get-name <name>` | Get DID by alias |
-| `remove-name <name>` | Remove alias |
-| `list-names` | List all aliases |
+| `add-alias <alias> <did>` | Add alias for DID |
+| `get-alias <alias>` | Get DID by alias |
+| `remove-alias <alias>` | Remove alias |
+| `list-aliases` | List all aliases |
 
 ##### Groups
 
@@ -276,13 +276,13 @@ Many commands support these options:
 
 | Option | Description |
 |--------|-------------|
-| `-n, --name <name>` | Assign a name to created DID |
+| `-a, --alias <alias>` | Assign an alias to created DID |
 | `-r, --registry <registry>` | Specify DID registry |
 
 Example:
 ```bash
 keymaster create-id MyBot -r hyperswarm
-keymaster create-schema schema.json -n my-schema -r local
+keymaster create-schema schema.json -a my-schema -r local
 ```
 
 ### Client

package/dist/cjs/db/typeGuards.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 function isWalletEncFile(obj) {
-    return !!obj && obj.version === 1 && typeof obj.enc === 'string' && obj.seed?.mnemonicEnc;
+    return !!obj && (obj.version === 1 || obj.version === 2) && typeof obj.enc === 'string' && obj.seed?.mnemonicEnc;
 }
 function isWalletFile(obj) {
-    return !!obj && obj.version === 1 && obj.seed?.mnemonicEnc && !('enc' in obj);
+    return !!obj && (obj.version === 1 || obj.version === 2) && obj.seed?.mnemonicEnc && !('enc' in obj);
 }
 
 exports.isWalletEncFile = isWalletEncFile;

package/dist/cjs/keymaster-client.cjs

@@ -275,36 +275,36 @@ class KeymasterClient {
             throwError(error);
         }
     }
-    async listNames() {
+    async listAliases() {
         try {
-            const response = await axios.get(`${this.API}/names`);
-            return response.data.names;
+            const response = await axios.get(`${this.API}/aliases`);
+            return response.data.aliases;
         }
         catch (error) {
             throwError(error);
         }
     }
-    async addName(name, did) {
+    async addAlias(alias, did) {
         try {
-            const response = await axios.post(`${this.API}/names`, { name, did });
+            const response = await axios.post(`${this.API}/aliases`, { alias, did });
             return response.data.ok;
         }
         catch (error) {
             throwError(error);
         }
     }
-    async getName(name) {
+    async getAlias(alias) {
         try {
-            const response = await axios.get(`${this.API}/names/${name}`);
+            const response = await axios.get(`${this.API}/aliases/${alias}`);
             return response.data.did;
         }
         catch (error) {
             throwError(error);
         }
     }
-    async removeName(name) {
+    async removeAlias(alias) {
         try {
-            const response = await axios.delete(`${this.API}/names/${name}`);
+            const response = await axios.delete(`${this.API}/aliases/${alias}`);
             return response.data.ok;
         }
         catch (error) {

package/dist/cjs/keymaster.cjs

@@ -1126,7 +1126,7 @@ class Keymaster {
     cipher;
     defaultRegistry;
     ephemeralRegistry;
-    maxNameLength;
+    maxAliasLength;
     maxDataLength;
     _walletCache;
     _hdkeyCache;
@@ -1149,7 +1149,7 @@ class Keymaster {
         this.cipher = options.cipher;
         this.defaultRegistry = options.defaultRegistry || 'hyperswarm';
         this.ephemeralRegistry = 'hyperswarm';
-        this.maxNameLength = options.maxNameLength || 32;
+        this.maxAliasLength = options.maxAliasLength || 32;
         this.maxDataLength = 8 * 1024; // 8 KB max data to store in a JSON object
     }
     async listRegistries() {
@@ -1181,18 +1181,18 @@ class Keymaster {
         if (!stored) {
             stored = await this.newWallet();
         }
-        const upgraded = await this.upgradeWallet(stored);
-        this._walletCache = await this.decryptWallet(upgraded);
+        const decrypted = await this.decryptWallet(stored);
+        this._walletCache = await this.upgradeWallet(decrypted);
         return this._walletCache;
     }
     async saveWallet(wallet, overwrite = true) {
-        let upgraded = await this.upgradeWallet(wallet);
         // Decrypt if encrypted to verify passphrase and get decrypted form
-        const decrypted = await this.decryptWallet(upgraded);
-        let toStore = await this.encryptWalletForStorage(decrypted);
+        const decrypted = await this.decryptWallet(wallet);
+        const upgraded = await this.upgradeWallet(decrypted);
+        let toStore = await this.encryptWalletForStorage(upgraded);
         const ok = await this.db.saveWallet(toStore, overwrite);
         if (ok) {
-            this._walletCache = decrypted;
+            this._walletCache = upgraded;
         }
         return ok;
     }
@@ -1208,7 +1208,7 @@ class Keymaster {
         }
         const mnemonicEnc = await encryption.encMnemonic(mnemonic, this.passphrase);
         const wallet = {
-            version: 1,
+            version: 2,
             seed: { mnemonicEnc },
             counter: 0,
             ids: {}
@@ -1275,10 +1275,10 @@ class Keymaster {
                 }
             }
         }
-        if (wallet.names) {
-            for (const name of Object.keys(wallet.names)) {
+        if (wallet.aliases) {
+            for (const alias of Object.keys(wallet.aliases)) {
                 try {
-                    const doc = await this.resolveDID(wallet.names[name]);
+                    const doc = await this.resolveDID(wallet.aliases[alias]);
                     if (doc.didDocumentMetadata?.deactivated) {
                         deleted += 1;
                     }
@@ -1295,7 +1295,7 @@ class Keymaster {
         let idsRemoved = 0;
         let ownedRemoved = 0;
         let heldRemoved = 0;
-        let namesRemoved = 0;
+        let aliasesRemoved = 0;
         await this.mutateWallet(async (wallet) => {
             for (const name of Object.keys(wallet.ids)) {
                 let remove = false;
@@ -1353,11 +1353,11 @@ class Keymaster {
                     }
                 }
             }
-            if (wallet.names) {
-                for (const name of Object.keys(wallet.names)) {
+            if (wallet.aliases) {
+                for (const alias of Object.keys(wallet.aliases)) {
                     let remove = false;
                     try {
-                        const doc = await this.resolveDID(wallet.names[name]);
+                        const doc = await this.resolveDID(wallet.aliases[alias]);
                         if (doc.didDocumentMetadata?.deactivated) {
                             remove = true;
                         }
@@ -1366,13 +1366,13 @@ class Keymaster {
                         remove = true;
                     }
                     if (remove) {
-                        delete wallet.names[name];
-                        namesRemoved++;
+                        delete wallet.aliases[alias];
+                        aliasesRemoved++;
                     }
                 }
             }
         });
-        return { idsRemoved, ownedRemoved, heldRemoved, namesRemoved };
+        return { idsRemoved, ownedRemoved, heldRemoved, aliasesRemoved };
     }
     async resolveSeedBank() {
         const keypair = await this.hdKeyPair();
@@ -1502,10 +1502,10 @@ class Keymaster {
                 for (const k in current) {
                     delete current[k];
                 }
-                // Upgrade the recovered wallet to the latest version if needed
-                wallet = await this.upgradeWallet(wallet);
                 // Decrypt the wallet if needed
                 wallet = db_typeGuards.isWalletEncFile(wallet) ? await this.decryptWalletFromStorage(wallet) : wallet;
+                // Upgrade the recovered wallet to the latest version if needed
+                wallet = await this.upgradeWallet(wallet);
                 // Copy all properties from the recovered wallet into the cleared current wallet
                 // This effectively replaces the current wallet with the recovered one
                 Object.assign(current, wallet);
@@ -1608,16 +1608,16 @@ class Keymaster {
         return null;
     }
     async createAsset(data, options = {}) {
-        let { registry = this.defaultRegistry, controller, validUntil, name } = options;
+        let { registry = this.defaultRegistry, controller, validUntil, alias } = options;
         if (validUntil) {
             const validate = new Date(validUntil);
             if (isNaN(validate.getTime())) {
                 throw new InvalidParameterError('options.validUntil');
             }
         }
-        if (name) {
+        if (alias) {
             const wallet = await this.loadWallet();
-            this.validateName(name, wallet);
+            this.validateAlias(alias, wallet, 'alias');
         }
         if (!data) {
             throw new InvalidParameterError('data');
@@ -1644,8 +1644,8 @@ class Keymaster {
         if (!validUntil) {
             await this.addToOwned(did);
         }
-        if (name) {
-            await this.addName(name, did);
+        if (alias) {
+            await this.addAlias(alias, did);
         }
         return did;
     }
@@ -1989,8 +1989,8 @@ class Keymaster {
             throw new InvalidDIDError();
         }
         const wallet = await this.loadWallet();
-        if (wallet.names && name in wallet.names) {
-            return wallet.names[name];
+        if (wallet.aliases && name in wallet.aliases) {
+            return wallet.aliases[name];
         }
         if (wallet.ids && name in wallet.ids) {
             return wallet.ids[name].did;
@@ -2080,25 +2080,25 @@ class Keymaster {
         const id = await this.fetchIdInfo(owner);
         return id.owned || [];
     }
-    validateName(name, wallet) {
-        if (typeof name !== 'string' || !name.trim()) {
-            throw new InvalidParameterError('name must be a non-empty string');
+    validateAlias(alias, wallet, label = 'name') {
+        if (typeof alias !== 'string' || !alias.trim()) {
+            throw new InvalidParameterError(`${label} must be a non-empty string`);
         }
-        name = name.trim(); // Remove leading/trailing whitespace
-        if (name.length > this.maxNameLength) {
-            throw new InvalidParameterError(`name too long`);
+        alias = alias.trim(); // Remove leading/trailing whitespace
+        if (alias.length > this.maxAliasLength) {
+            throw new InvalidParameterError(`${label} too long`);
         }
-        if (/[^\P{Cc}]/u.test(name)) {
-            throw new InvalidParameterError('name contains unprintable characters');
+        if (/[^\P{Cc}]/u.test(alias)) {
+            throw new InvalidParameterError(`${label} contains unprintable characters`);
         }
-        const alreadyUsedError = 'name already used';
-        if (wallet && wallet.names && name in wallet.names) {
+        const alreadyUsedError = `${label} already used`;
+        if (wallet && wallet.aliases && alias in wallet.aliases) {
             throw new InvalidParameterError(alreadyUsedError);
         }
-        if (wallet && wallet.ids && name in wallet.ids) {
+        if (wallet && wallet.ids && alias in wallet.ids) {
             throw new InvalidParameterError(alreadyUsedError);
         }
-        return name;
+        return alias;
     }
     async createId(name, options = {}) {
         let did = '';
@@ -2116,7 +2116,7 @@ class Keymaster {
     async createIdOperation(name, account = 0, options = {}) {
         const { registry = this.defaultRegistry } = options;
         const wallet = await this.loadWallet();
-        name = this.validateName(name, wallet);
+        name = this.validateAlias(name, wallet);
         const hdkey = await this.getHDKeyFromCacheOrMnemonic(wallet);
         const path = `m/44'/0'/${account}'/0/0`;
         const didkey = hdkey.derive(path);
@@ -2162,7 +2162,7 @@ class Keymaster {
     }
     async renameId(id, name) {
         await this.mutateWallet((wallet) => {
-            name = this.validateName(name);
+            name = this.validateAlias(name);
             if (!(id in wallet.ids)) {
                 throw new UnknownIDError();
             }
@@ -2271,40 +2271,40 @@ class Keymaster {
         });
         return ok;
     }
-    async listNames(options = {}) {
+    async listAliases(options = {}) {
         const { includeIDs = false } = options;
         const wallet = await this.loadWallet();
-        const names = { ...(wallet.names || {}) };
+        const aliases = { ...(wallet.aliases || {}) };
         if (includeIDs) {
             for (const [name, id] of Object.entries(wallet.ids || {})) {
-                names[name] = id.did;
+                aliases[name] = id.did;
             }
         }
-        return names;
+        return aliases;
     }
-    async addName(name, did) {
+    async addAlias(alias, did) {
         await this.mutateWallet((wallet) => {
-            if (!wallet.names) {
-                wallet.names = {};
+            if (!wallet.aliases) {
+                wallet.aliases = {};
             }
-            name = this.validateName(name, wallet);
-            wallet.names[name] = did;
+            alias = this.validateAlias(alias, wallet, 'alias');
+            wallet.aliases[alias] = did;
         });
         return true;
     }
-    async getName(name) {
+    async getAlias(alias) {
         const wallet = await this.loadWallet();
-        if (wallet.names && name in wallet.names) {
-            return wallet.names[name];
+        if (wallet.aliases && alias in wallet.aliases) {
+            return wallet.aliases[alias];
         }
         return null;
     }
-    async removeName(name) {
+    async removeAlias(alias) {
         await this.mutateWallet((wallet) => {
-            if (!wallet.names || !(name in wallet.names)) {
+            if (!wallet.aliases || !(alias in wallet.aliases)) {
                 return;
             }
-            delete wallet.names[name];
+            delete wallet.aliases[alias];
         });
         return true;
     }
@@ -3378,7 +3378,7 @@ class Keymaster {
         await this.checkVaultOwner(vaultId);
         const vault = await this.getVault(vaultId);
         const { privateJwk, items } = await this.decryptVault(vault);
-        const validName = this.validateName(name);
+        const validName = this.validateAlias(name);
         const encryptedData = this.cipher.encryptBytes(vault.publicJwk, privateJwk, buffer);
         const cid = await this.gatekeeper.addText(encryptedData);
         const sha256 = this.cipher.hashMessage(buffer);
@@ -3428,7 +3428,7 @@ class Keymaster {
         const id = await this.fetchIdInfo(undefined, wallet);
         const list = id.dmail || {};
         const dmailList = {};
-        const nameList = await this.listNames({ includeIDs: true });
+        const nameList = await this.listAliases({ includeIDs: true });
         const didToName = Object.entries(nameList).reduce((acc, [name, did]) => {
             acc[did] = name;
             return acc;
@@ -3466,7 +3466,7 @@ class Keymaster {
         const tagSet = new Set();
         for (const tag of tags) {
             try {
-                tagSet.add(this.validateName(tag));
+                tagSet.add(this.validateAlias(tag));
             }
             catch (error) {
                 throw new InvalidParameterError(`Invalid tag: '${tag}'`);
@@ -3499,7 +3499,7 @@ class Keymaster {
         if (!Array.isArray(list)) {
             throw new InvalidParameterError('list');
         }
-        const nameList = await this.listNames({ includeIDs: true });
+        const nameList = await this.listAliases({ includeIDs: true });
         let newList = [];
         for (const id of list) {
             if (typeof id !== 'string') {
@@ -3702,9 +3702,9 @@ class Keymaster {
             }
             const poll = await this.getPoll(noticeDID);
             if (poll) {
-                const names = await this.listNames();
+                const names = await this.listAliases();
                 if (!Object.values(names).includes(noticeDID)) {
-                    await this.addUnnamedPoll(noticeDID);
+                    await this.addUnaliasedPoll(noticeDID);
                 }
                 await this.addToNotices(did, [exports.NoticeTags.POLL]);
                 continue;
@@ -3788,10 +3788,10 @@ class Keymaster {
         }
         return payload && typeof payload.poll === "string" && typeof payload.vote === "number";
     }
-    async addUnnamedPoll(did) {
+    async addUnaliasedPoll(did) {
         const fallbackName = did.slice(-32);
         try {
-            await this.addName(fallbackName, did);
+            await this.addAlias(fallbackName, did);
         }
         catch { }
     }
@@ -3841,7 +3841,14 @@ class Keymaster {
         return wallet;
     }
     async upgradeWallet(wallet) {
-        if (wallet.version !== 1) {
+        if (wallet.version === 1) {
+            if (wallet.names && !wallet.aliases) {
+                wallet.aliases = wallet.names;
+                delete wallet.names;
+            }
+            wallet.version = 2;
+        }
+        if (wallet.version !== 2) {
             throw new KeymasterError("Unsupported wallet version.");
         }
         return wallet;