> For the complete documentation index, see [llms.txt](https://docs.truvera.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.truvera.io/credential-wallet/wallet-sdk/index/core.md).

# Wallet SDK Core

## Modules

[biometric-provider](#module_biometric-provider)

Biometric plugin for the Truvera Wallet SDK. This module provides functions for biometric enrollment, matching, and identity verification processes.

[cloud-wallet](#module_cloud-wallet)

Cloud wallet functionality for the Truvera Wallet SDK. This module provides the main cloud wallet creation and management functions.

[credential-provider](#module_credential-provider)

Verifiable credential management functionality for the Truvera Wallet SDK. This module provides functions for importing, verifying, storing, and managing verifiable credentials.

[did-provider](#module_did-provider)

DID (Decentralized Identifier) management functionality for the Truvera Wallet SDK. This module provides functions for creating, importing, exporting, and managing DIDs.

[message-provider](#module_message-provider)

DIDComm message management functionality for the Truvera Wallet SDK. This module provides functions for sending, receiving, and processing DIDComm messages.

[wallet](#module_wallet)

Core wallet functionality for the Dock Wallet SDK. This module provides the main wallet creation and management functions.

## Classes

[DefaultQRCodeProcessor](#DefaultQRCodeProcessor)

Default implementation of QRCodeProcessor

This processor manages a registry of QR code handlers and executes them in priority order to process scanned QR codes. It provides a flexible, extensible system for handling various types of QR codes in a wallet application.

[OID4VCHandler](#OID4VCHandler)

Built-in handler for OID4VC (OpenID for Verifiable Credentials) URIs

This is a generic handler that can be configured with app-specific callbacks for importing credentials. The handler itself only handles protocol detection and delegates the actual import logic to the configured callback.

### Example Usage

```
import { OID4VCHandler } from '@docknetwork/wallet-sdk-core/src/qr-handlers/builtin';
import { getCredentialProvider } from '@docknetwork/wallet-sdk-react-native';
const handler = new OID4VCHandler({
  onImportCredential: async (uri, context) => {
    try {
      // Use SDK to import credential
      await getCredentialProvider().importCredentialFromURI({
        uri,
        didProvider: getDIDProvider(),
        getAuthCode: async (authUrl) => {
          // App-specific auth handling
          return await showAuthWebView(authUrl);
        },
      });
  return { success: true };} catch (error) {  return {    success: false,    error: error instanceof Error ? error : new Error(String(error)),  };}
  },
});
processor.registerHandler(handler);
```

### Handler Priority

Default priority: 5 (very high) This ensures OID4VC URIs are checked before other credential handlers.

## Members

[Goals](#Goals) ⇒[dockDocumentNetworkResolver](#dockDocumentNetworkResolver)

Given an Api URL, resolve the network ID For now it will be applied for creds and certs It can be extended to resolve other external URLs

[OID4VCHandler](#OID4VCHandler) ⇒

Create an OID4VC handler with custom configuration

This is a convenience factory function for creating an OID4VC handler.

[DefaultQRCodeProcessor](#DefaultQRCodeProcessor) ⇒

Create a new QR code processor instance

This is a convenience factory function for creating a processor.

## Constants

[MessageTypes](#MessageTypes)

DIDComm Message helpers Check <https://identity.foundation/didcomm-messaging/spec/#out-of-band-messages> for more details

## Functions

[buildRequestVerifiablePresentationMessage()](#buildRequestVerifiablePresentationMessage)

Sender: Verifier OOB message to request a verifiable presentation from the holder

[buildAckWalletToWalletVerificationMessage()](#buildAckWalletToWalletVerificationMessage)

Sender: Holder Start a wallet to wallet verification flow

[buildVerifiablePresentationMessage()](#buildVerifiablePresentationMessage)

Sender: Holder Send a verifiable presentation to the verifier

[buildVerifiablePresentationAckMessage()](#buildVerifiablePresentationAckMessage)

Sender: Verifier Sends an the presentation result to the holder

[handleBlockchainNetworkChange()](#handleBlockchainNetworkChange)

Update existing substrate network connection Compare connected substrate connection with the current walle network Disconnect and Establish a new connection if the network is different

## Typedefs

[WalletStatus](#WalletStatus) : `'closed'` | `'loading'` | `'ready'` | `'error'`

Possible wallet status values

[KeypairType](#KeypairType) : `'sr25519'` | `'ed25519'` | `'ecdsa'`

Supported keypair types

[BiometricsProviderConfigs](#BiometricsProviderConfigs) : `Object`

Configuration options for biometric provider operations

## Interfaces

[~~IV1Wallet~~](#IV1Wallet)

Legacy V1 wallet interface for backward compatibility

[IWallet](#IWallet) ⇐ [`IV1Wallet`](#IV1Wallet)

Main wallet interface providing methods for document management, import/export, and network operations.

[IDIDProvider](#IDIDProvider)

Provides a high-level API for DID management operations

[IMessageProvider](#IMessageProvider)

Provides a high-level API for DIDComm message management operations

[ICredentialProvider](#ICredentialProvider)

Provides a high-level API for verifiable credential management operations

[IDVProcessOptions](#IDVProcessOptions)

Callback functions for handling different stages of the identity verification process

[BiometricPlugin](#BiometricPlugin)

Defines the contract for biometric enrollment and matching operations

[IDVProvider](#IDVProvider)

Defines the contract for identity verification operations

[IDVProviderFactory](#IDVProviderFactory)

Creates IDV provider instances with proper event handling and wallet integration

[IBiometricProvider](#IBiometricProvider)

Provides a high-level API for biometric identity verification operations

## biometric-provider

Biometric plugin for the Truvera Wallet SDK. This module provides functions for biometric enrollment, matching, and identity verification processes.

* [biometric-provider](#module_biometric-provider)
  * *static*
    * [.IDV\_EVENTS](#module_biometric-provider.IDV_EVENTS) ⇒ [`IBiometricProvider`](#IBiometricProvider)
  * *inner*
    * [\~setConfigs(configs)](#module_biometric-provider..setConfigs)
    * [\~isBiometricPluginEnabled()](#module_biometric-provider..isBiometricPluginEnabled) ⇒ `boolean`
    * [\~assertConfigs()](#module_biometric-provider..assertConfigs)
    * [\~getBiometricConfigs()](#module_biometric-provider..getBiometricConfigs) ⇒ `BiometricsProviderConfigs.<unknown>`
    * [\~hasProofOfBiometrics(proofRequest)](#module_biometric-provider..hasProofOfBiometrics) ⇒ `boolean`

### biometric-provider.IDV\_EVENTS ⇒ [`IBiometricProvider`](#IBiometricProvider)

Creates a biometric provider instance for identity verification and biometric credential management

**Kind**: static property of [`biometric-provider`](#module_biometric-provider)\
**Returns**: [`IBiometricProvider`](#IBiometricProvider) -

A biometric provider instance with identity verification methods

\
**Throws**:

* `Error`

  If wallet or idvProviderFactory is not provided

**See**: [IBiometricProvider](#IBiometricProvider) - The interface defining all available biometric provider methods

| Param                     | Type                                        | Description                                       |
| ------------------------- | ------------------------------------------- | ------------------------------------------------- |
| params                    | `Object`                                    | Provider configuration                            |
| params.wallet             | [`IWallet`](#IWallet)                       | The wallet instance to use for credential storage |
| params.idvProviderFactory | [`IDVProviderFactory`](#IDVProviderFactory) | Factory for creating IDV provider instances       |

**Example**

```js
import { createBiometricProvider } from '@docknetwork/wallet-sdk-core';

const biometricProvider = createBiometricProvider({
  wallet,
  idvProviderFactory: myIDVFactory
});

// Start identity verification process
const result = await biometricProvider.startIDV(proofRequest);
console.log('Enrollment credential:', result.enrollmentCredential);
console.log('Match credential:', result.matchCredential);

// Listen for IDV events
biometricProvider.eventEmitter.on('onComplete', (data) => {
  console.log('IDV process completed:', data);
});
```

### biometric-provider\~setConfigs(configs)

Sets the global biometric provider configurations for the SDK

**Kind**: inner method of [`biometric-provider`](#module_biometric-provider)

| Param                                | Type                                  | Description                                  |
| ------------------------------------ | ------------------------------------- | -------------------------------------------- |
| configs                              | `BiometricsProviderConfigs.<unknown>` | The biometric provider configurations to set |
| configs.enrollmentCredentialType     | `string`                              | The credential type for enrollment           |
| configs.biometricMatchCredentialType | `string`                              | The credential type for biometric matching   |
| \[configs.idvProvider]               | `any`                                 | Optional IDV provider configuration          |

**Example**

```js
import { setConfigs } from '@docknetwork/wallet-sdk-core/biometric-provider';

setConfigs({
  enrollmentCredentialType: 'BiometricEnrollment',
  biometricMatchCredentialType: 'BiometricMatch',
  idvProvider: myIDVProviderConfig
});
```

### biometric-provider\~isBiometricPluginEnabled() ⇒ `boolean`

Checks if the biometric plugin is enabled by verifying if biometric match credential type is configured

**Kind**: inner method of [`biometric-provider`](#module_biometric-provider)\
**Returns**: `boolean` -

True if biometric match credential type is configured, false otherwise

\
**Example**

```js
import { isBiometricPluginEnabled, setConfigs } from '@docknetwork/wallet-sdk-core/biometric-provider';

// Before configuration
console.log(isBiometricPluginEnabled()); // false

// After configuration
setConfigs({
  enrollmentCredentialType: 'BiometricEnrollment',
  biometricMatchCredentialType: 'BiometricMatch'
});
console.log(isBiometricPluginEnabled()); // true
```

### biometric-provider\~assertConfigs()

Asserts that biometric provider configurations are available

**Kind**: inner method of [`biometric-provider`](#module_biometric-provider)\
**Throws**:

* `Error`

  If biometric provider configs are not set

**Example**

```js
import { assertConfigs } from '@docknetwork/wallet-sdk-core/biometric-provider';

try {
  assertConfigs();
  console.log('Biometric configs are available');
} catch (error) {
  console.error('Biometric configs missing:', error.message);
}
```

### biometric-provider\~getBiometricConfigs() ⇒ `BiometricsProviderConfigs.<unknown>`

Gets the current biometric provider configurations

**Kind**: inner method of [`biometric-provider`](#module_biometric-provider)\
**Returns**: `BiometricsProviderConfigs.<unknown>` -

The current biometric provider configurations

\
**Throws**:

* `Error`

  If biometric provider configs are not set

**Example**

```js
import { getBiometricConfigs } from '@docknetwork/wallet-sdk-core/biometric-provider';

try {
  const configs = getBiometricConfigs();
  console.log('Enrollment credential type:', configs.enrollmentCredentialType);
  console.log('Match credential type:', configs.biometricMatchCredentialType);
} catch (error) {
  console.error('Failed to get configs:', error.message);
}
```

### biometric-provider\~hasProofOfBiometrics(proofRequest) ⇒ `boolean`

Checks if a proof request requires biometric credentials

**Kind**: inner method of [`biometric-provider`](#module_biometric-provider)\
**Returns**: `boolean` -

True if the proof request requires biometric credentials

| Param        | Type  | Description                  |
| ------------ | ----- | ---------------------------- |
| proofRequest | `any` | The proof request to analyze |

**Example**

```js
import { hasProofOfBiometrics } from '@docknetwork/wallet-sdk-core/biometric-provider';

const proofRequest = {
  input_descriptors: [{
    constraints: {
      fields: [{
        path: ['$.credentialSubject.biometric.id']
      }, {
        path: ['$.credentialSubject.biometric.created']
      }]
    }
  }]
};

if (hasProofOfBiometrics(proofRequest)) {
  console.log('This proof request requires biometric verification');
}
```

## cloud-wallet

Cloud wallet functionality for the Truvera Wallet SDK. This module provides the main cloud wallet creation and management functions.

* [cloud-wallet](#module_cloud-wallet)
  * [\~deriveBiometricKey(biometricData, identifier)](#module_cloud-wallet..deriveBiometricKey) ⇒
  * [\~deriveKeyMappingVaultKeys(biometricData, identifier)](#module_cloud-wallet..deriveKeyMappingVaultKeys) ⇒
  * [\~deriveBiometricEncryptionKey(biometricData, identifier)](#module_cloud-wallet..deriveBiometricEncryptionKey) ⇒
  * [\~encryptMasterKey(masterKey, encryptionKey, iv)](#module_cloud-wallet..encryptMasterKey) ⇒
  * [\~decryptMasterKey(encryptedKey, decryptionKey, iv)](#module_cloud-wallet..decryptMasterKey) ⇒
  * [\~initializeKeyMappingVault(edvUrl, authKey, biometricData, identifier)](#module_cloud-wallet..initializeKeyMappingVault) ⇒
  * [\~enrollUserWithBiometrics(edvUrl, authKey, biometricData, identifier)](#module_cloud-wallet..enrollUserWithBiometrics) ⇒
  * [\~getKeyMappingMasterKey(keyMappingEdv, identifier, decryptionKey, iv)](#module_cloud-wallet..getKeyMappingMasterKey) ⇒
  * [\~authenticateWithBiometrics(edvUrl, authKey, biometricData, identifier)](#module_cloud-wallet..authenticateWithBiometrics) ⇒
  * [\~initializeCloudWalletWithBiometrics(edvUrl, authKey, biometricData, identifier, dataStore)](#module_cloud-wallet..initializeCloudWalletWithBiometrics) ⇒

### cloud-wallet\~deriveBiometricKey(biometricData, identifier) ⇒

Derives a key from biometric data using HKDF

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Derived key

| Param         | Description                                           |
| ------------- | ----------------------------------------------------- |
| biometricData | Biometric data from provider                          |
| identifier    | User's identifier as salt (email, phone number, etc.) |

### cloud-wallet\~deriveKeyMappingVaultKeys(biometricData, identifier) ⇒

Derives EDV keys from biometric data for the KeyMappingVault

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Keys for accessing the KeyMappingVault

| Param         | Description                                                         |
| ------------- | ------------------------------------------------------------------- |
| biometricData | Biometric data from the provider                                    |
| identifier    | User's identifier as additional entropy (email, phone number, etc.) |

### cloud-wallet\~deriveBiometricEncryptionKey(biometricData, identifier) ⇒

Generates a key for encrypting/decrypting the master key

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Encryption key and IV for AES encryption

| Param         | Description                                           |
| ------------- | ----------------------------------------------------- |
| biometricData | Biometric data from provider                          |
| identifier    | User's identifier as salt (email, phone number, etc.) |

### cloud-wallet\~encryptMasterKey(masterKey, encryptionKey, iv) ⇒

Encrypts the master key using a key derived from biometric data

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Encrypted master key

| Param         | Description                                |
| ------------- | ------------------------------------------ |
| masterKey     | The CloudWalletVault master key to encrypt |
| encryptionKey | Key derived from biometric data            |
| iv            | Initialization vector                      |

### cloud-wallet\~decryptMasterKey(encryptedKey, decryptionKey, iv) ⇒

Decrypts the master key using biometric-derived key

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

The decrypted master key

| Param         | Description                     |
| ------------- | ------------------------------- |
| encryptedKey  | The encrypted master key        |
| decryptionKey | Key derived from biometric data |
| iv            | Initialization vector           |

### cloud-wallet\~initializeKeyMappingVault(edvUrl, authKey, biometricData, identifier) ⇒

Initializes the KeyMappingVault using biometric data

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Initialized EDV service

| Param         | Description                                   |
| ------------- | --------------------------------------------- |
| edvUrl        | URL for the edv                               |
| authKey       | Auth key for the edv                          |
| biometricData | User's biometric data                         |
| identifier    | User's identifier (email, phone number, etc.) |

### cloud-wallet\~enrollUserWithBiometrics(edvUrl, authKey, biometricData, identifier) ⇒

Enrolls a user by creating necessary vaults and keys

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

The master key and mnemonic for backup

| Param         | Description                                   |
| ------------- | --------------------------------------------- |
| edvUrl        | URL for the edv                               |
| authKey       | Auth key for the edv                          |
| biometricData | Biometric data from provider                  |
| identifier    | User's identifier (email, phone number, etc.) |

### cloud-wallet\~getKeyMappingMasterKey(keyMappingEdv, identifier, decryptionKey, iv) ⇒

Gets the master key from the key mapping vault using provided decryption keys

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

The decrypted master key for CloudWalletVault

| Param         | Description                                   |
| ------------- | --------------------------------------------- |
| keyMappingEdv | Initialized key mapping vault service         |
| identifier    | User's identifier (email, phone number, etc.) |
| decryptionKey | Key for decrypting the master key             |
| iv            | Initialization vector for decryption          |

### cloud-wallet\~authenticateWithBiometrics(edvUrl, authKey, biometricData, identifier) ⇒

Authenticates a user with biometric data and identifier

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

The decrypted master key for CloudWalletVault

| Param         | Description                                   |
| ------------- | --------------------------------------------- |
| edvUrl        | URL for the edv                               |
| authKey       | Auth key for the edv                          |
| biometricData | Biometric data from the provider              |
| identifier    | User's identifier (email, phone number, etc.) |

### cloud-wallet\~initializeCloudWalletWithBiometrics(edvUrl, authKey, biometricData, identifier, dataStore) ⇒

Initializes the Cloud Wallet using biometric authentication

**Kind**: inner method of [`cloud-wallet`](#module_cloud-wallet)\
**Returns**:

Initialized cloud wallet

| Param         | Description                                   |
| ------------- | --------------------------------------------- |
| edvUrl        | Cloud wallet vault URL                        |
| authKey       | Cloud wallet auth key                         |
| biometricData | User's biometric data                         |
| identifier    | User's identifier (email, phone number, etc.) |
| dataStore     | Optional data store for the wallet            |

## credential-provider

Verifiable credential management functionality for the Truvera Wallet SDK. This module provides functions for importing, verifying, storing, and managing verifiable credentials.

* [credential-provider](#module_credential-provider)
  * [\~isValid(credential)](#module_credential-provider..isValid) ⇒ `Promise.<Object>`
  * [\~createCredentialProvider(params)](#module_credential-provider..createCredentialProvider) ⇒ [`ICredentialProvider`](#ICredentialProvider)

### credential-provider\~isValid(credential) ⇒ `Promise.<Object>`

Uses Dock SDK to verify a credential

**Kind**: inner method of [`credential-provider`](#module_credential-provider)\
**Returns**: `Promise.<Object>` -

Verification result with status and optional error/warning messages

| Param      |
| ---------- |
| credential |

### credential-provider\~createCredentialProvider(params) ⇒ [`ICredentialProvider`](#ICredentialProvider)

Creates a credential provider instance bound to a wallet

**Kind**: inner method of [`credential-provider`](#module_credential-provider)\
**Returns**: [`ICredentialProvider`](#ICredentialProvider) -

A credential provider instance with all verifiable credential management methods

\
**See**: [ICredentialProvider](#ICredentialProvider) - The interface defining all available credential provider methods

| Param         | Type                  | Description                                       |
| ------------- | --------------------- | ------------------------------------------------- |
| params        | `Object`              | Provider configuration                            |
| params.wallet | [`IWallet`](#IWallet) | The wallet instance to use for credential storage |

**Example**

```js
import { createCredentialProvider } from '@docknetwork/wallet-sdk-core';

const credentialProvider = createCredentialProvider({wallet});

// Add a credential
const addedCredential = await credentialProvider.addCredential(myCredential);

// Validate a credential
const result = await credentialProvider.isValid(credential);
if (result.status === 'verified') {
  console.log('Credential is valid');
}

// Get all credentials
const allCredentials = credentialProvider.getCredentials();

// Import from URI
await credentialProvider.importCredentialFromURI({
  uri: 'https://example.com/credential-offer',
  didProvider
});
```

## did-provider

DID (Decentralized Identifier) management functionality for the Truvera Wallet SDK. This module provides functions for creating, importing, exporting, and managing DIDs.

### did-provider\~createDIDProvider(params) ⇒ [`IDIDProvider`](#IDIDProvider)

Creates a DID provider instance bound to a wallet

**Kind**: inner method of [`did-provider`](#module_did-provider)\
**Returns**: [`IDIDProvider`](#IDIDProvider) -

A DID provider instance with all DID management methods

\
**See**: [IDIDProvider](#IDIDProvider) - The interface defining all available DID provider methods

| Param         | Type                  | Description                                 |
| ------------- | --------------------- | ------------------------------------------- |
| params        | `Object`              | Provider configuration                      |
| params.wallet | [`IWallet`](#IWallet) | The wallet instance to bind the provider to |

**Example**

```js
import { createDIDProvider } from '@docknetwork/wallet-sdk-core';

const didProvider = createDIDProvider({wallet});

// Create a new DID
const {keyDoc, didDocumentResolution} = await didProvider.createDIDKey({
  name: 'My DID'
});

// Get all DIDs
const allDIDs = await didProvider.getAll();

// Export a DID
const exportedDID = await didProvider.exportDID({
  id: didDocumentResolution.id,
  password: 'mypassword'
});
```

## message-provider

DIDComm message management functionality for the Truvera Wallet SDK. This module provides functions for sending, receiving, and processing DIDComm messages.

### message-provider\~createMessageProvider(params) ⇒ [`IMessageProvider`](#IMessageProvider)

Creates a message provider instance bound to a wallet and DID provider

**Kind**: inner method of [`message-provider`](#module_message-provider)\
**Returns**: [`IMessageProvider`](#IMessageProvider) -

A message provider instance with all DIDComm message management methods

\
**See**: [IMessageProvider](#IMessageProvider) - The interface defining all available message provider methods

| Param                  | Type                            | Description                                                          |
| ---------------------- | ------------------------------- | -------------------------------------------------------------------- |
| params                 | `Object`                        | Provider configuration                                               |
| params.wallet          | [`IWallet`](#IWallet)           | The wallet instance to use for message storage                       |
| params.didProvider     | [`IDIDProvider`](#IDIDProvider) | The DID provider instance to use for key management                  |
| \[params.relayService] | `any`                           | Optional relay service implementation (defaults to built-in service) |

**Example**

```js
import { createMessageProvider } from '@docknetwork/wallet-sdk-core';

const messageProvider = createMessageProvider({
  wallet,
  didProvider
});

// Send a message
await messageProvider.sendMessage({
  did: 'did:key:sender123',
  recipientDid: 'did:key:recipient456',
  message: { hello: 'world' }
});

// Start auto-fetching messages
const stopAutoFetch = messageProvider.startAutoFetch(5000);

// Add message listener
const removeListener = messageProvider.addMessageListener((message) => {
  console.log('Received message:', message);
});
```

## wallet

Core wallet functionality for the Dock Wallet SDK. This module provides the main wallet creation and management functions.

### wallet\~createWallet(props) ⇒ [`Promise.<IWallet>`](#IWallet)

Creates a new wallet instance with the provided data store. The wallet provides secure storage and management of DIDs, credentials, keys, and other documents.

**Kind**: inner method of [`wallet`](#module_wallet)\
**Returns**: [`Promise.<IWallet>`](#IWallet) -

A promise that resolves to the created wallet instance

\
**Throws**:

* `Error`

  If the data store is not properly initialized

**See**: [IWallet](#IWallet) - The interface defining all available wallet methods

| Param           | Type                | Description                                          |
| --------------- | ------------------- | ---------------------------------------------------- |
| props           | `CreateWalletProps` | Configuration options for wallet creation            |
| props.dataStore | `DataStore`         | The data store implementation to use for persistence |

**Example**

```js
import { createWallet } from '@docknetwork/wallet-sdk-core';
import { createDataStore } from '@docknetwork/wallet-sdk-data-store';

const dataStore = await createDataStore();
const wallet = await createWallet({ dataStore });

// The wallet implements the IWallet interface
await wallet.addDocument(myCredential);
const documents = await wallet.getAllDocuments();
```

## ~~IV1Wallet~~

***This interface is obsolete and should not be used for new implementations. Use IWallet instead.***

Legacy V1 wallet interface for backward compatibility

**Kind**: global interface<br>

## IWallet ⇐ [`IV1Wallet`](#IV1Wallet)

Main wallet interface providing methods for document management, import/export, and network operations.

**Kind**: global interface\
**Extends**: [`IV1Wallet`](#IV1Wallet)

* [IWallet](#IWallet) ⇐ [`IV1Wallet`](#IV1Wallet)
  * [.deleteWallet()](#IWallet.deleteWallet) ⇒ `Promise.<void>`
  * [.setStatus(newStatus)](#IWallet.setStatus)
  * [.setNetwork(networkId)](#IWallet.setNetwork) ⇒ `Promise.<void>`
  * [.getNetworkId()](#IWallet.getNetworkId) ⇒ `string`
  * [.getDocumentById(id)](#IWallet.getDocumentById) ⇒ `Promise.<WalletDocument>`
  * [.getAllDocuments()](#IWallet.getAllDocuments) ⇒ `Promise.<Array.<WalletDocument>>`
  * [.getDocumentsById(idList)](#IWallet.getDocumentsById) ⇒ `Promise.<Array.<WalletDocument>>`
  * [.getDocumentsByType(type)](#IWallet.getDocumentsByType) ⇒ `Promise.<Array.<WalletDocument>>`
  * [.addDocument(json, \[options\])](#IWallet.addDocument) ⇒ `Promise.<WalletDocument>`
  * [.updateDocument(document, \[options\])](#IWallet.updateDocument) ⇒ `Promise.<WalletDocument>`
  * [.removeDocument(id, \[options\])](#IWallet.removeDocument) ⇒ `Promise.<void>`
  * [.getDocumentCorrelations(documentId)](#IWallet.getDocumentCorrelations) ⇒ `Promise.<Array.<WalletDocument>>`
  * [.getAccountKeyPair(accountId)](#IWallet.getAccountKeyPair) ⇒ `Promise.<any>`
  * [.getDocumentsFromEncryptedWallet(json, password)](#IWallet.getDocumentsFromEncryptedWallet) ⇒ `Promise.<any>`
  * [.importUniversalWalletJSON(json, password)](#IWallet.importUniversalWalletJSON) ⇒ `Promise.<void>`
  * [.exportDocuments(params)](#IWallet.exportDocuments) ⇒ `Promise.<any>`
  * [.exportUniversalWalletJSON(password)](#IWallet.exportUniversalWalletJSON) ⇒ `any`

### IWallet.deleteWallet() ⇒ `Promise.<void>`

Deletes the entire wallet and all its documents

**Kind**: static method of [`IWallet`](#IWallet)\
**Emits**: `WalletEvents.event:walletDeleted`<br>

### IWallet.setStatus(newStatus)

Sets the wallet status

**Kind**: static method of [`IWallet`](#IWallet)

| Param     | Type     | Description           |
| --------- | -------- | --------------------- |
| newStatus | `string` | The new status to set |

### IWallet.setNetwork(networkId) ⇒ `Promise.<void>`

Sets the active network for the wallet

**Kind**: static method of [`IWallet`](#IWallet)\
**Emits**: `WalletEvents.event:networkUpdated`

| Param     | Type     | Description                         |
| --------- | -------- | ----------------------------------- |
| networkId | `string` | The network identifier to switch to |

### IWallet.getNetworkId() ⇒ `string`

Gets the current network ID

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `string` -

The current network identifier

<br>

### IWallet.getDocumentById(id) ⇒ `Promise.<WalletDocument>`

Retrieves a document by its ID

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<WalletDocument>` -

The document with the specified ID

\
**Throws**:

* `Error`

  If document is not found

| Param | Type     | Description                           |
| ----- | -------- | ------------------------------------- |
| id    | `string` | The unique identifier of the document |

### IWallet.getAllDocuments() ⇒ `Promise.<Array.<WalletDocument>>`

Retrieves all documents stored in the wallet

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<Array.<WalletDocument>>` -

Array of all documents in the wallet

<br>

### IWallet.getDocumentsById(idList) ⇒ `Promise.<Array.<WalletDocument>>`

Retrieves multiple documents by their IDs

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<Array.<WalletDocument>>` -

Array of documents matching the provided IDs

| Param  | Type             | Description                       |
| ------ | ---------------- | --------------------------------- |
| idList | `Array.<string>` | Array of document IDs to retrieve |

### IWallet.getDocumentsByType(type) ⇒ `Promise.<Array.<WalletDocument>>`

Retrieves all documents of a specific type

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<Array.<WalletDocument>>` -

Array of documents matching the specified type

| Param | Type     | Description                                                                  |
| ----- | -------- | ---------------------------------------------------------------------------- |
| type  | `string` | The document type to filter by (e.g., 'VerifiableCredential', 'DIDDocument') |

### IWallet.addDocument(json, \[options]) ⇒ `Promise.<WalletDocument>`

Adds a new document to the wallet

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<WalletDocument>` -

The created document with generated metadata

\
**Emits**: `WalletEvents.event:documentAdded`

| Param      | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| json       | `any` | The document to add (must have valid JSON-LD structure) |
| \[options] | `any` | Optional parameters for document creation               |

**Example**

```js
const credential = {
  "@context": ["https://www.w3.org/2018/credentials/v1"],
  "type": ["VerifiableCredential"],
  "issuer": "did:dock:123",
  "credentialSubject": { "name": "John Doe" }
};
const addedDoc = await wallet.addDocument(credential);
```

### IWallet.updateDocument(document, \[options]) ⇒ `Promise.<WalletDocument>`

Updates an existing document

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<WalletDocument>` -

The updated document

\
**Throws**:

* `Error`

  If document doesn't exist

**Emits**: `WalletEvents.event:documentUpdated`

| Param      | Type  | Description                                      |
| ---------- | ----- | ------------------------------------------------ |
| document   | `any` | The document with updated data (must include ID) |
| \[options] | `any` | Optional parameters for document update          |

### IWallet.removeDocument(id, \[options]) ⇒ `Promise.<void>`

Removes a document from the wallet

**Kind**: static method of [`IWallet`](#IWallet)\
**Throws**:

* `Error`

  If document is not found

**Emits**: `WalletEvents.event:documentRemoved`

| Param      | Type     | Description                              |
| ---------- | -------- | ---------------------------------------- |
| id         | `string` | The ID of the document to remove         |
| \[options] | `any`    | Optional parameters for document removal |

### IWallet.getDocumentCorrelations(documentId) ⇒ `Promise.<Array.<WalletDocument>>`

Gets all documents correlated to a specific document

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<Array.<WalletDocument>>` -

Array of correlated documents

| Param      | Type     | Description                                     |
| ---------- | -------- | ----------------------------------------------- |
| documentId | `string` | The ID of the document to find correlations for |

### IWallet.getAccountKeyPair(accountId) ⇒ `Promise.<any>`

Retrieves the keypair associated with an account

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<any>` -

The keypair associated with the account

| Param     | Type     | Description                           |
| --------- | -------- | ------------------------------------- |
| accountId | `string` | The account ID to get the keypair for |

### IWallet.getDocumentsFromEncryptedWallet(json, password) ⇒ `Promise.<any>`

Decrypts and retrieves documents from an encrypted wallet without importing

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<any>` -

Array of decrypted documents

| Param    | Type     | Description                    |
| -------- | -------- | ------------------------------ |
| json     | `any`    | The encrypted wallet JSON      |
| password | `string` | Password to decrypt the wallet |

### IWallet.importUniversalWalletJSON(json, password) ⇒ `Promise.<void>`

Imports documents from an encrypted Universal Wallet 2020 JSON

**Kind**: static method of [`IWallet`](#IWallet)\
**See**: <https://w3c-ccg.github.io/universal-wallet-interop-spec/>

| Param    | Type     | Description                    |
| -------- | -------- | ------------------------------ |
| json     | `any`    | The encrypted wallet JSON      |
| password | `string` | Password to decrypt the wallet |

**Example**

```js
// Import from encrypted wallet backup
const walletBackup = { ... }; // encrypted wallet JSON
await wallet.importUniversalWalletJSON(walletBackup, 'mypassword');
```

### IWallet.exportDocuments(params) ⇒ `Promise.<any>`

Exports specified documents as an encrypted JSON (test)

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `Promise.<any>` -

Encrypted wallet JSON

| Param            | Type          | Description             |
| ---------------- | ------------- | ----------------------- |
| params           | `Object`      | Export parameters       |
| params.documents | `Array.<any>` | Documents to export     |
| params.password  | `string`      | Password for encryption |

### IWallet.exportUniversalWalletJSON(password) ⇒ `any`

Exports the entire wallet as an encrypted Universal Wallet 2020 JSON

**Kind**: static method of [`IWallet`](#IWallet)\
**Returns**: `any` -

Encrypted Universal Wallet JSON representation

\
**See**: <https://w3c-ccg.github.io/universal-wallet-interop-spec/>

| Param    | Type     | Description             |
| -------- | -------- | ----------------------- |
| password | `string` | Password for encryption |

**Example**

```js
// Create encrypted backup of entire wallet
const backup = await wallet.exportUniversalWalletJSON('mypassword');
// Save backup to file or cloud storage
```

## IDIDProvider

Provides a high-level API for DID management operations

**Kind**: global interface

* [IDIDProvider](#IDIDProvider)
  * [.importDID(params)](#IDIDProvider.importDID) ⇒ `Promise.<Array.<any>>`
  * [.createDIDKey(params)](#IDIDProvider.createDIDKey) ⇒ `Promise.<{keyDoc: any, didDocumentResolution: any}>`
  * [.editDID(params)](#IDIDProvider.editDID) ⇒ `Promise.<void>`
  * [.deleteDID(params)](#IDIDProvider.deleteDID) ⇒ `Promise.<void>`
  * [.exportDID(params)](#IDIDProvider.exportDID) ⇒ `Promise.<any>`
  * [.getAll()](#IDIDProvider.getAll) ⇒ `Promise.<Array.<any>>`
  * [.getDIDKeyPairs()](#IDIDProvider.getDIDKeyPairs) ⇒ `Promise.<Array.<any>>`
  * [.ensureDID()](#IDIDProvider.ensureDID) ⇒ `Promise.<({keyDoc: any, didDocumentResolution: any}|void)>`
  * [.getDefaultDID()](#IDIDProvider.getDefaultDID) ⇒ `Promise.<(string|undefined)>`

### IDIDProvider.importDID(params) ⇒ `Promise.<Array.<any>>`

Imports a DID from an encrypted wallet JSON

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<Array.<any>>` -

Array of imported documents

\
**Throws**:

* `Error`

  If password is incorrect or DID already exists in wallet

| Param                      | Type     | Description                                  |
| -------------------------- | -------- | -------------------------------------------- |
| params                     | `Object` | Import parameters                            |
| params.encryptedJSONWallet | `any`    | The encrypted wallet JSON containing the DID |
| params.password            | `string` | Password to decrypt the wallet               |

**Example**

```js
const importedDocs = await didProvider.importDID({
  encryptedJSONWallet: encryptedBackup,
  password: 'mypassword'
});
```

### IDIDProvider.createDIDKey(params) ⇒ `Promise.<{keyDoc: any, didDocumentResolution: any}>`

Creates a new DID:key with an associated keypair

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<{keyDoc: any, didDocumentResolution: any}>` -

The created keypair and DID document

\
**Throws**:

* `Error`

  If name is not provided

| Param                | Type     | Description                              |
| -------------------- | -------- | ---------------------------------------- |
| params               | `Object` | Creation parameters                      |
| params.name          | `string` | The name for the new DID                 |
| \[params.derivePath] | `string` | Optional derivation path for the keypair |
| \[params.type]       | `string` | Optional key type specification          |

**Example**

```js
const {keyDoc, didDocumentResolution} = await didProvider.createDIDKey({
  name: 'My Identity DID',
  derivePath: "m/44'/60'/0'/0/0"
});
```

### IDIDProvider.editDID(params) ⇒ `Promise.<void>`

Edits a DID document's name

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Throws**:

* `Error`

  If document ID is not set or document not found

| Param       | Type     | Description                        |
| ----------- | -------- | ---------------------------------- |
| params      | `Object` | Edit parameters                    |
| params.id   | `string` | The ID of the DID document to edit |
| params.name | `string` | The new name for the DID           |

**Example**

```js
await didProvider.editDID({
  id: 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK',
  name: 'Updated DID Name'
});
```

### IDIDProvider.deleteDID(params) ⇒ `Promise.<void>`

Deletes a DID from the wallet

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Throws**:

* `Error`

  If document ID is not set

| Param     | Type     | Description                          |
| --------- | -------- | ------------------------------------ |
| params    | `Object` | Delete parameters                    |
| params.id | `string` | The ID of the DID document to delete |

**Example**

```js
await didProvider.deleteDID({
  id: 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK'
});
```

### IDIDProvider.exportDID(params) ⇒ `Promise.<any>`

Exports a DID and its correlated documents as an encrypted JSON

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<any>` -

Encrypted wallet JSON containing the DID and correlations

\
**Throws**:

* `Error`

  If DID document or keypair not found

| Param           | Type     | Description                          |
| --------------- | -------- | ------------------------------------ |
| params          | `Object` | Export parameters                    |
| params.id       | `string` | The ID of the DID document to export |
| params.password | `string` | Password for encryption              |

**Example**

```js
const exportedDID = await didProvider.exportDID({
  id: 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK',
  password: 'mypassword'
});
```

### IDIDProvider.getAll() ⇒ `Promise.<Array.<any>>`

Retrieves all DIDs stored in the wallet

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<Array.<any>>` -

Array of DID resolution response documents

\
**Example**

```js
const allDIDs = await didProvider.getAll();
console.log(`Found ${allDIDs.length} DIDs in wallet`);
```

### IDIDProvider.getDIDKeyPairs() ⇒ `Promise.<Array.<any>>`

Retrieves all keypairs associated with DIDs in the wallet

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<Array.<any>>` -

Array of keypair documents

\
**Example**

```js
const keyPairs = await didProvider.getDIDKeyPairs();
console.log(`Found ${keyPairs.length} DID keypairs`);
```

### IDIDProvider.ensureDID() ⇒ `Promise.<({keyDoc: any, didDocumentResolution: any}|void)>`

Ensures at least one DID exists in the wallet, creating a default if none exist

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<({keyDoc: any, didDocumentResolution: any}|void)>` -

The created DID if one was created, undefined otherwise

\
**Example**

```js
// Ensure wallet has at least one DID
await didProvider.ensureDID();
```

### IDIDProvider.getDefaultDID() ⇒ `Promise.<(string|undefined)>`

Gets the default DID from the wallet (first DID if exists)

**Kind**: static method of [`IDIDProvider`](#IDIDProvider)\
**Returns**: `Promise.<(string|undefined)>` -

The default DID identifier or undefined if no DIDs exist

\
**Example**

```js
const defaultDID = await didProvider.getDefaultDID();
if (defaultDID) {
  console.log(`Default DID: ${defaultDID}`);
}
```

## IMessageProvider

Provides a high-level API for DIDComm message management operations

**Kind**: global interface

* [IMessageProvider](#IMessageProvider)
  * [.fetchMessages](#IMessageProvider.fetchMessages) ⇒ `Promise.<void>`
  * [.addMessageListener](#IMessageProvider.addMessageListener) ⇒ `function`
  * [.processDIDCommMessages](#IMessageProvider.processDIDCommMessages) ⇒ `Promise.<void>`
  * [.processMessageRecurrentJob](#IMessageProvider.processMessageRecurrentJob) ⇒ `Promise.<void>`
  * [.markMessageAsRead](#IMessageProvider.markMessageAsRead) ⇒ `Promise.<void>`
  * [.sendMessage(params)](#IMessageProvider.sendMessage) ⇒ `Promise.<any>`
  * [.waitForMessage()](#IMessageProvider.waitForMessage) ⇒ `Promise.<any>`
  * [.startAutoFetch(\[timeout\])](#IMessageProvider.startAutoFetch) ⇒ `function`
  * [.clearCache()](#IMessageProvider.clearCache) ⇒ `Promise.<void>`

### IMessageProvider.fetchMessages ⇒ `Promise.<void>`

Fetches new messages from the relay service

**Kind**: static property of [`IMessageProvider`](#IMessageProvider)\
**Throws**:

* `Error`

  If message fetching fails

**Example**

```js
await messageProvider.fetchMessages();
console.log('Messages fetched successfully');
```

### IMessageProvider.addMessageListener ⇒ `function`

Adds a listener for when messages are decrypted

**Kind**: static property of [`IMessageProvider`](#IMessageProvider)\
**Returns**: `function` -

Function to remove the listener

| Param   | Type       | Description                                    |
| ------- | ---------- | ---------------------------------------------- |
| handler | `function` | Callback function to handle decrypted messages |

**Example**

```js
const removeListener = messageProvider.addMessageListener((message) => {
  console.log('New message received:', message);
});
// Later, remove the listener
removeListener();
```

### IMessageProvider.processDIDCommMessages ⇒ `Promise.<void>`

Processes stored DIDComm messages and decrypts them

**Kind**: static property of [`IMessageProvider`](#IMessageProvider)\
**Throws**:

* `Error`

  If message processing fails

**Example**

```js
await messageProvider.processDIDCommMessages();
console.log('Messages processed successfully');
```

### IMessageProvider.processMessageRecurrentJob ⇒ `Promise.<void>`

Starts the recurrent message processing job

**Kind**: static property of [`IMessageProvider`](#IMessageProvider)\
**Example**

```js
await messageProvider.processMessageRecurrentJob();
```

### IMessageProvider.markMessageAsRead ⇒ `Promise.<void>`

Marks a message as read and removes it from storage

**Kind**: static property of [`IMessageProvider`](#IMessageProvider)\
**Throws**:

* `Error`

  If message is not found or not a DIDComm message

| Param     | Type     | Description                           |
| --------- | -------- | ------------------------------------- |
| messageId | `string` | The ID of the message to mark as read |

**Example**

```js
await messageProvider.markMessageAsRead('message-id-123');
console.log('Message marked as read');
```

### IMessageProvider.sendMessage(params) ⇒ `Promise.<any>`

Sends a DIDComm message to a recipient

**Kind**: static method of [`IMessageProvider`](#IMessageProvider)\
**Returns**: `Promise.<any>` -

Result of sending the message

\
**Throws**:

* `Error`

  If sender DID not found or message sending fails

| Param                  | Type     | Description                                                 |
| ---------------------- | -------- | ----------------------------------------------------------- |
| params                 | `Object` | Message parameters                                          |
| \[params.from]         | `string` | Sender DID identifier                                       |
| \[params.to]           | `string` | Recipient DID identifier                                    |
| \[params.message]      | `any`    | Message payload to send                                     |
| \[params.type]         | `string` | DIDComm message type                                        |
| \[params.did]          | `string` | @deprecated Use 'from' instead - Sender DID identifier      |
| \[params.recipientDid] | `string` | @deprecated Use 'to' instead - Recipient DID identifier     |
| \[params.body]         | `any`    | @deprecated Use 'message' instead - Message payload to send |

**Example**

```js
await messageProvider.sendMessage({
  from: 'did:key:sender123',
  to: 'did:key:recipient456',
  message: { hello: 'world' },
  type: 'basic-message'
});
```

### IMessageProvider.waitForMessage() ⇒ `Promise.<any>`

Waits for the next incoming message

**Kind**: static method of [`IMessageProvider`](#IMessageProvider)\
**Returns**: `Promise.<any>` -

Promise that resolves with the next received message

\
**Example**

```js
const nextMessage = await messageProvider.waitForMessage();
console.log('Received message:', nextMessage);
```

### IMessageProvider.startAutoFetch(\[timeout]) ⇒ `function`

Starts automatic message fetching at regular intervals

**Kind**: static method of [`IMessageProvider`](#IMessageProvider)\
**Returns**: `function` -

Function to stop the auto-fetch process

| Param      | Type     | Default | Description                                       |
| ---------- | -------- | ------- | ------------------------------------------------- |
| \[timeout] | `number` | `2000`  | Interval in milliseconds between fetch operations |

**Example**

```js
const stopAutoFetch = messageProvider.startAutoFetch(5000);
// Later, stop auto-fetching
stopAutoFetch();
```

### IMessageProvider.clearCache() ⇒ `Promise.<void>`

Clears all cached messages from the wallet

**Kind**: static method of [`IMessageProvider`](#IMessageProvider)\
**Example**

```js
await messageProvider.clearCache();
console.log('All messages cleared');
```

## ICredentialProvider

Provides a high-level API for verifiable credential management operations

**Kind**: global interface

* [ICredentialProvider](#ICredentialProvider)
  * [.getCredentials](#ICredentialProvider.getCredentials) ⇒ `Array.<any>`
  * [.isBBSPlusCredential](#ICredentialProvider.isBBSPlusCredential) ⇒ `boolean`
  * [.importCredentialFromURI(params)](#ICredentialProvider.importCredentialFromURI) ⇒ `Promise.<any>`
  * [.getMembershipWitness(credentialId)](#ICredentialProvider.getMembershipWitness) ⇒ `Promise.<any>`
  * [.getById(id)](#ICredentialProvider.getById) ⇒ `any`
  * [.isValid(credential, \[forceFetch\])](#ICredentialProvider.isValid) ⇒ `Promise.<Object>` | `string` | `string` | `string`
  * [.getCredentialStatus(credential)](#ICredentialProvider.getCredentialStatus) ⇒ `Promise.<Object>` | `string` | `string`
  * [.syncCredentialStatus(params)](#ICredentialProvider.syncCredentialStatus) ⇒ `Promise.<Array.<any>>`
  * [.addCredential(credential)](#ICredentialProvider.addCredential) ⇒ `Promise.<any>`
  * [.removeCredential(credential)](#ICredentialProvider.removeCredential) ⇒ `Promise.<void>`

### ICredentialProvider.getCredentials ⇒ `Array.<any>`

Retrieves credentials from the wallet, optionally filtered by type

**Kind**: static property of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Array.<any>` -

Array of credentials matching the specified type

| Param   | Type     | Default                    | Description                      |
| ------- | -------- | -------------------------- | -------------------------------- |
| \[type] | `string` | `"'VerifiableCredential'"` | The credential type to filter by |

**Example**

```js
const allCredentials = credentialProvider.getCredentials();
const certificates = credentialProvider.getCredentials('Certificate');
```

### ICredentialProvider.isBBSPlusCredential ⇒ `boolean`

Checks if a credential uses BBS+ signature

**Kind**: static property of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `boolean` -

True if the credential uses BBS+ signature

| Param      | Type  | Description             |
| ---------- | ----- | ----------------------- |
| credential | `any` | The credential to check |

**Example**

```js
const isBBS = credentialProvider.isBBSPlusCredential(credential);
if (isBBS) {
  console.log('This credential uses BBS+ signatures');
}
```

### ICredentialProvider.importCredentialFromURI(params) ⇒ `Promise.<any>`

Imports a credential from a URI (supports OpenID credential offers)

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<any>` -

The imported credential

\
**Throws**:

* `Error`

  If import fails

| Param                 | Type       | Description                               |
| --------------------- | ---------- | ----------------------------------------- |
| params                | `Object`   | Import parameters                         |
| params.uri            | `string`   | The URI containing the credential offer   |
| params.didProvider    | `any`      | DID provider instance for key management  |
| \[params.getAuthCode] | `function` | Optional callback to handle authorization |

**Example**

```js
const credential = await credentialProvider.importCredentialFromURI({
  uri: 'https://issuer.example.com/credential-offer',
  didProvider,
  getAuthCode: async (url) => getUserAuthCode(url)
});
```

### ICredentialProvider.getMembershipWitness(credentialId) ⇒ `Promise.<any>`

Gets the membership witness for a credential (used for BBS+ credentials)

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<any>` -

The membership witness data

| Param        | Type     | Description                              |
| ------------ | -------- | ---------------------------------------- |
| credentialId | `string` | The credential ID to get the witness for |

**Example**

```js
const witness = await credentialProvider.getMembershipWitness('credential-123');
```

### ICredentialProvider.getById(id) ⇒ `any`

Retrieves a credential by its ID

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `any` -

The credential document

\
**Throws**:

* `Error`

  If credential is not found

| Param | Type     | Description                             |
| ----- | -------- | --------------------------------------- |
| id    | `string` | The unique identifier of the credential |

**Example**

```js
const credential = await credentialProvider.getById('credential-123');
```

### ICredentialProvider.isValid(credential, \[forceFetch]) ⇒ `Promise.<Object>` | `string` | `string` | `string`

Validates a credential by verifying its cryptographic proof and status

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<Object>` -

Validation result

`string` -

returns.status - Validation status (verified, revoked, expired, invalid, pending)

`string` -

\[returns.error] - Error message if validation failed

`string` -

\[returns.warning] - Warning message if any

\
**Throws**:

* `Error`

  If validation fails

| Param         | Type      | Default | Description                                    |
| ------------- | --------- | ------- | ---------------------------------------------- |
| credential    | `any`     |         | The credential to validate                     |
| \[forceFetch] | `boolean` | `false` | Whether to force refresh the credential status |

**Example**

```js
const result = await credentialProvider.isValid(credential);
if (result.status === 'verified') {
  console.log('Credential is valid');
} else if (result.status === 'revoked') {
  console.log('Credential has been revoked');
}
```

### ICredentialProvider.getCredentialStatus(credential) ⇒ `Promise.<Object>` | `string` | `string`

Gets the current status of a credential (cached, fast operation)

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<Object>` -

Current credential status

`string` -

returns.status - Current status of the credential

`string` -

\[returns.error] - Error message if any

| Param      | Type  | Description             |
| ---------- | ----- | ----------------------- |
| credential | `any` | The credential to check |

**Example**

```js
const status = await credentialProvider.getCredentialStatus(credential);
console.log(`Credential status: ${status.status}`);
```

### ICredentialProvider.syncCredentialStatus(params) ⇒ `Promise.<Array.<any>>`

Synchronizes credential status from the blockchain

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<Array.<any>>` -

Array of credential status documents

| Param                   | Type             | Default | Description                              |
| ----------------------- | ---------------- | ------- | ---------------------------------------- |
| params                  | `Object`         |         | Sync parameters                          |
| \[params.credentialIds] | `Array.<string>` |         | Optional list of credential IDs to sync  |
| \[params.forceFetch]    | `boolean`        | `false` | Whether to force refresh from blockchain |

**Example**

```js
// Sync all credentials
await credentialProvider.syncCredentialStatus({});

// Sync specific credentials
await credentialProvider.syncCredentialStatus({
  credentialIds: ['cred-1', 'cred-2'],
  forceFetch: true
});
```

### ICredentialProvider.addCredential(credential) ⇒ `Promise.<any>`

Adds a credential to the wallet

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Returns**: `Promise.<any>` -

The added credential document

| Param      | Type  | Description           |
| ---------- | ----- | --------------------- |
| credential | `any` | The credential to add |

**Example**

```js
const addedCredential = await credentialProvider.addCredential({
  '@context': ['https://www.w3.org/2018/credentials/v1'],
  type: ['VerifiableCredential'],
  issuer: 'did:dock:issuer123',
  credentialSubject: { name: 'Alice' }
});
```

### ICredentialProvider.removeCredential(credential) ⇒ `Promise.<void>`

Removes a credential and all its related documents from the wallet

**Kind**: static method of [`ICredentialProvider`](#ICredentialProvider)\
**Throws**:

* `Error`

  If credential is not found

| Param      | Type  | Description              |
| ---------- | ----- | ------------------------ |
| credential | `any` | The credential to remove |

**Example**

```js
await credentialProvider.removeCredential(credential);
// Or by ID
await credentialProvider.removeCredential('credential-123');
```

## IDVProcessOptions

Callback functions for handling different stages of the identity verification process

**Kind**: global interface<br>

## BiometricPlugin

Defines the contract for biometric enrollment and matching operations

**Kind**: global interface<br>

## IDVProvider

Defines the contract for identity verification operations

**Kind**: global interface<br>

## IDVProviderFactory

Creates IDV provider instances with proper event handling and wallet integration

**Kind**: global interface<br>

## IBiometricProvider

Provides a high-level API for biometric identity verification operations

**Kind**: global interface

* [IBiometricProvider](#IBiometricProvider)
  * [.startIDV](#IBiometricProvider.startIDV)
  * [.eventEmitter](#IBiometricProvider.eventEmitter)
  * [.startIDV(proofRequest)](#IBiometricProvider.startIDV) ⇒ `Promise.<{enrollmentCredential: Credential, matchCredential: Credential}>`

### IBiometricProvider.startIDV

Starts the identity verification process using biometric credentials

**Kind**: static property of [`IBiometricProvider`](#IBiometricProvider)<br>

### IBiometricProvider.eventEmitter

Event emitter for IDV process events (onDeepLink, onMessage, onError, onCancel, onComplete)

**Kind**: static property of [`IBiometricProvider`](#IBiometricProvider)<br>

### IBiometricProvider.startIDV(proofRequest) ⇒ `Promise.<{enrollmentCredential: Credential, matchCredential: Credential}>`

Starts the identity verification process using biometric credentials

**Kind**: static method of [`IBiometricProvider`](#IBiometricProvider)\
**Returns**: `Promise.<{enrollmentCredential: Credential, matchCredential: Credential}>` -

The enrollment and match credentials

\
**Throws**:

* `Error`

  If IDV process fails or biometric configs are missing

| Param        | Type  | Description                                         |
| ------------ | ----- | --------------------------------------------------- |
| proofRequest | `any` | The proof request containing biometric requirements |

**Example**

```js
const result = await biometricProvider.startIDV({
  input_descriptors: [{
    constraints: {
      fields: [{
        path: ['$.credentialSubject.biometric.id'],
        purpose: 'Biometric ID verification'
      }]
    }
  }]
});
```

## DefaultQRCodeProcessor

Default implementation of QRCodeProcessor

This processor manages a registry of QR code handlers and executes them in priority order to process scanned QR codes. It provides a flexible, extensible system for handling various types of QR codes in a wallet application.

**Kind**: global class

* [DefaultQRCodeProcessor](#DefaultQRCodeProcessor)
  * [new DefaultQRCodeProcessor()](#new_DefaultQRCodeProcessor_new)
  * [.registerHandler(handler)](#DefaultQRCodeProcessor+registerHandler)
  * [.unregisterHandler(id)](#DefaultQRCodeProcessor+unregisterHandler) ⇒
  * [.getHandlers()](#DefaultQRCodeProcessor+getHandlers) ⇒
  * [.getHandler(id)](#DefaultQRCodeProcessor+getHandler) ⇒
  * [.clearHandlers()](#DefaultQRCodeProcessor+clearHandlers)
  * [.process(data, options)](#DefaultQRCodeProcessor+process) ⇒
  * [.defaultPrepareContext(data)](#DefaultQRCodeProcessor+defaultPrepareContext) ⇒
  * [.withTimeout(promise, timeoutMs)](#DefaultQRCodeProcessor+withTimeout) ⇒

### new DefaultQRCodeProcessor()

**Example**

```typescript
const processor = new DefaultQRCodeProcessor();

// Register handlers
processor.registerHandler(new OID4VCHandler());
processor.registerHandler(new CredentialHandler());

// Process QR code
const result = await processor.process(scannedData);
if (result.success) {
  console.log('QR code processed:', result.data);
} else {
  console.error('Failed to process QR code:', result.error);
}
```

### defaultQRCodeProcessor.registerHandler(handler)

Register a new QR code handler

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Throws**:

* Error if a handler with the same ID is already registered

| Param   | Description             |
| ------- | ----------------------- |
| handler | The handler to register |

### defaultQRCodeProcessor.unregisterHandler(id) ⇒

Unregister a QR code handler by its ID

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

True if the handler was found and removed, false otherwise

| Param | Description                         |
| ----- | ----------------------------------- |
| id    | The ID of the handler to unregister |

### defaultQRCodeProcessor.getHandlers() ⇒

Get all registered handlers sorted by priority

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Array of registered handlers sorted by priority (lowest first)

<br>

### defaultQRCodeProcessor.getHandler(id) ⇒

Get a specific handler by its ID

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

The handler if found, undefined otherwise

| Param | Description                       |
| ----- | --------------------------------- |
| id    | The ID of the handler to retrieve |

### defaultQRCodeProcessor.clearHandlers()

Clear all registered handlers

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)<br>

### defaultQRCodeProcessor.process(data, options) ⇒

Process QR code data through registered handlers

This method:

1. Prepares the context from raw QR data
2. Executes handlers in priority order
3. Returns the first successful result (or continues if stopOnFirstSuccess is false)
4. Returns an error result if no handler can process the data

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Result of the processing

| Param   | Description             |
| ------- | ----------------------- |
| data    | Raw QR code data string |
| options | Processing options      |

### defaultQRCodeProcessor.defaultPrepareContext(data) ⇒

Default context preparation function

This method attempts to parse the raw QR data as JSON or URL. Override this by providing a custom prepareContext function in ProcessOptions.

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Prepared context object

| Param | Description             |
| ----- | ----------------------- |
| data  | Raw QR code data string |

### defaultQRCodeProcessor.withTimeout(promise, timeoutMs) ⇒

Execute a promise with a timeout

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Result of the promise

\
**Throws**:

* Error if the promise times out

| Param     | Description             |
| --------- | ----------------------- |
| promise   | Promise to execute      |
| timeoutMs | Timeout in milliseconds |

## Goals ⇒

**Kind**: global variable\
**Returns**:

OOB message to start a wallet to wallet verification flow The holder will scan it as QR code and should have the context to start the verification flow

<br>

## dockDocumentNetworkResolver

Given an Api URL, resolve the network ID For now it will be applied for creds and certs It can be extended to resolve other external URLs

**Kind**: global variable<br>

## OID4VCHandler ⇒

Create an OID4VC handler with custom configuration

This is a convenience factory function for creating an OID4VC handler.

**Kind**: global variable\
**Returns**:

Configured OID4VC handler

| Param  | Description           |
| ------ | --------------------- |
| config | Handler configuration |

**Example**

```typescript
const handler = createOID4VCHandler({
  onImportCredential: async (uri) => {
    // Your import logic
    return { success: true };
  },
});
```

* [OID4VCHandler](#OID4VCHandler) ⇒
  * [.canHandle(context)](#OID4VCHandler+canHandle) ⇒
  * [.handle(context)](#OID4VCHandler+handle) ⇒

### oiD4VCHandler.canHandle(context) ⇒

Check if this is an OID4VC URI

Matches URIs that start with any of the configured prefixes. By default, matches: openid-credential-offer://

**Kind**: instance method of [`OID4VCHandler`](#OID4VCHandler)\
**Returns**:

True if this handler can process the URI

| Param   | Description         |
| ------- | ------------------- |
| context | The QR code context |

### oiD4VCHandler.handle(context) ⇒

Process the OID4VC credential offer URI

Delegates to the configured onImportCredential callback for actual processing. This allows apps to implement their own navigation, UI, and error handling.

**Kind**: instance method of [`OID4VCHandler`](#OID4VCHandler)\
**Returns**:

Result of the processing

| Param   | Description         |
| ------- | ------------------- |
| context | The QR code context |

## DefaultQRCodeProcessor ⇒

Create a new QR code processor instance

This is a convenience factory function for creating a processor.

**Kind**: global variable\
**Returns**:

New processor instance with handlers registered

| Param    | Description                                        |
| -------- | -------------------------------------------------- |
| handlers | Optional array of handlers to register immediately |

**Example**

```typescript
const processor = createQRCodeProcessor([
  new OID4VCHandler(),
  new CredentialHandler(),
]);
```

* [DefaultQRCodeProcessor](#DefaultQRCodeProcessor) ⇒
  * [new DefaultQRCodeProcessor()](#new_DefaultQRCodeProcessor_new)
  * [.registerHandler(handler)](#DefaultQRCodeProcessor+registerHandler)
  * [.unregisterHandler(id)](#DefaultQRCodeProcessor+unregisterHandler) ⇒
  * [.getHandlers()](#DefaultQRCodeProcessor+getHandlers) ⇒
  * [.getHandler(id)](#DefaultQRCodeProcessor+getHandler) ⇒
  * [.clearHandlers()](#DefaultQRCodeProcessor+clearHandlers)
  * [.process(data, options)](#DefaultQRCodeProcessor+process) ⇒
  * [.defaultPrepareContext(data)](#DefaultQRCodeProcessor+defaultPrepareContext) ⇒
  * [.withTimeout(promise, timeoutMs)](#DefaultQRCodeProcessor+withTimeout) ⇒

### new DefaultQRCodeProcessor()

**Example**

```typescript
const processor = new DefaultQRCodeProcessor();

// Register handlers
processor.registerHandler(new OID4VCHandler());
processor.registerHandler(new CredentialHandler());

// Process QR code
const result = await processor.process(scannedData);
if (result.success) {
  console.log('QR code processed:', result.data);
} else {
  console.error('Failed to process QR code:', result.error);
}
```

### defaultQRCodeProcessor.registerHandler(handler)

Register a new QR code handler

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Throws**:

* Error if a handler with the same ID is already registered

| Param   | Description             |
| ------- | ----------------------- |
| handler | The handler to register |

### defaultQRCodeProcessor.unregisterHandler(id) ⇒

Unregister a QR code handler by its ID

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

True if the handler was found and removed, false otherwise

| Param | Description                         |
| ----- | ----------------------------------- |
| id    | The ID of the handler to unregister |

### defaultQRCodeProcessor.getHandlers() ⇒

Get all registered handlers sorted by priority

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Array of registered handlers sorted by priority (lowest first)

<br>

### defaultQRCodeProcessor.getHandler(id) ⇒

Get a specific handler by its ID

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

The handler if found, undefined otherwise

| Param | Description                       |
| ----- | --------------------------------- |
| id    | The ID of the handler to retrieve |

### defaultQRCodeProcessor.clearHandlers()

Clear all registered handlers

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)<br>

### defaultQRCodeProcessor.process(data, options) ⇒

Process QR code data through registered handlers

This method:

1. Prepares the context from raw QR data
2. Executes handlers in priority order
3. Returns the first successful result (or continues if stopOnFirstSuccess is false)
4. Returns an error result if no handler can process the data

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Result of the processing

| Param   | Description             |
| ------- | ----------------------- |
| data    | Raw QR code data string |
| options | Processing options      |

### defaultQRCodeProcessor.defaultPrepareContext(data) ⇒

Default context preparation function

This method attempts to parse the raw QR data as JSON or URL. Override this by providing a custom prepareContext function in ProcessOptions.

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Prepared context object

| Param | Description             |
| ----- | ----------------------- |
| data  | Raw QR code data string |

### defaultQRCodeProcessor.withTimeout(promise, timeoutMs) ⇒

Execute a promise with a timeout

**Kind**: instance method of [`DefaultQRCodeProcessor`](#DefaultQRCodeProcessor)\
**Returns**:

Result of the promise

\
**Throws**:

* Error if the promise times out

| Param     | Description             |
| --------- | ----------------------- |
| promise   | Promise to execute      |
| timeoutMs | Timeout in milliseconds |

## MessageTypes

DIDComm Message helpers Check <https://identity.foundation/didcomm-messaging/spec/#out-of-band-messages> for more details

**Kind**: global constant<br>

## buildRequestVerifiablePresentationMessage()

Sender: Verifier OOB message to request a verifiable presentation from the holder

**Kind**: global function<br>

## buildAckWalletToWalletVerificationMessage()

Sender: Holder Start a wallet to wallet verification flow

**Kind**: global function<br>

## buildVerifiablePresentationMessage()

Sender: Holder Send a verifiable presentation to the verifier

**Kind**: global function<br>

## buildVerifiablePresentationAckMessage()

Sender: Verifier Sends an the presentation result to the holder

**Kind**: global function<br>

## handleBlockchainNetworkChange()

Update existing substrate network connection Compare connected substrate connection with the current walle network Disconnect and Establish a new connection if the network is different

**Kind**: global function<br>

## WalletStatus : `'closed'` | `'loading'` | `'ready'` | `'error'`

Possible wallet status values

**Kind**: global typedef<br>

## KeypairType : `'sr25519'` | `'ed25519'` | `'ecdsa'`

Supported keypair types

**Kind**: global typedef<br>

## BiometricsProviderConfigs : `Object`

Configuration options for biometric provider operations

**Kind**: global typedef\
**Properties**

| Name                         | Type     | Description                                       |
| ---------------------------- | -------- | ------------------------------------------------- |
| enrollmentCredentialType     | `string` | The credential type used for biometric enrollment |
| biometricMatchCredentialType | `string` | The credential type used for biometric matching   |
| idvConfigs                   | `E`      | IDV provider-specific configuration options       |

## OID4VCHandler

Built-in handler for OID4VC (OpenID for Verifiable Credentials) URIs

This is a generic handler that can be configured with app-specific callbacks for importing credentials. The handler itself only handles protocol detection and delegates the actual import logic to the configured callback.

## Example Usage

```
import { OID4VCHandler } from '@docknetwork/wallet-sdk-core/src/qr-handlers/builtin';
import { getCredentialProvider } from '@docknetwork/wallet-sdk-react-native';
const handler = new OID4VCHandler({
onImportCredential: async (uri, context) => {
try {
// Use SDK to import credential
await getCredentialProvider().importCredentialFromURI({
uri,
didProvider: getDIDProvider(),
getAuthCode: async (authUrl) => {
// App-specific auth handling
return await showAuthWebView(authUrl);
},
});
  return { success: true };} catch (error) {  return {    success: false,    error: error instanceof Error ? error : new Error(String(error)),  };}
},
});
processor.registerHandler(handler);
```

## Handler Priority

Default priority: 5 (very high) This ensures OID4VC URIs are checked before other credential handlers.

**Kind**: global class\
**Category**: Built-in Handlers

* [OID4VCHandler](#OID4VCHandler)
  * [.canHandle(context)](#OID4VCHandler+canHandle) ⇒
  * [.handle(context)](#OID4VCHandler+handle) ⇒

### oiD4VCHandler.canHandle(context) ⇒

Check if this is an OID4VC URI

Matches URIs that start with any of the configured prefixes. By default, matches: openid-credential-offer://

**Kind**: instance method of [`OID4VCHandler`](#OID4VCHandler)\
**Returns**:

True if this handler can process the URI

| Param   | Description         |
| ------- | ------------------- |
| context | The QR code context |

### oiD4VCHandler.handle(context) ⇒

Process the OID4VC credential offer URI

Delegates to the configured onImportCredential callback for actual processing. This allows apps to implement their own navigation, UI, and error handling.

**Kind**: instance method of [`OID4VCHandler`](#OID4VCHandler)\
**Returns**:

Result of the processing

| Param   | Description         |
| ------- | ------------------- |
| context | The QR code context |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.truvera.io/credential-wallet/wallet-sdk/index/core.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.