import { VirgilCrypto, VirgilCardCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { CachingJwtProvider, CardManager, PrivateKeyStorage, VirgilCardVerifier } from 'virgil-sdk';
 
(async function() {
    const virgilCrypto = new VirgilCrypto();
    const cardCrypto = new VirgilCardCrypto(virgilCrypto);
    
    const jwtProvider = new CachingJwtProvider(fetchVirgilJwt);
    const cardVerifier = new VirgilCardVerifier(cardCrypto);
    const cardManager = new CardManager({
        cardCrypto: cardCrypto,
        accessTokenProvider: jwtProvider,
        cardVerifier: cardVerifier
    });
    const privateKeyStorage = new PrivateKeyStorage(
        new VirgilPrivateKeyExporter(
            virgilCrypto,
            '[OPTIONAL_PASSWORD_TO_ENCRYPT_THE_KEYS_WITH]'
        )
    );
    
    // Generate a key pair
    const keyPair = virgilCrypto.generateKeys();
    
    // Store the private key
    await privateKeyStorage.save('alice_private_key', keyPair.privateKey);
    
    // Publish user's card on the Cards Service
    const card = await cardManager.publishCard({
        privateKey: keyPair.privateKey,
        publicKey: keyPair.publicKey,
        identity: 'alice@example.com'
    });
})();
 
async function fetchVirgilJwt (context) {
    // assuming your backend server is serving Virgil JWT tokens in plaintext
    // at /virgil-access-token endpoint
    const response = await fetch('/virgil-access-token');
    if (!response.ok) {
        throw new Error('Failed to get Virgil Access Token');
    }
 
    return await response.text();
}

import { VirgilCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { PrivateKeyStorage } from 'virgil-sdk';
 
(async function() {
    const virgilCrypto = new VirgilCrypto();
    const privateKeyStorage = new PrivateKeyStorage(
        new VirgilPrivateKeyExporter(
            virgilCrypto,
            '[OPTIONAL_PASSWORD_TO_ENCRYPT_THE_KEYS_WITH]'
        )
    );
    
    // Load the private key
    const alicePrivateKey = await privateKeyStorage.load('alice_private_key');
    if (alicePrivateKey === null) {
        console.log('Private key named "alice_private_key" does not exist');
        return;
    }
    
    const cards = await cardManager.searchCards('bob@example.com');
    if (cards.length === 0) {
        console.log('Virgil Card with identity "bob@example.com" does not exist');
        return;
    }
    
    const messageToEncrypt = 'Hello, Bob!';
    const bobPublicKeys = cards.map(card => card.publicKey);
    const encryptedMessage = virgilCrypto.signThenEncrypt(messageToEncrypt, alicePrivateKey, bobPublicKeys);
    console.log(encryptedMessage.toString('base64'));
})();

import { VirgilCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { PrivateKeyStorage } from 'virgil-sdk';
 
(async function() {
    const virgilCrypto = new VirgilCrypto();
    const privateKeyStorage = new PrivateKeyStorage(
        new VirgilPrivateKeyExporter(
            virgilCrypto,
            '[OPTIONAL_PASSWORD_TO_ENCRYPT_THE_KEYS_WITH]'
        )
    );
    
    // Load the private key 
    const bobPrivateKey = await privateKeyStorage.load('bob_private_key');
    if (bobPrivateKey === null) {
        console.log('Private key named "bob_private_key" does not exist');
        return;
    }
    
    const cards = await cardManager.searchCards('alice@example.com');
    if (cards.length === 0) {
        console.log('Virgil Card with identity "alice@example.com" does not exist');
        return;
    }
    
    const alicePublicKeys = cards.map(card => card.publicKey);
    const decryptedMessage = virgilCrypto.decryptThenVerify(encryptedMessage, bobPrivateKey, alicePublicKeys);
    console.log(decryptedMessage.toString());
})();