@originvault/ov-id-sdk
Version:
A TypeScript SDK for managing decentralized identities (DIDs) and verifiable credentials (VCs)
184 lines • 8.26 kB
JavaScript
import { createOVAgent, createCheqdProvider, CheqdNetwork, keyStore, privateKeyStore } from './OVAgent.js';
import { getUniversalResolverFor } from '@veramo/did-resolver';
import { getSelfBundlePrivateKey, getPackageDIDFromPackageJson, getSelfBundleHash } 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 { fileURLToPath } from 'url';
import { co2 } from "@tgwf/co2";
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
dotenv.config();
const universalResolver = getUniversalResolverFor(['cheqd', 'key']);
const packageJsonPath = path.join(__dirname, '../package.json');
let cheqdMainnetProvider = null;
let cheqdTestnetProvider = null;
let packageAgent = null;
let currentDIDKey = null;
let signedVCs = [];
let publishWorkingKey = null;
let publishRelease = async () => {
return Promise.reject(new Error("publishRelease not initialized"));
};
const initializePackageAgent = async ({ payerSeed, didRecoveryPhrase, dbConnection } = {}) => {
let cosmosPayerSeed = payerSeed || process.env.COSMOS_PAYER_SEED || '';
let didMnemonic = didRecoveryPhrase || process.env.PACKAGE_DID_RECOVERY_PHRASE || '';
cheqdMainnetProvider = createCheqdProvider(CheqdNetwork.Mainnet, cosmosPayerSeed, process.env.CHEQD_MAINNET_RPC_URL || 'https://cheqd.originvault.box:443');
cheqdTestnetProvider = createCheqdProvider(CheqdNetwork.Testnet, cosmosPayerSeed, process.env.CHEQD_TESTNET_RPC_URL || 'https://rpc.cheqd.network');
packageAgent = createOVAgent({ cheqdProvider: cheqdMainnetProvider, universalResolver, additionalResolvers: {}, cheqdTestnetProvider, dbConnection });
if (!packageAgent) {
throw new Error("Package agent could not be initialized");
}
const packageJsonDIDString = await getPackageDIDFromPackageJson();
if (didMnemonic) {
const packagePrivateKey = await convertRecoveryToPrivateKey(didMnemonic);
try {
const { credentials } = await importDID({ didString: packageJsonDIDString, privateKey: packagePrivateKey, method: 'cheqd', agent: packageAgent });
signedVCs.concat(credentials);
}
catch (error) {
console.error("❌ Error importing DID:", error);
throw error;
}
}
// Generate did:web after agent initialization
const bundle = await getSelfBundlePrivateKey();
const privateKeyHex = Buffer.from(bundle.key).toString("hex");
const importedKey = await packageAgent.keyManagerImport({
privateKeyHex,
type: "Ed25519",
kms: "local"
});
const { didKey, id } = await generateDIDKey(bundle.key);
await packageAgent.didManagerImport({
did: didKey,
keys: [{
kid: importedKey.kid,
type: 'Ed25519',
kms: 'local',
privateKeyHex,
}],
provider: `did:key`,
alias: didKey
});
const environmentMetadata = await getEnvironmentMetadata(packageJsonPath);
const environmentMetadataCredential = {
id,
assertionType: "environment-metadata",
assertionDate: new Date().toISOString(),
assertionDetails: environmentMetadata,
assertionResult: 'Passed',
verificationSteps: [
{
step: "Get development environment metadata using read-package-json-fast & process.env",
result: 'Passed',
timestamp: new Date().toISOString()
}
]
};
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: "package-runtime-agent-verification",
assertionDate: new Date().toISOString(),
assertionResult: 'Passed',
assertionDetails: {
bundleHash: bundle.hash,
bundleFiles: bundle.files,
environmentCredential: environmentMetadataCredential
},
},
'@context': ['https://www.w3.org/2018/credentials/v1'],
type: ['VerifiableCredential'],
expirationDate: new Date().toISOString() + '1000000000000'
};
const args = {
credential,
proofFormat: 'jwt'
};
const co2Emission = new co2();
const co2EmissionResult = co2Emission.perByte(JSON.stringify(args).length);
console.log(`🌱 ${packageJsonDIDString} - Package Runtime Credential size in carbon: ${co2EmissionResult.toFixed(5)}g`);
const signedVC = await packageAgent.createVerifiableCredential(args);
if (cheqdMainnetProvider !== null) {
publishWorkingKey = async () => {
if (!packageAgent) {
throw new Error("Package agent not initialized");
}
const result = await createResource({
data: signedVC,
did: packageJsonDIDString,
name: `${packageJsonDIDString}-keys`,
provider: cheqdMainnetProvider,
agent: packageAgent,
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 (!packageAgent) {
throw new Error("Package agent not initialized");
}
const resolvedPackageDid = await packageAgent.resolveDid({ didUrl: packageJsonDIDString });
const alreadyPublished = resolvedPackageDid?.didDocumentMetadata?.linkedResourceMetadata?.some(resource => resource.resourceName === name && resource.resourceVersion === version);
if (!resolvedPackageDid?.didDocument) {
throw new Error("Failed to resolve package DID");
}
if (alreadyPublished) {
console.warn("Package already published. Skipping.");
return;
}
const result = await createResource({
data: releaseCredential,
did: resolvedPackageDid.didDocument.id,
name,
provider: cheqdMainnetProvider,
agent: packageAgent,
keyStore: privateKeyStore,
resourceType: 'NPM-Package-Publish-Event',
version
});
if (!result) {
throw new Error("Failed to publish release");
}
return result;
};
return { agent: packageAgent, did: packageJsonDIDString, key: currentDIDKey, credentials: signedVCs, publishWorkingKey, publishRelease, privateKeyStore, cheqdTestnetProvider, cheqdMainnetProvider };
};
const packageStore = {
initialize: initializePackageAgent,
agent: packageAgent,
keyStore,
cheqdMainnetProvider,
cheqdTestnetProvider,
listDids: async (provider) => packageAgent ? listDIDs(packageAgent, provider) : [],
getDID: async (didString) => getDIDKeys(didString),
createDID: (props) => packageAgent ? createDID({ ...props, agent: packageAgent }) : Promise.reject(new Error("Package agent not initialized")),
importDID: (didString, privateKey, method) => packageAgent ? importDID({ didString, privateKey, method, agent: packageAgent }) : Promise.reject(new Error("Package agent not initialized")),
getPrimaryDID: async () => await getPackageDIDFromPackageJson(),
getBundleHash: async () => await getSelfBundleHash(),
publishWorkingKey,
publishRelease,
didKey: currentDIDKey,
packageJsonPath,
privateKeyStore
};
export { packageStore };
//# sourceMappingURL=packageAgent.js.map