@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.0

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"}

package/lib/src/services/relay-service/service.d.ts

@@ -1,19 +1,147 @@
+/**
+ * @module relay-service
+ * @description DIDComm message relay service for the Wallet SDK.
+ * This module provides functionality for sending, receiving, and managing DIDComm messages
+ * through a relay service, including push notification support.
+ */
 import { SendMessageParams, GetMessagesParams, ResolveDidcommMessageParams, RegisterDIDPushNotificationParams, AckMessagesParams } from './configs';
 import { RelayService as relayServiceClient } from '@docknetwork/wallet-sdk-relay-service/lib';
 /**
- * RelayService
+ * Service class for managing DIDComm message relay operations
+ * @class
+ * @description Provides methods for sending, receiving, and acknowledging DIDComm messages
+ * through a relay service infrastructure
  */
 export declare class RelayService {
     name: string;
     rpcMethods: (((params: AckMessagesParams) => any) | ((params: GetMessagesParams) => any) | ((params: RegisterDIDPushNotificationParams) => any) | ((params: ResolveDidcommMessageParams) => any) | ((params: SendMessageParams) => any))[];
+    /**
+     * Creates a new RelayService instance
+     * @constructor
+     */
     constructor();
+    /**
+     * Sends a DIDComm message through the relay service
+     * @param {SendMessageParams} params - Message parameters
+     * @param {Object} params.keyPairDoc - Key pair document for message encryption
+     * @param {Object} params.message - The message payload to send
+     * @param {string} params.recipientDid - DID of the message recipient
+     * @param {string} [params.type] - Message type identifier
+     * @returns {Promise<Object>} Result of the send operation
+     * @throws {Error} If validation fails or sending fails
+     * @example
+     * const result = await relayService.sendMessage({
+     *   keyPairDoc: senderKeyPair,
+     *   message: { content: 'Hello' },
+     *   recipientDid: 'did:key:recipient123',
+     *   type: 'basic-message'
+     * });
+     */
     sendMessage(params: SendMessageParams): any;
+    /**
+     * Acknowledges receipt of messages from the relay service
+     * @param {AckMessagesParams} params - Acknowledgment parameters
+     * @param {string} params.did - DID acknowledging the messages
+     * @param {Array<string>} params.messageIds - Array of message IDs to acknowledge
+     * @returns {Promise<Object>} Result of the acknowledgment operation
+     * @example
+     * await relayService.ackMessages({
+     *   did: 'did:key:holder123',
+     *   messageIds: ['msg-1', 'msg-2']
+     * });
+     */
     ackMessages(params: AckMessagesParams): any;
+    /**
+     * Resolves and decrypts a DIDComm message
+     * @param {ResolveDidcommMessageParams} params - Resolution parameters
+     * @param {Object} params.encryptedMessage - The encrypted message to resolve
+     * @param {Object} params.keyPairDoc - Key pair document for decryption
+     * @returns {Promise<Object>} The decrypted and resolved message
+     * @throws {Error} If validation fails or resolution fails
+     * @example
+     * const decrypted = await relayService.resolveDidcommMessage({
+     *   encryptedMessage: encryptedData,
+     *   keyPairDoc: recipientKeyPair
+     * });
+     */
     resolveDidcommMessage(params: ResolveDidcommMessageParams): any;
+    /**
+     * Signs a JWT using the provided key pair
+     * @param {ResolveDidcommMessageParams} params - Signing parameters
+     * @param {Object} params.payload - JWT payload to sign
+     * @param {Object} params.keyPairDoc - Key pair document for signing
+     * @returns {Promise<string>} The signed JWT token
+     * @throws {Error} If validation fails or signing fails
+     * @example
+     * const jwt = await relayService.signJwt({
+     *   payload: { sub: 'did:key:123', iat: Date.now() },
+     *   keyPairDoc: signerKeyPair
+     * });
+     */
     signJwt(params: ResolveDidcommMessageParams): any;
+    /**
+     * Retrieves messages from the relay service
+     * @param {GetMessagesParams} params - Retrieval parameters
+     * @param {Object} params.keyPairDocs - Key pair documents for decryption
+     * @param {number} [params.limit] - Maximum number of messages to retrieve
+     * @param {boolean} [params.skipMessageResolution] - Whether to skip message resolution
+     * @returns {Promise<Array>} Array of retrieved messages
+     * @throws {Error} If validation fails or retrieval fails
+     * @example
+     * const messages = await relayService.getMessages({
+     *   keyPairDocs: [keyPairDoc1, keyPairDoc2],
+     *   limit: 50,
+     *   skipMessageResolution: false
+     * });
+     */
     getMessages(params: GetMessagesParams): any;
+    /**
+     * Registers a DID for push notifications
+     * @param {RegisterDIDPushNotificationParams} params - Registration parameters
+     * @param {string} params.did - The DID to register for notifications
+     * @param {string} params.deviceToken - Device token for push notifications
+     * @param {string} [params.platform] - Platform identifier (ios, android, etc.)
+     * @returns {Promise<Object>} Result of the registration
+     * @throws {Error} If validation fails or registration fails
+     * @example
+     * await relayService.registerDIDPushNotification({
+     *   did: 'did:key:holder123',
+     *   deviceToken: 'fcm-token-123',
+     *   platform: 'android'
+     * });
+     */
     registerDIDPushNotification(params: RegisterDIDPushNotificationParams): any;
 }
+/**
+ * Low-level relay service client for direct API access
+ * @type {Object}
+ * @see {@link RelayService} - Higher-level service wrapper
+ */
 export { relayServiceClient };
+/**
+ * Singleton instance of the relay service
+ * @type {RelayService}
+ * @example
+ * import { relayService } from '@docknetwork/wallet-sdk-wasm/services/relay-service';
+ *
+ * // Send a DIDComm message
+ * await relayService.sendMessage({
+ *   keyPairDoc: senderKeyPair,
+ *   message: { type: 'greeting', content: 'Hello!' },
+ *   recipientDid: 'did:key:recipient123'
+ * });
+ *
+ * // Retrieve messages
+ * const messages = await relayService.getMessages({
+ *   keyPairDocs: [recipientKeyPair],
+ *   limit: 10
+ * });
+ *
+ * // Acknowledge messages
+ * await relayService.ackMessages({
+ *   did: 'did:key:recipient123',
+ *   messageIds: messages.map(m => m.id)
+ * });
+ */
 export declare const relayService: RelayService;
 //# sourceMappingURL=service.d.ts.map

package/lib/src/services/relay-service/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/relay-service/service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,iCAAiC,EAGjC,iBAAiB,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAC,YAAY,IAAI,kBAAkB,EAAC,MAAM,2CAA2C,CAAC;AAE7F;;GAEG;AACH,qBAAa,YAAY;IACvB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,aAkBU,iBAAiB,sBAcjB,iBAAiB,sBAKD,iCAAiC,sBAfvC,2BAA2B,sBATrC,iBAAiB,aANnC;;IAMF,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAKrC,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAIrC,qBAAqB,CAAC,MAAM,EAAE,2BAA2B;IAKzD,OAAO,CAAC,MAAM,EAAE,2BAA2B;IAK3C,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAKrC,2BAA2B,CAAC,MAAM,EAAE,iCAAiC;CAItE;AAED,OAAO,EAAC,kBAAkB,EAAC,CAAC;AAE5B,eAAO,MAAM,YAAY,EAAE,YAAiC,CAAC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/services/relay-service/service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,iCAAiC,EAGjC,iBAAiB,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAC,YAAY,IAAI,kBAAkB,EAAC,MAAM,2CAA2C,CAAC;AAE7F;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,aAmDU,iBAAiB,sBAuDjB,iBAAiB,sBAoBD,iCAAiC,sBA1DvC,2BAA2B,sBAlCrC,iBAAiB,aA3BnC;IAEF;;;OAGG;;IAKH;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAKrC;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAIrC;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,MAAM,EAAE,2BAA2B;IAKzD;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM,EAAE,2BAA2B;IAK3C;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAKrC;;;;;;;;;;;;;;OAcG;IACH,2BAA2B,CAAC,MAAM,EAAE,iCAAiC;CAItE;AAED;;;;GAIG;AACH,OAAO,EAAC,kBAAkB,EAAC,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,EAAE,YAAiC,CAAC"}

package/lib/src/services/rpc-service-client.d.ts

@@ -1,7 +1,7 @@
 export class RpcService {
     constructor(serviceName: any);
-    serviceName: string;
-    sandbox: Boolean;
+    serviceName: any;
+    sandbox: boolean;
     call(method: any, ...params: any[]): Promise<any>;
 }
 //# sourceMappingURL=rpc-service-client.d.ts.map