@cooperation/vc-storage 1.0.0 → 1.0.4

package/README.md

@@ -1,136 +1,109 @@
-# Trust Storage Library
+# @cooperation/vc-storage
 
-Store your files using up to three strategies. Currently, we offer the GoogleDriveStorage class, which is designed for storing files in Google Drive. Stay tuned for additional methods coming soon 😊
+**Version**: 1.0.0
 
-## Installation
-
-To install the Trust Storage library, you can use either npm or yarn. Run one of the following commands in your project directory:
-
-```bash
-npm install trust_storage
-```
-
-or
-
-```bash
-yarn add trust_storage
-```
-
-## Usage
-
-To use the `GoogleDriveStorage` class in your application, you need to pass an access token that has appropriate permissions for Google Drive operations. You can generate an access token by following these steps:
-
-1. Visit the [OAuth 2.0 Playground](https://developers.google.com/oauthplayground/).
-2. Enter the scope: `https://www.googleapis.com/auth/drive`.
-3. Copy the accessToken and pass it to the `GoogleDriveStorage` class.
-
-The `GoogleDriveStorage` class includes two methods:
-
-- `createFolder()`: It is designed to create a new folder in Google Drive.
-- `uploadFile()`: Ensure that the necessary folder has been created or identified where the file will be stored.
-
-## Notes
-
-- This library is a demonstration tool for uploading files to Google Drive.
-
-### Your First Code Contribution
-
-1. Clone the repository.
-2. Run yarn or npm install to install dependencies.
-3. Create a new branch for your feature or bugfix.
-4. Make your changes.
-5. Commit your changes and push your branch to your fork.
-6. Open a pull request.
-
-### Pull Requests
-
-When you're ready to submit your pull request:
-
-1. Ensure your work is aligned with the project's coding standards.
-2. Fill out the pull request template.
-3. Include a clear and detailed description of the changes.
-4. Link any related issues.
-5. Wait for review and address any feedback.
-
-## Development Workflow
-
-### Setup
+## Overview
 
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/yourusername/your-repo-name.git
-   ```
-2. Navigate to the project directory:
-   ```bash
-   cd your-repo-name
-   ```
-3. Install dependencies:
-   ```bash
-   npm install
-   ```
+`@cooperation/vc-storage` is a TypeScript library that allows you to sign and store Verifiable Credentials (VCs) in various storage strategies. This library provides flexibility and security by allowing you to choose where your VCs are stored, whether on cloud services like Google Drive, on your local device, or in your digital wallet. Support for Dropbox and wallet storage is currently under development.
 
-Certainly! Here is the provided text rewritten in `.md` format:
+## Features
 
-````markdown
-## Publishing Flow
+- **Sign and Store VCs**: Securely sign your Verifiable Credentials and store them in your preferred storage medium.
+- **Google Drive Integration**: Seamlessly store your VCs on Google Drive.
+- **Local Device Storage**: Store your VCs directly on your device.
+- **Future Integrations**:
+  - **Wallet Storage**: Integration for storing VCs directly in your digital wallet (under development).
+  - **Dropbox Storage**: Integration for storing VCs in Dropbox (under development).
 
-If you want to publish a new version of the package, please follow these steps:
-
-### Request Access
-
-Ask for access to publish the package in the Slack. Mention the version and any significant changes.
-
-### Update Version
-
-Ensure you update the version in `package.json` according to [Semantic Versioning](https://semver.org/). You can do this manually or using the npm command:
-
-```bash
-npm version [patch|minor|major]
-```
-````
-
-### Ensure Tests Pass
-
-Run all tests to make sure they are passing:
-
-```bash
-npm test
-```
-
-### Build the Project
+## Installation
 
-Build the project to ensure all changes are compiled:
+You can install this package via npm:
 
 ```bash
-npm run build
+npm install @cooperation/vc-storage
 ```
 
-### Commit and Push
-
-Commit and push your changes to the main branch:
+## Usage
 
-```bash
-git add .
-git commit -m "Prepare for release vX.Y.Z"
-git push origin main
+### Basic Example
+
+Here’s how you can use the `@cooperation/vc-storage` library to sign and store your VCs:
+
+```typescript
+import { saveToGoogleDrive, CredentialEngine, GoogleDriveStorage } from '@cooperation/vc-storage';
+
+const accessToken = 'your-google-drive-access-token';
+const credentialEngine = new CredentialEngine();
+const storage = new GoogleDriveStorage(accessToken);
+
+async function main(useWallet = false, walletAddress = '') {
+	const formData = {
+		expirationDate: '2025-12-31T23:59:59Z',
+		fullName: 'John Doe',
+		duration: '1 year',
+		criteriaNarrative: 'This is a narrative',
+		achievementDescription: 'This is an achievement',
+		achievementName: 'Achievement Name',
+		portfolio: [
+			{ name: 'Portfolio 1', url: 'https://example.com/portfolio1' },
+			{ name: 'Portfolio 2', url: 'https://example.com/portfolio2' },
+		],
+		evidenceLink: 'https://example.com/evidence',
+		evidenceDescription: 'This is an evidence description',
+		credentialType: 'Credential Type',
+	};
+
+	let didDocument, keyPair;
+
+	// Step 1: Create DID based on the selected method
+	if (useWallet && walletAddress) {
+		({ didDocument, keyPair } = await credentialEngine.createWalletDID(walletAddress));
+	} else {
+		({ didDocument, keyPair } = await credentialEngine.createDID());
+	}
+
+	await saveToGoogleDrive(storage, { ...didDocument, keyPair }, 'DID');
+
+	const issuerDid = didDocument.id;
+
+	// Step 2: Create an Unsigned VC
+	const unsignedVC = await credentialEngine.createUnsignedVC(formData, issuerDid);
+	await saveToGoogleDrive(storage, unsignedVC, 'UnsignedVC');
+	console.log('Unsigned VC:', unsignedVC);
+
+	// Step 3: Sign the VC
+	try {
+		const signedVC = await credentialEngine.signVC(unsignedVC, keyPair);
+		await saveToGoogleDrive(storage, signedVC, 'VC');
+		console.log('Signed VC:', signedVC);
+	} catch (error) {
+		console.error('Error during VC signing:', error);
+	}
+
+	// Retrieve all stored claims
+	const claims = await storage.getAllClaims();
+	console.log('Stored Claims:', claims);
+}
+
+// Example usage:
+// 1. For Google Drive storage with standard DID creation
+main().catch(console.error);
+
+// 2. For Google Drive storage with wallet-based DID creation
+// main(true, 'your-wallet-address').catch(console.error);
 ```
 
-### Login to npm
+### Available Storage Strategies
 
-If you are not already logged in, log in to npm using your credentials:
+1. **Google Drive**: Store your VCs on Google Drive.
+2. **Local Device**: Store your VCs on your local device.
+3. **Wallet Storage**: (Under Development) Store your VCs directly in your digital wallet.
+4. **Dropbox**: (Under Development) Store your VCs in Dropbox.
 
-```bash
-npm login
-```
-
-### Publish the Package
-
-Once you have access and everything is set, publish the package:
+## Contributing
 
-```bash
-npm publish
-```
+Contributions are welcome! Please feel free to submit a Pull Request or open an Issue for any bugs or feature requests.
 
-### Notify Team
+## License
 
-Inform the team in the Slack channel that the new version has been published.
+This project is licensed under the ISC License.

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;
         }
     }