@originals/sdk 1.2.0 → 1.4.2

package/dist/vc/CredentialManager.js

@@ -1,227 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,213 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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';