@didcid/keymaster 0.4.3 → 0.4.5

package/dist/esm/keymaster.js

@@ -14,6 +14,23 @@ function base64urlToHex(b64) {
     const bytes = base64url.baseDecode(b64);
     return Buffer.from(bytes).toString('hex');
 }
+function isPrivateHostname(hostname) {
+    return /^(localhost|127\.|10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(hostname);
+}
+const REMOTE_NAME_LOOKUP_TIMEOUT_MS = 2000;
+function isRemoteNameReference(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    if (value.startsWith('did:') || value.startsWith('mailto:') || value.includes('://')) {
+        return false;
+    }
+    if (/[/?#]/.test(value)) {
+        return false;
+    }
+    const parts = value.split('@');
+    return parts.length === 2 && !!parts[0] && !!parts[1];
+}
 const DefaultSchema = {
     "$schema": "http://json-schema.org/draft-07/schema#",
     "type": "object",
@@ -697,6 +714,24 @@ export default class Keymaster {
         const file = await this.generateFileAsset(filename, buffer);
         return this.mergeData(id, { file });
     }
+    async generateFileAssetFromStream(filename, stream, contentType, bytes) {
+        const cid = await this.gatekeeper.addDataStream(stream);
+        return { cid, filename, type: contentType, bytes };
+    }
+    async createFileStream(stream, options = {}) {
+        const filename = options.filename || 'file';
+        const contentType = options.contentType || 'application/octet-stream';
+        const bytes = options.bytes || 0;
+        const file = await this.generateFileAssetFromStream(filename, stream, contentType, bytes);
+        return this.createAsset({ file }, options);
+    }
+    async updateFileStream(id, stream, options = {}) {
+        const filename = options.filename || 'file';
+        const contentType = options.contentType || 'application/octet-stream';
+        const bytes = options.bytes || 0;
+        const file = await this.generateFileAssetFromStream(filename, stream, contentType, bytes);
+        return this.mergeData(id, { file });
+    }
     async getFile(id) {
         const asset = await this.resolveAsset(id);
         const file = asset.file;
@@ -901,6 +936,23 @@ export default class Keymaster {
         }
         return ok;
     }
+    async changeRegistry(id, registry) {
+        if (!registry) {
+            throw new InvalidParameterError('registry');
+        }
+        const did = await this.lookupDID(id);
+        const current = await this.resolveDID(did);
+        const currentRegistry = current.didDocumentRegistration?.registry;
+        if (registry === currentRegistry) {
+            return true;
+        }
+        return this.updateDID(did, {
+            didDocumentRegistration: {
+                ...current.didDocumentRegistration,
+                registry,
+            },
+        });
+    }
     async addToOwned(did, owner) {
         await this.mutateWallet(async (wallet) => {
             const id = await this.fetchIdInfo(owner, wallet);
@@ -959,8 +1011,47 @@ export default class Keymaster {
         if (wallet.ids && name in wallet.ids) {
             return wallet.ids[name].did;
         }
+        const remoteDid = await this.resolveRemoteName(name);
+        if (remoteDid) {
+            return remoteDid;
+        }
         throw new UnknownIDError();
     }
+    async resolveRemoteName(name) {
+        if (!isRemoteNameReference(name)) {
+            return null;
+        }
+        const [localName, domain] = name.split('@');
+        let url;
+        try {
+            url = new URL(`https://${domain}/.well-known/names/${encodeURIComponent(localName)}`);
+        }
+        catch {
+            return null;
+        }
+        if (isPrivateHostname(url.hostname)) {
+            return null;
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), REMOTE_NAME_LOOKUP_TIMEOUT_MS);
+        try {
+            const response = await fetch(url.toString(), { signal: controller.signal });
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            if (typeof data.did !== 'string' || !isValidDID(data.did)) {
+                return null;
+            }
+            return data.did;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
     async resolveDID(did, options) {
         const actualDid = await this.lookupDID(did);
         const docs = await this.gatekeeper.resolveDID(actualDid, options);
@@ -2896,9 +2987,16 @@ export default class Keymaster {
                 }
                 throw new InvalidParameterError(`Invalid recipient: ${id}`);
             }
-            if (isValidDID(id)) {
-                newList.push(id);
-                continue;
+            try {
+                const did = await this.lookupDID(id);
+                const isAgent = await this.testAgent(did);
+                if (isAgent) {
+                    newList.push(did);
+                    continue;
+                }
+            }
+            catch {
+                // Fall through to recipient-specific error below.
             }
             throw new InvalidParameterError(`Invalid recipient: ${id}`);
         }