@originvault/ov-id-sdk/dist/src/userAgent.js

A TypeScript SDK for managing decentralized identities (DIDs) and verifiable credentials (VCs)

import { getUniversalResolverFor } from '@veramo/did-resolver';
import dotenv from 'dotenv';
import { getDIDKeys, listDIDs, createDID, importDID } from './identityManager.js';
import fs from 'fs';
import path from 'path';
import os from 'os';
import { ensureKeyring } from './storePrivateKeys.js';
import { convertRecoveryToPrivateKey } from './encryption.js';
import { createOVAgent, createCheqdProvider, CheqdNetwork, keyStore, privateKeyStore } from './OVAgent.js';
dotenv.config();
export const PRIMARY_DID_WALLET_FILE = path.resolve(os.homedir(), '.originvault-primary-did-wallet.json');
export const ensurePrimaryDIDWallet = async () => {
    if (!fs.existsSync(PRIMARY_DID_WALLET_FILE)) {
        fs.writeFileSync(PRIMARY_DID_WALLET_FILE, JSON.stringify({}, null, 2));
    }
};
const universalResolver = getUniversalResolverFor(['cheqd', 'key']);
let signedVCs = [];
export async function getPrimaryDID() {
    ensurePrimaryDIDWallet();
    try {
        const kr = await ensureKeyring();
        const pairs = kr.getPairs();
        const primaryPair = pairs.find(p => p.meta?.isPrimary);
        const did = (primaryPair?.meta?.did || '');
        if (did)
            return did;
        try {
            const storedData = fs.readFileSync(PRIMARY_DID_WALLET_FILE, 'utf8');
            const { meta } = JSON.parse(storedData);
            if (!meta)
                return null;
            const { did, didCredential } = meta;
            if (!didCredential)
                return null;
            if (did)
                return did;
        }
        catch (error) {
            console.error("❌ Error accessing keyring. File may not exist");
        }
        return null;
    }
    catch (error) {
        console.error("❌ Error accessing keyring:", error);
        return null;
    }
}
let cheqdMainnetProvider = null;
export let userAgent = null;
const initializeAgent = async ({ payerSeed, didRecoveryPhrase } = {}) => {
    let cosmosPayerSeed = payerSeed || process.env.COSMOS_PAYER_SEED || '';
    let didMnemonic = didRecoveryPhrase || process.env.USER_DID_RECOVERY_PHRASE || '';
    cheqdMainnetProvider = createCheqdProvider(CheqdNetwork.Mainnet, cosmosPayerSeed, process.env.CHEQD_RPC_URL || 'https://cheqd.originvault.box:443');
    userAgent = createOVAgent(cheqdMainnetProvider, universalResolver);
    if (!userAgent) {
        throw new Error("User agent could not be initialized");
    }
    const primaryDID = await getPrimaryDID();
    if (primaryDID && didMnemonic) {
        const primaryPrivateKey = await convertRecoveryToPrivateKey(didMnemonic);
        const { credentials } = await importDID({ didString: primaryDID, privateKey: primaryPrivateKey, method: 'cheqd', agent: userAgent });
        signedVCs.concat(credentials);
    }
    return { agent: userAgent, did: primaryDID || '', key: primaryDID || '', credentials: signedVCs };
};
const userStore = {
    initialize: initializeAgent,
    agent: userAgent,
    cheqdMainnetProvider,
    privateKeyStore,
    keyStore,
    listDids: (provider) => userAgent ? listDIDs(userAgent, provider) : Promise.reject(new Error("User agent not initialized")),
    getDID: (didString) => userAgent ? getDIDKeys(didString) : Promise.reject(new Error("User agent not initialized")),
    createDID: (props) => userAgent ? createDID({ ...props, agent: userAgent }) : Promise.reject(new Error("User agent not initialized")),
    importDID: (didString, privateKey, method) => userAgent ? importDID({ didString, privateKey, method, agent: userAgent }) : Promise.reject(new Error("User agent not initialized")),
    getPrimaryDID: async () => await getPrimaryDID() || Promise.reject(new Error("User agent not initialized")),
};
export { userStore };
//# sourceMappingURL=userAgent.js.map