@cooperation/vc-storage 1.0.1 → 1.0.5

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './models/GoogleDriveStorage.js';
 export * from './models/CredentialEngine.js';
-export { saveToGoogleDrive } from './utils/saveToGoogle.js';
+export * from './utils/google.js';
+export * from './utils/presentation.js';

package/dist/models/CredentialEngine.js

@@ -1,62 +1,71 @@
 import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
 import { Ed25519Signature2020 } from '@digitalbazaar/ed25519-signature-2020';
-import { defaultDocumentLoader, issue } from '@digitalbazaar/vc';
+import * as vc from '@digitalbazaar/vc';
 import { v4 as uuidv4 } from 'uuid';
-import { localOBContext, localED25519Context } from '../utils/context.js';
-// Custom document loader
-export const customDocumentLoader = async (url) => {
-    const contextMap = {
-        'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json': localOBContext,
-        'https://w3id.org/security/suites/ed25519-2020/v1': localED25519Context,
-    };
-    if (contextMap[url]) {
-        return {
-            contextUrl: null,
-            documentUrl: url,
-            document: contextMap[url],
-        };
-    }
-    return defaultDocumentLoader(url); // Fallback to default loader for unknown URLs
-};
+import { extractKeyPairFromCredential, generateDIDSchema, generateUnsignedRecommendation, generateUnsignedVC, } from '../utils/credential.js';
+import { customDocumentLoader } from '../utils/digitalbazaar.js';
+import { saveToGoogleDrive } from '../utils/google.js';
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+/**
+ * Class representing the Credential Engine.
+ * @class CredentialEngine
+ * @param {string} accessToken - The access token for the user.
+ * @classdesc Credential Engine class to create DIDs and VCs.
+ * @method createDID - Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
+ * @method createWalletDID - Create a new DID with user metamask address as controller.
+ * @method signVC - Sign a Verifiable Credential (VC).
+ * @method verifyCredential - Verify a Verifiable Credential (VC).
+ * @method createPresentation - Create a Verifiable Presentation (VP).
+ * @method signPresentation - Sign a Verifiable Presentation (VP).
+ */
 export class CredentialEngine {
-    /**
-     * Create a DID document using the provided key pair.
-     * @param {object} keyPair - The key pair used to create the DID document.
-     * @returns {Promise<object>} The created DID document.
-     */
-    async generateDIDSchema(keyPair) {
-        try {
-            const DID = keyPair.controller;
-            const didDocument = {
-                '@context': ['https://www.w3.org/ns/did/v1'],
-                id: DID,
-                publicKey: [
-                    {
-                        id: keyPair.id,
-                        type: 'Ed25519VerificationKey2020',
-                        controller: DID,
-                        publicKeyMultibase: keyPair.publicKeyMultibase,
-                    },
-                ],
-                authentication: [keyPair.id],
-                assertionMethod: [keyPair.id],
-                capabilityDelegation: [keyPair.id],
-                capabilityInvocation: [keyPair.id],
-                keyAgreement: [
-                    {
-                        id: `${keyPair.id}-keyAgreement`,
-                        type: 'X25519KeyAgreementKey2020',
-                        controller: DID,
-                        publicKeyMultibase: keyPair.publicKeyMultibase,
-                    },
-                ],
-            };
-            return didDocument;
+    uuid;
+    storage;
+    keyPair;
+    constructor(accessToken) {
+        this.uuid = uuidv4();
+        this.storage = new GoogleDriveStorage(accessToken);
+    }
+    async getKeyPair(vc) {
+        // Fetch all stored key pairs
+        const keyPairs = await this.storage.getAllFilesByType('KEYPAIRs');
+        if (!keyPairs || keyPairs.length === 0) {
+            throw new Error('No key pairs found in storage.');
         }
-        catch (error) {
-            console.error('Error creating DID document:', error);
-            throw error;
+        // Extract UUID from VC ID
+        const vcIdParts = vc.id.split(':');
+        if (vcIdParts.length < 3) {
+            throw new Error('Invalid Verifiable Credential ID format.');
         }
+        const uuidFromVC = vcIdParts[2];
+        // Match UUID with key pair files
+        const matchingKeyPairFile = keyPairs.find((key) => {
+            const [uuidPart] = key.name.split('_');
+            return uuidPart === uuidFromVC;
+        });
+        if (!matchingKeyPairFile) {
+            throw new Error('No matching key pair found for the Verifiable Credential ID.');
+        }
+        // Return the key pair content
+        const key = matchingKeyPairFile.content;
+        this.keyPair = key;
+        return key;
+    }
+    generateKeyPair = async (address) => {
+        const keyPair = await Ed25519VerificationKey2020.generate();
+        const a = address || keyPair.publicKeyMultibase;
+        keyPair.controller = `did:key:${a}`;
+        keyPair.id = `${keyPair.controller}#${a}`;
+        keyPair.revoked = false;
+        return keyPair;
+    };
+    async verifyCreds(creds) {
+        await Promise.all(creds.map((cred) => {
+            const res = this.verifyCredential(cred);
+            if (!res)
+                return false;
+        }));
+        return true;
     }
     /**
      * Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
@@ -65,11 +74,10 @@ export class CredentialEngine {
      */
     async createDID() {
         try {
-            const keyPair = await Ed25519VerificationKey2020.generate();
-            keyPair.controller = `did:key:${keyPair.publicKeyMultibase}`;
-            keyPair.id = `${keyPair.controller}#${keyPair.publicKeyMultibase}`;
-            keyPair.revoked = false;
-            const didDocument = await this.generateDIDSchema(keyPair);
+            const keyPair = await this.generateKeyPair();
+            const keyFile = await saveToGoogleDrive(this.storage, keyPair, 'KEYPAIR', this.uuid);
+            console.log('🚀 ~ CredentialEngine ~ createDID ~ keyFile:', keyFile);
+            const didDocument = await generateDIDSchema(keyPair);
             return { didDocument, keyPair };
         }
         catch (error) {
@@ -85,11 +93,10 @@ export class CredentialEngine {
      */
     async createWalletDID(walletrAddress) {
         try {
-            const keyPair = await Ed25519VerificationKey2020.generate();
-            keyPair.controler = walletrAddress; // Using the MetaMask address as controller
-            keyPair.id = `${keyPair.controller}#${keyPair.fingerprint()}`;
-            keyPair.revoked = false;
-            const didDocument = await this.generateDIDSchema(keyPair);
+            const keyPair = await this.generateKeyPair(walletrAddress);
+            const keyFile = await saveToGoogleDrive(this.storage, keyPair, 'KEYPAIR', this.uuid);
+            console.log('🚀 ~ CredentialEngine ~ createWalletDID ~ keyFile:', keyFile);
+            const didDocument = await generateDIDSchema(keyPair);
             return { didDocument, keyPair };
         }
         catch (error) {
@@ -98,89 +105,109 @@ export class CredentialEngine {
         }
     }
     /**
-     * Create an unsigned Verifiable Credential (VC)
-     * @param {object} formData - The form data to include in the VC.
-     * @param {string} issuerDid - The DID of the issuer.
-     * @returns {Promise<object>} The created unsigned VC.
-     * @throws Will throw an error if unsigned VC creation fails.
+     * Sign a Verifiable Credential (VC)
+     * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
+     * @param {string} issuerId - The ID of the issuer [currently we put it as the did id]
+     * @param {KeyPair} keyPair - The key pair to use for signing.
+     * @returns {Promise<Credential>} The signed VC.
+     * @throws Will throw an error if VC signing fails.
      */
-    async createUnsignedVC(formData, issuerDid) {
+    async signVC(formData, type, keyPair, issuerId) {
+        let credential;
+        if (type == 'VC') {
+            credential = generateUnsignedVC(formData, issuerId, this.uuid);
+        }
+        else if (type == 'RECOMMENDATION') {
+            credential = generateUnsignedRecommendation(formData, issuerId);
+        }
+        const suite = new Ed25519Signature2020({ key: keyPair, verificationMethod: keyPair.id });
         try {
-            const issuanceDate = new Date().toISOString();
-            if (issuanceDate > formData.expirationDate)
-                throw Error('issuanceDate cannot be after expirationDate');
-            const unsignedCredential = {
-                '@context': [
-                    'https://www.w3.org/2018/credentials/v1',
-                    'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
-                    {
-                        duration: 'https://schema.org/duration',
-                        fullName: 'https://schema.org/name',
-                        portfolio: 'https://schema.org/portfolio',
-                        evidenceLink: 'https://schema.org/evidenceLink',
-                        evidenceDescription: 'https://schema.org/evidenceDescription',
-                        credentialType: 'https://schema.org/credentialType',
-                    },
-                ],
-                id: `urn:uuid:${uuidv4()}`, // Add the id property
-                type: ['VerifiableCredential', 'OpenBadgeCredential'],
-                issuer: {
-                    id: issuerDid,
-                    type: ['Profile'],
-                },
-                issuanceDate,
-                expirationDate: formData.expirationDate,
-                credentialSubject: {
-                    type: ['AchievementSubject'],
-                    name: formData.fullName,
-                    portfolio: formData.portfolio,
-                    evidenceLink: formData.evidenceLink,
-                    evidenceDescription: formData.achievementDescription,
-                    duration: formData.duration,
-                    credentialType: formData.credentialType,
-                    achievement: [
-                        {
-                            id: `urn:uuid:${uuidv4()}`,
-                            type: ['Achievement'],
-                            criteria: {
-                                narrative: formData.criteriaNarrative,
-                            },
-                            description: formData.achievementDescription,
-                            name: formData.achievementName,
-                            image: formData.evidenceLink
-                                ? {
-                                    id: formData.evidenceLink,
-                                    type: 'Image',
-                                }
-                                : undefined,
-                        },
-                    ],
-                },
-            };
-            console.log('Successfully created Unsigned Credentials', unsignedCredential);
-            return unsignedCredential;
+            const signedVC = await vc.issue({ credential, suite, documentLoader: customDocumentLoader });
+            return signedVC;
         }
         catch (error) {
-            console.error('Error creating unsigned VC', error);
+            console.error('Error signing VC:', error);
             throw error;
         }
     }
     /**
-     * Sign a Verifiable Credential (VC)
-     * @param {object} credential - The credential to sign.
-     * @param {object} keyPair - The key pair to use for signing.
-     * @returns {Promise<object>} The signed VC.
-     * @throws Will throw an error if VC signing fails.
+     * Verify a Verifiable Credential (VC)
+     * @param {object} credential - The Verifiable Credential to verify.
+     * @returns {Promise<boolean>} The verification result.
+     * @throws Will throw an error if VC verification fails.
      */
-    async signVC(credential, keyPair) {
-        const suite = new Ed25519Signature2020({ key: keyPair, verificationMethod: keyPair.id });
+    async verifyCredential(credential) {
         try {
-            const signedVC = await issue({ credential, suite, documentLoader: customDocumentLoader });
-            console.log('Successfully created Signed VC', signedVC);
-            return signedVC;
+            const keyPair = await extractKeyPairFromCredential(credential);
+            const suite = new Ed25519Signature2020({
+                key: keyPair,
+                verificationMethod: keyPair.id,
+            });
+            const result = await vc.verifyCredential({
+                credential,
+                suite,
+                documentLoader: customDocumentLoader,
+            });
+            console.log(JSON.stringify(result));
+            return result;
         }
         catch (error) {
-            console.error('Error signing VC:', error);
+            console.error('Verification failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a Verifiable Presentation (VP)
+     * @param verifiableCredential
+     * @returns
+     */
+    async createPresentation(verifiableCredential) {
+        try {
+            const res = await this.verifyCreds(verifiableCredential);
+            if (!res)
+                throw new Error('Some credentials failed verification');
+            const id = `urn:uuid:${uuidv4()}`;
+            const keyPair = await this.getKeyPair(verifiableCredential[0]);
+            console.log('🚀 ~ CredentialEngine ~ createPresentation ~ keyPair:', keyPair);
+            const VP = await vc.createPresentation({ verifiableCredential, id, holder: keyPair.controller });
+            return VP;
+        }
+        catch (error) {
+            console.error('Error creating presentation:', error);
+            throw error;
+        }
+    }
+    /**
+     * Sign a Verifiable Presentation (VP)
+     * @param presentation
+     * @returns
+     */
+    async signPresentation(presentation) {
+        try {
+            // Wrap the keyPair into an Ed25519VerificationKey2020 that includes the signer method
+            const signingKey = new Ed25519VerificationKey2020({
+                id: this.keyPair.id,
+                controller: this.keyPair.controller,
+                type: this.keyPair.type,
+                publicKeyMultibase: this.keyPair.publicKeyMultibase,
+                privateKeyMultibase: this.keyPair.privateKeyMultibase,
+            });
+            // Create the Ed25519Signature2020 suite with the wrapped key that includes the signer
+            const suite = new Ed25519Signature2020({
+                key: signingKey,
+                verificationMethod: this.keyPair.id,
+            });
+            // Sign the presentation
+            const signedVP = await vc.signPresentation({
+                presentation,
+                suite,
+                documentLoader: customDocumentLoader,
+                challenge: '', // Provide the challenge if required
+            });
+            return signedVP;
+        }
+        catch (error) {
+            console.error('Error signing presentation:', error);
             throw error;
         }
     }