@sphereon/ssi-sdk.ebsi-support 0.34.1-fix.79 → 0.34.1-next.278

package/dist/index.d.ts

@@ -1,19 +1,21 @@
 import * as _sphereon_ssi_types from '@sphereon/ssi-types';
-import { W3CVerifiableCredential, PresentationSubmission } from '@sphereon/ssi-types';
-import { IIdentifier, MinimalImportableKey, TKeyType, IService, IKey, IAgentContext, IKeyManager, IDIDManager, IPluginMethodMap, IResolver, IAgentPlugin } from '@veramo/core';
+import { W3CVerifiableCredential, CredentialRole, PresentationSubmission } from '@sphereon/ssi-types';
+import { IIdentifier, MinimalImportableKey, TKeyType, IService, IAgentContext, IKeyManager, IKey, IDIDManager, IPluginMethodMap, IResolver, IAgentPlugin } from '@veramo/core';
 import { DiscoveryMetadataPayload, JWK } from '@sphereon/did-auth-siop';
 import { RequestObjectOpts, OID4VCICredentialFormat } from '@sphereon/oid4vci-common';
 import { PresentationDefinitionV2, Format } from '@sphereon/pex-models';
 import { ManagedIdentifierDidResult, IIdentifierResolution, ManagedIdentifierDidOpts } from '@sphereon/ssi-sdk-ext.identifier-resolution';
 import { IJwtService } from '@sphereon/ssi-sdk-ext.jwt-service';
-import { CredentialRole, Party, IBasicCredentialLocaleBranding } from '@sphereon/ssi-sdk.data-store';
+import { Party, IBasicCredentialLocaleBranding } from '@sphereon/ssi-sdk.data-store-types';
 import { PrepareStartArgs, IssuanceOpts, IOID4VCIHolder, ErrorDetails, MappedCredentialToAccept } from '@sphereon/ssi-sdk.oid4vci-holder';
 import { IPresentationExchange } from '@sphereon/ssi-sdk.presentation-exchange';
 import { IDidAuthSiopOpAuthenticator } from '@sphereon/ssi-sdk.siopv2-oid4vp-op-auth';
 import { _ExtendedIKey } from '@veramo/utils';
-import { DIDDocument } from 'did-resolver';
+import { DIDDocument, DIDResolver } from 'did-resolver';
+import { BigNumberish, BytesLike, AccessListish } from 'ethers';
 import { AbstractIdentifierProvider } from '@veramo/did-manager';
 
+type IContext = IAgentContext<IKeyManager>;
 /**
  * The type of the DID to be created
  * @readonly
@@ -42,6 +44,7 @@ interface EbsiDidSpecInfo {
     didLength?: number;
     privateKeyLength?: number;
 }
+declare const EBSI_DID_SPEC_INFOS: Record<string, EbsiDidSpecInfo>;
 /**
  * A minimal importable key with restricted types to choose from and purposes of the public key
  * @typedef IKeyOpts
@@ -56,6 +59,14 @@ interface IKeyOpts extends WithRequiredProperty<Partial<MinimalImportableKey>, '
 type WithRequiredProperty<Type, Key extends keyof Type> = Type & {
     [Property in Key]-?: Type[Property];
 };
+type RpcMethodArgs = {
+    params: RPCParams[];
+    rpcId: number;
+    accessToken: string;
+    rpcMethod: EbsiRpcMethod;
+    apiOpts?: ApiOpts;
+    doNotThrowErrors?: boolean;
+};
 type EbsiCreateIdentifierOpts = {
     methodSpecificId?: string;
     rpcId?: number;
@@ -102,6 +113,36 @@ declare enum EbsiPublicKeyPurpose {
     AssertionMethod = "assertionMethod",
     CapabilityInvocation = "capabilityInvocation"
 }
+/**
+ * @typedef InsertDidDocumentParams
+ * @type {object}
+ * @property {string} from - Ethereum address of the signer
+ * @property {string} did - DID to insert. It must be for a legal entity (DID v1)
+ * @property {string} BASE_CONTEXT_DOC - JSON string containing the @context of the DID document
+ * @property {string} vMethodId - Thumbprint of the public key
+ * @property {string} publicKey - Public key for secp256k1 in uncompressed format prefixed with "0x04"
+ * @property {boolean} isSecp256k1 -  It must be true
+ * @property {number} notBefore - Capability invocation is valid from this time
+ * @property {number} notAfter - Expiration of the capability invocation
+ */
+type InsertDidDocumentParams = {
+    from: string;
+    did: string;
+    baseDocument: string;
+    vMethodId: string;
+    publicKey: string;
+    isSecp256k1: boolean;
+    notBefore: number;
+    notAfter: number;
+};
+/**
+ * @typedef UpdateBaseDocumentParams
+ * @type {object}
+ * @property {string} from - Ethereum address of the signer
+ * @property {string} did - Existing DID
+ * @property {string} BASE_CONTEXT_DOC - JSON string containing the @context of the DID document
+ */
+type UpdateBaseDocumentParams = Pick<InsertDidDocumentParams, 'from' | 'did' | 'baseDocument'>;
 /**
  * @typedef UpdateIdentifierParams
  * @type {object}
@@ -116,6 +157,79 @@ type UpdateIdentifierParams = {
         [p: string]: any;
     };
 };
+type AddServiceParams = {
+    from: string;
+    did: string;
+    service: IService;
+};
+/**
+ * @typedef AddVerificationMethodParams
+ * @type {object}
+ * @property {string} from - Ethereum address of the signer
+ * @property {string} did - Existing DID
+ * @property {string} vMethodId - New verification method id
+ * @property {boolean} isSecp256k1 - Boolean defining if the public key is for secp256k1 curve or not
+ * @property {string} publicKey - Public key as hex string. For an ES256K key, it must be in uncompressed format
+ * prefixed with "0x04". For other algorithms, it must be the JWK transformed to string and then to hex format.
+ */
+type AddVerificationMethodParams = Pick<InsertDidDocumentParams, 'from' | 'did' | 'vMethodId' | 'isSecp256k1' | 'publicKey'>;
+/**
+ * @typedef AddVerificationMethodRelationshipParams
+ * @type {object}
+ * @property {string} from - Ethereum address of the signer
+ * @property {string} did -  Existing DID
+ * @property {string} name - Name of the verification relationship
+ * @property {string} vMethodId - Reference to the verification method
+ * @property {number} notBefore - Verification relationship is valid from this time
+ * @property {number} notAfter - Expiration of the verification relationship
+ */
+type AddVerificationMethodRelationshipParams = Pick<InsertDidDocumentParams, 'from' | 'did' | 'vMethodId' | 'notBefore' | 'notAfter'> & {
+    name: string;
+};
+/**
+ * @typedef UnsignedTransaction
+ * @type {object}
+ * @property {string} from -  The sending address.
+ * @property {string} to - The receiving address (if EOA, the transaction will transfer value. If a smart contract
+ * account, the transaction will use contract code).
+ * @property {string} data - Can contain code or a message to the recipient.
+ * @property {string} nonce - A number used to track ordering of transactions and prevent replay attacks
+ * @property {string} chainId - The Ethereum Network ID (ex: 1 - Ethereum Mainnet).
+ * @property {string} gasLimit - The maximum amount of gas units that can be used.
+ * @property {string} gasPrice - Gas price provided by the sender in Wei.
+ * @property {string} value - The amount of ETH to be sent from the sending address (denominated in Wei)
+ */
+type UnsignedTransaction = {
+    to?: string;
+    nonce?: number;
+    gasLimit?: BigNumberish;
+    gasPrice?: BigNumberish;
+    data?: BytesLike;
+    value?: BigNumberish;
+    chainId?: number;
+    type?: number | null;
+    accessList?: AccessListish;
+    maxPriorityFeePerGas?: BigNumberish;
+    maxFeePerGas?: BigNumberish;
+};
+/**
+ * @typedef SendSignedTransactionParams
+ * @type {object}
+ * @property {string} protocol - Example: eth
+ * @property {UnsignedTransaction} unsignedTransaction - The unsigned transaction
+ * @property {string} r - ECDSA signature r
+ * @property {string} s - ECDSA signature s
+ * @property {string} v - ECDSA recovery id
+ * @property {string} signedRawTransaction - The signed raw transaction
+ */
+type SendSignedTransactionParams = {
+    protocol: string;
+    unsignedTransaction: UnsignedTransaction;
+    r: string;
+    s: string;
+    v: string;
+    signedRawTransaction: string;
+};
 /**
  * @typedef RpcOkResponse
  * @type {object}
@@ -136,6 +250,93 @@ type RpcErrorResponse = {
         message: string;
     };
 };
+/**
+ * @typedef ResponseNot200
+ * @type {object}
+ * @property {URL | string} type - An absolute URI that identifies the problem type. When dereferenced,
+ * it SHOULD provide human-readable documentation for the problem type.
+ * @property {string} title - A short summary of the problem type.
+ * @property {number} status - The HTTP status code generated by the origin server for this occurrence of the problem.
+ * @property {string} detail - A human-readable explanation specific to this occurrence of the problem.
+ * @property {URL | string} instance An absolute URI that identifies the specific occurrence of the problem.
+ * It may or may not yield further information if dereferenced.
+ */
+type ResponseNot200 = {
+    type: URL | string;
+    id?: number;
+    title: string;
+    error?: {
+        code: number;
+        message: string;
+    };
+    status: number;
+    detail: string;
+    instance: URL | string;
+};
+/**
+ * @typedef GetDidDocumentParams
+ * @type {object}
+ * @property {string} did
+ * @property {string} validAt
+ */
+type GetDidDocumentParams = {
+    did: string;
+    validAt?: string;
+};
+/**
+ * @typedef GetDidDocumentsParams
+ * @type {object}
+ * @property {string} offset Originally page[after] Cursor that points to the end of the page of data that has been returned.
+ * @property {number} size Originally page[size] Defines the maximum number of objects that may be returned.
+ * @property {string} controller Filter by controller DID.
+ */
+type GetDidDocumentsParams = {
+    offset?: string;
+    size?: number;
+    controller?: string;
+};
+/**
+ * Result of listing dids
+ * @typedef {Item}
+ * @type {object}
+ * @property {string} did - The DID
+ * @property {string} href - The referrer of the DID
+ */
+type Item = {
+    did: string;
+    href: string;
+};
+/**
+ * The links related to pagination
+ * @typedef Links
+ * @type {object}
+ * @property {string} first - The link to the first page
+ * @property {string} prev - The link ot the previous page
+ * @property {string} next - The link to the next page
+ * @property {string} last - The link to the last page
+ */
+type Links = {
+    first: string;
+    prev: string;
+    next: string;
+    last: string;
+};
+/**
+ * @typedef GetDidDocumentResponse
+ * @type {object}
+ * @property {string} self - Absolute path to the collection (consult)
+ * @property {Item[]} items - List of DIDs and their referrers
+ * @property {number} total - Total number of items across all pages.
+ * @property {pageSize} number - Maximum number of items per page. For the last page, its value should be independent of the number of actually returned items.
+ * @property {Links} links - The links related to pagination
+ */
+type GetDidDocumentsResponse = {
+    self: string;
+    items: Item[];
+    total: number;
+    pageSize: number;
+    links: Links;
+};
 type EbsiAccessTokenOpts = {
     attestationToOnboard?: W3CVerifiableCredential;
     attestationToOnboardCredentialRole: CredentialRole;
@@ -173,6 +374,32 @@ interface CreateEbsiDidOnLedgerResult {
     addAssertionMethodRelationship: EbsiRPCResponse;
     addAuthenticationRelationship: EbsiRPCResponse;
 }
+/**
+ * @constant JSON_RPC_VERSION
+ */
+declare const JSON_RPC_VERSION = "2.0";
+/**
+ * @constant BASE_CONTEXT_DOC
+ */
+declare const BASE_CONTEXT_DOC: string;
+interface EbsiDidRegistryAPIEndpoints {
+    mutate: string;
+    query: string;
+}
+/**
+ * The EBSI RPC operations
+ * @readonly
+ * @enum {string}
+ */
+declare enum EbsiRpcMethod {
+    INSERT_DID_DOCUMENT = "insertDidDocument",
+    UPDATE_DID_DOCUMENT = "updateBaseDocument",
+    ADD_VERIFICATION_METHOD = "addVerificationMethod",
+    ADD_VERIFICATION_RELATIONSHIP = "addVerificationRelationship",
+    ADD_SERVICE = "addService",
+    SEND_SIGNED_TRANSACTION = "sendSignedTransaction"
+}
+type RPCParams = InsertDidDocumentParams | UpdateBaseDocumentParams | AddVerificationMethodParams | AddVerificationMethodRelationshipParams | SendSignedTransactionParams | AddServiceParams;
 type EbsiRPCResponse = RpcOkResponse | (RpcErrorResponse & {
     nonce: string;
 });
@@ -219,6 +446,101 @@ declare class EbsiDidProvider extends AbstractIdentifierProvider {
     updateIdentifier(args: UpdateIdentifierParams, context: IAgentContext<IKeyManager & IDIDManager>): Promise<IIdentifier>;
 }
 
+declare function getDidEbsiResolver(): {
+    key: DIDResolver;
+};
+
+declare function generateEbsiMethodSpecificId(specInfo?: EbsiDidSpecInfo): string;
+declare function generateOrUseProvidedEbsiPrivateKeyHex(specInfo?: EbsiDidSpecInfo, privateKeyBytes?: Uint8Array): string;
+/**
+ * Returns the public key in the correct format to be used with the did registry v5
+ * - in case of Secp256k1 - returns the uncompressed public key as hex string prefixed with 0x04
+ * - in case of Secp256r1 - returns the jwk public key as hex string
+ * @param {{ key: IKey, type: EbsiKeyType }} args
+ *  - key is the cryptographic key containing the public key
+ *  - type is the type of the key which can be Secp256k1 or Secp256r1
+ *  @returns {string} The properly formatted public key
+ *  @throws {Error} If the key type is invalid
+ */
+declare const formatEbsiPublicKey: (args: {
+    key: IKey;
+    type: TKeyType;
+}) => string;
+declare const ebsiGetIssuerMock: (args: {
+    environment?: EbsiEnvironment;
+    version?: EbsiApiVersion;
+}) => string;
+declare const ebsiGetAuthorisationServer: (args: {
+    environment?: EbsiEnvironment;
+    version?: EbsiApiVersion;
+}) => string;
+declare const ebsiGetRegistryAPIUrls: (args: {
+    environment?: EbsiEnvironment;
+    version?: EbsiApiVersion;
+}) => EbsiDidRegistryAPIEndpoints;
+declare const determineWellknownEndpoint: ({ environment, version, type, system, mock }: WellknownOpts) => string;
+declare const ebsiSignAndSendTransaction: (args: {
+    rpcRequest: RpcMethodArgs;
+    previousTxResponse?: EbsiRPCResponse;
+    kid: string;
+    accessToken: string;
+    apiOpts?: ApiOpts;
+}, context: IContext) => Promise<EbsiRPCResponse>;
+declare const ebsiGenerateOrUseKeyPair: (args: {
+    keyOpts?: IKeyOpts;
+    keyType: EbsiKeyType;
+    kms: string;
+    controllerKey?: boolean;
+}, context: IAgentContext<IKeyManager>) => Promise<MinimalImportableKey>;
+declare const toMinimalImportableKey: (args: {
+    key?: IKeyOpts;
+    type: EbsiKeyType;
+    kms: string;
+}) => Promise<MinimalImportableKey>;
+declare const assertedPurposes: (args: {
+    key?: IKeyOpts;
+}) => EbsiPublicKeyPurpose[] | undefined;
+declare const setPurposes: (args: {
+    key?: IKeyOpts;
+    type: EbsiKeyType;
+}) => EbsiPublicKeyPurpose[];
+declare const randomRpcId: () => number;
+declare const ebsiCreateDidOnLedger: (args: CreateEbsiDidParams, context: IRequiredContext) => Promise<CreateEbsiDidOnLedgerResult>;
+
+/**
+ * Gets the DID document corresponding to the DID.
+ * @param {{ params: GetDidDocumentParams, apiOpts?: ApiOpts }} args
+ * @returns a did document
+ */
+declare const ebsiGetDidDocument: (args: {
+    params: GetDidDocumentParams;
+    apiOpts?: ApiOpts;
+}) => Promise<DIDDocument>;
+/**
+ * Wait up to the number of MS for a DID Document or Verification methods and relationships to be registered. This is needed, as the EBSI blockchain does not directly propagate across all nodes, since it needs to mine for consensus first
+ * @param args
+ */
+declare const ebsiWaitTillDocumentAnchored: (args: GetDidDocumentParams & ApiOpts & {
+    startIntervalMS?: number;
+    minIntervalMS?: number;
+    decreaseIntervalMSPerStep?: number;
+    maxWaitTime?: number;
+    searchForObject?: Record<string, any>;
+}) => Promise<{
+    totalWaitTime: number;
+    count: number;
+    didDocument: DIDDocument | undefined;
+}>;
+/**
+ * listDidDocuments - Returns a list of identifiers.
+ * @param {{ params: GetDidDocumentsParams; apiOpts?: ApiOpts }} args
+ * @returns a list of identifiers
+ */
+declare const ebsiListDidDocuments: (args: {
+    params: GetDidDocumentsParams;
+    apiOpts?: ApiOpts;
+}) => Promise<GetDidDocumentsResponse>;
+
 interface AttestationAuthRequestUrlResult extends Omit<Required<PrepareStartArgs>, 'issuanceOpt'> {
     issuanceOpt?: IssuanceOpts;
     authorizationCodeURL: string;
@@ -443,4 +765,4 @@ declare class EbsiSupport implements IAgentPlugin {
 declare const logger: _sphereon_ssi_types.ISimpleLogger<unknown>;
 declare const schema: any;
 
-export { type ApiOpts, type AttestationResult, type CreateAttestationAuthRequestURLArgs, type EBSIAuthAccessTokenGetArgs, type EBSIScope, type EbsiApiVersion, EbsiDidProvider, type EbsiEnvironment, type EbsiMock, type EbsiOpenIDMetadata, EbsiSupport, type EbsiSystem, type ExceptionResponse, type GetAccessTokenArgs, type GetAccessTokenResponse, type GetAccessTokenResult, type GetAccessTokenSuccessResponse, type GetAttestationArgs, type GetOIDProviderJwksResponse, type GetOIDProviderJwksSuccessResponse, type GetOIDProviderMetadataResponse, type GetPresentationDefinitionArgs, type GetPresentationDefinitionResponse, type GetPresentationDefinitionSuccessResponse, type IEbsiSupport, type IRequiredContext, TokenType, type WellknownOpts, type WellknownType, ebsiSupportMethods, logger, schema };
+export { type AddServiceParams, type AddVerificationMethodParams, type AddVerificationMethodRelationshipParams, type ApiOpts, type AttestationResult, BASE_CONTEXT_DOC, type CreateAttestationAuthRequestURLArgs, type CreateEbsiDidOnLedgerResult, type CreateEbsiDidParams, type EBSIAuthAccessTokenGetArgs, type EBSIScope, EBSI_DID_SPEC_INFOS, type EbsiAccessTokenOpts, type EbsiApiVersion, type EbsiCreateIdentifierOpts, type EbsiDIDPrefix, type EbsiDIDType, EbsiDidProvider, type EbsiDidRegistryAPIEndpoints, type EbsiDidSpecInfo, type EbsiEnvironment, type EbsiKeyType, type EbsiMock, type EbsiOpenIDMetadata, EbsiPublicKeyPurpose, type EbsiRPCResponse, EbsiRpcMethod, EbsiSupport, type EbsiSystem, type ExceptionResponse, type GetAccessTokenArgs, type GetAccessTokenResponse, type GetAccessTokenResult, type GetAccessTokenSuccessResponse, type GetAttestationArgs, type GetDidDocumentParams, type GetDidDocumentsParams, type GetDidDocumentsResponse, type GetOIDProviderJwksResponse, type GetOIDProviderJwksSuccessResponse, type GetOIDProviderMetadataResponse, type GetPresentationDefinitionArgs, type GetPresentationDefinitionResponse, type GetPresentationDefinitionSuccessResponse, type IContext, type ICreateIdentifierArgs, type IEbsiSupport, type IKeyOpts, type IRequiredContext, type InsertDidDocumentParams, type Item, JSON_RPC_VERSION, type Links, type RPCParams, type ResponseNot200, type RpcErrorResponse, type RpcMethodArgs, type RpcOkResponse, type SendSignedTransactionParams, TokenType, type UnsignedTransaction, type UpdateBaseDocumentParams, type UpdateIdentifierParams, type WellknownOpts, type WellknownType, assertedPurposes, determineWellknownEndpoint, ebsiCreateDidOnLedger, ebsiGenerateOrUseKeyPair, ebsiGetAuthorisationServer, ebsiGetDidDocument, ebsiGetIssuerMock, ebsiGetRegistryAPIUrls, ebsiListDidDocuments, ebsiSignAndSendTransaction, ebsiSupportMethods, ebsiWaitTillDocumentAnchored, formatEbsiPublicKey, generateEbsiMethodSpecificId, generateOrUseProvidedEbsiPrivateKeyHex, getDidEbsiResolver, logger, randomRpcId, schema, setPurposes, toMinimalImportableKey };

package/dist/index.js

@@ -356,7 +356,7 @@ var require_plugin_schema = __commonJS({
                 di_vp: {
                   $ref: "#/components/schemas/DiObject"
                 },
-                "vc+sd-jwt": {
+                "dc+sd-jwt": {
                   $ref: "#/components/schemas/SdJwtObject"
                 }
               }
@@ -2066,13 +2066,14 @@ import { getAuthenticationKey, SupportedDidMethodEnum } from "@sphereon/ssi-sdk-
 import { calculateJwkThumbprintForKey, signatureAlgorithmFromKey } from "@sphereon/ssi-sdk-ext.key-utils";
 import { OID4VCICallbackStateListener, OID4VCIMachineStates, signCallback } from "@sphereon/ssi-sdk.oid4vci-holder";
 import { OID4VPCallbackStateListener, Siopv2MachineStates, Siopv2OID4VPLinkHandler } from "@sphereon/ssi-sdk.siopv2-oid4vp-op-auth";
-import { waitFor } from "xstate/lib/waitFor";
+import { waitFor } from "xstate/lib/waitFor.js";
 
 // src/functions/AttestationHeadlessCallbacks.ts
 import { decodeUriAsJson } from "@sphereon/did-auth-siop";
 import { getIssuerName } from "@sphereon/oid4vci-common";
-import { ConnectionType, CorrelationIdentifierType, CredentialRole, IdentityOrigin, PartyOrigin, PartyTypeType } from "@sphereon/ssi-sdk.data-store";
+import { ConnectionType, CorrelationIdentifierType, IdentityOrigin, PartyOrigin, PartyTypeType } from "@sphereon/ssi-sdk.data-store-types";
 import { OID4VCIMachineEvents } from "@sphereon/ssi-sdk.oid4vci-holder";
+import { CredentialRole } from "@sphereon/ssi-types";
 import fetch from "cross-fetch";
 var addContactCallback = /* @__PURE__ */ __name((context) => {
   return async (oid4vciMachine, state) => {
@@ -2536,6 +2537,24 @@ var ebsiWaitTillDocumentAnchored = /* @__PURE__ */ __name(async (args) => {
     count
   };
 }, "ebsiWaitTillDocumentAnchored");
+var ebsiListDidDocuments = /* @__PURE__ */ __name(async (args) => {
+  const { params, apiOpts } = args;
+  const { offset, size, controller } = params;
+  const queryParams = [];
+  if (offset) {
+    queryParams.push(`page[after]=${offset}`);
+  }
+  if (size) {
+    queryParams.push(`page[size]=${size}`);
+  }
+  if (controller) {
+    queryParams.push(`controller=${controller}`);
+  }
+  const query = `?${queryParams.filter(Boolean).join("&")}`;
+  return await (await fetch2(`${ebsiGetRegistryAPIUrls({
+    ...apiOpts
+  }).query}/${query}`)).json();
+}, "ebsiListDidDocuments");
 
 // src/did/services/EbsiRPCService.ts
 import fetch3 from "cross-fetch";
@@ -2554,12 +2573,12 @@ var EBSI_DID_SPEC_INFOS = {
     method: "did:key:"
   }
 };
-var EbsiPublicKeyPurpose = /* @__PURE__ */ function(EbsiPublicKeyPurpose2) {
+var EbsiPublicKeyPurpose = /* @__PURE__ */ (function(EbsiPublicKeyPurpose2) {
   EbsiPublicKeyPurpose2["Authentication"] = "authentication";
   EbsiPublicKeyPurpose2["AssertionMethod"] = "assertionMethod";
   EbsiPublicKeyPurpose2["CapabilityInvocation"] = "capabilityInvocation";
   return EbsiPublicKeyPurpose2;
-}({});
+})({});
 var JSON_RPC_VERSION = "2.0";
 var BASE_CONTEXT_DOC = JSON.stringify({
   "@context": [
@@ -2567,7 +2586,7 @@ var BASE_CONTEXT_DOC = JSON.stringify({
     "https://w3id.org/security/suites/jws-2020/v1"
   ]
 });
-var EbsiRpcMethod = /* @__PURE__ */ function(EbsiRpcMethod2) {
+var EbsiRpcMethod = /* @__PURE__ */ (function(EbsiRpcMethod2) {
   EbsiRpcMethod2["INSERT_DID_DOCUMENT"] = "insertDidDocument";
   EbsiRpcMethod2["UPDATE_DID_DOCUMENT"] = "updateBaseDocument";
   EbsiRpcMethod2["ADD_VERIFICATION_METHOD"] = "addVerificationMethod";
@@ -2575,7 +2594,7 @@ var EbsiRpcMethod = /* @__PURE__ */ function(EbsiRpcMethod2) {
   EbsiRpcMethod2["ADD_SERVICE"] = "addService";
   EbsiRpcMethod2["SEND_SIGNED_TRANSACTION"] = "sendSignedTransaction";
   return EbsiRpcMethod2;
-}({});
+})({});
 
 // src/did/services/EbsiRPCService.ts
 var callRpcMethod = /* @__PURE__ */ __name(async (args) => {
@@ -2693,6 +2712,14 @@ var ebsiGetIssuerMock = /* @__PURE__ */ __name((args) => {
     system: environment
   })}/issuer-mock`;
 }, "ebsiGetIssuerMock");
+var ebsiGetAuthorisationServer = /* @__PURE__ */ __name((args) => {
+  const { environment = "pilot", version = "v4" } = args;
+  return `${getEbsiApiBaseUrl({
+    environment,
+    version,
+    system: "authorisation"
+  })}`;
+}, "ebsiGetAuthorisationServer");
 var ebsiGetRegistryAPIUrls = /* @__PURE__ */ __name((args) => {
   const { environment = "pilot", version = "v5" } = args;
   const baseUrl = `${getEbsiApiBaseUrl({
@@ -2806,7 +2833,7 @@ var toMinimalImportableKey = /* @__PURE__ */ __name(async (args) => {
   minimalImportableKey.meta = {
     purposes: assertedPurposes({
       key
-    }) ?? setDefaultPurposes({
+    }) ?? setPurposes({
       key,
       type
     }),
@@ -2842,7 +2869,7 @@ var assertedPurposes = /* @__PURE__ */ __name((args) => {
   }
   return key?.purposes;
 }, "assertedPurposes");
-var setDefaultPurposes = /* @__PURE__ */ __name((args) => {
+var setPurposes = /* @__PURE__ */ __name((args) => {
   const { key, type } = args;
   if (!key?.purposes || key.purposes.length === 0) {
     switch (type) {
@@ -2860,7 +2887,7 @@ var setDefaultPurposes = /* @__PURE__ */ __name((args) => {
     }
   }
   return key.purposes;
-}, "setDefaultPurposes");
+}, "setPurposes");
 var randomRpcId = /* @__PURE__ */ __name(() => {
   return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
 }, "randomRpcId");
@@ -3296,10 +3323,10 @@ ${JSON.stringify(accessTokenResponse)}`);
 };
 
 // src/types/IEbsiSupport.ts
-var TokenType = /* @__PURE__ */ function(TokenType2) {
+var TokenType = /* @__PURE__ */ (function(TokenType2) {
   TokenType2["BEARER"] = "Bearer";
   return TokenType2;
-}({});
+})({});
 
 // src/did/EbsiDidProvider.ts
 import { getControllerKey as getControllerKey2, getEthereumAddressFromKey as getEthereumAddressFromKey2 } from "@sphereon/ssi-sdk-ext.did-utils";
@@ -3510,6 +3537,18 @@ var EbsiDidProvider = class _EbsiDidProvider extends AbstractIdentifierProvider
 // src/did/EbsiDidResolver.ts
 import { Resolver } from "did-resolver";
 import { getResolver } from "@sphereon/ssi-sdk-ext.did-resolver-ebsi";
+var resolveDidEbsi = /* @__PURE__ */ __name(async (didUrl, _parsed, _resolver, options) => {
+  const resolver = new Resolver({
+    ...getResolver()
+  });
+  return resolver.resolve(didUrl, options);
+}, "resolveDidEbsi");
+function getDidEbsiResolver() {
+  return {
+    key: resolveDidEbsi
+  };
+}
+__name(getDidEbsiResolver, "getDidEbsiResolver");
 
 // src/index.ts
 var logger = Loggers.DEFAULT.options("sphereon:ebsi-support", {
@@ -3521,11 +3560,34 @@ var logger = Loggers.DEFAULT.options("sphereon:ebsi-support", {
 }).get("sphereon:ebsi-support");
 var schema = require_plugin_schema();
 export {
+  BASE_CONTEXT_DOC,
+  EBSI_DID_SPEC_INFOS,
   EbsiDidProvider,
+  EbsiPublicKeyPurpose,
+  EbsiRpcMethod,
   EbsiSupport,
+  JSON_RPC_VERSION,
   TokenType,
+  assertedPurposes,
+  determineWellknownEndpoint,
+  ebsiCreateDidOnLedger,
+  ebsiGenerateOrUseKeyPair,
+  ebsiGetAuthorisationServer,
+  ebsiGetDidDocument,
+  ebsiGetIssuerMock,
+  ebsiGetRegistryAPIUrls,
+  ebsiListDidDocuments,
+  ebsiSignAndSendTransaction,
   ebsiSupportMethods,
+  ebsiWaitTillDocumentAnchored,
+  formatEbsiPublicKey,
+  generateEbsiMethodSpecificId,
+  generateOrUseProvidedEbsiPrivateKeyHex,
+  getDidEbsiResolver,
   logger,
-  schema
+  randomRpcId,
+  schema,
+  setPurposes,
+  toMinimalImportableKey
 };
 //# sourceMappingURL=index.js.map