@originals/sdk 1.1.0

package/dist/vc/CredentialManager.js

@@ -0,0 +1,227 @@
+import { canonicalizeDocument } from '../utils/serialization';
+import { encodeBase64UrlMultibase, decodeBase64UrlMultibase } from '../utils/encoding';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { ES256KSigner, Ed25519Signer, ES256Signer } from '../crypto/Signer';
+import { Issuer } from './Issuer';
+import { createDocumentLoader } from './documentLoader';
+import { Verifier } from './Verifier';
+export class CredentialManager {
+    constructor(config, didManager) {
+        this.config = config;
+        this.didManager = didManager;
+    }
+    async createResourceCredential(type, subject, issuer) {
+        return {
+            '@context': ['https://www.w3.org/2018/credentials/v1'],
+            type: ['VerifiableCredential', type],
+            issuer,
+            issuanceDate: new Date().toISOString(),
+            credentialSubject: subject
+        };
+    }
+    async signCredential(credential, privateKeyMultibase, verificationMethod) {
+        if (this.didManager && typeof verificationMethod === 'string' && verificationMethod.startsWith('did:')) {
+            try {
+                const loader = createDocumentLoader(this.didManager);
+                const { document } = await loader(verificationMethod);
+                if (document && document.publicKeyMultibase) {
+                    const vm = {
+                        id: verificationMethod,
+                        controller: typeof credential.issuer === 'string' ? credential.issuer : credential.issuer?.id,
+                        publicKeyMultibase: document.publicKeyMultibase,
+                        secretKeyMultibase: privateKeyMultibase,
+                        type: document.type || 'Multikey'
+                    };
+                    const issuer = new Issuer(this.didManager, vm);
+                    const unsigned = { ...credential };
+                    delete unsigned['@context'];
+                    delete unsigned.proof;
+                    return issuer.issueCredential(unsigned, { proofPurpose: 'assertionMethod' });
+                }
+            }
+            catch {
+                // fall through to legacy signing
+            }
+        }
+        // fallback to legacy local signer
+        const proofBase = {
+            type: 'DataIntegrityProof',
+            created: new Date().toISOString(),
+            verificationMethod,
+            proofPurpose: 'assertionMethod',
+            proofValue: ''
+        };
+        const proofValue = await this.generateProofValue(credential, privateKeyMultibase, proofBase);
+        const proof = { ...proofBase, proofValue };
+        return { ...credential, proof };
+    }
+    /**
+     * Sign a credential using an external signer (e.g., hardware wallet, Privy)
+     * @param credential - The unsigned credential
+     * @param signer - External signer implementation
+     * @returns Signed verifiable credential
+     */
+    async signCredentialWithExternalSigner(credential, signer) {
+        const verificationMethodId = await signer.getVerificationMethodId();
+        // Create proof structure
+        const proofBase = {
+            type: 'DataIntegrityProof',
+            cryptosuite: 'eddsa-rdfc-2022', // Or derive from signer type
+            created: new Date().toISOString(),
+            verificationMethod: verificationMethodId,
+            proofPurpose: 'assertionMethod'
+        };
+        // Prepare unsigned credential
+        const unsignedCredential = { ...credential };
+        delete unsignedCredential.proof;
+        // Use external signer to sign
+        const { proofValue } = await signer.sign({
+            document: unsignedCredential,
+            proof: proofBase
+        });
+        // Return signed credential
+        return {
+            ...credential,
+            proof: {
+                ...proofBase,
+                proofValue
+            }
+        };
+    }
+    async verifyCredential(credential) {
+        if (this.didManager) {
+            const proofAny = credential.proof;
+            if (proofAny && (proofAny.cryptosuite || (Array.isArray(proofAny) && proofAny[0]?.cryptosuite))) {
+                const verifier = new Verifier(this.didManager);
+                const res = await verifier.verifyCredential(credential);
+                return res.verified;
+            }
+        }
+        const proof = credential.proof;
+        if (!proof) {
+            return false;
+        }
+        const { proofValue, verificationMethod } = proof;
+        if (!proofValue || !verificationMethod)
+            return false;
+        const signature = this.decodeMultibase(proofValue);
+        if (!signature)
+            return false;
+        const proofSansValue = { ...proof };
+        delete proofSansValue.proofValue;
+        const proofInput = { ...proofSansValue };
+        const credentialContext = credential['@context'];
+        if (credentialContext && !proofInput['@context']) {
+            proofInput['@context'] = credentialContext;
+        }
+        const unsignedCredential = { ...credential };
+        delete unsignedCredential.proof;
+        const c14nProof = await canonicalizeDocument(proofInput);
+        const c14nCred = await canonicalizeDocument(unsignedCredential);
+        const hProof = Buffer.from(sha256(Buffer.from(c14nProof, 'utf8')));
+        const hCred = Buffer.from(sha256(Buffer.from(c14nCred, 'utf8')));
+        const digest = Buffer.concat([hProof, hCred]);
+        const signer = this.getSigner();
+        try {
+            const resolvedKey = proof.publicKeyMultibase
+                || await this.resolveVerificationMethodMultibase(verificationMethod);
+            if (!resolvedKey) {
+                return false;
+            }
+            return await signer.verify(Buffer.from(digest), Buffer.from(signature), resolvedKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    async createPresentation(credentials, holder) {
+        return {
+            '@context': ['https://www.w3.org/2018/credentials/v1'],
+            type: ['VerifiablePresentation'],
+            holder,
+            verifiableCredential: credentials
+        };
+    }
+    async generateProofValue(credential, privateKeyMultibase, proofBase) {
+        // Construct canonical digest including provided proof sans proofValue
+        const proofSansValue = { ...proofBase };
+        delete proofSansValue.proofValue;
+        const proofInput = { ...proofSansValue };
+        const credentialContext = credential['@context'];
+        if (credentialContext && !proofInput['@context']) {
+            proofInput['@context'] = credentialContext;
+        }
+        const unsignedCredential = { ...credential };
+        delete unsignedCredential.proof;
+        const c14nProof = await canonicalizeDocument(proofInput);
+        const c14nCred = await canonicalizeDocument(unsignedCredential);
+        const hProof = Buffer.from(sha256(Buffer.from(c14nProof, 'utf8')));
+        const hCred = Buffer.from(sha256(Buffer.from(c14nCred, 'utf8')));
+        const digest = Buffer.concat([hProof, hCred]);
+        const signer = this.getSigner();
+        const sig = await signer.sign(Buffer.from(digest), privateKeyMultibase);
+        return encodeBase64UrlMultibase(sig);
+    }
+    getSigner() {
+        switch (this.config.defaultKeyType) {
+            case 'ES256K':
+                return new ES256KSigner();
+            case 'Ed25519':
+                return new Ed25519Signer();
+            case 'ES256':
+                return new ES256Signer();
+            default:
+                return new ES256KSigner();
+        }
+    }
+    async resolveVerificationMethodMultibase(verificationMethod) {
+        if (typeof verificationMethod === 'string' && verificationMethod.startsWith('z')) {
+            return verificationMethod;
+        }
+        if (!this.didManager || typeof verificationMethod !== 'string' || !verificationMethod.startsWith('did:')) {
+            return null;
+        }
+        const loader = createDocumentLoader(this.didManager);
+        try {
+            const { document } = await loader(verificationMethod);
+            if (document && typeof document.publicKeyMultibase === 'string') {
+                return document.publicKeyMultibase;
+            }
+        }
+        catch (err) {
+            // Document loader failed; will try alternative resolution method
+            if (this.config.enableLogging) {
+                console.warn('Failed to load verification method via document loader:', err);
+            }
+        }
+        try {
+            const did = verificationMethod.split('#')[0];
+            if (!did) {
+                return null;
+            }
+            const didDoc = await this.didManager.resolveDID(did);
+            const vms = didDoc?.verificationMethod;
+            if (Array.isArray(vms)) {
+                const vm = vms.find((m) => m?.id === verificationMethod);
+                if (vm && typeof vm.publicKeyMultibase === 'string') {
+                    return vm.publicKeyMultibase;
+                }
+            }
+        }
+        catch (err) {
+            // Failed to resolve DID document
+            if (this.config.enableLogging) {
+                console.warn('Failed to resolve DID for verification method:', err);
+            }
+        }
+        return null;
+    }
+    decodeMultibase(s) {
+        try {
+            return decodeBase64UrlMultibase(s);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/vc/Issuer.d.ts

@@ -0,0 +1,27 @@
+import { VerifiableCredential, VerifiablePresentation } from '../types';
+import { DIDManager } from '../did/DIDManager';
+export interface IssueOptions {
+    proofPurpose: 'assertionMethod' | 'authentication';
+    documentLoader?: (iri: string) => Promise<{
+        document: any;
+        documentUrl: string;
+        contextUrl: string | null;
+    }>;
+    challenge?: string;
+    domain?: string;
+}
+export type VerificationMethodLike = {
+    id: string;
+    controller: string;
+    publicKeyMultibase: string;
+    secretKeyMultibase?: string;
+    type?: 'Multikey' | string;
+};
+export declare class Issuer {
+    private didManager;
+    private verificationMethod;
+    constructor(didManager: DIDManager, verificationMethod: VerificationMethodLike);
+    private inferKeyType;
+    issueCredential(unsigned: Omit<VerifiableCredential, '@context' | 'proof'>, options: IssueOptions): Promise<VerifiableCredential>;
+    issuePresentation(presentation: Omit<VerifiablePresentation, '@context' | 'proof'>, options: IssueOptions): Promise<VerifiablePresentation>;
+}

package/dist/vc/Issuer.js

@@ -0,0 +1,70 @@
+import { multikey } from '../crypto/Multikey';
+import { createDocumentLoader } from './documentLoader';
+import { DataIntegrityProofManager } from './proofs/data-integrity';
+export class Issuer {
+    constructor(didManager, verificationMethod) {
+        this.didManager = didManager;
+        this.verificationMethod = verificationMethod;
+    }
+    inferKeyType(publicKeyMultibase) {
+        try {
+            return multikey.decodePublicKey(publicKeyMultibase).type;
+        }
+        catch {
+            return 'Ed25519';
+        }
+    }
+    async issueCredential(unsigned, options) {
+        const documentLoader = options.documentLoader || createDocumentLoader(this.didManager);
+        await documentLoader(this.verificationMethod.id);
+        const issuerId = typeof unsigned.issuer === 'string' ? unsigned.issuer : unsigned.issuer?.id;
+        const credential = {
+            ...unsigned,
+            '@context': ['https://www.w3.org/ns/credentials/v2'],
+            issuer: issuerId || this.verificationMethod.controller,
+            proof: undefined
+        };
+        if (!this.verificationMethod.secretKeyMultibase) {
+            throw new Error('Missing secretKeyMultibase for issuance');
+        }
+        const keyType = this.inferKeyType(this.verificationMethod.publicKeyMultibase);
+        if (keyType !== 'Ed25519') {
+            throw new Error('Only Ed25519 supported for eddsa-rdfc-2022');
+        }
+        const proof = await DataIntegrityProofManager.createProof(credential, {
+            verificationMethod: this.verificationMethod.id,
+            proofPurpose: options.proofPurpose,
+            cryptosuite: 'eddsa-rdfc-2022',
+            type: 'DataIntegrityProof',
+            privateKey: this.verificationMethod.secretKeyMultibase,
+            documentLoader
+        });
+        return { ...credential, proof };
+    }
+    async issuePresentation(presentation, options) {
+        const documentLoader = options.documentLoader || createDocumentLoader(this.didManager);
+        await documentLoader(this.verificationMethod.id);
+        if (!this.verificationMethod.secretKeyMultibase) {
+            throw new Error('Missing secretKeyMultibase for issuance');
+        }
+        const keyType = this.inferKeyType(this.verificationMethod.publicKeyMultibase);
+        if (keyType !== 'Ed25519') {
+            throw new Error('Only Ed25519 supported for eddsa-rdfc-2022');
+        }
+        const proof = await DataIntegrityProofManager.createProof({ ...presentation, '@context': ['https://www.w3.org/ns/credentials/v2'] }, {
+            verificationMethod: this.verificationMethod.id,
+            proofPurpose: options.proofPurpose,
+            cryptosuite: 'eddsa-rdfc-2022',
+            type: 'DataIntegrityProof',
+            privateKey: this.verificationMethod.secretKeyMultibase,
+            challenge: options.challenge,
+            domain: options.domain,
+            documentLoader
+        });
+        return {
+            ...presentation,
+            '@context': ['https://www.w3.org/ns/credentials/v2'],
+            proof
+        };
+    }
+}

package/dist/vc/Verifier.d.ts

@@ -0,0 +1,16 @@
+import { VerifiableCredential, VerifiablePresentation } from '../types';
+import { DIDManager } from '../did/DIDManager';
+export type VerificationResult = {
+    verified: boolean;
+    errors: string[];
+};
+export declare class Verifier {
+    private didManager;
+    constructor(didManager: DIDManager);
+    verifyCredential(vc: VerifiableCredential, options?: {
+        documentLoader?: (iri: string) => Promise<any>;
+    }): Promise<VerificationResult>;
+    verifyPresentation(vp: VerifiablePresentation, options?: {
+        documentLoader?: (iri: string) => Promise<any>;
+    }): Promise<VerificationResult>;
+}

package/dist/vc/Verifier.js

@@ -0,0 +1,50 @@
+import { createDocumentLoader } from './documentLoader';
+import { DataIntegrityProofManager } from './proofs/data-integrity';
+export class Verifier {
+    constructor(didManager) {
+        this.didManager = didManager;
+    }
+    async verifyCredential(vc, options = {}) {
+        try {
+            if (!vc || !vc['@context'] || !vc.type)
+                throw new Error('Invalid credential');
+            if (!vc.proof)
+                throw new Error('Credential has no proof');
+            const loader = options.documentLoader || createDocumentLoader(this.didManager);
+            const ctxs = Array.isArray(vc['@context']) ? vc['@context'] : [vc['@context']];
+            for (const c of ctxs)
+                await loader(c);
+            const proof = Array.isArray(vc.proof) ? vc.proof[0] : vc.proof;
+            const result = await DataIntegrityProofManager.verifyProof(vc, proof, { documentLoader: loader });
+            return result.verified ? { verified: true, errors: [] } : { verified: false, errors: result.errors ?? ['Verification failed'] };
+        }
+        catch (e) {
+            return { verified: false, errors: [e?.message ?? 'Unknown error in verifyCredential'] };
+        }
+    }
+    async verifyPresentation(vp, options = {}) {
+        try {
+            if (!vp || !vp['@context'] || !vp.type)
+                throw new Error('Invalid presentation');
+            if (!vp.proof)
+                throw new Error('Presentation has no proof');
+            const loader = options.documentLoader || createDocumentLoader(this.didManager);
+            const ctxs = Array.isArray(vp['@context']) ? vp['@context'] : [vp['@context']];
+            for (const c of ctxs)
+                await loader(c);
+            if (vp.verifiableCredential) {
+                for (const c of vp.verifiableCredential) {
+                    const res = await this.verifyCredential(c, { documentLoader: loader });
+                    if (!res.verified)
+                        return res;
+                }
+            }
+            const proof = Array.isArray(vp.proof) ? vp.proof[0] : vp.proof;
+            const result = await DataIntegrityProofManager.verifyProof(vp, proof, { documentLoader: loader });
+            return result.verified ? { verified: true, errors: [] } : { verified: false, errors: result.errors ?? ['Verification failed'] };
+        }
+        catch (e) {
+            return { verified: false, errors: [e?.message ?? 'Unknown error in verifyPresentation'] };
+        }
+    }
+}

package/dist/vc/cryptosuites/bbs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Minimal BBS utility methods ported from legacy for working with
+ * Data Integrity BBS (bbs-2023) base and derived proof value encoding.
+ *
+ * Notes:
+ * - This module focuses on serialization/parsing helpers used by callers
+ *   to pack/unpack proof values. It does not perform signing or verification.
+ * - All methods operate on Uint8Array inputs and return multibase strings
+ *   (base64url with 'u' prefix) where applicable to match the spec.
+ */
+export declare class BBSCryptosuiteUtils {
+    private static encodeBase64urlNoPad;
+    private static decodeBase64urlNoPad;
+    private static compareBytes;
+    private static concatBytes;
+    static serializeBaseProofValue(bbsSignature: Uint8Array, bbsHeader: Uint8Array, publicKey: Uint8Array, hmacKey: Uint8Array, mandatoryPointers: string[], featureOption: 'baseline' | 'anonymous_holder_binding' | 'pseudonym_issuer_pid' | 'pseudonym_hidden_pid', pid?: Uint8Array, signerBlind?: Uint8Array): string;
+    static parseBaseProofValue(proofValue: string): {
+        bbsSignature: Uint8Array;
+        bbsHeader: Uint8Array;
+        publicKey: Uint8Array;
+        hmacKey: Uint8Array;
+        mandatoryPointers: string[];
+        featureOption: 'baseline' | 'anonymous_holder_binding' | 'pseudonym_issuer_pid' | 'pseudonym_hidden_pid' | 'base_proof';
+        pid?: Uint8Array;
+        signerBlind?: Uint8Array;
+    };
+    private static compressLabelMap;
+    private static decompressLabelMap;
+    static serializeDerivedProofValue(bbsProof: Uint8Array, labelMap: {
+        [key: string]: string;
+    }, mandatoryIndexes: number[], selectiveIndexes: number[], presentationHeader: Uint8Array, featureOption: 'baseline' | 'anonymous_holder_binding' | 'pseudonym', pseudonym?: string, lengthBBSMessages?: number): string;
+    static parseDerivedProofValue(proofValue: string): {
+        bbsProof: Uint8Array;
+        labelMap: {
+            [key: string]: string;
+        };
+        mandatoryIndexes: number[];
+        selectiveIndexes: number[];
+        presentationHeader: Uint8Array;
+        featureOption: 'baseline' | 'anonymous_holder_binding' | 'pseudonym';
+        pseudonym?: string;
+        lengthBBSMessages?: number;
+    };
+}

package/dist/vc/cryptosuites/bbs.js

@@ -0,0 +1,213 @@
+import * as cbor from 'cbor-js';
+/**
+ * Minimal BBS utility methods ported from legacy for working with
+ * Data Integrity BBS (bbs-2023) base and derived proof value encoding.
+ *
+ * Notes:
+ * - This module focuses on serialization/parsing helpers used by callers
+ *   to pack/unpack proof values. It does not perform signing or verification.
+ * - All methods operate on Uint8Array inputs and return multibase strings
+ *   (base64url with 'u' prefix) where applicable to match the spec.
+ */
+export class BBSCryptosuiteUtils {
+    static encodeBase64urlNoPad(bytes) {
+        const b64 = Buffer.from(bytes).toString('base64');
+        const b64url = b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+        return 'u' + b64url;
+    }
+    static decodeBase64urlNoPad(s) {
+        if (!s.startsWith('u'))
+            throw new Error('Not a multibase base64url (u- prefixed) string');
+        const raw = s.slice(1);
+        const b64 = raw.replace(/-/g, '+').replace(/_/g, '/');
+        const pad = b64.length % 4 === 2 ? '==' : b64.length % 4 === 3 ? '=' : '';
+        return new Uint8Array(Buffer.from(b64 + pad, 'base64'));
+    }
+    static compareBytes(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < b.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    static concatBytes(a, b) {
+        const out = new Uint8Array(a.length + b.length);
+        out.set(a, 0);
+        out.set(b, a.length);
+        return out;
+    }
+    // ===== Base proof (serialize/parse) =====
+    static serializeBaseProofValue(bbsSignature, bbsHeader, publicKey, hmacKey, mandatoryPointers, featureOption, pid, signerBlind) {
+        let headerBytes;
+        let components;
+        switch (featureOption) {
+            case 'baseline':
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x02]);
+                components = [bbsSignature, bbsHeader, publicKey, hmacKey, mandatoryPointers];
+                break;
+            case 'anonymous_holder_binding':
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x04]);
+                if (!signerBlind)
+                    throw new Error('signerBlind is required for anonymous_holder_binding');
+                components = [bbsSignature, bbsHeader, publicKey, hmacKey, mandatoryPointers, signerBlind];
+                break;
+            case 'pseudonym_issuer_pid':
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x06]);
+                if (!pid)
+                    throw new Error('pid is required for pseudonym_issuer_pid');
+                components = [bbsSignature, bbsHeader, publicKey, hmacKey, mandatoryPointers, pid];
+                break;
+            case 'pseudonym_hidden_pid':
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x08]);
+                if (!signerBlind)
+                    throw new Error('signerBlind is required for pseudonym_hidden_pid');
+                components = [bbsSignature, bbsHeader, publicKey, hmacKey, mandatoryPointers, signerBlind];
+                break;
+            default:
+                throw new Error(`Unsupported feature option: ${featureOption}`);
+        }
+        const encodedComponents = cbor.encode(components);
+        const proofBytes = BBSCryptosuiteUtils.concatBytes(headerBytes, new Uint8Array(encodedComponents));
+        return BBSCryptosuiteUtils.encodeBase64urlNoPad(proofBytes);
+    }
+    static parseBaseProofValue(proofValue) {
+        const decoded = BBSCryptosuiteUtils.decodeBase64urlNoPad(proofValue);
+        const header = decoded.slice(0, 3);
+        let featureOption;
+        if (this.compareBytes(header, [0xd9, 0x5d, 0x02]))
+            featureOption = 'baseline';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x04]))
+            featureOption = 'anonymous_holder_binding';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x06]))
+            featureOption = 'pseudonym_issuer_pid';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x08]))
+            featureOption = 'pseudonym_hidden_pid';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x03]))
+            featureOption = 'base_proof';
+        else
+            throw new Error('Invalid BBS base proof header');
+        const components = cbor.decode(decoded.slice(3).buffer);
+        const base = {
+            bbsSignature: components[0],
+            bbsHeader: components[1],
+            publicKey: components[2],
+            hmacKey: components[3],
+            mandatoryPointers: components[4],
+            featureOption
+        };
+        if (featureOption === 'anonymous_holder_binding' || featureOption === 'pseudonym_hidden_pid') {
+            base.signerBlind = components[5];
+        }
+        if (featureOption === 'pseudonym_issuer_pid') {
+            base.pid = components[5];
+        }
+        return base;
+    }
+    // ===== Label map compression helpers =====
+    static compressLabelMap(labelMap) {
+        const map = {};
+        for (const [k, v] of Object.entries(labelMap)) {
+            const c14nMatch = k.match(/^c14n(\d+)$/);
+            const bMatch = v.match(/^b(\d+)$/);
+            if (!c14nMatch || !bMatch) {
+                throw new Error(`Invalid label map entry: ${k} -> ${v}`);
+            }
+            const key = parseInt(c14nMatch[1], 10);
+            const value = parseInt(bMatch[1], 10);
+            map[key] = value.toString();
+        }
+        return map;
+    }
+    static decompressLabelMap(compressed) {
+        const map = {};
+        for (const [k, v] of Object.entries(compressed)) {
+            map[`c14n${k}`] = `b${v}`;
+        }
+        return map;
+    }
+    // ===== Derived proof (serialize/parse) =====
+    static serializeDerivedProofValue(bbsProof, labelMap, mandatoryIndexes, selectiveIndexes, presentationHeader, featureOption, pseudonym, lengthBBSMessages) {
+        const compressedLabelMap = this.compressLabelMap(labelMap);
+        let headerBytes;
+        let components;
+        switch (featureOption) {
+            case 'baseline':
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x03]);
+                components = [
+                    bbsProof,
+                    compressedLabelMap,
+                    mandatoryIndexes,
+                    selectiveIndexes,
+                    presentationHeader
+                ];
+                break;
+            case 'anonymous_holder_binding':
+                if (typeof lengthBBSMessages !== 'number') {
+                    throw new Error('lengthBBSMessages is required for anonymous_holder_binding');
+                }
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x05]);
+                components = [
+                    bbsProof,
+                    compressedLabelMap,
+                    mandatoryIndexes,
+                    selectiveIndexes,
+                    presentationHeader,
+                    lengthBBSMessages
+                ];
+                break;
+            case 'pseudonym':
+                if (!pseudonym || typeof lengthBBSMessages !== 'number') {
+                    throw new Error('pseudonym and lengthBBSMessages are required for pseudonym features');
+                }
+                headerBytes = new Uint8Array([0xd9, 0x5d, 0x07]);
+                components = [
+                    bbsProof,
+                    compressedLabelMap,
+                    mandatoryIndexes,
+                    selectiveIndexes,
+                    presentationHeader,
+                    pseudonym,
+                    lengthBBSMessages
+                ];
+                break;
+            default:
+                throw new Error(`Unsupported feature option: ${featureOption}`);
+        }
+        const encodedComponents = cbor.encode(components);
+        const proofBytes = this.concatBytes(headerBytes, new Uint8Array(encodedComponents));
+        return this.encodeBase64urlNoPad(proofBytes);
+    }
+    static parseDerivedProofValue(proofValue) {
+        const decoded = this.decodeBase64urlNoPad(proofValue);
+        const header = decoded.slice(0, 3);
+        let featureOption;
+        if (this.compareBytes(header, [0xd9, 0x5d, 0x03]))
+            featureOption = 'baseline';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x05]))
+            featureOption = 'anonymous_holder_binding';
+        else if (this.compareBytes(header, [0xd9, 0x5d, 0x07]))
+            featureOption = 'pseudonym';
+        else
+            throw new Error('Invalid BBS derived proof header');
+        const components = cbor.decode(decoded.slice(3).buffer);
+        const decompressedLabelMap = this.decompressLabelMap(components[1]);
+        const result = {
+            bbsProof: components[0],
+            labelMap: decompressedLabelMap,
+            mandatoryIndexes: components[2],
+            selectiveIndexes: components[3],
+            presentationHeader: components[4],
+            featureOption
+        };
+        if (featureOption === 'anonymous_holder_binding') {
+            result.lengthBBSMessages = components[5];
+        }
+        else if (featureOption === 'pseudonym') {
+            result.pseudonym = components[5];
+            result.lengthBBSMessages = components[6];
+        }
+        return result;
+    }
+}

package/dist/vc/cryptosuites/bbsSimple.d.ts

@@ -0,0 +1,9 @@
+export type BbsKeyPair = {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+};
+export declare class BbsSimple {
+    static readonly CIPHERSUITE = "BLS12-381-SHA-256";
+    static sign(messages: Uint8Array[], keypair: BbsKeyPair, header?: Uint8Array): Promise<Uint8Array>;
+    static verify(messages: Uint8Array[], signature: Uint8Array, publicKey: Uint8Array, header?: Uint8Array): Promise<boolean>;
+}

package/dist/vc/cryptosuites/bbsSimple.js

@@ -0,0 +1,12 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+export class BbsSimple {
+    static async sign(messages, keypair, header) {
+        const headerBytes = header ?? new Uint8Array(sha256(new Uint8Array(0)));
+        throw new Error('BbsSimple.sign is not implemented');
+    }
+    static async verify(messages, signature, publicKey, header) {
+        const headerBytes = header ?? new Uint8Array(sha256(new Uint8Array(0)));
+        throw new Error('BbsSimple.verify is not implemented');
+    }
+}
+BbsSimple.CIPHERSUITE = 'BLS12-381-SHA-256';