// client.js
 
import { CachingJwtProvider } from 'virgil-sdk';
 
const fetchJwt = () => fetch('/virgil-jwt', { credentials: 'same-origin' })
    .then(response => response.text());
 
const jwtProvider = new CachingJwtProvider(fetchJwt);
// pass jwtProvider as `accessTokenProvider` to the `CardManager` constructor

// server.js
 
import express from 'express';
import { initCrypto, VirgilCrypto, VirgilAccessTokenSigner } from 'virgil-crypto';
import { JwtGenerator } from 'virgil-sdk';
 
async function getJwtGenerator() {
  await initCrypto();
 
  const virgilCrypto = new VirgilCrypto();
  // initialize JWT generator with your App ID and App Key ID you got in
  // Virgil Dashboard and the `appKey` object you've just imported.
  return new JwtGenerator({
    appId: process.env.APP_ID,
    apiKeyId: process.env.APP_KEY_ID,
    // import your App Key that you got in Virgil Dashboard from string.
    apiKey: virgilCrypto.importPrivateKey(process.env.APP_KEY),
    // initialize accessTokenSigner that signs users JWTs
    accessTokenSigner: new VirgilAccessTokenSigner(virgilCrypto),
    millisecondsToLive:  20 * 60 * 1000 // JWT lifetime - 20 minutes (default)
  });
}
 
app.get('/virgil-jwt', (req, res) => {
  const generator = await generatorPromise;
  const virgilJwtToken = generator.generateToken(req.user.identity);
 
  res.json({ virgilToken: virgilJwtToken.toString() });
});

import { initCrypto, VirgilCrypto, VirgilCardCrypto } from 'virgil-crypto';
import { VirgilCardVerifier } from 'virgil-sdk';
 
(async function() {
    // initialize Crypto library
    await initCrypto();
    const cardCrypto = new VirgilCardCrypto(new VirgilCrypto());
    const cardVerifier = new VirgilCardVerifier(cardCrypto);
})();

import { CardManager } from 'virgil-sdk';
 
// initialize cardManager and specify accessTokenProvider, cardVerifier
const cardManager = new CardManager({
  cardCrypto: cardCrypto,
  accessTokenProvider: accessTokenProvider,
  cardVerifier: cardVerifier
});

import { initCrypto, VirgilCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { PrivateKeyStorage } from 'virgil-sdk';
 
(async function() {
    // initialize Virgil Crypto library
    await initCrypto();
 
    const virgilCrypto = new VirgilCrypto();
    const privateKeyExporter = new VirgilPrivateKeyExporter(
        virgilCrypto,
        // if provided, will be used to encrypt the key bytes before exporting
        // and decrypt before importing.
        '[OPTIONAL_PASSWORD_TO_ENCRYPT_THE_KEYS_WITH]'
    );
    // Generate a private key
    const keyPair = virgilCrypto.generateKeys();
 
    const privateKeyStorage = new PrivateKeyStorage(privateKeyExporter);
 
    // Store the private key with optional metadata (i.e. the PrivateKeyEntry)
    await privateKeyStorage.store('my private key', keyPair.privateKey, { optional: 'data' });
 
    // Load the private key entry
    const privateKeyEntry = await privateKeyStorage.load('my private key');
 
    if (privateKeyEntry === null) {
        return;
    }
 
    console.log(privateKeyEntry.privateKey); // VirgilPrivateKey instance
    console.log(privateKeyEntry.meta); // { optional: 'data' }
 
    const privateKey = privateKeyEntry.privateKey;
 
    // Use the privateKey in virgilCrypto operations
 
    // Delete a private key
    await privateKeyStorage.delete('my private key');
 
    console.log('Private key has been removed');
})();

import { initCrypto, VirgilCrypto, VirgilCardCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { CachingJwtProvider, CardManager, PrivateKeyStorage, VirgilCardVerifier } from 'virgil-sdk';
 
(async function() {
    await initCrypto();
 
    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)
    );
 
    // Generate a key pair
    const keyPair = virgilCrypto.generateKeys();
 
    // Store the private key
    await privateKeyStorage.store('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 { initCrypto, VirgilCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { PrivateKeyStorage } from 'virgil-sdk';
 
(async function() {
    await initCrypto();
 
    const virgilCrypto = new VirgilCrypto();
    const privateKeyStorage = new PrivateKeyStorage(
        new VirgilPrivateKeyExporter(virgilCrypto)
    );
 
    // 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 { initCrypto, VirgilCrypto, VirgilPrivateKeyExporter } from 'virgil-crypto';
import { PrivateKeyStorage } from 'virgil-sdk';
 
(async function() {
    await initCrypto();
 
    const virgilCrypto = new VirgilCrypto();
    const privateKeyStorage = new PrivateKeyStorage(
        new VirgilPrivateKeyExporter(virgilCrypto)
    );
 
    // 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());
})();

cardManager.getCard('f4bf9f7fcbedaba0392f108c59d8f4a38b3838efb64877380171b54475c2ade8')
.then(card => {
    console.log('Got: ', card);
});

cardManager.searchCards('alice@example.com')
.then(cards => {
    cards.map(card => console.log(card.id));
});