@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/lib/src/services/credential/pex-helpers.d.ts

@@ -16,8 +16,8 @@ export const EPSILON_INT: 1;
 export const MAX_DATE_PLACEHOLDER: 884541351600000;
 export const MIN_DATE_PLACEHOLDER: -17592186044415;
 export const MAX_INTEGER: number;
-export const MIN_INTEGER: -4294967295;
+export const MIN_INTEGER: number;
 export const MAX_NUMBER: number;
-export const MIN_NUMBER: -4294967294;
+export const MIN_NUMBER: number;
 export function shouldSkipAttribute(attributeName: any): boolean;
 //# sourceMappingURL=pex-helpers.d.ts.map

package/lib/src/services/credential/pex-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pex-helpers.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/pex-helpers.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;GAUG;AACH,wGAqMC;AAcD,4FAgCC;AA1TD,mCAAoC;AACpC,4BAA6B;AAE7B,mDAAoD;AACpD,mDAAoD;AACpD,iCAAoC;AACpC,sCAAuC;AACvC,gCAAmC;AACnC,qCAAsC;AA+Q/B,iEACoD"}
+{"version":3,"file":"pex-helpers.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/pex-helpers.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;GAUG;AACH,wCATW,GAAC,wBACD,GAAC,sBACD,GAAC,SA4MX;AAcD,4FAgCC;AA1TD,6BAA8B,KAAK,CAAC;AACpC,0BAA2B,CAAC,CAAC;AAE7B,mCAAoC,eAAe,CAAC;AACpD,mCAAoC,CAAC,cAAc,CAAC;AACpD,iCAAmD;AACnD,iCAAmD;AACnD,gCAAkD;AAClD,gCAAkD;AA+Q3C,iEACoD"}

package/lib/src/services/credential/sd-jwt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sd-jwt.test.d.ts.map

package/lib/src/services/credential/sd-jwt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sd-jwt.test.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/sd-jwt.test.ts"],"names":[],"mappings":""}

package/lib/src/services/credential/service.d.ts

@@ -1,43 +1,313 @@
+/**
+ * Checks if a credential uses BBS+ signature
+ * @param {Object} credential - The credential to check
+ * @returns {boolean} True if the credential uses BBS+ signature
+ * @example
+ * const isBBS = isBBSPlusCredential(credential);
+ * if (isBBS) {
+ *   console.log('This credential uses BBS+ signatures');
+ * }
+ */
 export declare function isBBSPlusCredential(credential: any): any;
+/**
+ * Checks if a credential uses KVAC (BBDT16) signature
+ * @param {Object} credential - The credential to check
+ * @returns {boolean} True if the credential uses KVAC signature
+ * @example
+ * const isKVAC = isKvacCredential(credential);
+ */
 export declare function isKvacCredential(credential: any): any;
+/**
+ * Checks if a credential is anonymous (BBS+ or KVAC)
+ * @param {Object} credential - The credential to check
+ * @returns {boolean} True if the credential is anonymous
+ * @example
+ * if (isAnnonymousCredential(credential)) {
+ *   console.log('This credential supports selective disclosure');
+ * }
+ */
 export declare function isAnnonymousCredential(credential: any): any;
+/**
+ * Service class for managing verifiable credentials
+ * @class
+ * @description Provides methods for creating, signing, verifying, and presenting
+ * verifiable credentials with support for various signature types
+ */
 declare class CredentialService {
+    /**
+     * Creates a new CredentialService instance
+     * @constructor
+     */
     constructor();
     rpcMethods: ((params?: {}) => any)[];
+    createSDJWTPresentation(params: any): Promise<string>;
+    /**
+     * Generates a new verifiable credential template
+     * @param {Object} [params={}] - Generation parameters
+     * @param {Object} [params.subject] - The credential subject
+     * @returns {VerifiableCredential} A new verifiable credential instance
+     * @example
+     * const credential = credentialService.generateCredential({
+     *   subject: { id: 'did:example:123', name: 'Alice' }
+     * });
+     */
     generateCredential(params?: {}): any;
+    /**
+     * Signs a verifiable credential
+     * @param {Object} params - Signing parameters
+     * @param {Object} params.vcJson - The credential JSON to sign
+     * @param {Object} params.keyDoc - The key document for signing
+     * @returns {Promise<VerifiableCredential>} The signed verifiable credential
+     * @throws {Error} If validation fails or signing fails
+     * @example
+     * const signedCredential = await credentialService.signCredential({
+     *   vcJson: credentialData,
+     *   keyDoc: issuerKeyDocument
+     * });
+     */
     signCredential(params: any): Promise<any>;
+    /**
+     * Creates a verifiable presentation from credentials
+     * @param {Object} params - Presentation parameters
+     * @param {Array<Object>} params.credentials - Array of verifiable credentials to include
+     * @param {Object} params.keyDoc - The key document for signing the presentation
+     * @param {string} [params.challenge] - Challenge string for the presentation proof
+     * @param {string} [params.id] - Presentation identifier
+     * @param {string} [params.domain] - Domain for the presentation proof
+     * @returns {Promise<Object>} The signed verifiable presentation
+     * @throws {Error} If validation fails
+     * @example
+     * const presentation = await credentialService.createPresentation({
+     *   credentials: [credential1, credential2],
+     *   keyDoc: holderKeyDocument,
+     *   challenge: 'abc123',
+     *   domain: 'example.com'
+     * });
+     */
     createPresentation(params: any): Promise<any>;
+    /**
+     * Verifies a verifiable presentation
+     * @param {Object} params - Verification parameters
+     * @param {Object} params.presentation - The presentation to verify
+     * @param {Object} [params.options] - Verification options
+     * @returns {Promise<Object>} Verification result with verified status and any errors
+     * @example
+     * const result = await credentialService.verifyPresentation({
+     *   presentation: presentationData
+     * });
+     * console.log('Verified:', result.verified);
+     */
     verifyPresentation({ presentation, options }: any): Promise<any>;
+    /**
+     * Verifies a verifiable credential including revocation check
+     * @param {Object} params - Verification parameters
+     * @param {Object} params.credential - The credential to verify
+     * @param {Object} [params.membershipWitness] - Membership witness for revocation check
+     * @returns {Promise<Object>} Verification result
+     * @returns {boolean} returns.verified - Whether the credential is valid
+     * @returns {string} [returns.error] - Error message if verification failed
+     * @throws {Error} If validation fails
+     * @example
+     * const result = await credentialService.verifyCredential({
+     *   credential: credentialData,
+     *   membershipWitness: witnessData
+     * });
+     * if (!result.verified) {
+     *   console.error('Verification failed:', result.error);
+     * }
+     */
     verifyCredential(params: any): Promise<any>;
+    /**
+     * Filters credentials based on a presentation definition
+     * @param {Object} params - Filter parameters
+     * @param {Array<Object>} params.credentials - Array of credentials to filter
+     * @param {Object} params.presentationDefinition - PEX presentation definition
+     * @param {string} [params.holderDid] - DID of the credential holder
+     * @returns {Object} Filtered credentials matching the presentation definition
+     * @example
+     * const filtered = credentialService.filterCredentials({
+     *   credentials: allCredentials,
+     *   presentationDefinition: definition,
+     *   holderDid: 'did:example:holder'
+     * });
+     */
     filterCredentials(params: any): import("@sphereon/pex").SelectResults;
+    /**
+     * Evaluates a presentation against a presentation definition
+     * @param {Object} params - Evaluation parameters
+     * @param {Object} params.presentation - The presentation to evaluate
+     * @param {Object} params.presentationDefinition - PEX presentation definition
+     * @returns {Object} Evaluation result with validation details
+     * @example
+     * const evaluation = credentialService.evaluatePresentation({
+     *   presentation: presentationData,
+     *   presentationDefinition: definition
+     * });
+     */
     evaluatePresentation(params: any): import("@sphereon/pex").EvaluationResults;
+    /**
+     * Checks if a credential uses BBS+ signature
+     * @param {Object} params - Check parameters
+     * @param {Object} params.credential - The credential to check
+     * @returns {boolean} True if the credential uses BBS+ signature
+     */
     isBBSPlusCredential(params: any): any;
+    /**
+     * Checks if a credential uses KVAC signature
+     * @param {Object} params - Check parameters
+     * @param {Object} params.credential - The credential to check
+     * @returns {boolean} True if the credential uses KVAC signature
+     */
     isKvacCredential(params: any): any;
+    /**
+     * Checks if a credential is an SD-JWT (Selective Disclosure JWT) credential
+     * @param {Object} params - Check parameters
+     * @param {string} params.credential - The JWT string to check
+     * @returns {boolean} True if the credential is an SD-JWT credential
+     * @example
+     * const isSDJWT = credentialService.isSDJWTCredential({
+     *   credential: 'eyJ0eXAiOiJ2YytzZC1qd3Q...'
+     * });
+     */
+    isSDJWTCredential(params: any): boolean;
+    /**
+     * Converts a credential to W3C Verifiable Credential format
+     * @description Handles both SD-JWT credentials (needs decoding) and regular W3C credentials (returns as-is)
+     * @param {Object} params - Conversion parameters
+     * @param {string|Object} params.credential - Either an SD-JWT string or a credential object
+     * @returns {Promise<Object>} W3C Verifiable Credential format
+     * @throws {Error} If credential cannot be converted to W3C format
+     * @example
+     * // Convert SD-JWT to W3C format
+     * const w3cCredential = await credentialService.credentialToW3C({
+     *   credential: 'eyJ0eXAiOiJ2YytzZC1qd3Q...'
+     * });
+     *
+     * // Returns W3C credential as-is
+     * const w3cCredential = await credentialService.credentialToW3C({
+     *   credential: { '@context': [...], type: [...], ... }
+     * });
+     */
+    credentialToW3C(params: any): Promise<any>;
+    /**
+     * Acquires a credential through OpenID for Verifiable Credentials (OID4VC)
+     * @param {Object} params - Acquisition parameters
+     * @param {string} params.uri - The credential offer URI
+     * @param {string} [params.authorizationCode] - Authorization code if required
+     * @param {Object} params.holderKeyDocument - Key document for the credential holder
+     * @returns {Promise<Object>} Result containing the credential or authorization URL
+     * @returns {Object} [returns.credential] - The acquired credential
+     * @returns {string} [returns.authorizationURL] - Authorization URL if auth is required
+     * @example
+     * const result = await credentialService.acquireOIDCredential({
+     *   uri: 'openid-credential-offer://...',
+     *   holderKeyDocument: keyDoc
+     * });
+     */
     acquireOIDCredential({ uri, authorizationCode, holderKeyDocument, }: {
         uri: string;
         authorizationCode?: string;
         holderKeyDocument: any;
     }): Promise<any>;
+    /**
+     * Creates a BBS+ presentation with selective disclosure
+     * @param {Object} params - Presentation parameters
+     * @param {Array<Object>} params.credentials - Array of credentials with attributes to reveal
+     * @param {Object} params.credentials[].credential - The BBS+ credential
+     * @param {Array<string>} [params.credentials[].attributesToReveal] - Attributes to reveal
+     * @returns {Promise<Object>} The BBS+ presentation
+     * @throws {Error} If validation fails
+     * @example
+     * const presentation = await credentialService.createBBSPresentation({
+     *   credentials: [{
+     *     credential: bbsCredential,
+     *     attributesToReveal: ['name', 'age']
+     *   }]
+     * });
+     */
     createBBSPresentation(params: any): Promise<any>;
+    /**
+     * Gets the accumulator ID from a credential's status
+     * @param {Object} params - Parameters
+     * @param {Object} params.credential - The credential to get accumulator ID from
+     * @returns {string|null} The accumulator ID or null if not present
+     * @throws {Error} If credential is not provided
+     */
     getAccumulatorId({ credential }: {
         credential: any;
     }): any;
+    /**
+     * Gets accumulator data from the blockchain for a credential
+     * @param {Object} params - Parameters
+     * @param {Object} params.credential - The credential to get accumulator data for
+     * @returns {Promise<Object|null>} The accumulator data or null if not found
+     * @throws {Error} If credential is not provided
+     */
     getAccumulatorData({ credential }: {
         credential: any;
     }): Promise<any>;
     /**
-     * Fetch the latest accumulator witness updates for a given credential and membership witness
-     * The witness is generated by the issuer when the credential is created and is stored in the wallet when the credential is imported
-     *
-     * @param param0
+     * Updates the membership witness with the latest accumulator state
+     * @description The witness is generated by the issuer when the credential is created
+     * and is stored in the wallet when the credential is imported. This method updates
+     * it with the latest accumulator changes from the blockchain.
+     * @param {Object} params - Update parameters
+     * @param {Object} params.credential - The credential with revocation status
+     * @param {Object} params.membershipWitnessJSON - Current membership witness in JSON format
+     * @returns {Promise<Object>} Updated membership witness in JSON format
+     * @throws {Error} If updates cannot be fetched or applied
      */
     updateMembershipWitness({ credential, membershipWitnessJSON }: {
         credential: any;
         membershipWitnessJSON: any;
     }): Promise<any>;
+    /**
+     * Derives verifiable credentials from a presentation with selective disclosure
+     * @param {Object} params - Derivation parameters
+     * @param {Array<Object>} params.credentials - Array of credential objects
+     * @param {Object} params.credentials[].credential - The credential
+     * @param {Array<string>} params.credentials[].attributesToReveal - Attributes to reveal
+     * @param {Object} [params.credentials[].witness] - Membership witness for revocation
+     * @param {Object} [params.options={}] - Additional options for derivation
+     * @param {Object} [params.proofRequest] - Proof request with constraints
+     * @returns {Promise<Array>} Array of derived credentials
+     * @throws {Error} If validation fails
+     * @example
+     * const derivedCredentials = await credentialService.deriveVCFromPresentation({
+     *   credentials: [{
+     *     credential: bbsCredential,
+     *     attributesToReveal: ['name', 'dateOfBirth']
+     *   }]
+     * });
+     */
     deriveVCFromPresentation(params: any): Promise<any>;
+    /**
+     * Test method for range proofs
+     * @private
+     * @returns {Promise<void>}
+     */
     testRangeProof(): Promise<void>;
 }
+/**
+ * Singleton instance of the credential service
+ * @type {CredentialService}
+ * @example
+ * import { credentialService } from '@docknetwork/wallet-sdk-wasm/services/credential';
+ *
+ * // Create and sign a credential
+ * const credential = credentialService.generateCredential({
+ *   subject: { id: 'did:example:123' }
+ * });
+ * const signed = await credentialService.signCredential({
+ *   vcJson: credential,
+ *   keyDoc: issuerKey
+ * });
+ *
+ * // Verify a credential
+ * const result = await credentialService.verifyCredential({
+ *   credential: signedCredential
+ * });
+ */
 export declare const credentialService: CredentialService;
 export {};
 //# sourceMappingURL=service.d.ts.map

package/lib/src/services/credential/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/service.ts"],"names":[],"mappings":"AAoCA,wBAAgB,mBAAmB,CAAC,UAAU,KAAA,OAS7C;AAED,wBAAgB,gBAAgB,CAAC,UAAU,KAAA,OAK1C;AAED,wBAAgB,sBAAsB,CAAC,UAAU,KAAA,OAEhD;AAED,cAAM,iBAAiB;;IAIrB,UAAU,2BAUR;IACF,kBAAkB,CAAC,MAAM,KAAK;IAkBxB,cAAc,CAAC,MAAM,KAAA;IAerB,kBAAkB,CAAC,MAAM,KAAA;IAyBzB,kBAAkB,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,GAAG;IAIjD,gBAAgB,CAAC,MAAM,KAAA;IA2B7B,iBAAiB,CAAC,MAAM,KAAA;IAWxB,oBAAoB,CAAC,MAAM,KAAA;IAU3B,mBAAmB,CAAC,MAAM,KAAA;IAK1B,gBAAgB,CAAC,MAAM,KAAA;IAKjB,oBAAoB,CAAC,EACzB,GAAG,EACH,iBAAiB,EACjB,iBAAiB,GAClB,EAAE;QACD,GAAG,EAAE,MAAM,CAAC;QACZ,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,GAAG,CAAC;KACxB,GAAG,OAAO,CAAC,GAAG,CAAC;IAiEV,qBAAqB,CAAC,MAAM,KAAA;IAgBlC,gBAAgB,CAAC,EAAC,UAAU,EAAC;;KAAA;IASvB,kBAAkB,CAAC,EAAC,UAAU,EAAC;;KAAA;IAcrC;;;;;OAKG;IACG,uBAAuB,CAAC,EAAC,UAAU,EAAE,qBAAqB,EAAC;;;KAAA;IAkD3D,wBAAwB,CAAC,MAAM,KAAA;IAoF/B,cAAc;CAGrB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/service.ts"],"names":[],"mappings":"AAiDA;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,KAAA,OAS7C;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,KAAA,OAK1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,KAAA,OAEhD;AAED;;;;;GAKG;AACH,cAAM,iBAAiB;IACrB;;;OAGG;;IAIH,UAAU,2BAaR;IAGF,uBAAuB,CAAC,MAAM,KAAA;IAK9B;;;;;;;;;OASG;IACH,kBAAkB,CAAC,MAAM,KAAK;IAkB9B;;;;;;;;;;;;OAYG;IACG,cAAc,CAAC,MAAM,KAAA;IAe3B;;;;;;;;;;;;;;;;;OAiBG;IACG,kBAAkB,CAAC,MAAM,KAAA;IAmC/B;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,GAAG;IAIvD;;;;;;;;;;;;;;;;;OAiBG;IACG,gBAAgB,CAAC,MAAM,KAAA;IAoC7B;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,MAAM,KAAA;IAWxB;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,MAAM,KAAA;IAU3B;;;;;OAKG;IACH,mBAAmB,CAAC,MAAM,KAAA;IAK1B;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,KAAA;IAKvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,MAAM,KAAA;IAKxB;;;;;;;;;;;;;;;;;OAiBG;IACG,eAAe,CAAC,MAAM,KAAA;IAK5B;;;;;;;;;;;;;;OAcG;IACG,oBAAoB,CAAC,EACzB,GAAG,EACH,iBAAiB,EACjB,iBAAiB,GAClB,EAAE;QACD,GAAG,EAAE,MAAM,CAAC;QACZ,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,GAAG,CAAC;KACxB,GAAG,OAAO,CAAC,GAAG,CAAC;IAmEhB;;;;;;;;;;;;;;;OAeG;IACG,qBAAqB,CAAC,MAAM,KAAA;IAgBlC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAC,UAAU,EAAC;;KAAA;IAS7B;;;;;;OAMG;IACG,kBAAkB,CAAC,EAAC,UAAU,EAAC;;KAAA;IAcrC;;;;;;;;;;OAUG;IACG,uBAAuB,CAAC,EAAC,UAAU,EAAE,qBAAqB,EAAC;;;KAAA;IAkDjE;;;;;;;;;;;;;;;;;;OAkBG;IACG,wBAAwB,CAAC,MAAM,KAAA;IAoFrC;;;;OAIG;IACG,cAAc;CAGrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/lib/src/services/dids/keypair-utils.d.ts

@@ -10,6 +10,6 @@ export function keypairToKeydoc(key: any, controller: any, id?: any): {
     publicKeyBase58: any;
 };
 export const MULTIBASE_BASE58BTC_HEADER: "z";
-export const MULTICODEC_ED25519_PUB_HEADER: Uint8Array;
-export const MULTICODEC_ED25519_PRIV_HEADER: Uint8Array;
+export const MULTICODEC_ED25519_PUB_HEADER: Uint8Array<ArrayBuffer>;
+export const MULTICODEC_ED25519_PRIV_HEADER: Uint8Array<ArrayBuffer>;
 //# sourceMappingURL=keypair-utils.d.ts.map

package/lib/src/services/dids/keypair-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keypair-utils.d.ts","sourceRoot":"","sources":["../../../../src/services/dids/keypair-utils.js"],"names":[],"mappings":"AASA,8CAWC;AAMD,2DAKC;AAeD;;;;;;;;EAgEC;AAxFD,6CAA8C;AAC9C,uDAA0E;AAC1E,wDAA2E"}
+{"version":3,"file":"keypair-utils.d.ts","sourceRoot":"","sources":["../../../../src/services/dids/keypair-utils.js"],"names":[],"mappings":"AASA,8CAWC;AAMD,2DAKC;AAeD;;;;;;;;EAgEC;AAxFD,yCAA0C,GAAG,CAAC;AAC9C,oEAA0E;AAC1E,qEAA2E"}

package/lib/src/services/dids/service.d.ts

@@ -2,13 +2,45 @@ import { KeypairToDIDKeyDocumentParams, GetDIDResolutionParams } from './config'
 declare class DIDService {
     name: string;
     constructor();
-    rpcMethods: (((params: KeypairToDIDKeyDocumentParams) => any) | ((params: GetDIDResolutionParams) => any) | (({ payload, privateKeyDoc, headerInput }: {
+    rpcMethods: (((params: KeypairToDIDKeyDocumentParams) => Promise<{
+        didDocument: any;
+        keyDoc: any;
+    }>) | ((params: GetDIDResolutionParams) => {
+        '@context': string[];
+        id: string;
+        type: string;
+        correlation: any[];
+        created: string;
+        expires: string;
+        name: any;
+        didDocument: any;
+    }) | ((params: any) => Promise<{
+        controller: any;
+        type: any;
+        id: any;
+        publicKeyMultibase: string;
+        privateKeyMultibase: string;
+        privateKeyBase58: any;
+        publicKeyBase58: any;
+    }>) | (({ payload, privateKeyDoc, headerInput }: {
         payload: any;
         privateKeyDoc: any;
         headerInput: any;
     }) => Promise<string>))[];
-    keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams): any;
-    getDIDResolution(params: GetDIDResolutionParams): any;
+    keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams): Promise<{
+        didDocument: any;
+        keyDoc: any;
+    }>;
+    getDIDResolution(params: GetDIDResolutionParams): {
+        '@context': string[];
+        id: string;
+        type: string;
+        correlation: any[];
+        created: string;
+        expires: string;
+        name: any;
+        didDocument: any;
+    };
     generateKeyDoc(params: any): Promise<{
         controller: any;
         type: any;

package/lib/src/services/dids/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/dids/service.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,6BAA6B,EAC7B,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAkDlB,cAAM,UAAU;IACd,IAAI,EAAE,MAAM,CAAC;;IAKb,UAAU,aAOsB,6BAA6B,sBAMpC,sBAAsB;;;;8BAP7C;IACF,uBAAuB,CAAC,MAAM,EAAE,6BAA6B;IAM7D,gBAAgB,CAAC,MAAM,EAAE,sBAAsB;IAMzC,cAAc,CAAC,MAAM,KAAA;;;;;;;;;IAOrB,YAAY,CAAC,MAAM,KAAA;;;;;;;;;IAOnB,eAAe,CAAC,EAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAC;;;;KAAA;CAmB5D;AAED,eAAO,MAAM,UAAU,YAAmB,CAAC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/dids/service.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,6BAA6B,EAC7B,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAkDlB,cAAM,UAAU;IACd,IAAI,EAAE,MAAM,CAAC;;IAKb,UAAU,aAOsB,6BAA6B;;;oBAMpC,sBAAsB;;;;;;;;;;;;;;;;;;;;;8BAP7C;IACF,uBAAuB,CAAC,MAAM,EAAE,6BAA6B;;;;IAM7D,gBAAgB,CAAC,MAAM,EAAE,sBAAsB;;;;;;;;;;IAMzC,cAAc,CAAC,MAAM,KAAA;;;;;;;;;IAOrB,YAAY,CAAC,MAAM,KAAA;;;;;;;;;IAOnB,eAAe,CAAC,EAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAC;;;;KAAA;CAmB5D;AAED,eAAO,MAAM,UAAU,YAAmB,CAAC"}

package/lib/src/services/edv/service.d.ts

@@ -1,30 +1,229 @@
+/**
+ * @module edv-service
+ * @description Encrypted Data Vault (EDV) service for the Wallet SDK.
+ * This module provides secure, encrypted storage functionality using EDV protocol,
+ * enabling privacy-preserving data storage with client-side encryption.
+ */
 import { InitializeEDVParams } from './configs';
 import EDVHTTPStorageInterface from '@docknetwork/universal-wallet/storage/edv-http-storage';
+export declare const HKDF_LENGTH = 32;
+export declare const HKDF_HASH = "SHA-256";
 /**
- * EDVService
+ * Service class for managing Encrypted Data Vaults
+ * @class
+ * @description Provides methods for creating, managing, and interacting with
+ * encrypted data vaults for secure storage of sensitive wallet data
  */
 export declare class EDVService {
     storageInterface: EDVHTTPStorageInterface;
     private insertQueue;
     controller: string;
-    rpcMethods: ((params: any) => any)[];
+    rpcMethods: (((params: any) => any) | ((biometricData: Buffer, identifier: string) => Buffer) | ((biometricData: Buffer, identifier: string) => Promise<{
+        key: Buffer;
+        iv: Buffer;
+    }>) | ((masterKey: Uint8Array, encryptionKey: Buffer, iv: Buffer) => Promise<Uint8Array>))[];
+    /**
+     * Creates a new EDVService instance
+     * @constructor
+     */
     constructor();
+    /**
+     * Initializes the EDV service with encryption keys and connection parameters
+     * @param {InitializeEDVParams} params - Initialization parameters
+     * @param {Object} params.hmacKey - HMAC key for document indexing
+     * @param {Object} params.agreementKey - Key agreement key for encryption
+     * @param {Object} params.verificationKey - Verification key for authentication
+     * @param {string} params.edvUrl - URL of the EDV server
+     * @param {string} params.authKey - Authentication key for the EDV server
+     * @returns {Promise<void>}
+     * @throws {Error} If unable to create or connect to EDV
+     * @example
+     * await edvService.initialize({
+     *   hmacKey: hmacKeyData,
+     *   agreementKey: agreementKeyData,
+     *   verificationKey: verificationKeyData,
+     *   edvUrl: 'https://edv.example.com',
+     *   authKey: 'auth-token-123'
+     * });
+     */
     initialize({ hmacKey, agreementKey, verificationKey, edvUrl, authKey, }: InitializeEDVParams): Promise<void>;
+    /**
+     * Generates new cryptographic keys for EDV operations
+     * @returns {Promise<Object>} Generated keys
+     * @returns {Object} returns.verificationKey - Ed25519 verification key for authentication
+     * @returns {Object} returns.agreementKey - X25519 key agreement key for encryption
+     * @returns {Object} returns.hmacKey - HMAC key for indexing
+     * @example
+     * const keys = await edvService.generateKeys();
+     * // Use keys for EDV initialization
+     * await edvService.initialize({
+     *   ...keys,
+     *   edvUrl: 'https://edv.example.com',
+     *   authKey: 'auth-token'
+     * });
+     */
     generateKeys(): Promise<{
         verificationKey: any;
         agreementKey: any;
         hmacKey: any;
     }>;
+    /**
+     * Derives cryptographic keys from a master key
+     * @param {Uint8Array} masterKey - Master key for derivation
+     * @returns {Promise<Object>} Derived keys
+     * @returns {Object} returns.verificationKey - Derived Ed25519 verification key
+     * @returns {Object} returns.agreementKey - Derived X25519 key agreement key
+     * @returns {Object} returns.hmacKey - Derived HMAC key
+     * @example
+     * const masterKey = new Uint8Array(32); // Your master key
+     * const keys = await edvService.deriveKeys(masterKey);
+     */
     deriveKeys(masterKey: Uint8Array): Promise<{
         verificationKey: any;
         agreementKey: any;
         hmacKey: any;
     }>;
+    /**
+     * Gets the controller identifier for the current EDV
+     * @returns {Promise<string>} The controller DID or identifier
+     * @example
+     * const controller = await edvService.getController();
+     * console.log('EDV Controller:', controller);
+     */
     getController(): Promise<string>;
+    /**
+     * Finds documents in the EDV based on query parameters
+     * @param {Object} params - Query parameters
+     * @param {Object} [params.equals] - Equality-based query conditions
+     * @param {boolean} [params.has] - Existence-based query conditions
+     * @param {number} [params.limit] - Maximum number of results
+     * @returns {Promise<Array>} Array of matching documents
+     * @example
+     * const documents = await edvService.find({
+     *   equals: { 'content.type': 'VerifiableCredential' },
+     *   limit: 10
+     * });
+     */
     find(params: any): any;
+    /**
+     * Updates a document in the EDV
+     * @param {Object} params - Update parameters
+     * @param {string} params.id - Document ID to update
+     * @param {Object} params.content - New document content
+     * @returns {Promise<Object>} Updated document
+     * @example
+     * const updated = await edvService.update({
+     *   id: 'doc-123',
+     *   content: { ...existingContent, updated: true }
+     * });
+     */
     update(params: any): any;
+    /**
+     * Inserts a new document into the EDV
+     * @param {Object} params - Insert parameters
+     * @param {string} params.id - Document ID
+     * @param {Object} params.content - Document content to store
+     * @returns {Promise<Object>} The inserted document
+     * @throws {Error} If insertion fails
+     * @example
+     * const document = await edvService.insert({
+     *   id: 'doc-456',
+     *   content: {
+     *     type: 'VerifiableCredential',
+     *     data: credentialData
+     *   }
+     * });
+     */
     insert(params: any): Promise<any>;
+    /**
+     * Deletes a document from the EDV
+     * @param {Object} params - Deletion parameters
+     * @param {string} params.id - Document ID to delete
+     * @returns {Promise<boolean>} True if deletion successful
+     * @example
+     * const deleted = await edvService.delete({
+     *   id: 'doc-123'
+     * });
+     */
     delete(params: any): any;
+    /**
+     * Derives a key from biometric data using HKDF
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Buffer} Derived key
+     * @example
+     * const key = edvService.deriveBiometricKey(biometricData, 'user@example.com');
+     */
+    deriveBiometricKey(biometricData: Buffer, identifier: string): Buffer;
+    /**
+     * Generates a key for encrypting/decrypting the master key
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Promise<Object>} Encryption key and IV for AES encryption
+     * @returns {Buffer} returns.key - Encryption key
+     * @returns {Buffer} returns.iv - Initialization vector
+     * @example
+     * const { key, iv } = await edvService.deriveBiometricEncryptionKey(biometricData, 'user@example.com');
+     */
+    deriveBiometricEncryptionKey(biometricData: Buffer, identifier: string): Promise<{
+        key: Buffer;
+        iv: Buffer;
+    }>;
+    /**
+     * Encrypts the master key using a key derived from biometric data
+     * @param {Uint8Array} masterKey - The CloudWalletVault master key to encrypt
+     * @param {Buffer} encryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} Encrypted master key
+     * @example
+     * const encrypted = await edvService.encryptMasterKey(masterKey, encryptionKey, iv);
+     */
+    encryptMasterKey(masterKey: Uint8Array, encryptionKey: Buffer, iv: Buffer): Promise<Uint8Array>;
+    /**
+     * Decrypts the master key using biometric-derived key
+     * @param {Uint8Array} encryptedKey - The encrypted master key
+     * @param {Buffer} decryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} The decrypted master key
+     * @throws {Error} If decryption fails
+     * @example
+     * const masterKey = await edvService.decryptMasterKey(encryptedKey, decryptionKey, iv);
+     */
+    decryptMasterKey(encryptedKey: Uint8Array, decryptionKey: Buffer, iv: Buffer): Promise<Uint8Array>;
 }
+/**
+ * Singleton instance of the EDV service
+ * @type {EDVService}
+ * @example
+ * import { edvService } from '@docknetwork/wallet-sdk-wasm/services/edv';
+ *
+ * // Generate keys and initialize
+ * const keys = await edvService.generateKeys();
+ * await edvService.initialize({
+ *   ...keys,
+ *   edvUrl: 'https://edv.example.com',
+ *   authKey: 'auth-token'
+ * });
+ *
+ * // Store encrypted data
+ * await edvService.insert({
+ *   id: 'credential-1',
+ *   content: {
+ *     type: 'VerifiableCredential',
+ *     data: credentialData
+ *   }
+ * });
+ *
+ * // Query encrypted data
+ * const credentials = await edvService.find({
+ *   equals: { 'content.type': 'VerifiableCredential' }
+ * });
+ *
+ * // Update encrypted data
+ * await edvService.update({
+ *   id: 'credential-1',
+ *   content: updatedData
+ * });
+ */
 export declare const edvService: EDVService;
 //# sourceMappingURL=service.d.ts.map

package/lib/src/services/edv/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/edv/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,mBAAmB,EAAc,MAAM,WAAW,CAAC;AAC3D,OAAO,uBAAuB,MAAM,wDAAwD,CAAC;AAU7F;;GAEG;AACH,qBAAa,UAAU;IACrB,gBAAgB,EAAE,uBAAuB,CAAC;IAE1C,OAAO,CAAC,WAAW,CAAmC;IAC/C,UAAU,EAAE,MAAM,CAAC;IAE1B,UAAU,YA+GG,GAAG,YAtGd;;IAMI,UAAU,CAAC,EACf,OAAO,EACP,YAAY,EACZ,eAAe,EACf,MAAM,EACN,OAAO,GACR,EAAE,mBAAmB;IAuDhB,YAAY;;;;;IAgBZ,UAAU,CAAC,SAAS,EAAE,UAAU;;;;;IAehC,aAAa;IAInB,IAAI,CAAC,MAAM,EAAE,GAAG;IAIhB,MAAM,CAAC,MAAM,EAAE,GAAG;IAIlB,MAAM,CAAC,MAAM,EAAE,GAAG;IAUlB,MAAM,CAAC,MAAM,EAAE,GAAG;CAGnB;AAED,eAAO,MAAM,UAAU,EAAE,UAA6B,CAAC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/edv/service.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,EAAC,mBAAmB,EAAc,MAAM,WAAW,CAAC;AAC3D,OAAO,uBAAuB,MAAM,wDAAwD,CAAC;AAY7F,eAAO,MAAM,WAAW,KAAK,CAAC;AAC9B,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,gBAAgB,EAAE,uBAAuB,CAAC;IAE1C,OAAO,CAAC,WAAW,CAAmC;IAC/C,UAAU,EAAE,MAAM,CAAC;IAE1B,UAAU,aAwLG,GAAG,6BAoEkB,MAAM,cAAc,MAAM,KAAG,MAAM,qBAgBpD,MAAM,cACT,MAAM,KACjB,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,iBAqB1B,UAAU,iBACN,MAAM,MACjB,MAAM,KACT,OAAO,CAAC,UAAU,CAAC,KAzRpB;IAEF;;;OAGG;;IAKH;;;;;;;;;;;;;;;;;;OAkBG;IACG,UAAU,CAAC,EACf,OAAO,EACP,YAAY,EACZ,eAAe,EACf,MAAM,EACN,OAAO,GACR,EAAE,mBAAmB;IAuDtB;;;;;;;;;;;;;;OAcG;IACG,YAAY;;;;;IAgBlB;;;;;;;;;;OAUG;IACG,UAAU,CAAC,SAAS,EAAE,UAAU;;;;;IAetC;;;;;;OAMG;IACG,aAAa;IAInB;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,MAAM,EAAE,GAAG;IAIhB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,MAAM,EAAE,GAAG;IAIlB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,EAAE,GAAG;IAUlB;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,GAAG;IAIlB;;;;;;;OAOG;IACH,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAKrE;;;;;;;;;OASG;IACG,4BAA4B,CAChC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAWvC;;;;;;;;OAQG;IACG,gBAAgB,CACpB,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,UAAU,CAAC;IAqBtB;;;;;;;;;OASG;IACG,gBAAgB,CACpB,YAAY,EAAE,UAAU,EACxB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,UAAU,CAAC;CAwBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,UAAU,EAAE,UAA6B,CAAC"}

package/lib/src/services/pex/config.d.ts

@@ -1,6 +1,7 @@
 export declare const serviceName = "pex";
 export declare const validation: {
     filterCredentials: (params: FilterCredentialsParams) => void;
+    evaluateCredentials: (params: EvaluateCredentialsParams) => void;
     evaluatePresentation: (params: EvaluatePresentationParams) => void;
 };
 export type FilterCredentialsParams = {