@docknetwork/wallet-sdk-wasm 1.5.11 → 1.7.0

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,UAAU;;;;;;;CA4CtB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,UAAU;;;;;;;CAkDtB,CAAC"}

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

@@ -1,5 +1,6 @@
 export declare const credentialServiceRPC: {
     rpcMethods: ((params?: {}) => any)[];
+    createSDJWTPresentation(params: any): Promise<string>;
     generateCredential(params?: {}): any;
     signCredential(params: any): Promise<any>;
     createPresentation(params: any): Promise<any>;
@@ -9,6 +10,8 @@ export declare const credentialServiceRPC: {
     evaluatePresentation(params: any): import("@sphereon/pex").EvaluationResults;
     isBBSPlusCredential(params: any): any;
     isKvacCredential(params: any): any;
+    isSDJWTCredential(params: any): boolean;
+    credentialToW3C(params: any): Promise<any>;
     acquireOIDCredential({ uri, authorizationCode, holderKeyDocument, }: {
         uri: string;
         authorizationCode?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/credential/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC"}

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

@@ -1,4 +1,15 @@
-export function pexToBounds(pexRequest: any, selectedCredentials?: any[], removeFromRequest?: boolean): any[];
+/**
+ * Convert PEX request to bounds for each descriptor
+ * @param {*} pexRequest - The PEX request object containing input descriptors and constraints
+ * @param {*} selectedCredentials  - Array of selected credentials corresponding to the input descriptors
+ * @param {*} removeFromRequest - if true, removes range proofs fields from the request. it might be dangerous if you will be using the proof request later
+ *  because it will not have the range proofs fields anymore.
+ * @returns {Array} - Array of bounds for each descriptor, where each bound is an object with attributeName, min, and max
+ * @throws {Error} - If a field path is missing or empty
+ * @throws {Error} - If an unsupported format or type is encountered
+ * @throws {Error} - If a selected credential is expected but not found at the given index
+ */
+export function pexToBounds(pexRequest: any, selectedCredentials?: any, removeFromRequest?: any): any[];
 export function getPexRequiredAttributes(pexRequest: any, selectedCredentials?: any[]): any;
 export const EPSILON_NUMBER: 0.001;
 export const EPSILON_INT: 1;
@@ -8,4 +19,5 @@ export const MAX_INTEGER: number;
 export const MIN_INTEGER: -4294967295;
 export const MAX_NUMBER: number;
 export const MIN_NUMBER: -4294967294;
+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,8GA8LC;AAaD,4FAgCC;AAvSD,mCAAoC;AACpC,4BAA6B;AAE7B,mDAAoD;AACpD,mDAAoD;AACpD,iCAAoC;AACpC,sCAAuC;AACvC,gCAAmC;AACnC,qCAAsC"}
+{"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"}

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/edv/service.d.ts

@@ -1,30 +1,180 @@
+/**
+ * @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';
 /**
- * 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)[];
+    /**
+     * 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;
 }
+/**
+ * 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;AAU7F;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,gBAAgB,EAAE,uBAAuB,CAAC;IAE1C,OAAO,CAAC,WAAW,CAAmC;IAC/C,UAAU,EAAE,MAAM,CAAC;IAE1B,UAAU,YAoLG,GAAG,YA3Kd;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;CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,UAAU,EAAE,UAA6B,CAAC"}