@empe/identity NPM

@empe/identity

A TypeScript implementation of Self-Sovereign Identity (SSI) components following W3C standards for Decentralized Identifiers (DIDs) and Verifiable Credentials (VCs).

Overview

This package provides comprehensive functionality for working with decentralized identity, including:

Decentralized Identifiers (DIDs): Creation, management, and resolution of DIDs
Verifiable Credentials (VCs): Issuance, verification, and storage of credentials
Verifiable Presentations (VPs): Creation and verification of credential presentations
Cryptographic Primitives: Key management, signatures, and proofs

The implementation follows the W3C Decentralized Identifiers and W3C Verifiable Credentials Data Model specifications.

Key Components

Decentralized Identifiers (DIDs)

CoreDID: Core implementation of DIDs following the standard format did:method:id
CoreDocument: Basic DID Document implementation
EmpeDocument: Extended DID Document for the Empe method

Verifiable Credentials

VerifiableCredential: Implementation of the W3C Verifiable Credential data model
VerifiablePresentation: Container for presenting one or more credentials with proof of ownership

Identity Roles

Issuer: Entity that creates and signs verifiable credentials
Holder: Entity that receives and stores credentials and can create presentations
Verifier: Entity that verifies credentials and presentations (implicit in the verification methods)

Key Management

KeyService: Management of cryptographic keys
JwkService: JSON Web Key operations
MnemonicService: Mnemonic phrase generation and handling

Cryptography

Proof: Cryptographic proofs for credentials and presentations
JWS: JSON Web Signature implementation
Signature: Digital signature creation and verification

Usage

Creating a DID

import { CoreDID, JwkService, Secp256k1Factory } from '@empe/identity';
import { MemKeyStorageAdapter } from '@empe/common';

// Create a new DID
const storage = new MemKeyStorageAdapter();
const keyService = new JwkService(storage, new Secp256k1Factory());
const did = await CoreDID.from(keyService);

Creating a Verifiable Credential

import { VerifiableCredential, Issuer, IssuerConfiguration, Client, Network, CoreDID } from '@empe/identity';
import { MemKeyStorageAdapter } from '@empe/common';

// Create a client and document
const storage = new MemKeyStorageAdapter();
const client = new Client({ storage, network: Network.TESTNET });
const document = await client.createEmpeDocument();

// Configure issuer
const config: IssuerConfiguration = {
    document: document,
};
const issuer = client.issuerFromConfiguration(config);

// Issue a verifiable credential
const holderDid = CoreDID.parse('did:empe:testnet:example');
const credential = await issuer.issueVerifiableCredential(holderDid, {
    name: 'John Doe',
    degree: 'Bachelor of Science',
});

Creating a Verifiable Presentation

import { Holder, HolderConfiguration, VerifiablePresentation } from '@empe/identity';
import { MemKeyStorageAdapter } from '@empe/common';

// Configure holder
const config: HolderConfiguration = {
    document: document,
};
const holder = new Holder(config, keyService);

// Create and sign a presentation
const presentation = await holder.issueVerifiablePresentation(
    recipientDid, // DID of the entity receiving the presentation
    holderDid, // DID of the holder creating the presentation
    [credential] // Array of credentials to include
);