@originvault/ov-id-sdk
Version:
A TypeScript SDK for managing decentralized identities (DIDs) and verifiable credentials (VCs)
184 lines • 8.21 kB
JavaScript
import { createOVAgent, createCheqdProvider, CheqdNetwork, keyStore, privateKeyStore } from './OVAgent.js';
import { getUniversalResolverFor } from '@veramo/did-resolver';
import { getParentDIDFromPackageJson, getParentBundlePrivateKey, getParentBundleHash } from './packageManager.js';
import { generateDIDKey } from './didKey.js';
import dotenv from 'dotenv';
import { v5 as uuidv5 } from 'uuid';
import { convertRecoveryToPrivateKey } from './encryption.js';
import { importDID, listDIDs, getDIDKeys, createDID } from './identityManager.js';
import { createResource } from './resourceManager.js';
import { getEnvironmentMetadata } from './environment.js';
import path from 'path';
import { co2 } from "@tgwf/co2";
dotenv.config();
const universalResolver = getUniversalResolverFor(['cheqd', 'key']);
const packageJsonPath = path.join(process.cwd(), './package.json');
let cheqdMainnetProvider = null;
let cheqdTestnetProvider = null;
export let parentAgent = null;
let currentDIDKey = null;
let signedVCs = [];
let publishWorkingKey = null;
let publishRelease = async () => {
return Promise.reject(new Error("publishRelease not initialized"));
};
const initializeParentAgent = async ({ payerSeed, didRecoveryPhrase } = {}) => {
let cosmosPayerSeed = payerSeed || process.env.COSMOS_PAYER_SEED || '';
let didMnemonic = didRecoveryPhrase || process.env.PARENT_DID_RECOVERY_PHRASE || '';
cheqdMainnetProvider = createCheqdProvider(CheqdNetwork.Mainnet, cosmosPayerSeed, process.env.CHEQD_RPC_URL || 'https://cheqd.originvault.box:443');
cheqdTestnetProvider = createCheqdProvider(CheqdNetwork.Testnet, cosmosPayerSeed, process.env.CHEQD_RPC_URL || 'https://rpc.cheqd.network');
parentAgent = createOVAgent(cheqdMainnetProvider, universalResolver);
if (!parentAgent) {
throw new Error("Parent agent could not be initialized");
}
const parentDIDString = await getParentDIDFromPackageJson();
if (didMnemonic) {
const parentPrivateKey = await convertRecoveryToPrivateKey(didMnemonic);
const { credentials } = await importDID({ didString: parentDIDString, privateKey: parentPrivateKey, method: 'cheqd', agent: parentAgent });
signedVCs.concat(credentials);
}
// Generate did:web after agent initialization
const bundle = await getParentBundlePrivateKey();
const privateKeyHex = Buffer.from(bundle.key).toString("hex");
const importedKey = await parentAgent.keyManagerImport({
privateKeyHex,
type: "Ed25519",
kms: "local"
});
const { didKey, id } = await generateDIDKey(bundle.key);
await parentAgent.didManagerImport({
did: didKey,
keys: [{
kid: importedKey.kid,
type: 'Ed25519',
kms: 'local',
privateKeyHex,
}],
provider: `did:key`,
alias: didKey
});
const environmentMetadata = await getEnvironmentMetadata(packageJsonPath);
const environmentCredentialId = uuidv5(bundle.hash + new Date().toISOString(), uuidv5.URL);
const environmentCredential = {
id: environmentCredentialId,
issuer: { id: didKey },
credentialSubject: {
id,
assertionType: "environment-metadata",
assertionDate: new Date().toISOString(),
assertionDetails: environmentMetadata,
assertionResult: 'Passed',
verificationSteps: [
{
step: "Get development environment metadata using read-parent-json-fast & process.env",
result: 'Passed',
timestamp: new Date().toISOString()
}
]
},
'@context': ['https://www.w3.org/2018/credentials/v1'],
type: ['VerifiableCredential'],
expirationDate: new Date().toISOString()
};
const signedEnvironmentVC = await parentAgent.createVerifiableCredential({
credential: environmentCredential,
proofFormat: 'jwt'
});
const credentialId = uuidv5(didKey + new Date().toISOString(), uuidv5.URL); // Generate a UUID from the did
const credential = {
id: credentialId,
issuer: { id: didKey },
credentialSubject: {
id: didKey,
assertionType: "parent-runtime-agent-verification",
assertionDate: new Date().toISOString(),
assertionResult: 'Passed',
assertionDetails: {
bundleHash: bundle.hash,
bundleFiles: bundle.files,
environmentMetadata: environmentMetadata,
environmentCredential: signedEnvironmentVC
},
},
'@context': ['https://www.w3.org/2018/credentials/v1'],
type: ['VerifiableCredential'],
expirationDate: new Date().toISOString()
};
const args = {
credential,
proofFormat: 'jwt'
};
const co2Emission = new co2();
const co2EmissionResult = co2Emission.perByte(JSON.stringify(args).length);
console.log(`🌱 ${parentDIDString} - Parent Runtime Credential size in carbon: ${co2EmissionResult.toFixed(5)}g`);
const signedVC = await parentAgent.createVerifiableCredential(args);
if (cheqdMainnetProvider !== null) {
publishWorkingKey = async () => {
if (!parentAgent) {
throw new Error("Parent agent not initialized");
}
const result = await createResource({
data: signedVC,
did: parentDIDString,
name: `${parentDIDString}-keys`,
provider: cheqdMainnetProvider,
agent: parentAgent,
keyStore: privateKeyStore,
resourceId: uuidv5(id, uuidv5.URL),
resourceType: 'Working-Directory-Derived-Key',
version: credentialId
});
if (!result) {
throw new Error("Failed to publish release");
}
return result;
};
}
signedVCs.push(signedVC);
currentDIDKey = didKey;
publishRelease = async (releaseCredential, name, version) => {
if (!parentAgent) {
throw new Error("Parent agent not initialized");
}
const resolvedPackageDid = await parentAgent?.resolveDid({ didUrl: parentDIDString });
const alreadyPublished = resolvedPackageDid?.didDocumentMetadata?.linkedResourceMetadata?.some(resource => resource.resourceVersion === version);
if (alreadyPublished) {
console.warn("Package already published. Skipping.");
return;
}
const result = await createResource({
data: releaseCredential,
did: parentDIDString,
name,
version,
provider: cheqdMainnetProvider,
agent: parentAgent,
keyStore: privateKeyStore,
resourceType: 'NPM-Package-Publish-Event',
});
if (!result) {
throw new Error("Failed to publish release");
}
return result;
};
return { agent: parentAgent, did: parentDIDString, key: currentDIDKey, credentials: signedVCs, publishWorkingKey, publishRelease, privateKeyStore, cheqdTestnetProvider, cheqdMainnetProvider };
};
const parentStore = {
initialize: initializeParentAgent,
agent: parentAgent,
keyStore,
cheqdMainnetProvider,
cheqdTestnetProvider,
didKey: currentDIDKey,
credentials: signedVCs,
listDids: async (provider) => parentAgent ? listDIDs(parentAgent, provider) : [],
getDID: async (didString) => getDIDKeys(didString),
createDID: (props) => parentAgent ? createDID({ ...props, agent: parentAgent }) : Promise.reject(new Error("Parent agent not initialized")),
importDID: (didString, privateKey, method) => parentAgent ? importDID({ didString, privateKey, method, agent: parentAgent }) : Promise.reject(new Error("Parent agent not initialized")),
getPrimaryDID: async () => await getParentDIDFromPackageJson(),
getBundleHash: async () => await getParentBundleHash(),
publishWorkingKey,
packageJsonPath
};
export { parentStore };
//# sourceMappingURL=parentAgent.js.map