@didcid/keymaster 0.3.9 → 0.4.0

package/dist/esm/keymaster.js

@@ -4,7 +4,7 @@ import { base64url } from 'multiformats/bases/base64';
 import { InvalidDIDError, InvalidParameterError, KeymasterError, UnknownIDError } from '@didcid/common/errors';
 import { isWalletEncFile, isWalletFile } from './db/typeGuards.js';
 import { isValidDID } from '@didcid/ipfs/utils';
-import { decMnemonic, encMnemonic } from "./encryption.js";
+import { decryptWithPassphrase, encryptWithPassphrase } from '@didcid/cipher/passphrase';
 function hexToBase64url(hex) {
     const bytes = Buffer.from(hex, 'hex');
     return base64url.baseEncode(bytes);
@@ -42,6 +42,11 @@ export var NoticeTags;
     NoticeTags["POLL"] = "poll";
     NoticeTags["CREDENTIAL"] = "credential";
 })(NoticeTags || (NoticeTags = {}));
+export var PollItems;
+(function (PollItems) {
+    PollItems["POLL"] = "poll";
+    PollItems["RESULTS"] = "results";
+})(PollItems || (PollItems = {}));
 export default class Keymaster {
     passphrase;
     gatekeeper;
@@ -129,7 +134,7 @@ export default class Keymaster {
         catch (error) {
             throw new InvalidParameterError('mnemonic');
         }
-        const mnemonicEnc = await encMnemonic(mnemonic, this.passphrase);
+        const mnemonicEnc = await encryptWithPassphrase(mnemonic, this.passphrase);
         const wallet = {
             version: 2,
             seed: { mnemonicEnc },
@@ -147,7 +152,7 @@ export default class Keymaster {
         return this.getMnemonicForDerivation(wallet);
     }
     async getMnemonicForDerivation(wallet) {
-        return decMnemonic(wallet.seed.mnemonicEnc, this.passphrase);
+        return decryptWithPassphrase(wallet.seed.mnemonicEnc, this.passphrase);
     }
     async checkWallet() {
         const wallet = await this.loadWallet();
@@ -359,7 +364,7 @@ export default class Keymaster {
         const keypair = await this.hdKeyPair();
         const seedBank = await this.resolveSeedBank();
         const msg = JSON.stringify(wallet);
-        const backup = this.cipher.encryptMessage(keypair.publicJwk, keypair.privateJwk, msg);
+        const backup = this.cipher.encryptMessage(keypair.publicJwk, msg);
         const operation = {
             type: "create",
             created: new Date().toISOString(),
@@ -412,12 +417,12 @@ export default class Keymaster {
             if (typeof castData.backup !== 'string') {
                 throw new InvalidParameterError('Asset "backup" is missing or not a string');
             }
-            const backup = this.cipher.decryptMessage(keypair.publicJwk, keypair.privateJwk, castData.backup);
+            const backup = this.cipher.decryptMessage(keypair.privateJwk, castData.backup, keypair.publicJwk);
             let wallet = JSON.parse(backup);
             if (isWalletFile(wallet)) {
                 const mnemonic = await this.decryptMnemonic();
                 // Backup might have a different mnemonic passphase so re-encrypt
-                wallet.seed.mnemonicEnc = await encMnemonic(mnemonic, this.passphrase);
+                wallet.seed.mnemonicEnc = await encryptWithPassphrase(mnemonic, this.passphrase);
             }
             await this.mutateWallet(async (current) => {
                 // Clear all existing properties from the current wallet
@@ -581,7 +586,7 @@ export default class Keymaster {
         const cloneData = { ...assetData, cloned: assetDoc.didDocument.id };
         return this.createAsset(cloneData, options);
     }
-    async generateImageAsset(buffer) {
+    async generateImageAsset(filename, buffer) {
         let metadata;
         try {
             metadata = imageSize(buffer);
@@ -590,33 +595,38 @@ export default class Keymaster {
             throw new InvalidParameterError('buffer');
         }
         const cid = await this.gatekeeper.addData(buffer);
-        const image = {
+        const file = {
             cid,
+            filename,
+            type: `image/${metadata.type}`,
             bytes: buffer.length,
-            ...metadata,
-            type: `image/${metadata.type}`
         };
-        return image;
+        const image = {
+            width: metadata.width,
+            height: metadata.height,
+        };
+        return { file, image };
     }
     async createImage(buffer, options = {}) {
-        const image = await this.generateImageAsset(buffer);
-        return this.createAsset({ image }, options);
+        const filename = options.filename || 'image';
+        const { file, image } = await this.generateImageAsset(filename, buffer);
+        return this.createAsset({ file, image }, options);
     }
-    async updateImage(id, buffer) {
-        const image = await this.generateImageAsset(buffer);
-        return this.mergeData(id, { image });
+    async updateImage(id, buffer, options = {}) {
+        const filename = options.filename || 'image';
+        const { file, image } = await this.generateImageAsset(filename, buffer);
+        return this.mergeData(id, { file, image });
     }
     async getImage(id) {
         const asset = await this.resolveAsset(id);
-        const image = asset.image;
-        if (!image || !image.cid) {
+        if (!asset.file || !asset.file.cid || !asset.image) {
             return null;
         }
-        const buffer = await this.gatekeeper.getData(image.cid);
+        const buffer = await this.gatekeeper.getData(asset.file.cid);
         if (buffer) {
-            image.data = buffer;
+            asset.file.data = buffer;
         }
-        return image;
+        return { file: asset.file, image: asset.image };
     }
     async testImage(id) {
         try {
@@ -659,24 +669,32 @@ export default class Keymaster {
         };
         return file;
     }
-    async createDocument(buffer, options = {}) {
-        const filename = options.filename || 'document';
-        const document = await this.generateFileAsset(filename, buffer);
-        return this.createAsset({ document }, options);
+    async createFile(buffer, options = {}) {
+        const filename = options.filename || 'file';
+        const file = await this.generateFileAsset(filename, buffer);
+        return this.createAsset({ file }, options);
     }
-    async updateDocument(id, buffer, options = {}) {
-        const filename = options.filename || 'document';
-        const document = await this.generateFileAsset(filename, buffer);
-        return this.mergeData(id, { document });
+    async updateFile(id, buffer, options = {}) {
+        const filename = options.filename || 'file';
+        const file = await this.generateFileAsset(filename, buffer);
+        return this.mergeData(id, { file });
     }
-    async getDocument(id) {
+    async getFile(id) {
         const asset = await this.resolveAsset(id);
-        return asset.document ?? null;
+        const file = asset.file;
+        if (!file || !file.cid) {
+            return null;
+        }
+        const buffer = await this.gatekeeper.getData(file.cid);
+        if (buffer) {
+            file.data = buffer;
+        }
+        return file;
     }
-    async testDocument(id) {
+    async testFile(id) {
         try {
-            const document = await this.getDocument(id);
-            return document !== null;
+            const file = await this.getFile(id);
+            return file !== null;
         }
         catch (error) {
             return false;
@@ -684,19 +702,16 @@ export default class Keymaster {
     }
     async encryptMessage(msg, receiver, options = {}) {
         const { encryptForSender = true, includeHash = false, } = options;
-        const id = await this.fetchIdInfo();
         const senderKeypair = await this.fetchKeyPair();
         if (!senderKeypair) {
             throw new KeymasterError('No valid sender keypair');
         }
         const doc = await this.resolveDID(receiver, { confirm: true });
         const receivePublicJwk = this.getPublicKeyJwk(doc);
-        const cipher_sender = encryptForSender ? this.cipher.encryptMessage(senderKeypair.publicJwk, senderKeypair.privateJwk, msg) : null;
-        const cipher_receiver = this.cipher.encryptMessage(receivePublicJwk, senderKeypair.privateJwk, msg);
+        const cipher_sender = encryptForSender ? this.cipher.encryptMessage(senderKeypair.publicJwk, msg) : null;
+        const cipher_receiver = this.cipher.encryptMessage(receivePublicJwk, msg);
         const cipher_hash = includeHash ? this.cipher.hashMessage(msg) : null;
         const encrypted = {
-            sender: id.did,
-            created: new Date().toISOString(),
             cipher_hash,
             cipher_sender,
             cipher_receiver,
@@ -712,7 +727,7 @@ export default class Keymaster {
             const didkey = hdkey.derive(path);
             const receiverKeypair = this.cipher.generateJwk(didkey.privateKey);
             try {
-                return this.cipher.decryptMessage(senderPublicJwk, receiverKeypair.privateJwk, ciphertext);
+                return this.cipher.decryptMessage(receiverKeypair.privateJwk, ciphertext, senderPublicJwk);
             }
             catch (error) {
                 index -= 1;
@@ -723,7 +738,8 @@ export default class Keymaster {
     async decryptMessage(did) {
         const wallet = await this.loadWallet();
         const id = await this.fetchIdInfo();
-        const asset = await this.resolveAsset(did);
+        const msgDoc = await this.resolveDID(did);
+        const asset = msgDoc.didDocumentData;
         if (!asset) {
             throw new InvalidParameterError('did not encrypted');
         }
@@ -732,9 +748,16 @@ export default class Keymaster {
             throw new InvalidParameterError('did not encrypted');
         }
         const crypt = (castAsset.encrypted ? castAsset.encrypted : castAsset);
-        const doc = await this.resolveDID(crypt.sender, { confirm: true, versionTime: crypt.created });
-        const senderPublicJwk = this.getPublicKeyJwk(doc);
-        const ciphertext = (crypt.sender === id.did && crypt.cipher_sender) ? crypt.cipher_sender : crypt.cipher_receiver;
+        // Derive sender and created from the message DID document,
+        // falling back to fields in the asset for legacy messages
+        const sender = crypt.sender || msgDoc.didDocument?.controller;
+        const created = crypt.created || msgDoc.didDocumentMetadata?.created;
+        if (!sender) {
+            throw new InvalidParameterError('Sender DID could not be determined from message or DID document');
+        }
+        const senderDoc = await this.resolveDID(sender, { confirm: true, versionTime: created });
+        const senderPublicJwk = this.getPublicKeyJwk(senderDoc);
+        const ciphertext = (sender === id.did && crypt.cipher_sender) ? crypt.cipher_sender : crypt.cipher_receiver;
         return await this.decryptWithDerivedKeys(wallet, id, senderPublicJwk, ciphertext);
     }
     async encryptJSON(json, did, options = {}) {
@@ -1115,7 +1138,7 @@ export default class Keymaster {
             id: idInfo,
         };
         const msg = JSON.stringify(data);
-        const backup = this.cipher.encryptMessage(keypair.publicJwk, keypair.privateJwk, msg);
+        const backup = this.cipher.encryptMessage(keypair.publicJwk, msg);
         const doc = await this.resolveDID(idInfo.did);
         const registry = doc.didDocumentRegistration?.registry;
         if (!registry) {
@@ -1141,7 +1164,7 @@ export default class Keymaster {
             if (typeof backupStore.backup !== 'string') {
                 throw new InvalidDIDError('backup not found in backupStore');
             }
-            const backup = this.cipher.decryptMessage(keypair.publicJwk, keypair.privateJwk, backupStore.backup);
+            const backup = this.cipher.decryptMessage(keypair.privateJwk, backupStore.backup, keypair.publicJwk);
             const data = JSON.parse(backup);
             await this.mutateWallet((wallet) => {
                 if (wallet.ids[data.name]) {
@@ -1242,7 +1265,13 @@ export default class Keymaster {
             validFrom = new Date().toISOString();
         }
         const id = await this.fetchIdInfo();
-        const subjectDID = await this.lookupDID(subjectId);
+        let subjectURI;
+        try {
+            subjectURI = await this.lookupDID(subjectId);
+        }
+        catch {
+            subjectURI = subjectId;
+        }
         const vc = {
             "@context": [
                 "https://www.w3.org/ns/credentials/v2",
@@ -1253,7 +1282,7 @@ export default class Keymaster {
             validFrom,
             validUntil,
             credentialSubject: {
-                id: subjectDID,
+                id: subjectURI,
             },
         };
         // If schema provided, add credentialSchema and generate claims from schema
@@ -1278,7 +1307,7 @@ export default class Keymaster {
         }
         if (claims && Object.keys(claims).length) {
             vc.credentialSubject = {
-                id: subjectDID,
+                id: subjectURI,
                 ...claims,
             };
         }
@@ -1293,21 +1322,32 @@ export default class Keymaster {
             throw new InvalidParameterError('credential.issuer');
         }
         const signed = await this.addProof(credential);
-        return this.encryptJSON(signed, credential.credentialSubject.id, { ...options, includeHash: true });
+        const subjectId = credential.credentialSubject.id;
+        if (this.isManagedDID(subjectId)) {
+            return this.encryptJSON(signed, subjectId, { ...options, includeHash: true });
+        }
+        return this.encryptJSON(signed, id.did, { ...options, includeHash: true, encryptForSender: false });
     }
     async sendCredential(did, options = {}) {
         const vc = await this.getCredential(did);
         if (!vc) {
             return null;
         }
+        const subjectId = vc.credentialSubject.id;
+        if (!this.isManagedDID(subjectId)) {
+            return null;
+        }
         const registry = this.ephemeralRegistry;
         const validUntil = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(); // Default to 7 days
         const message = {
-            to: [vc.credentialSubject.id],
+            to: [subjectId],
             dids: [did],
         };
         return this.createNotice(message, { registry, validUntil, ...options });
     }
+    isManagedDID(value) {
+        return value.startsWith('did:cid:');
+    }
     isVerifiableCredential(obj) {
         if (typeof obj !== 'object' || !obj) {
             return false;
@@ -1329,24 +1369,29 @@ export default class Keymaster {
         delete credential.proof;
         const signed = await this.addProof(credential);
         const msg = JSON.stringify(signed);
-        const id = await this.fetchIdInfo();
         const senderKeypair = await this.fetchKeyPair();
         if (!senderKeypair) {
             throw new KeymasterError('No valid sender keypair');
         }
         const holder = credential.credentialSubject.id;
-        const holderDoc = await this.resolveDID(holder, { confirm: true });
-        const receivePublicJwk = this.getPublicKeyJwk(holderDoc);
-        const cipher_sender = this.cipher.encryptMessage(senderKeypair.publicJwk, senderKeypair.privateJwk, msg);
-        const cipher_receiver = this.cipher.encryptMessage(receivePublicJwk, senderKeypair.privateJwk, msg);
         const msgHash = this.cipher.hashMessage(msg);
-        const encrypted = {
-            sender: id.did,
-            created: new Date().toISOString(),
-            cipher_hash: msgHash,
-            cipher_sender: cipher_sender,
-            cipher_receiver: cipher_receiver,
-        };
+        let encrypted;
+        if (this.isManagedDID(holder)) {
+            const holderDoc = await this.resolveDID(holder, { confirm: true });
+            const receivePublicJwk = this.getPublicKeyJwk(holderDoc);
+            encrypted = {
+                cipher_hash: msgHash,
+                cipher_sender: this.cipher.encryptMessage(senderKeypair.publicJwk, msg),
+                cipher_receiver: this.cipher.encryptMessage(receivePublicJwk, msg),
+            };
+        }
+        else {
+            encrypted = {
+                cipher_hash: msgHash,
+                cipher_sender: null,
+                cipher_receiver: this.cipher.encryptMessage(senderKeypair.publicJwk, msg),
+            };
+        }
         return this.updateDID(did, { didDocumentData: { encrypted } });
     }
     async revokeCredential(credential) {
@@ -1842,72 +1887,64 @@ export default class Keymaster {
         const nextWeek = new Date();
         nextWeek.setDate(now.getDate() + 7);
         return {
-            type: 'poll',
-            version: 1,
+            version: 2,
+            name: 'poll-name',
             description: 'What is this poll about?',
-            roster: 'DID of the eligible voter group',
             options: ['yes', 'no', 'abstain'],
             deadline: nextWeek.toISOString(),
         };
     }
-    async createPoll(poll, options = {}) {
-        if (poll.type !== 'poll') {
-            throw new InvalidParameterError('poll');
-        }
-        if (poll.version !== 1) {
+    async createPoll(config, options = {}) {
+        if (config.version !== 2) {
             throw new InvalidParameterError('poll.version');
         }
-        if (!poll.description) {
+        if (!config.name) {
+            throw new InvalidParameterError('poll.name');
+        }
+        if (!config.description) {
             throw new InvalidParameterError('poll.description');
         }
-        if (!poll.options || !Array.isArray(poll.options) || poll.options.length < 2 || poll.options.length > 10) {
+        if (!config.options || !Array.isArray(config.options) || config.options.length < 2 || config.options.length > 10) {
             throw new InvalidParameterError('poll.options');
         }
-        if (!poll.roster) {
-            // eslint-disable-next-line
-            throw new InvalidParameterError('poll.roster');
-        }
-        try {
-            const isValidGroup = await this.testGroup(poll.roster);
-            if (!isValidGroup) {
-                throw new InvalidParameterError('poll.roster');
-            }
-        }
-        catch {
-            throw new InvalidParameterError('poll.roster');
-        }
-        if (!poll.deadline) {
-            // eslint-disable-next-line
+        if (!config.deadline) {
             throw new InvalidParameterError('poll.deadline');
         }
-        const deadline = new Date(poll.deadline);
+        const deadline = new Date(config.deadline);
         if (isNaN(deadline.getTime())) {
             throw new InvalidParameterError('poll.deadline');
         }
         if (deadline < new Date()) {
             throw new InvalidParameterError('poll.deadline');
         }
-        return this.createAsset({ poll }, options);
+        const vaultDid = await this.createVault(options);
+        const buffer = Buffer.from(JSON.stringify(config), 'utf-8');
+        await this.addVaultItem(vaultDid, PollItems.POLL, buffer);
+        return vaultDid;
     }
     async getPoll(id) {
-        const asset = await this.resolveAsset(id);
-        // TEMP during did:cid, return old version poll
-        const castOldAsset = asset;
-        if (castOldAsset.options) {
-            return castOldAsset;
+        const isVault = await this.testVault(id);
+        if (!isVault) {
+            return null;
         }
-        const castAsset = asset;
-        if (!castAsset.poll) {
+        try {
+            const buffer = await this.getVaultItem(id, PollItems.POLL);
+            if (!buffer) {
+                return null;
+            }
+            const config = JSON.parse(buffer.toString('utf-8'));
+            return config;
+        }
+        catch {
             return null;
         }
-        return castAsset.poll;
     }
     async testPoll(id) {
         try {
-            const poll = await this.getPoll(id);
-            return poll !== null;
+            const config = await this.getPoll(id);
+            return config !== null;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -1922,113 +1959,243 @@ export default class Keymaster {
         }
         return polls;
     }
+    async addPollVoter(pollId, memberId) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
+            throw new InvalidParameterError('pollId');
+        }
+        return this.addVaultMember(pollId, memberId);
+    }
+    async removePollVoter(pollId, memberId) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
+            throw new InvalidParameterError('pollId');
+        }
+        return this.removeVaultMember(pollId, memberId);
+    }
+    async listPollVoters(pollId) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
+            throw new InvalidParameterError('pollId');
+        }
+        return this.listVaultMembers(pollId);
+    }
     async viewPoll(pollId) {
         const id = await this.fetchIdInfo();
-        const poll = await this.getPoll(pollId);
-        if (!poll) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
             throw new InvalidParameterError('pollId');
         }
+        const doc = await this.resolveDID(pollId);
+        const isOwner = (doc.didDocument?.controller === id.did);
+        const voteExpired = Date.now() > new Date(config.deadline).getTime();
+        let isEligible = false;
         let hasVoted = false;
-        if (poll.ballots) {
-            hasVoted = !!poll.ballots[id.did];
+        const ballots = [];
+        try {
+            const vault = await this.getVault(pollId);
+            const members = await this.listVaultMembers(pollId);
+            isEligible = isOwner || !!members[id.did];
+            const items = await this.listVaultItems(pollId);
+            for (const itemName of Object.keys(items)) {
+                if (itemName !== PollItems.POLL && itemName !== PollItems.RESULTS) {
+                    ballots.push(itemName);
+                }
+            }
+            const myBallotKey = this.generateBallotKey(vault, id.did);
+            hasVoted = ballots.includes(myBallotKey);
+        }
+        catch {
+            isEligible = false;
         }
-        const voteExpired = Date.now() > new Date(poll.deadline).getTime();
-        const isEligible = await this.testGroup(poll.roster, id.did);
-        const doc = await this.resolveDID(pollId);
         const view = {
-            description: poll.description,
-            options: poll.options,
-            deadline: poll.deadline,
-            isOwner: (doc.didDocument?.controller === id.did),
-            isEligible: isEligible,
-            voteExpired: voteExpired,
-            hasVoted: hasVoted,
+            description: config.description,
+            options: config.options,
+            deadline: config.deadline,
+            isOwner,
+            isEligible,
+            voteExpired,
+            hasVoted,
+            ballots,
         };
-        if (id.did === doc.didDocument?.controller) {
-            let voted = 0;
-            const results = {
-                tally: [],
-                ballots: [],
-            };
-            results.tally.push({
-                vote: 0,
-                option: 'spoil',
-                count: 0,
-            });
-            for (let i = 0; i < poll.options.length; i++) {
-                results.tally.push({
-                    vote: i + 1,
-                    option: poll.options[i],
-                    count: 0,
+        if (isOwner) {
+            view.results = await this.computePollResults(pollId, config);
+        }
+        else {
+            try {
+                const resultsBuffer = await this.getVaultItem(pollId, PollItems.RESULTS);
+                if (resultsBuffer) {
+                    view.results = JSON.parse(resultsBuffer.toString('utf-8'));
+                }
+            }
+            catch { }
+        }
+        return view;
+    }
+    async computePollResults(pollId, config) {
+        const vault = await this.getVault(pollId);
+        const members = await this.listVaultMembers(pollId);
+        const items = await this.listVaultItems(pollId);
+        const results = {
+            tally: [],
+            ballots: [],
+        };
+        results.tally.push({ vote: 0, option: 'spoil', count: 0 });
+        for (let i = 0; i < config.options.length; i++) {
+            results.tally.push({ vote: i + 1, option: config.options[i], count: 0 });
+        }
+        // Build ballotKey → memberDID mapping
+        const keyToMember = {};
+        for (const memberDID of Object.keys(members)) {
+            const ballotKey = this.generateBallotKey(vault, memberDID);
+            keyToMember[ballotKey] = memberDID;
+        }
+        // Include owner in mapping
+        const id = await this.fetchIdInfo();
+        const ownerKey = this.generateBallotKey(vault, id.did);
+        keyToMember[ownerKey] = id.did;
+        let voted = 0;
+        for (const [itemName, itemMeta] of Object.entries(items)) {
+            if (itemName === PollItems.POLL || itemName === PollItems.RESULTS) {
+                continue;
+            }
+            const ballotBuffer = await this.getVaultItem(pollId, itemName);
+            if (!ballotBuffer) {
+                continue;
+            }
+            const ballotDid = ballotBuffer.toString('utf-8');
+            const decrypted = await this.decryptJSON(ballotDid);
+            const vote = decrypted.vote;
+            const voterDID = keyToMember[itemName] || itemName;
+            if (results.ballots) {
+                results.ballots.push({
+                    voter: voterDID,
+                    vote,
+                    option: vote === 0 ? 'spoil' : config.options[vote - 1],
+                    received: itemMeta.added || '',
                 });
             }
-            for (let voter in poll.ballots) {
-                const ballot = poll.ballots[voter];
-                const decrypted = await this.decryptJSON(ballot.ballot);
-                const vote = decrypted.vote;
-                if (results.ballots) {
-                    results.ballots.push({
-                        ...ballot,
-                        voter,
-                        vote,
-                        option: poll.options[vote - 1],
-                    });
-                }
-                voted += 1;
+            voted += 1;
+            if (vote >= 0 && vote < results.tally.length) {
                 results.tally[vote].count += 1;
             }
-            const roster = await this.getGroup(poll.roster);
-            const total = roster.members.length;
-            results.votes = {
-                eligible: total,
-                received: voted,
-                pending: total - voted,
-            };
-            results.final = voteExpired || (voted === total);
-            view.results = results;
         }
-        return view;
+        const total = Object.keys(members).length + 1; // +1 for owner
+        const voteExpired = Date.now() > new Date(config.deadline).getTime();
+        results.votes = {
+            eligible: total,
+            received: voted,
+            pending: total - voted,
+        };
+        results.final = voteExpired || (voted === total);
+        return results;
     }
     async votePoll(pollId, vote, options = {}) {
-        const { spoil = false } = options;
         const id = await this.fetchIdInfo();
         const didPoll = await this.lookupDID(pollId);
         const doc = await this.resolveDID(didPoll);
-        const poll = await this.getPoll(pollId);
-        if (!poll) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
             throw new InvalidParameterError('pollId');
         }
-        const eligible = await this.testGroup(poll.roster, id.did);
-        const expired = Date.now() > new Date(poll.deadline).getTime();
         const owner = doc.didDocument?.controller;
         if (!owner) {
-            throw new KeymasterError('owner mising from poll');
+            throw new KeymasterError('owner missing from poll');
+        }
+        // Check vault membership
+        let isEligible = false;
+        if (id.did === owner) {
+            isEligible = true;
         }
-        if (!eligible) {
-            throw new InvalidParameterError('voter not in roster');
+        else {
+            try {
+                const vault = await this.getVault(didPoll);
+                await this.decryptVault(vault);
+                isEligible = true;
+            }
+            catch {
+                isEligible = false;
+            }
         }
+        if (!isEligible) {
+            throw new InvalidParameterError('voter is not a poll member');
+        }
+        const expired = Date.now() > new Date(config.deadline).getTime();
         if (expired) {
             throw new InvalidParameterError('poll has expired');
         }
-        let ballot;
-        if (spoil) {
-            ballot = {
-                poll: didPoll,
-                vote: 0,
-            };
+        const max = config.options.length;
+        if (!Number.isInteger(vote) || vote < 0 || vote > max) {
+            throw new InvalidParameterError('vote');
         }
-        else {
-            const max = poll.options.length;
-            if (!Number.isInteger(vote) || vote < 1 || vote > max) {
-                throw new InvalidParameterError('vote');
+        const ballot = {
+            poll: didPoll,
+            vote: vote,
+        };
+        // Encrypt for owner and sender (voter can view their own ballot)
+        return await this.encryptJSON(ballot, owner, options);
+    }
+    async sendPoll(pollId) {
+        const didPoll = await this.lookupDID(pollId);
+        const config = await this.getPoll(didPoll);
+        if (!config) {
+            throw new InvalidParameterError('pollId');
+        }
+        const members = await this.listVaultMembers(didPoll);
+        const voters = Object.keys(members);
+        if (voters.length === 0) {
+            throw new KeymasterError('No poll voters found');
+        }
+        const registry = this.ephemeralRegistry;
+        const validUntil = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+        const message = {
+            to: voters,
+            dids: [didPoll],
+        };
+        return this.createNotice(message, { registry, validUntil });
+    }
+    async sendBallot(ballotDid, pollId) {
+        const didPoll = await this.lookupDID(pollId);
+        const config = await this.getPoll(didPoll);
+        if (!config) {
+            throw new InvalidParameterError('pollId is not a valid poll');
+        }
+        const pollDoc = await this.resolveDID(didPoll);
+        const ownerDid = pollDoc.didDocument?.controller;
+        if (!ownerDid) {
+            throw new KeymasterError('poll owner not found');
+        }
+        const registry = this.ephemeralRegistry;
+        const validUntil = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+        const message = {
+            to: [ownerDid],
+            dids: [ballotDid],
+        };
+        return this.createNotice(message, { registry, validUntil });
+    }
+    async viewBallot(ballotDid) {
+        const docBallot = await this.resolveDID(ballotDid);
+        const voter = docBallot.didDocument?.controller;
+        const result = {
+            poll: '',
+            voter: voter || undefined,
+        };
+        try {
+            const data = await this.decryptJSON(ballotDid);
+            result.poll = data.poll;
+            result.vote = data.vote;
+            const config = await this.getPoll(data.poll);
+            if (config && data.vote > 0 && data.vote <= config.options.length) {
+                result.option = config.options[data.vote - 1];
             }
-            ballot = {
-                poll: didPoll,
-                vote: vote,
-            };
+            else if (data.vote === 0) {
+                result.option = 'spoil';
+            }
+        }
+        catch {
+            // Caller cannot decrypt (not the owner) — return limited info
         }
-        // Encrypt for receiver only
-        return await this.encryptJSON(ballot, owner, { ...options, encryptForSender: false });
+        return result;
     }
     async updatePoll(ballot) {
         const id = await this.fetchIdInfo();
@@ -2038,7 +2205,7 @@ export default class Keymaster {
         let dataBallot;
         try {
             dataBallot = await this.decryptJSON(didBallot);
-            if (!dataBallot.poll || !dataBallot.vote) {
+            if (!dataBallot.poll || dataBallot.vote === undefined) {
                 throw new InvalidParameterError('ballot');
             }
         }
@@ -2048,34 +2215,34 @@ export default class Keymaster {
         const didPoll = dataBallot.poll;
         const docPoll = await this.resolveDID(didPoll);
         const didOwner = docPoll.didDocument.controller;
-        const poll = await this.getPoll(didPoll);
-        if (!poll) {
+        const config = await this.getPoll(didPoll);
+        if (!config) {
             throw new KeymasterError('Cannot find poll related to ballot');
         }
         if (id.did !== didOwner) {
             throw new InvalidParameterError('only owner can update a poll');
         }
-        const eligible = await this.testGroup(poll.roster, didVoter);
-        if (!eligible) {
-            throw new InvalidParameterError('voter not in roster');
+        // Check voter is a vault member
+        const vault = await this.getVault(didPoll);
+        const voterBallotKey = this.generateBallotKey(vault, didVoter);
+        const members = await this.listVaultMembers(didPoll);
+        const isMember = !!members[didVoter] || didVoter === id.did;
+        if (!isMember) {
+            throw new InvalidParameterError('voter is not a poll member');
         }
-        const expired = Date.now() > new Date(poll.deadline).getTime();
+        const expired = Date.now() > new Date(config.deadline).getTime();
         if (expired) {
             throw new InvalidParameterError('poll has expired');
         }
-        const max = poll.options.length;
+        const max = config.options.length;
         const vote = dataBallot.vote;
-        if (!vote || vote < 0 || vote > max) {
+        if (vote < 0 || vote > max) {
             throw new InvalidParameterError('ballot.vote');
         }
-        if (!poll.ballots) {
-            poll.ballots = {};
-        }
-        poll.ballots[didVoter] = {
-            ballot: didBallot,
-            received: new Date().toISOString(),
-        };
-        return this.mergeData(didPoll, { poll });
+        // Store ballot DID as vault item keyed by voter's ballot key
+        const buffer = Buffer.from(didBallot, 'utf-8');
+        await this.addVaultItem(didPoll, voterBallotKey, buffer);
+        return true;
     }
     async publishPoll(pollId, options = {}) {
         const { reveal = false } = options;
@@ -2085,19 +2252,20 @@ export default class Keymaster {
         if (id.did !== owner) {
             throw new InvalidParameterError('only owner can publish a poll');
         }
-        const view = await this.viewPoll(pollId);
-        if (!view.results?.final) {
-            throw new InvalidParameterError('poll not final');
+        const config = await this.getPoll(pollId);
+        if (!config) {
+            throw new InvalidParameterError(pollId);
         }
-        if (!reveal && view.results.ballots) {
-            delete view.results.ballots;
+        const results = await this.computePollResults(pollId, config);
+        if (!results.final) {
+            throw new InvalidParameterError('poll not final');
         }
-        const poll = await this.getPoll(pollId);
-        if (!poll) {
-            throw new InvalidParameterError(pollId);
+        if (!reveal) {
+            delete results.ballots;
         }
-        poll.results = view.results;
-        return this.mergeData(pollId, { poll });
+        const buffer = Buffer.from(JSON.stringify(results), 'utf-8');
+        await this.addVaultItem(pollId, PollItems.RESULTS, buffer);
+        return true;
     }
     async unpublishPoll(pollId) {
         const id = await this.fetchIdInfo();
@@ -2106,12 +2274,11 @@ export default class Keymaster {
         if (id.did !== owner) {
             throw new InvalidParameterError(pollId);
         }
-        const poll = await this.getPoll(pollId);
-        if (!poll) {
+        const config = await this.getPoll(pollId);
+        if (!config) {
             throw new InvalidParameterError(pollId);
         }
-        delete poll.results;
-        return this.mergeData(pollId, { poll });
+        return this.removeVaultItem(pollId, PollItems.RESULTS);
     }
     async createVault(options = {}) {
         const id = await this.fetchIdInfo();
@@ -2123,10 +2290,10 @@ export default class Keymaster {
         const salt = this.cipher.generateRandomSalt();
         const vaultKeypair = this.cipher.generateRandomJwk();
         const keys = {};
-        const config = this.cipher.encryptMessage(idKeypair.publicJwk, vaultKeypair.privateJwk, JSON.stringify(options));
+        const config = this.cipher.encryptMessage(idKeypair.publicJwk, JSON.stringify(options));
         const publicJwk = options.secretMembers ? idKeypair.publicJwk : vaultKeypair.publicJwk; // If secret, encrypt for the owner only
-        const members = this.cipher.encryptMessage(publicJwk, vaultKeypair.privateJwk, JSON.stringify({}));
-        const items = this.cipher.encryptMessage(vaultKeypair.publicJwk, vaultKeypair.privateJwk, JSON.stringify({}));
+        const members = this.cipher.encryptMessage(publicJwk, JSON.stringify({}));
+        const items = this.cipher.encryptMessage(vaultKeypair.publicJwk, JSON.stringify({}));
         const sha256 = this.cipher.hashJSON({});
         const vault = {
             version,
@@ -2157,6 +2324,9 @@ export default class Keymaster {
             return false;
         }
     }
+    generateBallotKey(vault, memberDID) {
+        return this.generateSaltedId(vault, memberDID).slice(0, this.maxAliasLength);
+    }
     generateSaltedId(vault, memberDID) {
         if (!vault.version) {
             return this.cipher.hashMessage(vault.salt + memberDID);
@@ -2195,13 +2365,13 @@ export default class Keymaster {
         }
         else {
             try {
-                const membersJSON = this.cipher.decryptMessage(vault.publicJwk, privateJwk, vault.members);
+                const membersJSON = this.cipher.decryptMessage(privateJwk, vault.members, vault.publicJwk);
                 members = JSON.parse(membersJSON);
             }
             catch (error) {
             }
         }
-        const itemsJSON = this.cipher.decryptMessage(vault.publicJwk, privateJwk, vault.items);
+        const itemsJSON = this.cipher.decryptMessage(privateJwk, vault.items, vault.publicJwk);
         const items = JSON.parse(itemsJSON);
         return {
             isOwner,
@@ -2223,7 +2393,7 @@ export default class Keymaster {
     async addMemberKey(vault, memberDID, privateJwk) {
         const memberDoc = await this.resolveDID(memberDID, { confirm: true });
         const memberPublicJwk = this.getPublicKeyJwk(memberDoc);
-        const memberKey = this.cipher.encryptMessage(memberPublicJwk, privateJwk, JSON.stringify(privateJwk));
+        const memberKey = this.cipher.encryptMessage(memberPublicJwk, JSON.stringify(privateJwk));
         const memberKeyId = this.generateSaltedId(vault, memberDID);
         vault.keys[memberKeyId] = memberKey;
     }
@@ -2268,7 +2438,7 @@ export default class Keymaster {
         }
         members[memberDID] = { added: new Date().toISOString() };
         const publicJwk = config.secretMembers ? idKeypair.publicJwk : vault.publicJwk;
-        vault.members = this.cipher.encryptMessage(publicJwk, privateJwk, JSON.stringify(members));
+        vault.members = this.cipher.encryptMessage(publicJwk, JSON.stringify(members));
         await this.addMemberKey(vault, memberDID, privateJwk);
         return this.mergeData(vaultId, { vault });
     }
@@ -2276,7 +2446,7 @@ export default class Keymaster {
         const owner = await this.checkVaultOwner(vaultId);
         const idKeypair = await this.fetchKeyPair();
         const vault = await this.getVault(vaultId);
-        const { privateJwk, config, members } = await this.decryptVault(vault);
+        const { config, members } = await this.decryptVault(vault);
         const memberDoc = await this.resolveDID(memberId, { confirm: true });
         const memberDID = this.getAgentDID(memberDoc);
         // Don't allow removing the vault owner
@@ -2285,7 +2455,7 @@ export default class Keymaster {
         }
         delete members[memberDID];
         const publicJwk = config.secretMembers ? idKeypair.publicJwk : vault.publicJwk;
-        vault.members = this.cipher.encryptMessage(publicJwk, privateJwk, JSON.stringify(members));
+        vault.members = this.cipher.encryptMessage(publicJwk, JSON.stringify(members));
         const memberKeyId = this.generateSaltedId(vault, memberDID);
         delete vault.keys[memberKeyId];
         return this.mergeData(vaultId, { vault });
@@ -2301,9 +2471,9 @@ export default class Keymaster {
     async addVaultItem(vaultId, name, buffer) {
         await this.checkVaultOwner(vaultId);
         const vault = await this.getVault(vaultId);
-        const { privateJwk, items } = await this.decryptVault(vault);
+        const { items } = await this.decryptVault(vault);
         const validName = this.validateAlias(name);
-        const encryptedData = this.cipher.encryptBytes(vault.publicJwk, privateJwk, buffer);
+        const encryptedData = this.cipher.encryptBytes(vault.publicJwk, buffer);
         const cid = await this.gatekeeper.addText(encryptedData);
         const sha256 = this.cipher.hashMessage(buffer);
         const type = await this.getMimeType(buffer);
@@ -2316,16 +2486,16 @@ export default class Keymaster {
             added: new Date().toISOString(),
             data,
         };
-        vault.items = this.cipher.encryptMessage(vault.publicJwk, privateJwk, JSON.stringify(items));
+        vault.items = this.cipher.encryptMessage(vault.publicJwk, JSON.stringify(items));
         vault.sha256 = this.cipher.hashJSON(items);
         return this.mergeData(vaultId, { vault });
     }
     async removeVaultItem(vaultId, name) {
         await this.checkVaultOwner(vaultId);
         const vault = await this.getVault(vaultId);
-        const { privateJwk, items } = await this.decryptVault(vault);
+        const { items } = await this.decryptVault(vault);
         delete items[name];
-        vault.items = this.cipher.encryptMessage(vault.publicJwk, privateJwk, JSON.stringify(items));
+        vault.items = this.cipher.encryptMessage(vault.publicJwk, JSON.stringify(items));
         vault.sha256 = this.cipher.hashJSON(items);
         return this.mergeData(vaultId, { vault });
     }
@@ -2344,7 +2514,7 @@ export default class Keymaster {
         if (!encryptedData) {
             throw new KeymasterError(`Failed to retrieve data for item '${name}' (CID: ${items[name].cid})`);
         }
-        const bytes = this.cipher.decryptBytes(vault.publicJwk, privateJwk, encryptedData);
+        const bytes = this.cipher.decryptBytes(privateJwk, encryptedData, vault.publicJwk);
         return Buffer.from(bytes);
     }
     async listDmail() {
@@ -2628,7 +2798,7 @@ export default class Keymaster {
             if (poll) {
                 const names = await this.listAliases();
                 if (!Object.values(names).includes(noticeDID)) {
-                    await this.addUnaliasedPoll(noticeDID);
+                    await this.addUnaliasedPoll(noticeDID, poll.name);
                 }
                 await this.addToNotices(did, [NoticeTags.POLL]);
                 continue;
@@ -2712,10 +2882,20 @@ export default class Keymaster {
         }
         return payload && typeof payload.poll === "string" && typeof payload.vote === "number";
     }
-    async addUnaliasedPoll(did) {
-        const fallbackName = did.slice(-32);
+    async addUnaliasedPoll(did, name) {
+        const baseName = name || did.slice(-32);
+        const aliases = await this.listAliases();
+        let candidate = baseName;
+        let suffix = 2;
+        while (candidate in aliases) {
+            if (aliases[candidate] === did) {
+                return; // Already aliased to this DID
+            }
+            candidate = `${baseName}-${suffix}`;
+            suffix++;
+        }
         try {
-            await this.addAlias(fallbackName, did);
+            await this.addAlias(candidate, did);
         }
         catch { }
     }
@@ -2731,26 +2911,27 @@ export default class Keymaster {
         const { version, seed, ...rest } = decrypted;
         const safeSeed = { mnemonicEnc: seed.mnemonicEnc };
         const hdkey = await this.getHDKeyFromCacheOrMnemonic(decrypted);
-        const { publicJwk, privateJwk } = this.cipher.generateJwk(hdkey.privateKey);
+        const { publicJwk } = this.cipher.generateJwk(hdkey.privateKey);
         const plaintext = JSON.stringify(rest);
-        const enc = this.cipher.encryptMessage(publicJwk, privateJwk, plaintext);
+        const enc = this.cipher.encryptMessage(publicJwk, plaintext);
         return { version: version, seed: safeSeed, enc };
     }
     async decryptWalletFromStorage(stored) {
         let mnemonic;
         try {
-            mnemonic = await decMnemonic(stored.seed.mnemonicEnc, this.passphrase);
+            mnemonic = await decryptWithPassphrase(stored.seed.mnemonicEnc, this.passphrase);
         }
         catch (error) {
-            // OperationError is thrown by crypto.subtle.decrypt when the passphrase is wrong
-            if (error?.name === 'OperationError') {
+            const msg = error?.message || '';
+            // OperationError: Web Crypto API (legacy); 'invalid ghash tag': @noble/ciphers
+            if (error?.name === 'OperationError' || msg.includes('invalid ghash tag')) {
                 throw new KeymasterError('Incorrect passphrase.');
             }
             throw error;
         }
         this._hdkeyCache = this.cipher.generateHDKey(mnemonic);
         const { publicJwk, privateJwk } = this.cipher.generateJwk(this._hdkeyCache.privateKey);
-        const plaintext = this.cipher.decryptMessage(publicJwk, privateJwk, stored.enc);
+        const plaintext = this.cipher.decryptMessage(privateJwk, stored.enc, publicJwk);
         const data = JSON.parse(plaintext);
         const wallet = { version: stored.version, seed: stored.seed, ...data };
         return wallet;