@verixyz/core NPM

verixyz Core

Core functions

instantiate and orchestrate plugins
coordinate events
validate schemas
define core types

Functions

Helper function to create a new instance of the Agent class with correct type.

Parameters:

options: IAgentOptions & { Context ?: C;}

Returns: TAgent & {Context? : C'}

Example

import { createAgent, IResolver, IMessageHandler } from '@verixyz/core'
import { AgentRestClient } from '@verixyz/remote-client'
import { CredentialIssuer, ICredentialIssuer } from '@verixyz/credential-w3c'
const agent = createAgent<IResolver & IMessageHandler & ICredentialIssuer>({
  plugins: [
    new CredentialIssuer(),
    new AgentRestClient({
      url: 'http://localhost:3002/agent',
      enabledMethods: ['resolveDid', 'handleMessage'],
    }),
  ],
})

Interfaces

GetDIDComponentArgs

Input arguments for getDIDComponentById

didDocument The DID document from which to extract the fragment. This MUST be the document resolved by
didUrl The DID URI that refers to the subsection by #fragment. Example: did:example:identifier#controller
section The section of the DID document where to search for the fragment. Example 'keyAgreement', or 'assertionMethod', or 'authentication', etc

IAgent

Agent that can execute methods

emit (eventType: string, data: any) => Promise
excute <A = any, R = any>(method: string, args: A) => Promise

IAgentBase

Agent base interface

availableMethods () => string[]
getSchema () => IAgentPluginSchema

IAgentContext

Standard plugin method context interface

agent TAgent

await agent.resolveDid({
  didUrl: 'did:example:123',
})

IAgentOptions

Agent configuration options.

This interface is used to describe the constellation of plugins that this agent will use and provide.

You will use this to attach plugins, to setup overrides for their methods and to explicitly set the methods that this agent instance is allowed to call. This permissioning method is also used for internal calls made by plugin code.

authorizedMethods:string[] The array of method names that will be exposed by the agent
context : Record<string, any> The context object that will be available to the plugin methods
overrides : IPluginMethodMap The map of plugin methods. Can be used to override methods provided by plugins, or to add additional methods without writing a plugin
plugins : IAgentPlugin [] The array of agent plugins
schemaValidation : boolean Flag that enables schema validation for plugin methods. false

IAgentPlugin

Agent plugin interface

methods IPluginMethodMap
schema IAgentPluginSchema

IAgentPluginSchema

Agent plugin schema

components { schemas: any; methods: any; }

IDataStore

Basic data store interface

dataStoreDeleteVerifiableCredential(args) Deletes verifiable credential from the data store
dataStoreGetMessage(args) Gets message from the data store
dataStoreGetVerifiableCredential(args) Gets verifiable credential from the data store
dataStoreGetVerifiablePresentation(args) Gets verifiable presentation from the data store
dataStoreSaveMessage(args) Saves message to the data store
dataStoreSaveVerifiableCredential(args) Saves verifiable credential to the data store
dataStoreSaveVerifiablePresentation(args) Saves verifiable presentation to the data store

IDataStoreDeleteVerifiableCredentialArgs

Input arguments for

hash: string Required. VerifiableCredential hash

IDataStoreGetMessageArgs

Input arguments for dataStoreGetMessage

id: string Required. Messgae ID

IDataStoreGetVerifiableCredentialArgs

Input arguments for dataStoreGetVerifiableCredential

hash: string Required. VerifiableCredential hash

IDataStoreGetVerifiablePresentationArgs

Input arguments for dataStoreGetVerifiablePresentation

hash: string Required. VerifiablePresentation hash

IDataStoreSaveMessageArgs

Input arguments for dataStoreSaveMessage

message: IMessgae Required. Required message

IDataStoreSaveVerifiableCredentialArgs

Input arguments for dataStoreSaveVerifiableCredential

IDataStoreSaveVerifiablePresentationArgs

Input arguments for dataStoreSaveVerifiablePresentation

verifiablePresentation:VerifiablePresentation
Required. VerifiablePresentation

IDIDManager

Identifier manager interface

didManagerAddKey(args, context) Adds a key to a DID Document
args: IDIDManagerAddKeyArgs
context: IAgentContext
Returns: Promise
didManagerAddService(args, context) Adds a service to a DID Document
args: IDIDManagerAddServiceArgs
context: IAgentContext
Returns: Promise
didManagerCreate(args, context) Creates and returns a new identifier
args: IDIDManagerCreateArgs
context: IAgentContext
Returns: Promise Example
```
const identifier = await agent.didManagerCreate({
    alias: 'charlie',
    provider: 'did:ethr:rinkeby',
    kms: 'local',
})
```
didManagerDelete(args, context) Deletes identifier
args: IDIDManagerDeleteArgs
conext: IAgentContext
Returns: Promise
didManagerFind(args) Returns a list of managed identifiers
args: IDIDManagerFindArgs
Returns: Promise<Array> Example
```
const aliceIdentifiers = await agent.didManagerFind({
    alias: 'alice',
})
```
const rinkebyIdentifiers = await agent.didManagerFind({ provider: 'did:ethr:rinkeby', })
didManagerGet(args) Returns a specific identifier
args: IDIDManagerGetArgs
Returns: Promise
didManagerGetByAlias(args) Returns a specific identifier by alias
args: IDIDManagerGetByAliasArgs
Returns: Promise Example
```
const identifier = await agent.didManagerGetByAlias({
    alias: 'charlie',
    provider: 'did:ethr:rinkeby',
})
```
didManagerGetOrCreate(args, context) Returns an existing identifier or creates a new one for a specific alias
args: IDIDManagerGetOrCreateArgs
contex: IAgentContext
Returns: Promise
didManagerGetProviders() Returns a list of available identifier providers
Rerturns: Promise
didManagerImport(args, context) Imports identifier
args: MinimallmportableIdentifier
context: IagentContext
Returns: Promise
didManagerRemoveKey(args, context) Removes a key from a DID Document
args: IDIDManagerRemoveKeyArgs
context: IAgentContext
Returns: Promise
didManagerRemoveService(args, context) Removes a service from a DID Document
args: IDIDManagerRemoveServiceArgs
context: IAgentContext
Returns: Promise

didManagerSetAlias(args, context) Sets identifier alias

args: IDIDManagerSetAliasArgs

context: IAgentContext

Returns: Promise Example

const identifier = await agent.didManagerCreate()
const result = await agent.didManagerSetAlias({
    did: identifier.did,
    alias: 'carol',
})

IDIDManagerAddKeyArgs

Input arguments for didManagerAddKey

did: string
key: IKey
options: object

IDIDManagerAddServiceArgs

Input arguments for didManagerAddService

did: string
options: object
service: IService

IDIDManagerCreateArgs

Input arguments for didManagerCreate

alias: string
kms: string
options: object
provider: string

IDIDManagerDeleteArgs

Input arguments for didManagerDelete

did: string

IDIDManagerFindArgs

Input arguments for didManagerFind

alias: string
provider: string

IDIDManagerGetArgs

Input arguments for didManagerGet

did: string

IDIDManagerGetByAliasArgs

Input arguments for didManagerGetByAlias

alias: string
provider: string

IDIDManagerGetOrCreateArgs

Input arguments for didManagerGetOrCreate

alias: string
kms: string
options: object
provider: string

IDIDManagerRemoveKeyArgs

Input arguments for didManagerRemoveKey

did: string
kdid: string
options: object

IDIDManagerRemoveServiceArgs

Input arguments for didManagerRemoveService

did: string
id: string
options: object

IDIDManagerSetAliasArgs

Input arguments for didManagerSetAlias

alias: string
did: string

IEventListener

Describes a listener interface that needs to be implemented by components interested in listening to events emitted by an agent.

eventTypes:string[] Declares the event types that this listener is interested in.

onEvent(event, context) Processes an event emitted by the agent.

IHandleMessageArgs

Input arguments for handleMessage

metaData: IMetaData[] Optional. Message metadata.
raw: string Raw message data.
save: boolean Optional. If set to true, the message will be saved using dataStoreSaveMessage.

IIdentifier

Identifier interface

alias: string Optional. Identifier alias. Can be used to reference an object in an external system
controllerKeyId:string Controller key id
did: string Decentralized identifier
keys: IKey[] Array of managed keys
provdier: string Identifier provider name
services: IService[] Array of services

IKey

Cryptographic key

kid: string Key ID
kms: string Key Management Systems
meta: KeyMetadata | Null Optional. Key metadata. This should be used to determine which algorithms are supported.
privateKeyHex: string Optional. Private key.
publicKeyHex: string Public key
type: TKeyType Key type

IKeyManager

Key manager interface

keyManagerCreate(args) Creates and returns a new key
args: IKeyManagerCreateArgs
Returns: Promise
keyManagerDecryptJWE(args) (BETA) Decrypts data
args: IKeyManagerDecryptJWEArgs
Returns: Promise
keyManagerDelete(args) Deletes a key
args:IKeyManagerDeleteArgs
Returns: Promise
keyManagerEncryptJWE(args) (BETA) Encrypts data
args: IKeyManagerEncryptJWEArgs
Returns: Promise
keyManagerGet(args) Returns an existing key
args: IKeyManagerGetArgs
Returns: Promise
keyManagerGetKeyManagementSystems() Lists available key management systems
Returns: Promise<Array>
keyManagerImport(args) Imports a created key
args: MinimalImportableKey
Returns: Promise
keyManagerSharedSecret(args) Compute a shared secret with the public key of another party. This computes the raw shared secret (the result of a Diffie-Hellman computation) To use this for symmetric encryption you MUST apply a KDF on the result.
args: IKeyManagerSharedSecretArgs
Returns: Promise
keyManagerSign(args) Generates a signature according to the algorithm specified.
args: IKeyManagerSignArgs
Returns: Promise
keyManagerSignEthTX(args) Signs Ethereum transaction
args: IKeyManagerSignEthTXArgs
Returns: Promise
keyManagerSignJWT(args) Signs JWT
args:IKeyManagerSignJWTArgs
Returns: Promise

IKeyManagerCreateArgs

Input arguments for keyManagerCreate

kms:string Key Management Systems
meta: keyMetadata Optional. Key Metadata.
type: TKeyType Key type

IKeyManagerDecryptJWEArgs

(BETA) Input arguments for keyManagerDecryptJWE

data: string (BETA) Encrypted dta
kid: string (BETA) Key ID

IKeyManagerDeleteArgs

Input arguments for keyManagerDelete

kid: string Key DID

IKeyManagerEncryptJWEArgs

(BETA) Input arguments for keyManagerEncryptJWE

data:string (BETA) Data to encrypt
kid:string (BETA) Key ID to use for encryption
to:Omit<IKey , 'kms'> (BETA) Recipient key object

IKeyManagerGetArgs

Input arguments for keyManagerGet

-kid: string Key DID

IKeyManagerSharedSecretArgs

Input arguments for keyManagerSharedSecret

publicKey:Pick<IKey , 'publicKeyHex' | 'type'> The public key of the other party. The type of key MUST be compatible with the type referenced by secretKeyRef
secretKeyRef:string The secret key handle (kid) as returned by keyManagerCreate

IKeyManagerSignArgs

Input arguments for keyManagerSign

algorithm:string The algorithm to use for signing. This must be one of the algorithms supported by the KMS for this key type. The algorithm used here should match one of the names listed in IKey.meta.algorithms
data:string Data to sign
encoding:'utf-8' | 'base16' | 'base64' | 'hex' If the data is a "string" then you can specify which encoding is used. Default is "utf-8"
keyRef:string The key handle, as returned during keyManagerCreateKey

IKeyManagerSignEthTXArgs

Input arguments for keyManagerSignEthTX

kid: string Key ID
transaction: object

IKeyManagerSignJWTArgs

Input arguments for keyManagerSignJWT

data: string | Uint8Array Data to sign
kid: string Key ID

IMessage

DIDComm message

createdAt: string Optional. Creation date (ISO 8601)
credentials: VerifiableCredential [] Optional. Array of attached verifiable credentials
data: object | null Optional. Parsed data
expiresAt: string Optional. Expiration date (ISO 8601)
from:string Optional. Sender DID
id:string Unique message ID
metaData:IMetaData [] | null Optional. Array of message metadata
presentations:VerifiablePresentation [] Optional. Array of attached verifiable presentations
raw:string Optional. Original message raw data
replyTo:string[] Optional. List of DIDs to reply to
replyUrl:string Optional. URL to post a reply message to
threadId:string Optional. Thread ID
to:string Optional. Recipient DID
type:string Message type

IMessageHandler

Message handler interface

handleMessage(args, context) Parses and optionally saves a message args: IHandleMessageArgs context: IAgentContext
Returns: Promise

IMetaData

Message meta data

type: string Type
value: string Optional. Value

IPluginMethod

Agent plugin method interface

IPluginMethodMap

Plugin method map interface

IResolver

DID Resolver interface

getDIDComponentById(args) (BETA) Dereferences a DID URL fragment and returns the corresponding DID document entry. args: GetDIDComponentArgs

Returns: Promise Example

const did = 'did:ethr:rinkeby:[xxx]'
const didFragment = `${did}#controller`
const fragment = await agent.getDIDComponentById({
    didDocument: (await agent.resolveDid({ didUrl: did }))?.didDocument,
    didUrl: didFragment,
    section: 'authentication',
    })
expect(fragment).toEqual({
    id: 'did:ethr:rinkeby:[]',
    type: 'EcdsaSecp256k1RecoveryMethod2020',
    controller: 'did:ethr:rinkeby:[]',
    blockchainAccountId: '[]',
})

resolveDid(args) Resolves DID and returns DID Resolution Result args: ResolveDidArgs Input arguments for resolving a DID

Exmaple

const doc = await agent.resolveDid({
    didUrl: 'did:ethr:rinkeby:[]',
})
expect(doc.didDocument).toEqual({
    '@context': [
    'https://www.w3.org/ns/did/v1',
    'https://identity.foundation/EcdsaSecp256k1RecoverySignature2020/lds-ecdsa-secp256k1-recovery2020-0.0.jsonld',
    ],
    id: 'did:ethr:rinkeby:[]',
    verificationMethod: [
        {
            id: 'did:ethr:rinkeby:[]#controller',
            type: 'EcdsaSecp256k1RecoveryMethod2020',
            controller: 'did:ethr:rinkeby:[]',
            blockchainAccountId: '[]',
         },
    ],
    authentication: ['did:ethr:rinkeby:[]#controller'],
    assertionMethod: ['did:ethr:rinkeby:[]#controller'],
})

### IService	
Identifier service

> Properties

- description: string	
    Optional. Description
- id:string	
    ID
- serviceEndpoint:string	
    Endpoint URL
- type: string	
    Service type

### KeyMetadata	

> Properties

- algorithms:string[]

### RemoveContext	
Removes context parameter from plugin method interface


### ResolveDidArgs	
Input arguments for resolveDid

> Properties

- didUrl: string
    DID URL
- options: DIDResolutionOptions
    DID resolution options that will be passed to the method specific resolver. See: https://w3c.github.io/did-spec-registries/\#did-resolution-input-metadata See: https://www.w3.org/TR/did-core/\#did-resolution-options

### VerifiableCredential	
Verifiable Credential https://github.com/decentralized-identifier/did-jwt-vc


> Properties

- "@context" :string[]
- crendentialStatus: {id: string; type: string; }
- credentialSubject: {id?: string; [x: string]: ant;}
- expirationDate: string
- id: string
- issuanceDate: string
- issuer: {id: string; [x: string]: any;}
- proof: { type?: string; [x: string]: any;}
- type: string[]


### VerifiablePresentation	
Verifiable Presentation https://github.com/decentralized-identifier/did-jwt-vc


> Properties

- "@context" :string[]
- expirationDate: string
- holder:string
- id: string
- issuanceDate: string
- proof: {type?:string; [x: string]: any;}
- type: string[]
- verifibaleCredential: VerifiableCredential[]
- verifier: string[]


### W3CCredential	
W3CCredential https://github.com/decentralized-identifier/did-jwt-vc

> Properties

- "@context" :string[]
- crendentialStatus: {id: string; type: string; }
- credentialSubject: {id?: string; [x: string]: ant;}
- expirationDate: string
- id: string
- issuanceDate: string
- issuer: {id: string; [x: string]: any;}
- type: string[]

### W3CPresentation	
W3CPresentation https://github.com/decentralized-identifier/did-jwt-vc

> Properties

- "@context" :string[]
- expirationData: string
- holder: string
- id: string
- issuanceDate: string
- type: string[]
- verifiableCredential: VerifiableCredential[]
- verifier: string[]


## Variables
 - CoreEvents	
    This collection defines the core event types.
    ```json
    CoreEvents: {
        error: string
        warning: string
    }

 - Schema<any>	

## Type Aliases

### DIDDocComponent	
(BETA) Return type of getDIDComponentById represents a VerificationMethod or a ServiceEndpoint entry.

```js
export declare type DIDDocComponent = VerificationMethod | ServiceEndpoint
``


### DIDDocumentSection	

```js
export declare type DIDDocumentSection =
  | 'verificationMethod'
  | 'publicKey'
  | 'service'
  | 'authentication'
  | 'assertionMethod'
  | 'keyAgreement'
  | 'capabilityInvocation'
  | 'capabilityDelegation'

ManagedKeyInfo

Represents information about a managed key. Private or secret key material is not present.

export declare type ManagedKeyInfo = Omit<IKey, 'privateKeyHex'>

MinimalImportableIdentifier

Represents the minimum amount of information needed to import an IIdentifier

export declare type MinimalImportableIdentifier = {
  keys: MinimalImportableKey[]
  services?: IService[]
} & Omit<IIdentifier, 'keys' | 'services'>

MinimalImportableKey

Represents the properties required to import a key.

export declare type MinimalImportableKey = RequireOnly<IKey, 'privateKeyHex' | 'type' | 'kms'>

RequireOnly

Represents an object type where a subset of keys are required and everything else is optional.

export declare type RequireOnly<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>

TAgent

Utility type for constructing agent type that has a list of available methods

export declare type TAgent<T extends IPluginMethodMap> = {
  [P in keyof T]: RemoveContext<T[P]>
} & IAgent

TKeyType

Cryptographic key type

export declare type TKeyType = 'Ed25519' | 'Secp256k1' | 'X25519'