@sphereon/ssi-sdk.siopv2-oid4vp-rp-auth 0.33.1-next.3 → 0.33.1-next.73

package/dist/index.js

@@ -1,26 +1,990 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module) {
+    module.exports = {
+      IDidAuthSiopOpAuthenticator: {
+        components: {
+          schemas: {
+            IGetSiopSessionArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSessionForSiop } "
+            },
+            IRegisterSiopSessionArgs: {
+              type: "object",
+              properties: {
+                identifier: {
+                  type: "object",
+                  properties: {
+                    did: {
+                      type: "string"
+                    },
+                    alias: {
+                      type: "string"
+                    },
+                    provider: {
+                      type: "string"
+                    },
+                    controllerKeyId: {
+                      type: "string"
+                    },
+                    keys: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          additionalProperties: true
+                        }
+                      }
+                    },
+                    services: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          additionalProperties: true
+                        }
+                      }
+                    }
+                  },
+                  additionalProperties: false,
+                  required: ["did", "provider", "keys", "services"]
+                },
+                sessionId: {
+                  type: "string"
+                },
+                expiresIn: {
+                  type: "number"
+                },
+                additionalProperties: false
+              },
+              required: ["identifier"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.registerSessionForSiop } "
+            },
+            IRemoveSiopSessionArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.removeSessionForSiop } "
+            },
+            IAuthenticateWithSiopArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                stateId: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId", "stateId", "redirectUrl"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.authenticateWithSiop } "
+            },
+            IResponse: {
+              type: "object",
+              properties: {
+                status: {
+                  type: "number"
+                },
+                additionalProperties: true
+              },
+              required: ["status"],
+              description: "Result of {@link DidAuthSiopOpAuthenticator.authenticateWithSiop & DidAuthSiopOpAuthenticator.sendSiopAuthenticationResponse } "
+            },
+            IGetSiopAuthenticationRequestFromRpArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                stateId: {
+                  type: "string"
+                },
+                redirectUrl: {
+                  type: "string"
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId", "stateId", "redirectUrl"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestFromRP } "
+            },
+            ParsedAuthenticationRequestURI: {
+              type: "object",
+              properties: {
+                jwt: {
+                  type: "string"
+                },
+                requestPayload: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                registration: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["jwt", "requestPayload", "registration"],
+              description: "Result of {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestFromRP } "
+            },
+            IGetSiopAuthenticationRequestDetailsArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                verifiedAuthenticationRequest: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                credentialFilter: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId", "verifiedAuthenticationRequest"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestDetails } "
+            },
+            IAuthRequestDetails: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                alsoKnownAs: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                vpResponseOpts: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["id", "vpResponseOpts"],
+              description: "Result of {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestDetails } "
+            },
+            IVerifySiopAuthenticationRequestUriArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                ParsedAuthenticationRequestURI: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId", "ParsedAuthenticationRequestURI"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.verifySiopAuthenticationRequestURI } "
+            },
+            VerifiedAuthorizationRequest: {
+              type: "object",
+              properties: {
+                payload: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                presentationDefinitions: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                verifyOpts: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["payload", "verifyOpts"],
+              description: "Result of {@link DidAuthSiopOpAuthenticator.verifySiopAuthenticationRequestURI } "
+            },
+            ISendSiopAuthenticationResponseArgs: {
+              type: "object",
+              properties: {
+                sessionId: {
+                  type: "string"
+                },
+                verifiedAuthenticationRequest: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                verifiablePresentationResponse: {
+                  type: "object",
+                  properties: {
+                    additionalProperties: true
+                  }
+                },
+                additionalProperties: false
+              },
+              required: ["sessionId", "verifiedAuthenticationRequest"],
+              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.sendSiopAuthenticationResponse } "
+            }
+          },
+          methods: {
+            getSessionForSiop: {
+              description: "Get SIOP session",
+              arguments: {
+                $ref: "#/components/schemas/IGetSiopSessionArgs"
+              },
+              returnType: "object"
+            },
+            registerSessionForSiop: {
+              description: "Register SIOP session",
+              arguments: {
+                $ref: "#/components/schemas/IRegisterSiopSessionArgs"
+              },
+              returnType: "object"
+            },
+            removeSessionForSiop: {
+              description: "Remove SIOP session",
+              arguments: {
+                $ref: "#/components/schemas/IRemoveSiopSessionArgs"
+              },
+              returnType: "boolean"
+            },
+            authenticateWithSiop: {
+              description: "Authenticate using DID Auth SIOP",
+              arguments: {
+                $ref: "#/components/schemas/IAuthenticateWithSiopArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/Response"
+              }
+            },
+            getSiopAuthenticationRequestFromRP: {
+              description: "Get authentication request from RP",
+              arguments: {
+                $ref: "#/components/schemas/IGetSiopAuthenticationRequestFromRpArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ParsedAuthenticationRequestURI"
+              }
+            },
+            getSiopAuthenticationRequestDetails: {
+              description: "Get authentication request details",
+              arguments: {
+                $ref: "#/components/schemas/IGetSiopAuthenticationRequestDetailsArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IAuthRequestDetails"
+              }
+            },
+            verifySiopAuthenticationRequestURI: {
+              description: "Verify authentication request URI",
+              arguments: {
+                $ref: "#/components/schemas/IVerifySiopAuthenticationRequestUriArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerifiedAuthorizationRequest"
+              }
+            },
+            sendSiopAuthenticationResponse: {
+              description: "Send authentication response",
+              arguments: {
+                $ref: "#/components/schemas/ISendSiopAuthenticationResponseArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IRequiredContext"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/agent/SIOPv2RP.ts
+import { AuthorizationResponseStateStatus, decodeUriAsJson } from "@sphereon/did-auth-siop";
+import { getAgentResolver as getAgentResolver2 } from "@sphereon/ssi-sdk-ext.did-utils";
+import { CredentialMapper as CredentialMapper2 } from "@sphereon/ssi-types";
+
+// src/functions.ts
+import { InMemoryRPSessionManager, PassBy, PropertyTarget, ResponseMode, ResponseType, RevocationVerification, RP, Scope, SubjectType, SupportedVersion } from "@sphereon/did-auth-siop";
+import { SigningAlgo } from "@sphereon/oid4vc-common";
+import { getAgentDIDMethods, getAgentResolver } from "@sphereon/ssi-sdk-ext.did-utils";
+import { isExternalIdentifierOIDFEntityIdOpts, isManagedIdentifierDidOpts, isManagedIdentifierDidResult, isManagedIdentifierX5cOpts } from "@sphereon/ssi-sdk-ext.identifier-resolution";
+import { CredentialMapper } from "@sphereon/ssi-types";
+import { EventEmitter } from "events";
+import { defaultHasher } from "@sphereon/ssi-sdk.core";
+function getRequestVersion(rpOptions) {
+  if (Array.isArray(rpOptions.supportedVersions) && rpOptions.supportedVersions.length > 0) {
+    return rpOptions.supportedVersions[0];
+  }
+  return SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1;
+}
+__name(getRequestVersion, "getRequestVersion");
+function getWellKnownDIDVerifyCallback(siopIdentifierOpts, context) {
+  return siopIdentifierOpts.wellknownDIDVerifyCallback ? siopIdentifierOpts.wellknownDIDVerifyCallback : async (args) => {
+    const result = await context.agent.cvVerifyCredential({
+      credential: args.credential,
+      fetchRemoteContexts: true
+    });
+    return {
+      verified: result.result
+    };
+  };
+}
+__name(getWellKnownDIDVerifyCallback, "getWellKnownDIDVerifyCallback");
+function getPresentationVerificationCallback(idOpts, context) {
+  async function presentationVerificationCallback(args, presentationSubmission) {
+    if (CredentialMapper.isSdJwtEncoded(args)) {
+      const result2 = await context.agent.verifySdJwtPresentation({
+        presentation: args,
+        kb: true
+      });
+      return {
+        verified: !!result2.payload
+      };
+    }
+    if (CredentialMapper.isMsoMdocOid4VPEncoded(args)) {
+      if (context.agent.mdocOid4vpRPVerify === void 0) {
+        return Promise.reject("ImDLMdoc agent plugin must be enabled to support MsoMdoc types");
+      }
+      if (presentationSubmission !== void 0 && presentationSubmission !== null) {
+        const verifyResult = await context.agent.mdocOid4vpRPVerify({
+          vp_token: args,
+          presentation_submission: presentationSubmission
+        });
+        return {
+          verified: !verifyResult.error
+        };
+      }
+      throw Error(`mdocOid4vpRPVerify(...) method requires a presentation submission`);
+    }
+    const result = await context.agent.verifyPresentation({
+      presentation: args,
+      fetchRemoteContexts: true,
+      domain: (await context.agent.identifierManagedGet(idOpts)).kid?.split("#")[0]
+    });
+    return {
+      verified: result.verified
+    };
+  }
+  __name(presentationVerificationCallback, "presentationVerificationCallback");
+  return presentationVerificationCallback;
+}
+__name(getPresentationVerificationCallback, "getPresentationVerificationCallback");
+async function createRPBuilder(args) {
+  const { rpOpts, pexOpts, context } = args;
+  const { identifierOpts } = rpOpts;
+  let definition = args.definition;
+  let dcqlQuery = args.dcql;
+  if (!definition && pexOpts && pexOpts.definitionId) {
+    const presentationDefinitionItems = await context.agent.pdmGetDefinitions({
+      filter: [
+        {
+          definitionId: pexOpts.definitionId,
+          version: pexOpts.version,
+          tenantId: pexOpts.tenantId
+        }
+      ]
+    });
+    if (presentationDefinitionItems.length > 0) {
+      const presentationDefinitionItem = presentationDefinitionItems[0];
+      definition = presentationDefinitionItem.definitionPayload;
+      if (!dcqlQuery && presentationDefinitionItem.dcqlPayload) {
+        dcqlQuery = presentationDefinitionItem.dcqlPayload;
+      }
+    }
+  }
+  const didMethods = identifierOpts.supportedDIDMethods ?? await getAgentDIDMethods(context);
+  const eventEmitter = rpOpts.eventEmitter ?? new EventEmitter();
+  const defaultClientMetadata = {
+    // FIXME: All of the below should be configurable. Some should come from builder, some should be determined by the agent.
+    // For now it is either preconfigured or everything passed in as a single object
+    idTokenSigningAlgValuesSupported: [
+      SigningAlgo.EDDSA,
+      SigningAlgo.ES256,
+      SigningAlgo.ES256K
+    ],
+    requestObjectSigningAlgValuesSupported: [
+      SigningAlgo.EDDSA,
+      SigningAlgo.ES256,
+      SigningAlgo.ES256K
+    ],
+    responseTypesSupported: [
+      ResponseType.ID_TOKEN
+    ],
+    client_name: "Sphereon",
+    vpFormatsSupported: {
+      jwt_vc: {
+        alg: [
+          "EdDSA",
+          "ES256K"
+        ]
+      },
+      jwt_vp: {
+        alg: [
+          "ES256K",
+          "EdDSA"
+        ]
+      }
+    },
+    scopesSupported: [
+      Scope.OPENID_DIDAUTHN
+    ],
+    subjectTypesSupported: [
+      SubjectType.PAIRWISE
+    ],
+    subject_syntax_types_supported: didMethods.map((method) => `did:${method}`),
+    passBy: PassBy.VALUE
+  };
+  const resolver = rpOpts.identifierOpts.resolveOpts?.resolver ?? getAgentResolver(context, {
+    resolverResolution: true,
+    localResolution: true,
+    uniresolverResolution: rpOpts.identifierOpts.resolveOpts?.noUniversalResolverFallback !== true
+  });
+  let hasher = rpOpts.credentialOpts?.hasher;
+  if (!rpOpts.credentialOpts?.hasher || typeof rpOpts.credentialOpts?.hasher !== "function") {
+    hasher = defaultHasher;
+  }
+  const builder = RP.builder({
+    requestVersion: getRequestVersion(rpOpts)
+  }).withScope("openid", PropertyTarget.REQUEST_OBJECT).withResponseMode(rpOpts.responseMode ?? ResponseMode.POST).withResponseType(ResponseType.VP_TOKEN, PropertyTarget.REQUEST_OBJECT).withSupportedVersions(rpOpts.supportedVersions ?? [
+    SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1,
+    SupportedVersion.SIOPv2_ID1,
+    SupportedVersion.SIOPv2_D11
+  ]).withEventEmitter(eventEmitter).withSessionManager(rpOpts.sessionManager ?? new InMemoryRPSessionManager(eventEmitter)).withClientMetadata(rpOpts.clientMetadataOpts ?? defaultClientMetadata, PropertyTarget.REQUEST_OBJECT).withVerifyJwtCallback(rpOpts.verifyJwtCallback ? rpOpts.verifyJwtCallback : getVerifyJwtCallback({
+    resolver,
+    verifyOpts: {
+      wellknownDIDVerifyCallback: getWellKnownDIDVerifyCallback(rpOpts.identifierOpts, context),
+      checkLinkedDomain: "if_present"
+    }
+  }, context)).withRevocationVerification(RevocationVerification.NEVER).withPresentationVerification(getPresentationVerificationCallback(identifierOpts.idOpts, context));
+  const oidfOpts = identifierOpts.oidfOpts;
+  if (oidfOpts && isExternalIdentifierOIDFEntityIdOpts(oidfOpts)) {
+    builder.withEntityId(oidfOpts.identifier, PropertyTarget.REQUEST_OBJECT).withClientIdScheme("entity_id", PropertyTarget.REQUEST_OBJECT);
+  } else {
+    const resolution = await context.agent.identifierManagedGet(identifierOpts.idOpts);
+    builder.withClientId(resolution.issuer ?? (isManagedIdentifierDidResult(resolution) ? resolution.did : resolution.jwkThumbprint), PropertyTarget.REQUEST_OBJECT).withClientIdScheme(resolution.clientIdScheme ?? identifierOpts.idOpts.clientIdScheme, PropertyTarget.REQUEST_OBJECT);
+  }
+  if (hasher) {
+    builder.withHasher(hasher);
+  }
+  if (definition) {
+    builder.withPresentationDefinition({
+      definition
+    }, PropertyTarget.REQUEST_OBJECT);
+  }
+  if (dcqlQuery) {
+    builder.withDcqlQuery(dcqlQuery);
+  }
+  if (rpOpts.responseRedirectUri) {
+    builder.withResponseRedirectUri(rpOpts.responseRedirectUri);
+  }
+  const createJwtCallback = signCallback(rpOpts.identifierOpts.idOpts, context);
+  builder.withCreateJwtCallback(createJwtCallback);
+  return builder;
+}
+__name(createRPBuilder, "createRPBuilder");
+function signCallback(idOpts, context) {
+  return async (jwtIssuer, jwt, kid) => {
+    if (!(isManagedIdentifierDidOpts(idOpts) || isManagedIdentifierX5cOpts(idOpts))) {
+      return Promise.reject(Error(`JWT issuer method ${jwtIssuer.method} not yet supported`));
+    }
+    const result = await context.agent.jwtCreateJwsCompactSignature({
+      // FIXME fix cose-key inference
+      // @ts-ignore
+      issuer: {
+        identifier: idOpts.identifier,
+        kmsKeyRef: idOpts.kmsKeyRef,
+        noIdentifierInHeader: false
+      },
+      // FIXME fix JWK key_ops
+      // @ts-ignore
+      protectedHeader: jwt.header,
+      payload: jwt.payload
+    });
+    return result.jwt;
+  };
+}
+__name(signCallback, "signCallback");
+function getVerifyJwtCallback(_opts, context) {
+  return async (_jwtVerifier, jwt) => {
+    const result = await context.agent.jwtVerifyJwsSignature({
+      jws: jwt.raw
+    });
+    console.log(result.message);
+    return !result.error;
+  };
+}
+__name(getVerifyJwtCallback, "getVerifyJwtCallback");
+function getSigningAlgo(type) {
+  switch (type) {
+    case "Ed25519":
+      return SigningAlgo.EDDSA;
+    case "Secp256k1":
+      return SigningAlgo.ES256K;
+    case "Secp256r1":
+      return SigningAlgo.ES256;
+    // @ts-ignore
+    case "RSA":
+      return SigningAlgo.RS256;
+    default:
+      throw Error("Key type not yet supported");
+  }
+}
+__name(getSigningAlgo, "getSigningAlgo");
+
+// src/RPInstance.ts
+import { v4 as uuidv4 } from "uuid";
+import { ensureManagedIdentifierResult, isManagedIdentifierDidResult as isManagedIdentifierDidResult2, isManagedIdentifierX5cResult } from "@sphereon/ssi-sdk-ext.identifier-resolution";
+var RPInstance = class {
+  static {
+    __name(this, "RPInstance");
+  }
+  _rp;
+  _pexOptions;
+  _rpOptions;
+  constructor({ rpOpts, pexOpts }) {
+    this._rpOptions = rpOpts;
+    this._pexOptions = pexOpts;
+  }
+  async get(context) {
+    if (!this._rp) {
+      const builder = await createRPBuilder({
+        rpOpts: this._rpOptions,
+        pexOpts: this._pexOptions,
+        context
+      });
+      this._rp = builder.build();
+    }
+    return this._rp;
+  }
+  get rpOptions() {
+    return this._rpOptions;
+  }
+  get pexOptions() {
+    return this._pexOptions;
+  }
+  hasDefinition() {
+    return this.definitionId !== void 0;
+  }
+  get definitionId() {
+    return this.pexOptions?.definitionId;
+  }
+  async getPresentationDefinition(context) {
+    return this.definitionId ? await context.agent.pexStoreGetDefinition({
+      definitionId: this.definitionId,
+      tenantId: this.pexOptions?.tenantId
+    }) : void 0;
+  }
+  async createAuthorizationRequestURI(createArgs, context) {
+    const { correlationId, claims, requestByReferenceURI, responseURI, responseURIType } = createArgs;
+    const nonce = createArgs.nonce ?? uuidv4();
+    const state = createArgs.state ?? correlationId;
+    let jwtIssuer;
+    const idOpts = this.rpOptions.identifierOpts.idOpts;
+    const resolution = await ensureManagedIdentifierResult(idOpts, context);
+    if (isManagedIdentifierDidResult2(resolution)) {
+      jwtIssuer = {
+        didUrl: resolution.kid,
+        method: "did",
+        alg: getSigningAlgo(resolution.key.type)
+      };
+    } else if (isManagedIdentifierX5cResult(resolution)) {
+      if (!resolution.issuer) {
+        return Promise.reject("missing issuer in idOpts");
+      }
+      jwtIssuer = {
+        issuer: resolution.issuer,
+        x5c: resolution.x5c,
+        method: "x5c",
+        alg: getSigningAlgo(resolution.key.type)
+      };
+    } else {
+      return Promise.reject(Error(`JWT issuer method ${resolution.method} not yet supported`));
+    }
+    return await this.get(context).then((rp) => rp.createAuthorizationRequestURI({
+      version: getRequestVersion(this.rpOptions),
+      correlationId,
+      nonce,
+      state,
+      claims,
+      requestByReferenceURI,
+      responseURI,
+      responseURIType,
+      jwtIssuer
+    }));
+  }
+  async createAuthorizationRequest(createArgs, context) {
+    const { correlationId, claims, requestByReferenceURI, responseURI, responseURIType } = createArgs;
+    const nonce = createArgs.nonce ?? uuidv4();
+    const state = createArgs.state ?? correlationId;
+    const idOpts = this.rpOptions.identifierOpts.idOpts;
+    const resolution = await ensureManagedIdentifierResult(idOpts, context);
+    let jwtIssuer;
+    if (isManagedIdentifierX5cResult(resolution) && resolution.issuer) {
+      jwtIssuer = {
+        method: resolution.method,
+        alg: getSigningAlgo(resolution.key.type),
+        x5c: resolution.x5c,
+        issuer: resolution.issuer
+      };
+    } else if (isManagedIdentifierDidResult2(resolution)) {
+      jwtIssuer = {
+        method: resolution.method,
+        alg: getSigningAlgo(resolution.key.type),
+        didUrl: resolution.did
+      };
+    } else {
+      return Promise.reject(Error("Only did & x5c supported at present"));
+    }
+    return await this.get(context).then((rp) => rp.createAuthorizationRequest({
+      version: getRequestVersion(this.rpOptions),
+      correlationId,
+      nonce,
+      state,
+      claims,
+      requestByReferenceURI,
+      responseURIType,
+      responseURI,
+      jwtIssuer
+    }));
+  }
+};
+
+// src/agent/SIOPv2RP.ts
+import { shaHasher as defaultHasher2 } from "@sphereon/ssi-sdk.core";
+var SIOPv2RP = class _SIOPv2RP {
+  static {
+    __name(this, "SIOPv2RP");
+  }
+  opts;
+  static _DEFAULT_OPTS_KEY = "_default";
+  instances = /* @__PURE__ */ new Map();
+  schema = schema.IDidAuthSiopOpAuthenticator;
+  methods = {
+    siopCreateAuthRequestURI: this.createAuthorizationRequestURI.bind(this),
+    siopCreateAuthRequestPayloads: this.createAuthorizationRequestPayloads.bind(this),
+    siopGetAuthRequestState: this.siopGetRequestState.bind(this),
+    siopGetAuthResponseState: this.siopGetResponseState.bind(this),
+    siopUpdateAuthRequestState: this.siopUpdateRequestState.bind(this),
+    siopDeleteAuthState: this.siopDeleteState.bind(this),
+    siopVerifyAuthResponse: this.siopVerifyAuthResponse.bind(this),
+    siopImportDefinitions: this.siopImportDefinitions.bind(this),
+    siopGetRedirectURI: this.siopGetRedirectURI.bind(this)
+  };
+  constructor(opts) {
+    this.opts = opts;
+  }
+  setDefaultOpts(rpDefaultOpts, context) {
+    this.opts.defaultOpts = rpDefaultOpts;
+    if (!this.opts.defaultOpts.identifierOpts.resolveOpts?.resolver || typeof this.opts.defaultOpts.identifierOpts.resolveOpts.resolver.resolve !== "function") {
+      this.opts.defaultOpts.identifierOpts.resolveOpts = {
+        ...this.opts.defaultOpts.identifierOpts.resolveOpts,
+        resolver: getAgentResolver2(context, {
+          uniresolverResolution: true,
+          resolverResolution: true,
+          localResolution: true
+        })
+      };
+    }
+  }
+  async createAuthorizationRequestURI(createArgs, context) {
+    return await this.getRPInstance({
+      definitionId: createArgs.definitionId,
+      responseRedirectURI: createArgs.responseRedirectURI
+    }, context).then((rp) => rp.createAuthorizationRequestURI(createArgs, context)).then((URI) => URI.encodedUri);
+  }
+  async createAuthorizationRequestPayloads(createArgs, context) {
+    return await this.getRPInstance({
+      definitionId: createArgs.definitionId
+    }, context).then((rp) => rp.createAuthorizationRequest(createArgs, context)).then(async (request) => {
+      const authRequest = {
+        authorizationRequest: request.payload,
+        requestObject: await request.requestObjectJwt(),
+        requestObjectDecoded: await request.requestObject?.getPayload()
+      };
+      return authRequest;
+    });
+  }
+  async siopGetRequestState(args, context) {
+    return await this.getRPInstance({
+      definitionId: args.definitionId
+    }, context).then((rp) => rp.get(context).then((rp2) => rp2.sessionManager.getRequestStateByCorrelationId(args.correlationId, args.errorOnNotFound)));
+  }
+  async siopGetResponseState(args, context) {
+    const rpInstance = await this.getRPInstance({
+      definitionId: args.definitionId
+    }, context);
+    const authorizationResponseState = await rpInstance.get(context).then((rp) => rp.sessionManager.getResponseStateByCorrelationId(args.correlationId, args.errorOnNotFound));
+    if (authorizationResponseState === void 0) {
+      return void 0;
+    }
+    const responseState = authorizationResponseState;
+    if (responseState.status === AuthorizationResponseStateStatus.VERIFIED && args.includeVerifiedData && args.includeVerifiedData !== VerifiedDataMode.NONE) {
+      let hasher;
+      if (CredentialMapper2.isSdJwtEncoded(responseState.response.payload.vp_token) && (!rpInstance.rpOptions.credentialOpts?.hasher || typeof rpInstance.rpOptions.credentialOpts?.hasher !== "function")) {
+        hasher = defaultHasher2;
+      }
+      const presentationDecoded = CredentialMapper2.decodeVerifiablePresentation(
+        responseState.response.payload.vp_token,
+        //todo: later we want to conditionally pass in options for mdl-mdoc here
+        hasher
+      );
+      switch (args.includeVerifiedData) {
+        case VerifiedDataMode.VERIFIED_PRESENTATION:
+          responseState.response.payload.verifiedData = this.presentationOrClaimsFrom(presentationDecoded);
+          break;
+        case VerifiedDataMode.CREDENTIAL_SUBJECT_FLATTENED:
+          const allClaims = {};
+          for (const credential of this.presentationOrClaimsFrom(presentationDecoded).verifiableCredential || []) {
+            const vc = credential;
+            const schemaValidationResult = await context.agent.cvVerifySchema({
+              credential,
+              hasher,
+              validationPolicy: rpInstance.rpOptions.verificationPolicies?.schemaValidation
+            });
+            if (!schemaValidationResult.result) {
+              responseState.status = AuthorizationResponseStateStatus.ERROR;
+              responseState.error = new Error(schemaValidationResult.error);
+              return responseState;
+            }
+            const credentialSubject = vc.credentialSubject;
+            if (!("id" in allClaims)) {
+              allClaims["id"] = credentialSubject.id;
+            }
+            Object.entries(credentialSubject).forEach(([key, value]) => {
+              if (!(key in allClaims)) {
+                allClaims[key] = value;
+              }
+            });
+          }
+          responseState.verifiedData = allClaims;
+          break;
+      }
+    }
+    return responseState;
+  }
+  presentationOrClaimsFrom = /* @__PURE__ */ __name((presentationDecoded) => CredentialMapper2.isSdJwtDecodedCredential(presentationDecoded) ? presentationDecoded.decodedPayload : CredentialMapper2.toUniformPresentation(presentationDecoded), "presentationOrClaimsFrom");
+  async siopUpdateRequestState(args, context) {
+    if (args.state !== "sent") {
+      throw Error(`Only 'sent' status is supported for this method at this point`);
+    }
+    return await this.getRPInstance({
+      definitionId: args.definitionId
+    }, context).then((rp) => rp.get(context).then(async (rp2) => {
+      await rp2.signalAuthRequestRetrieved({
+        correlationId: args.correlationId,
+        error: args.error ? new Error(args.error) : void 0
+      });
+      return await rp2.sessionManager.getRequestStateByCorrelationId(args.correlationId, true);
+    }));
+  }
+  async siopDeleteState(args, context) {
+    return await this.getRPInstance({
+      definitionId: args.definitionId
+    }, context).then((rp) => rp.get(context).then((rp2) => rp2.sessionManager.deleteStateForCorrelationId(args.correlationId))).then(() => true);
+  }
+  async siopVerifyAuthResponse(args, context) {
+    if (!args.authorizationResponse) {
+      throw Error("No SIOPv2 Authorization Response received");
+    }
+    const authResponse = typeof args.authorizationResponse === "string" ? decodeUriAsJson(args.authorizationResponse) : args.authorizationResponse;
+    return await this.getRPInstance({
+      definitionId: args.definitionId
+    }, context).then((rp) => rp.get(context).then((rp2) => rp2.verifyAuthorizationResponse(authResponse, {
+      correlationId: args.correlationId,
+      ...args.presentationDefinitions && !args.dcqlQuery ? {
+        presentationDefinitions: args.presentationDefinitions
+      } : {},
+      ...args.dcqlQuery ? {
+        dcqlQuery: args.dcqlQuery
+      } : {},
+      audience: args.audience
+    })));
+  }
+  async siopImportDefinitions(args, context) {
+    const { definitions, tenantId, version, versionControlMode } = args;
+    await Promise.all(definitions.map(async (definitionPair) => {
+      const definitionPayload = definitionPair.definitionPayload;
+      await context.agent.pexValidateDefinition({
+        definition: definitionPayload
+      });
+      console.log(`persisting definition ${definitionPayload.id} / ${definitionPayload.name} with versionControlMode ${versionControlMode}`);
+      return context.agent.pdmPersistDefinition({
+        definitionItem: {
+          tenantId,
+          version,
+          definitionPayload,
+          dcqlPayload: definitionPair.dcqlPayload
+        },
+        opts: {
+          versionControlMode
+        }
+      });
+    }));
+  }
+  async siopGetRedirectURI(args, context) {
+    const instanceId = args.definitionId ?? _SIOPv2RP._DEFAULT_OPTS_KEY;
+    if (this.instances.has(instanceId)) {
+      const rpInstance = this.instances.get(instanceId);
+      if (rpInstance !== void 0) {
+        const rp = await rpInstance.get(context);
+        return rp.getResponseRedirectUri({
+          correlation_id: args.correlationId,
+          correlationId: args.correlationId,
+          ...args.state && {
+            state: args.state
+          }
+        });
+      }
+    }
+    return void 0;
+  }
+  async getRPInstance({ definitionId, responseRedirectURI }, context) {
+    const instanceId = definitionId ?? _SIOPv2RP._DEFAULT_OPTS_KEY;
+    if (!this.instances.has(instanceId)) {
+      const instanceOpts = this.getInstanceOpts(definitionId);
+      const rpOpts = await this.getRPOptions(context, {
+        definitionId,
+        responseRedirectURI
+      });
+      if (!rpOpts.identifierOpts.resolveOpts?.resolver || typeof rpOpts.identifierOpts.resolveOpts.resolver.resolve !== "function") {
+        if (!rpOpts.identifierOpts?.resolveOpts) {
+          rpOpts.identifierOpts = {
+            ...rpOpts.identifierOpts
+          };
+          rpOpts.identifierOpts.resolveOpts = {
+            ...rpOpts.identifierOpts.resolveOpts
+          };
+        }
+        console.log("Using agent DID resolver for RP instance with definition id " + definitionId);
+        rpOpts.identifierOpts.resolveOpts.resolver = getAgentResolver2(context, {
+          uniresolverResolution: true,
+          localResolution: true,
+          resolverResolution: true
+        });
+      }
+      this.instances.set(instanceId, new RPInstance({
+        rpOpts,
+        pexOpts: instanceOpts
+      }));
+    }
+    const rpInstance = this.instances.get(instanceId);
+    if (responseRedirectURI) {
+      rpInstance.rpOptions.responseRedirectUri = responseRedirectURI;
+    }
+    return rpInstance;
+  }
+  async getRPOptions(context, opts) {
+    const { definitionId, responseRedirectURI } = opts;
+    const options = this.getInstanceOpts(definitionId)?.rpOpts ?? this.opts.defaultOpts;
+    if (!options) {
+      throw Error(`Could not get specific nor default options for definition ${definitionId}`);
+    }
+    if (this.opts.defaultOpts) {
+      if (!options.identifierOpts) {
+        options.identifierOpts = this.opts.defaultOpts?.identifierOpts;
+      } else {
+        if (!options.identifierOpts.idOpts) {
+          options.identifierOpts.idOpts = this.opts.defaultOpts.identifierOpts.idOpts;
+        }
+        if (!options.identifierOpts.supportedDIDMethods) {
+          options.identifierOpts.supportedDIDMethods = this.opts.defaultOpts.identifierOpts.supportedDIDMethods;
+        }
+        if (!options.supportedVersions) {
+          options.supportedVersions = this.opts.defaultOpts.supportedVersions;
+        }
+      }
+      if (!options.identifierOpts.resolveOpts || typeof options.identifierOpts.resolveOpts.resolver?.resolve !== "function") {
+        options.identifierOpts.resolveOpts = {
+          ...this.opts.defaultOpts.identifierOpts.resolveOpts,
+          resolver: this.opts.defaultOpts.identifierOpts?.resolveOpts?.resolver ?? getAgentResolver2(context, {
+            localResolution: true,
+            resolverResolution: true,
+            uniresolverResolution: true
+          })
+        };
+      }
+    }
+    if (responseRedirectURI !== void 0 && responseRedirectURI !== options.responseRedirectUri) {
+      options.responseRedirectUri = responseRedirectURI;
+    }
+    return options;
+  }
+  getInstanceOpts(definitionId) {
+    if (!this.opts.instanceOpts) return void 0;
+    const instanceOpt = definitionId ? this.opts.instanceOpts.find((i) => i.definitionId === definitionId) : void 0;
+    return instanceOpt ?? this.getDefaultOptions(definitionId);
+  }
+  getDefaultOptions(definitionId) {
+    if (!this.opts.instanceOpts) return void 0;
+    const defaultOptions = this.opts.instanceOpts.find((i) => i.definitionId === "default");
+    if (defaultOptions) {
+      const clonedOptions = {
+        ...defaultOptions
+      };
+      if (definitionId !== void 0) {
+        clonedOptions.definitionId = definitionId;
+      }
+      return clonedOptions;
+    }
+    return void 0;
+  }
+};
+
+// src/types/ISIOPv2RP.ts
+var VerifiedDataMode = /* @__PURE__ */ function(VerifiedDataMode2) {
+  VerifiedDataMode2["NONE"] = "none";
+  VerifiedDataMode2["VERIFIED_PRESENTATION"] = "vp";
+  VerifiedDataMode2["CREDENTIAL_SUBJECT_FLATTENED"] = "cs-flat";
+  return VerifiedDataMode2;
+}({});
+
+// src/index.ts
+var schema = require_plugin_schema();
+export {
+  SIOPv2RP,
+  VerifiedDataMode,
+  schema
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SIOPv2RP = exports.schema = void 0;
-/**
- * @public
- */
-const schema = require('../plugin.schema.json');
-exports.schema = schema;
-var SIOPv2RP_1 = require("./agent/SIOPv2RP");
-Object.defineProperty(exports, "SIOPv2RP", { enumerable: true, get: function () { return SIOPv2RP_1.SIOPv2RP; } });
-__exportStar(require("./types/ISIOPv2RP"), exports);
 //# sourceMappingURL=index.js.map