@sphereon/ssi-sdk.siopv2-oid4vp-op-auth 0.34.1-next.3 → 0.34.1-next.323

package/dist/index.cjs

@@ -60,375 +60,371 @@ var require_nl = __commonJS({
   }
 });
 
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_JWT_PROOF_TYPE: () => DEFAULT_JWT_PROOF_TYPE,
+  DID_PREFIX: () => DID_PREFIX,
+  DidAuthSiopOpAuthenticator: () => DidAuthSiopOpAuthenticator,
+  LOGGER_NAMESPACE: () => LOGGER_NAMESPACE,
+  OID4VPCallbackStateListener: () => OID4VPCallbackStateListener,
+  OpSession: () => OpSession,
+  Siopv2HolderEvent: () => Siopv2HolderEvent,
+  Siopv2Machine: () => Siopv2Machine,
+  Siopv2MachineAddContactStates: () => Siopv2MachineAddContactStates,
+  Siopv2MachineEvents: () => Siopv2MachineEvents,
+  Siopv2MachineGuards: () => Siopv2MachineGuards,
+  Siopv2MachineServices: () => Siopv2MachineServices,
+  Siopv2MachineStates: () => Siopv2MachineStates,
+  Siopv2OID4VPLinkHandler: () => Siopv2OID4VPLinkHandler,
+  SupportedLanguage: () => SupportedLanguage,
+  convertToDcqlCredentials: () => convertToDcqlCredentials,
+  createJwtCallbackWithIdOpts: () => createJwtCallbackWithIdOpts,
+  createJwtCallbackWithOpOpts: () => createJwtCallbackWithOpOpts,
+  createOID4VPPresentationSignCallback: () => createOID4VPPresentationSignCallback,
+  createOP: () => createOP,
+  createOPBuilder: () => createOPBuilder,
+  createVerifiablePresentationForFormat: () => createVerifiablePresentationForFormat,
+  didAuthSiopOpAuthenticatorMethods: () => didAuthSiopOpAuthenticatorMethods,
+  getSigningAlgo: () => getSigningAlgo,
+  schema: () => plugin_schema_default
+});
+module.exports = __toCommonJS(index_exports);
+
 // plugin.schema.json
-var require_plugin_schema = __commonJS({
-  "plugin.schema.json"(exports, module2) {
-    module2.exports = {
-      IDidAuthSiopOpAuthenticator: {
-        components: {
-          schemas: {
-            IGetSiopSessionArgs: {
-              type: "object",
-              properties: {
-                sessionId: {
-                  type: "string"
-                },
-                additionalProperties: false
-              },
-              required: ["sessionId"],
-              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSessionForSiop } "
+var plugin_schema_default = {
+  IDidAuthSiopOpAuthenticator: {
+    components: {
+      schemas: {
+        IGetSiopSessionArgs: {
+          type: "object",
+          properties: {
+            sessionId: {
+              type: "string"
             },
-            IRegisterSiopSessionArgs: {
+            additionalProperties: false
+          },
+          required: ["sessionId"],
+          description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSessionForSiop } "
+        },
+        IRegisterSiopSessionArgs: {
+          type: "object",
+          properties: {
+            identifier: {
               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: {
+                did: {
                   type: "string"
                 },
-                expiresIn: {
-                  type: "number"
-                },
-                additionalProperties: false
-              },
-              required: ["identifier"],
-              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.registerSessionForSiop } "
-            },
-            IRemoveSiopSessionArgs: {
-              type: "object",
-              properties: {
-                sessionId: {
+                alias: {
                   type: "string"
                 },
-                additionalProperties: false
-              },
-              required: ["sessionId"],
-              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.removeSessionForSiop } "
-            },
-            IAuthenticateWithSiopArgs: {
-              type: "object",
-              properties: {
-                sessionId: {
+                provider: {
                   type: "string"
                 },
-                stateId: {
+                controllerKeyId: {
                   type: "string"
                 },
-                redirectUrl: {
-                  type: "string"
+                keys: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      additionalProperties: true
+                    }
+                  }
                 },
-                additionalProperties: false
+                services: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      additionalProperties: true
+                    }
+                  }
+                }
               },
-              required: ["sessionId", "stateId", "redirectUrl"],
-              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.authenticateWithSiop } "
+              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"
             },
-            IResponse: {
+            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: {
-                status: {
-                  type: "number"
-                },
                 additionalProperties: true
-              },
-              required: ["status"],
-              description: "Result of {@link DidAuthSiopOpAuthenticator.authenticateWithSiop & DidAuthSiopOpAuthenticator.sendSiopAuthenticationResponse } "
+              }
             },
-            IGetSiopAuthenticationRequestFromRpArgs: {
+            registration: {
               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 } "
+                additionalProperties: true
+              }
             },
-            ParsedAuthenticationRequestURI: {
+            additionalProperties: false
+          },
+          required: ["jwt", "requestPayload", "registration"],
+          description: "Result of {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestFromRP } "
+        },
+        IGetSiopAuthenticationRequestDetailsArgs: {
+          type: "object",
+          properties: {
+            sessionId: {
+              type: "string"
+            },
+            verifiedAuthenticationRequest: {
               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 } "
+                additionalProperties: true
+              }
             },
-            IGetSiopAuthenticationRequestDetailsArgs: {
+            credentialFilter: {
               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 } "
+                additionalProperties: true
+              }
+            },
+            additionalProperties: false
+          },
+          required: ["sessionId", "verifiedAuthenticationRequest"],
+          description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestDetails } "
+        },
+        IAuthRequestDetails: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
             },
-            IAuthRequestDetails: {
+            alsoKnownAs: {
+              type: "array",
+              items: {
+                type: "string"
+              }
+            },
+            vpResponseOpts: {
               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 } "
+                additionalProperties: true
+              }
+            },
+            additionalProperties: false
+          },
+          required: ["id", "vpResponseOpts"],
+          description: "Result of {@link DidAuthSiopOpAuthenticator.getSiopAuthenticationRequestDetails } "
+        },
+        IVerifySiopAuthenticationRequestUriArgs: {
+          type: "object",
+          properties: {
+            sessionId: {
+              type: "string"
             },
-            IVerifySiopAuthenticationRequestUriArgs: {
+            ParsedAuthenticationRequestURI: {
               type: "object",
               properties: {
-                sessionId: {
-                  type: "string"
-                },
-                ParsedAuthenticationRequestURI: {
-                  type: "object",
-                  properties: {
-                    additionalProperties: true
-                  }
-                },
-                additionalProperties: false
-              },
-              required: ["sessionId", "ParsedAuthenticationRequestURI"],
-              description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.verifySiopAuthenticationRequestURI } "
+                additionalProperties: true
+              }
             },
-            VerifiedAuthorizationRequest: {
+            additionalProperties: false
+          },
+          required: ["sessionId", "ParsedAuthenticationRequestURI"],
+          description: "Arguments needed for {@link DidAuthSiopOpAuthenticator.verifySiopAuthenticationRequestURI } "
+        },
+        VerifiedAuthorizationRequest: {
+          type: "object",
+          properties: {
+            payload: {
               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 } "
+                additionalProperties: true
+              }
             },
-            ISendSiopAuthenticationResponseArgs: {
+            presentationDefinitions: {
               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"
+                additionalProperties: true
               }
             },
-            getSiopAuthenticationRequestFromRP: {
-              description: "Get authentication request from RP",
-              arguments: {
-                $ref: "#/components/schemas/IGetSiopAuthenticationRequestFromRpArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/ParsedAuthenticationRequestURI"
+            verifyOpts: {
+              type: "object",
+              properties: {
+                additionalProperties: true
               }
             },
-            getSiopAuthenticationRequestDetails: {
-              description: "Get authentication request details",
-              arguments: {
-                $ref: "#/components/schemas/IGetSiopAuthenticationRequestDetailsArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/IAuthRequestDetails"
-              }
+            additionalProperties: false
+          },
+          required: ["payload", "verifyOpts"],
+          description: "Result of {@link DidAuthSiopOpAuthenticator.verifySiopAuthenticationRequestURI } "
+        },
+        ISendSiopAuthenticationResponseArgs: {
+          type: "object",
+          properties: {
+            sessionId: {
+              type: "string"
             },
-            verifySiopAuthenticationRequestURI: {
-              description: "Verify authentication request URI",
-              arguments: {
-                $ref: "#/components/schemas/IVerifySiopAuthenticationRequestUriArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/VerifiedAuthorizationRequest"
+            verifiedAuthenticationRequest: {
+              type: "object",
+              properties: {
+                additionalProperties: true
               }
             },
-            sendSiopAuthenticationResponse: {
-              description: "Send authentication response",
-              arguments: {
-                $ref: "#/components/schemas/ISendSiopAuthenticationResponseArgs"
-              },
-              returnType: {
-                $ref: "#/components/schemas/IRequiredContext"
+            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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEFAULT_JWT_PROOF_TYPE: () => DEFAULT_JWT_PROOF_TYPE,
-  DID_PREFIX: () => DID_PREFIX,
-  DidAuthSiopOpAuthenticator: () => DidAuthSiopOpAuthenticator,
-  LOGGER_NAMESPACE: () => LOGGER_NAMESPACE,
-  OID4VP: () => OID4VP,
-  OID4VPCallbackStateListener: () => OID4VPCallbackStateListener,
-  OpSession: () => OpSession,
-  Siopv2HolderEvent: () => Siopv2HolderEvent,
-  Siopv2Machine: () => Siopv2Machine,
-  Siopv2MachineAddContactStates: () => Siopv2MachineAddContactStates,
-  Siopv2MachineEvents: () => Siopv2MachineEvents,
-  Siopv2MachineGuards: () => Siopv2MachineGuards,
-  Siopv2MachineServices: () => Siopv2MachineServices,
-  Siopv2MachineStates: () => Siopv2MachineStates,
-  Siopv2OID4VPLinkHandler: () => Siopv2OID4VPLinkHandler,
-  SupportedLanguage: () => SupportedLanguage,
-  createJwtCallbackWithIdOpts: () => createJwtCallbackWithIdOpts,
-  createJwtCallbackWithOpOpts: () => createJwtCallbackWithOpOpts,
-  createOID4VPPresentationSignCallback: () => createOID4VPPresentationSignCallback,
-  createOP: () => createOP,
-  createOPBuilder: () => createOPBuilder,
-  didAuthSiopOpAuthenticatorMethods: () => didAuthSiopOpAuthenticatorMethods,
-  events: () => events,
-  getSigningAlgo: () => getSigningAlgo,
-  schema: () => schema
-});
-module.exports = __toCommonJS(index_exports);
+};
 
 // src/agent/DidAuthSiopOpAuthenticator.ts
-var import_did_auth_siop5 = require("@sphereon/did-auth-siop");
-var import_ssi_sdk8 = require("@sphereon/ssi-sdk.data-store");
+var import_did_auth_siop4 = require("@sphereon/did-auth-siop");
+var import_ssi_sdk7 = require("@sphereon/ssi-sdk.data-store-types");
 var import_ssi_types7 = require("@sphereon/ssi-types");
 var import_uuid2 = require("uuid");
 
@@ -455,10 +451,8 @@ __name(createOID4VPPresentationSignCallback, "createOID4VPPresentationSignCallba
 async function createOPBuilder({ opOptions, idOpts: idOpts1, context }) {
   const eventEmitter = opOptions.eventEmitter ?? new import_events.EventEmitter();
   const builder = import_did_auth_siop.OP.builder().withResponseMode(opOptions.responseMode ?? import_did_auth_siop.ResponseMode.DIRECT_POST).withSupportedVersions(opOptions.supportedVersions ?? [
-    import_did_auth_siop.SupportedVersion.SIOPv2_ID1,
-    import_did_auth_siop.SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1,
-    import_did_auth_siop.SupportedVersion.SIOPv2_D11,
-    import_did_auth_siop.SupportedVersion.SIOPv2_D12_OID4VP_D18
+    import_did_auth_siop.SupportedVersion.OID4VP_v1,
+    import_did_auth_siop.SupportedVersion.SIOPv2_OID4VP_D28
   ]).withExpiresIn(opOptions.expiresIn ?? 300).withEventEmitter(eventEmitter).withRegistration({
     passBy: import_did_auth_siop.PassBy.VALUE
   });
@@ -586,34 +580,29 @@ function getSigningAlgo(type) {
 __name(getSigningAlgo, "getSigningAlgo");
 
 // src/session/OID4VP.ts
-var import_did_auth_siop2 = require("@sphereon/did-auth-siop");
-var import_pex = require("@sphereon/pex");
+var import_utils = require("@sphereon/pex/dist/main/lib/utils/index.js");
 var import_ssi_sdk_ext2 = require("@sphereon/ssi-sdk-ext.identifier-resolution");
-var import_ssi_sdk2 = require("@sphereon/ssi-sdk.core");
-var import_ssi_sdk3 = require("@sphereon/ssi-sdk.credential-store");
+var import_ssi_sdk2 = require("@sphereon/ssi-sdk.sd-jwt");
+var import_ssi_types = require("@sphereon/ssi-types");
 
 // src/types/IDidAuthSiopOpAuthenticator.ts
 var LOGGER_NAMESPACE = "sphereon:siopv2-oid4vp:op-auth";
-var events = /* @__PURE__ */ function(events2) {
-  events2["DID_SIOP_AUTHENTICATED"] = "didSiopAuthenticated";
-  return events2;
-}({});
 var DEFAULT_JWT_PROOF_TYPE = "JwtProof2020";
 
 // src/types/siop-service/index.ts
-var Siopv2HolderEvent = /* @__PURE__ */ function(Siopv2HolderEvent2) {
+var Siopv2HolderEvent = /* @__PURE__ */ (function(Siopv2HolderEvent2) {
   Siopv2HolderEvent2["CONTACT_IDENTITY_CREATED"] = "contact_identity_created";
   Siopv2HolderEvent2["IDENTIFIER_CREATED"] = "identifier_created";
   return Siopv2HolderEvent2;
-}({});
-var SupportedLanguage = /* @__PURE__ */ function(SupportedLanguage2) {
+})({});
+var SupportedLanguage = /* @__PURE__ */ (function(SupportedLanguage2) {
   SupportedLanguage2["ENGLISH"] = "en";
   SupportedLanguage2["DUTCH"] = "nl";
   return SupportedLanguage2;
-}({});
+})({});
 
 // src/types/machine/index.ts
-var Siopv2MachineStates = /* @__PURE__ */ function(Siopv2MachineStates2) {
+var Siopv2MachineStates = /* @__PURE__ */ (function(Siopv2MachineStates2) {
   Siopv2MachineStates2["createConfig"] = "createConfig";
   Siopv2MachineStates2["getSiopRequest"] = "getSiopRequest";
   Siopv2MachineStates2["getSelectableCredentials"] = "getSelectableCredentials";
@@ -629,14 +618,14 @@ var Siopv2MachineStates = /* @__PURE__ */ function(Siopv2MachineStates2) {
   Siopv2MachineStates2["error"] = "error";
   Siopv2MachineStates2["done"] = "done";
   return Siopv2MachineStates2;
-}({});
-var Siopv2MachineAddContactStates = /* @__PURE__ */ function(Siopv2MachineAddContactStates2) {
+})({});
+var Siopv2MachineAddContactStates = /* @__PURE__ */ (function(Siopv2MachineAddContactStates2) {
   Siopv2MachineAddContactStates2["idle"] = "idle";
   Siopv2MachineAddContactStates2["executing"] = "executing";
   Siopv2MachineAddContactStates2["next"] = "next";
   return Siopv2MachineAddContactStates2;
-}({});
-var Siopv2MachineEvents = /* @__PURE__ */ function(Siopv2MachineEvents2) {
+})({});
+var Siopv2MachineEvents = /* @__PURE__ */ (function(Siopv2MachineEvents2) {
   Siopv2MachineEvents2["NEXT"] = "NEXT";
   Siopv2MachineEvents2["PREVIOUS"] = "PREVIOUS";
   Siopv2MachineEvents2["DECLINE"] = "DECLINE";
@@ -645,8 +634,8 @@ var Siopv2MachineEvents = /* @__PURE__ */ function(Siopv2MachineEvents2) {
   Siopv2MachineEvents2["CREATE_CONTACT"] = "CREATE_CONTACT";
   Siopv2MachineEvents2["SET_SELECTED_CREDENTIALS"] = "SET_SELECTED_CREDENTIALS";
   return Siopv2MachineEvents2;
-}({});
-var Siopv2MachineGuards = /* @__PURE__ */ function(Siopv2MachineGuards2) {
+})({});
+var Siopv2MachineGuards = /* @__PURE__ */ (function(Siopv2MachineGuards2) {
   Siopv2MachineGuards2["hasNoContactGuard"] = "Siopv2HasNoContactGuard";
   Siopv2MachineGuards2["createContactGuard"] = "Siopv2CreateContactGuard";
   Siopv2MachineGuards2["hasContactGuard"] = "Siopv2HasContactGuard";
@@ -656,8 +645,8 @@ var Siopv2MachineGuards = /* @__PURE__ */ function(Siopv2MachineGuards2) {
   Siopv2MachineGuards2["siopOnlyGuard"] = "Siopv2IsSiopOnlyGuard";
   Siopv2MachineGuards2["siopWithOID4VPGuard"] = "Siopv2IsSiopWithOID4VPGuard";
   return Siopv2MachineGuards2;
-}({});
-var Siopv2MachineServices = /* @__PURE__ */ function(Siopv2MachineServices2) {
+})({});
+var Siopv2MachineServices = /* @__PURE__ */ (function(Siopv2MachineServices2) {
   Siopv2MachineServices2["getSiopRequest"] = "getSiopRequest";
   Siopv2MachineServices2["getSelectableCredentials"] = "getSelectableCredentials";
   Siopv2MachineServices2["retrieveContact"] = "retrieveContact";
@@ -665,212 +654,131 @@ var Siopv2MachineServices = /* @__PURE__ */ function(Siopv2MachineServices2) {
   Siopv2MachineServices2["sendResponse"] = "sendResponse";
   Siopv2MachineServices2["createConfig"] = "createConfig";
   return Siopv2MachineServices2;
-}({});
+})({});
 
 // src/types/identifier/index.ts
 var DID_PREFIX = "did";
 
 // src/session/OID4VP.ts
-var OID4VP = class _OID4VP {
-  static {
-    __name(this, "OID4VP");
+var CLOCK_SKEW = 120;
+var logger = import_ssi_types.Loggers.DEFAULT.get(LOGGER_NAMESPACE);
+function extractOriginalCredential(credential) {
+  if (typeof credential === "string") {
+    return credential;
   }
-  session;
-  allIdentifiers;
-  hasher;
-  constructor(args) {
-    const { session, allIdentifiers, hasher = import_ssi_sdk2.defaultHasher } = args;
-    this.session = session;
-    this.allIdentifiers = allIdentifiers ?? [];
-    this.hasher = hasher;
-  }
-  static async init(session, allIdentifiers, hasher) {
-    return new _OID4VP({
-      session,
-      allIdentifiers: allIdentifiers ?? await session.getSupportedDIDs(),
-      hasher
-    });
-  }
-  async getPresentationDefinitions() {
-    const definitions = await this.session.getPresentationDefinitions();
-    if (definitions) {
-      import_did_auth_siop2.PresentationExchange.assertValidPresentationDefinitionWithLocations(definitions);
+  if ("digitalCredential" in credential) {
+    const udc = credential;
+    if (udc.originalVerifiableCredential) {
+      return udc.originalVerifiableCredential;
     }
-    return definitions;
-  }
-  getPresentationExchange(args) {
-    const { verifiableCredentials, allIdentifiers, hasher } = args;
-    return new import_did_auth_siop2.PresentationExchange({
-      allDIDs: allIdentifiers ?? this.allIdentifiers,
-      allVerifiableCredentials: verifiableCredentials,
-      hasher: hasher ?? this.hasher
-    });
+    return udc.uniformVerifiableCredential;
   }
-  async createVerifiablePresentations(credentialRole, credentialsWithDefinitions, opts) {
-    return await Promise.all(credentialsWithDefinitions.map((cred) => this.createVerifiablePresentation(credentialRole, cred, opts)));
+  if ("original" in credential) {
+    return credential.original;
   }
-  async createVerifiablePresentation(credentialRole, selectedVerifiableCredentials, opts) {
-    const { subjectIsHolder, holder, forceNoCredentialsInVP = false } = {
-      ...opts
-    };
-    if (subjectIsHolder && holder) {
-      throw Error("Cannot both have subject is holder and a holderDID value at the same time (programming error)");
-    }
-    if (forceNoCredentialsInVP) {
-      selectedVerifiableCredentials.credentials = [];
-    } else if (!selectedVerifiableCredentials?.credentials || selectedVerifiableCredentials.credentials.length === 0) {
-      throw Error("No verifiable verifiableCredentials provided for presentation definition");
-    }
-    const proofOptions = {
-      ...opts?.proofOpts,
-      challenge: opts?.proofOpts?.nonce ?? opts?.proofOpts?.challenge ?? this.session.nonce,
-      domain: opts?.proofOpts?.domain ?? await this.session.getRedirectUri()
-    };
-    let idOpts2 = opts?.idOpts;
-    if (!idOpts2) {
-      if (opts?.subjectIsHolder) {
-        if (forceNoCredentialsInVP) {
-          return Promise.reject(Error(`Cannot have subject is holder, when force no credentials is being used, as we could never determine the holder then. Please provide holderDID`));
-        }
-        const firstUniqueDC = selectedVerifiableCredentials.credentials[0];
-        if (typeof firstUniqueDC !== "object" || !("digitalCredential" in firstUniqueDC)) {
-          return Promise.reject(Error("If no opts provided, credentials should be of type UniqueDigitalCredential"));
-        }
-        idOpts2 = (0, import_ssi_sdk_ext2.isOID4VCIssuerIdentifier)(firstUniqueDC.digitalCredential.kmsKeyRef) ? await this.session.context.agent.identifierManagedGetByIssuer({
-          identifier: firstUniqueDC.digitalCredential.kmsKeyRef
-        }) : await this.session.context.agent.identifierManagedGetByKid({
-          identifier: firstUniqueDC.digitalCredential.kmsKeyRef,
-          kmsKeyRef: firstUniqueDC.digitalCredential.kmsKeyRef
-        });
-      } else if (opts?.holder) {
-        idOpts2 = {
-          identifier: opts.holder
-        };
-      }
-    }
-    const vcs = forceNoCredentialsInVP ? selectedVerifiableCredentials : opts?.applyFilter ? await this.filterCredentials(credentialRole, selectedVerifiableCredentials.definition, {
-      restrictToFormats: opts?.restrictToFormats,
-      restrictToDIDMethods: opts?.restrictToDIDMethods,
-      filterOpts: {
-        verifiableCredentials: selectedVerifiableCredentials.credentials
-      }
-    }) : {
-      definition: selectedVerifiableCredentials.definition,
-      credentials: selectedVerifiableCredentials.credentials
-    };
-    if (!idOpts2) {
-      return Promise.reject(Error(`No identifier options present at this point`));
+  return credential;
+}
+__name(extractOriginalCredential, "extractOriginalCredential");
+function getIdentifierString(identifier) {
+  if ("opts" in identifier && "method" in identifier) {
+    if ((0, import_ssi_sdk_ext2.isManagedIdentifierDidResult)(identifier)) {
+      return identifier.did;
     }
-    const signCallback = await createOID4VPPresentationSignCallback({
-      presentationSignCallback: this.session.options.presentationSignCallback,
-      idOpts: idOpts2,
-      context: this.session.context,
-      domain: proofOptions.domain,
-      challenge: proofOptions.challenge,
-      format: opts?.restrictToFormats ?? selectedVerifiableCredentials.definition.definition.format,
-      skipDidResolution: opts?.skipDidResolution ?? false
-    });
-    const identifier = await this.session.context.agent.identifierManagedGet(idOpts2);
-    const verifiableCredentials = vcs.credentials.map((credential) => typeof credential === "object" && "digitalCredential" in credential ? credential.originalVerifiableCredential : credential);
-    const presentationResult = await this.getPresentationExchange({
-      verifiableCredentials,
-      allIdentifiers: this.allIdentifiers,
-      hasher: opts?.hasher
-    }).createVerifiablePresentation(vcs.definition.definition, verifiableCredentials, signCallback, {
-      proofOptions,
-      // fixme: Update to newer siop-vp to not require dids here. But when Veramo is creating the VP it's still looking at this field to pass into didManagerGet
-      ...identifier && (0, import_ssi_sdk_ext2.isManagedIdentifierDidResult)(identifier) && {
-        holderDID: identifier.did
-      }
-    });
-    const verifiablePresentations = presentationResult.verifiablePresentations.map((verifiablePresentation) => typeof verifiablePresentation !== "string" && "proof" in verifiablePresentation && "jwt" in verifiablePresentation.proof && verifiablePresentation.proof.jwt ? verifiablePresentation.proof.jwt : verifiablePresentation);
-    return {
-      ...presentationResult,
-      verifiablePresentations,
-      verifiableCredentials,
-      definition: selectedVerifiableCredentials.definition,
-      idOpts: idOpts2
-    };
   }
-  async filterCredentialsAgainstAllDefinitions(credentialRole, opts) {
-    const defs = await this.getPresentationDefinitions();
-    const result = [];
-    if (defs) {
-      for (const definition of defs) {
-        result.push(await this.filterCredentials(credentialRole, definition, opts));
-      }
-    }
-    return result;
-  }
-  async filterCredentials(credentialRole, presentationDefinition, opts) {
-    const udcMap = /* @__PURE__ */ new Map();
-    opts?.filterOpts?.verifiableCredentials?.forEach((credential) => {
-      if (typeof credential === "object" && "digitalCredential" in credential) {
-        udcMap.set(credential.originalVerifiableCredential, credential);
-      } else {
-        udcMap.set(credential, credential);
-      }
-    });
-    const credentials = (await this.filterCredentialsWithSelectionStatus(credentialRole, presentationDefinition, {
-      ...opts,
-      filterOpts: {
-        verifiableCredentials: opts?.filterOpts?.verifiableCredentials?.map((credential) => {
-          if (typeof credential === "object" && "digitalCredential" in credential) {
-            return credential.originalVerifiableCredential;
-          } else {
-            return credential;
-          }
-        })
-      }
-    })).verifiableCredential;
-    return {
-      definition: presentationDefinition,
-      credentials: credentials?.map((vc) => udcMap.get(vc)) ?? []
-    };
-  }
-  async filterCredentialsWithSelectionStatus(credentialRole, presentationDefinition, opts) {
-    const selectionResults = await this.getPresentationExchange({
-      verifiableCredentials: await this.getCredentials(credentialRole, opts?.filterOpts)
-    }).selectVerifiableCredentialsForSubmission(presentationDefinition.definition, opts);
-    if (selectionResults.errors && selectionResults.errors.length > 0) {
-      throw Error(JSON.stringify(selectionResults.errors));
-    } else if (selectionResults.areRequiredCredentialsPresent === import_pex.Status.ERROR) {
-      throw Error(`Not all required credentials are available to satisfy the relying party's request`);
+  return identifier.issuer ?? identifier.kid ?? "";
+}
+__name(getIdentifierString, "getIdentifierString");
+async function createVerifiablePresentationForFormat(credential, identifier, context) {
+  const { nonce, audience, agent, clockSkew = CLOCK_SKEW } = context;
+  const originalCredential = extractOriginalCredential(credential);
+  const documentFormat = import_ssi_types.CredentialMapper.detectDocumentType(originalCredential);
+  logger.debug(`Creating VP for format: ${documentFormat}`);
+  switch (documentFormat) {
+    case import_ssi_types.DocumentFormat.SD_JWT_VC: {
+      const decodedSdJwt = await import_ssi_types.CredentialMapper.decodeSdJwtVcAsync(typeof originalCredential === "string" ? originalCredential : originalCredential.compactSdJwtVc, import_ssi_sdk2.defaultGenerateDigest);
+      const hashAlg = decodedSdJwt.signedPayload._sd_alg ?? "sha-256";
+      const sdHash = (0, import_utils.calculateSdHash)(decodedSdJwt.compactSdJwtVc, hashAlg, import_ssi_sdk2.defaultGenerateDigest);
+      const kbJwtPayload = {
+        iat: Math.floor(Date.now() / 1e3 - clockSkew),
+        sd_hash: sdHash,
+        nonce,
+        aud: audience
+      };
+      const presentationResult = await agent.createSdJwtPresentation({
+        presentation: decodedSdJwt.compactSdJwtVc,
+        kb: {
+          payload: kbJwtPayload
+        }
+      });
+      return presentationResult.presentation;
     }
-    const matches = selectionResults.matches;
-    if (!matches || matches.length === 0 || !selectionResults.verifiableCredential || selectionResults.verifiableCredential.length === 0) {
-      throw Error(JSON.stringify(selectionResults.errors));
+    case import_ssi_types.DocumentFormat.JSONLD: {
+      const vcObject = typeof originalCredential === "string" ? JSON.parse(originalCredential) : originalCredential;
+      const vpObject = {
+        "@context": [
+          "https://www.w3.org/2018/credentials/v1"
+        ],
+        type: [
+          "VerifiablePresentation"
+        ],
+        verifiableCredential: [
+          vcObject
+        ]
+      };
+      return await agent.createVerifiablePresentation({
+        presentation: vpObject,
+        proofFormat: "lds",
+        challenge: nonce,
+        domain: audience,
+        keyRef: identifier.kmsKeyRef || identifier.kid
+      });
     }
-    return selectionResults;
-  }
-  async getCredentials(credentialRole, filterOpts) {
-    if (filterOpts?.verifiableCredentials && filterOpts.verifiableCredentials.length > 0) {
-      return filterOpts.verifiableCredentials;
+    case import_ssi_types.DocumentFormat.MSO_MDOC: {
+      logger.warning("mso_mdoc format has basic support - production use requires proper mdoc VP token implementation");
+      return originalCredential;
+    }
+    default: {
+      const vcJwt = typeof originalCredential === "string" ? originalCredential : JSON.stringify(originalCredential);
+      const identifierString = getIdentifierString(identifier);
+      const vpPayload = {
+        iss: identifierString,
+        aud: audience,
+        nonce,
+        vp: {
+          "@context": [
+            "https://www.w3.org/2018/credentials/v1"
+          ],
+          type: [
+            "VerifiablePresentation"
+          ],
+          holder: identifierString,
+          verifiableCredential: [
+            vcJwt
+          ]
+        },
+        iat: Math.floor(Date.now() / 1e3 - clockSkew),
+        exp: Math.floor(Date.now() / 1e3 + 600 + clockSkew)
+      };
+      const vpJwt = await agent.createVerifiablePresentation({
+        presentation: vpPayload.vp,
+        proofFormat: "jwt",
+        domain: audience,
+        challenge: nonce,
+        keyRef: identifier.kmsKeyRef || identifier.kid
+      });
+      return vpJwt.proof?.jwt || vpJwt;
     }
-    const filter = (0, import_ssi_sdk3.verifiableCredentialForRoleFilter)(credentialRole, filterOpts?.filter);
-    const uniqueCredentials = await this.session.context.agent.crsGetUniqueCredentials({
-      filter
-    });
-    return uniqueCredentials.map((uniqueVC) => {
-      const vc = uniqueVC.uniformVerifiableCredential;
-      const proof = Array.isArray(vc.proof) ? vc.proof : [
-        vc.proof
-      ];
-      const jwtProof = proof.find((p) => p?.type === DEFAULT_JWT_PROOF_TYPE);
-      return jwtProof ? jwtProof.jwt : vc;
-    });
   }
-};
+}
+__name(createVerifiablePresentationForFormat, "createVerifiablePresentationForFormat");
 
 // src/session/OpSession.ts
-var import_did_auth_siop3 = require("@sphereon/did-auth-siop");
+var import_did_auth_siop2 = require("@sphereon/did-auth-siop");
 var import_ssi_sdk_ext3 = require("@sphereon/ssi-sdk-ext.did-utils");
-var import_ssi_sdk4 = require("@sphereon/ssi-sdk.core");
-var import_ssi_types = require("@sphereon/ssi-types");
-var import_uuid = require("uuid");
-var import_pex2 = require("@sphereon/pex");
+var import_ssi_sdk3 = require("@sphereon/ssi-sdk.core");
 var import_ssi_types2 = require("@sphereon/ssi-types");
-var logger = import_ssi_types2.Loggers.DEFAULT.get("sphereon:oid4vp:OpSession");
+var import_uuid = require("uuid");
+var logger2 = import_ssi_types2.Loggers.DEFAULT.get("sphereon:oid4vp:OpSession");
 var OpSession = class _OpSession {
   static {
     __name(this, "OpSession");
@@ -883,13 +791,11 @@ var OpSession = class _OpSession {
   verifiedAuthorizationRequest;
   _nonce;
   _state;
-  _providedPresentationDefinitions;
   constructor(options) {
     this.id = options.sessionId;
     this.options = options.op;
     this.context = options.context;
     this.requestJwtOrUri = options.requestJwtOrUri;
-    this._providedPresentationDefinitions = options.providedPresentationDefinitions;
   }
   static async init(options) {
     return new _OpSession(options);
@@ -908,7 +814,7 @@ var OpSession = class _OpSession {
     return this.verifiedAuthorizationRequest;
   }
   async getAuthorizationRequestURI() {
-    return await import_did_auth_siop3.URI.fromAuthorizationRequest((await this.getAuthorizationRequest()).authorizationRequest);
+    return await import_did_auth_siop2.URI.fromAuthorizationRequest((await this.getAuthorizationRequest()).authorizationRequest);
   }
   get nonce() {
     if (!this._nonce) {
@@ -936,9 +842,9 @@ var OpSession = class _OpSession {
       didPrefix,
       agentMethods
     });
-    logger.debug(`RP supports subject syntax types: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
+    logger2.debug(`RP supports subject syntax types: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
     if (rpMethods.dids.length === 0) {
-      logger.debug(`RP does not support DIDs. Supported: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
+      logger2.debug(`RP does not support DIDs. Supported: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
       return [];
     }
     let intersection;
@@ -956,7 +862,7 @@ var OpSession = class _OpSession {
   }
   getAgentDIDMethodsSupported(opts) {
     const agentMethods = this.options.supportedDIDMethods?.map((method) => convertDidMethod(method, opts.didPrefix));
-    logger.debug(`agent methods: ${JSON.stringify(agentMethods)}`);
+    logger2.debug(`agent methods: ${JSON.stringify(agentMethods)}`);
     return agentMethods;
   }
   async getSubjectSyntaxTypesSupported() {
@@ -967,15 +873,15 @@ var OpSession = class _OpSession {
   async getRPDIDMethodsSupported(opts) {
     let keyType;
     const agentMethods = (opts.agentMethods ?? this.getAgentDIDMethodsSupported(opts))?.map((method) => convertDidMethod(method, opts.didPrefix)) ?? [];
-    logger.debug(`agent methods supported: ${JSON.stringify(agentMethods)}`);
+    logger2.debug(`agent methods supported: ${JSON.stringify(agentMethods)}`);
     const authReq = await this.getAuthorizationRequest();
     const subjectSyntaxTypesSupported = authReq.registrationMetadataPayload?.subject_syntax_types_supported?.map((method) => convertDidMethod(method, opts.didPrefix)).filter((val) => !val.startsWith("did"));
-    logger.debug(`subject syntax types supported in rp method supported: ${JSON.stringify(subjectSyntaxTypesSupported)}`);
+    logger2.debug(`subject syntax types supported in rp method supported: ${JSON.stringify(subjectSyntaxTypesSupported)}`);
     const aud = await authReq.authorizationRequest.getMergedProperty("aud");
     let rpMethods = [];
     if (aud && aud.startsWith("did:")) {
-      const didMethod = convertDidMethod((0, import_ssi_types.parseDid)(aud).method, opts.didPrefix);
-      logger.debug(`aud did method: ${didMethod}`);
+      const didMethod = convertDidMethod((0, import_ssi_types2.parseDid)(aud).method, opts.didPrefix);
+      logger2.debug(`aud did method: ${didMethod}`);
       if (subjectSyntaxTypesSupported && subjectSyntaxTypesSupported.length > 0 && !subjectSyntaxTypesSupported.includes("did") && !subjectSyntaxTypesSupported.includes(didMethod)) {
         throw Error(`The aud DID method ${didMethod} is not in the supported types ${subjectSyntaxTypesSupported}`);
       }
@@ -987,10 +893,10 @@ var OpSession = class _OpSession {
         subjectSyntaxTypesSupported
       ]).map((method) => convertDidMethod(method, opts.didPrefix));
     }
-    const isEBSI = rpMethods.length === 0 && (authReq.issuer?.includes(".ebsi.eu") || (await authReq.authorizationRequest.getMergedProperty("client_id"))?.includes(".ebsi.eu"));
+    const isEBSI = rpMethods.length === 0 && (authReq.issuer?.includes(".ebsi.eu") || authReq.authorizationRequest.getMergedProperty("client_id")?.includes(".ebsi.eu"));
     let codecName = void 0;
     if (isEBSI && (!aud || !aud.startsWith("http"))) {
-      logger.debug(`EBSI detected, adding did:key to supported DID methods for RP`);
+      logger2.debug(`EBSI detected, adding did:key to supported DID methods for RP`);
       const didKeyMethod = convertDidMethod("did:key", opts.didPrefix);
       if (!agentMethods?.includes(didKeyMethod)) {
         throw Error(`EBSI detected, but agent did not support did:key. Please reconfigure agent`);
@@ -1009,13 +915,13 @@ var OpSession = class _OpSession {
   }
   async getSupportedIdentifiers(opts) {
     const methods = await this.getSupportedDIDMethods(true);
-    logger.debug(`supported DID methods (did: prefix = true): ${JSON.stringify(methods)}`);
+    logger2.debug(`supported DID methods (did: prefix = true): ${JSON.stringify(methods)}`);
     if (methods.length === 0) {
       throw Error(`No DID methods are supported`);
     }
     const identifiers = await this.context.agent.didManagerFind().then((ids) => ids.filter((id) => methods.includes(id.provider)));
     if (identifiers.length === 0) {
-      logger.debug(`No identifiers available in agent supporting methods ${JSON.stringify(methods)}`);
+      logger2.debug(`No identifiers available in agent supporting methods ${JSON.stringify(methods)}`);
       if (opts?.createInCaseNoDIDFound !== false) {
         const { codecName, keyType } = await this.getRPDIDMethodsSupported({
           didPrefix: true,
@@ -1029,11 +935,11 @@ var OpSession = class _OpSession {
             type: keyType
           }
         });
-        logger.debug(`Created a new identifier for the SIOP interaction: ${identifier.did}`);
+        logger2.debug(`Created a new identifier for the SIOP interaction: ${identifier.did}`);
         identifiers.push(identifier);
       }
     }
-    logger.debug(`supported identifiers: ${JSON.stringify(identifiers.map((id) => id.did))}`);
+    logger2.debug(`supported identifiers: ${JSON.stringify(identifiers.map((id) => id.did))}`);
     return identifiers;
   }
   async getSupportedDIDs() {
@@ -1042,56 +948,11 @@ var OpSession = class _OpSession {
   async getRedirectUri() {
     return Promise.resolve(this.verifiedAuthorizationRequest.responseURI);
   }
-  async hasPresentationDefinitions() {
-    const defs = this._providedPresentationDefinitions ?? (await this.getAuthorizationRequest()).presentationDefinitions;
-    return defs !== void 0 && defs.length > 0;
-  }
-  async getPresentationDefinitions() {
-    if (!await this.hasPresentationDefinitions()) {
-      throw Error(`No presentation definitions found`);
-    }
-    return this._providedPresentationDefinitions ?? (await this.getAuthorizationRequest()).presentationDefinitions;
-  }
-  async getOID4VP(args) {
-    return await OID4VP.init(this, args.allIdentifiers ?? [], args.hasher);
-  }
-  createPresentationVerificationCallback(context) {
-    async function presentationVerificationCallback(args, presentationSubmission) {
-      let result;
-      if (import_ssi_types.CredentialMapper.isSdJwtEncoded(args)) {
-        try {
-          const sdJwtResult = await context.agent.verifySdJwtPresentation({
-            presentation: args
-          });
-          result = {
-            verified: "header" in sdJwtResult,
-            error: "header" in sdJwtResult ? void 0 : {
-              message: "could not verify SD JWT presentation"
-            }
-          };
-        } catch (error) {
-          result = {
-            verified: false,
-            error: {
-              message: error.message
-            }
-          };
-        }
-      } else {
-        result = await context.agent.verifyPresentation({
-          presentation: args
-        });
-      }
-      return result;
-    }
-    __name(presentationVerificationCallback, "presentationVerificationCallback");
-    return presentationVerificationCallback;
-  }
   async createJarmResponseCallback({ responseOpts }) {
     const agent = this.context.agent;
     return /* @__PURE__ */ __name(async function jarmResponse(opts) {
       const { clientMetadata, requestObjectPayload, authorizationResponsePayload: authResponse } = opts;
-      const jwk = await import_did_auth_siop3.OP.extractEncJwksFromClientMetadata(clientMetadata);
+      const jwk = await import_did_auth_siop2.OP.extractEncJwksFromClientMetadata(clientMetadata);
       const recipientKey = await agent.identifierExternalResolveByJwk({
         identifier: jwk
       });
@@ -1100,8 +961,8 @@ var OpSession = class _OpSession {
         protectedHeader: {},
         alg: requestObjectPayload.client_metadata.authorization_encrypted_response_alg ?? "ECDH-ES",
         enc: requestObjectPayload.client_metadata.authorization_encrypted_response_enc ?? "A256GCM",
-        apv: (0, import_ssi_sdk4.encodeBase64url)(opts.requestObjectPayload.nonce),
-        apu: (0, import_ssi_sdk4.encodeBase64url)((0, import_uuid.v4)()),
+        apv: (0, import_ssi_sdk3.encodeBase64url)(opts.requestObjectPayload.nonce),
+        apu: (0, import_ssi_sdk3.encodeBase64url)((0, import_uuid.v4)()),
         payload: authResponse,
         issuer: responseOpts.issuer,
         audience: responseOpts.audience
@@ -1113,6 +974,7 @@ var OpSession = class _OpSession {
     }, "jarmResponse");
   }
   async sendAuthorizationResponse(args) {
+    const { responseSignerOpts, dcqlResponse, isFirstParty } = args;
     const resolveOpts = this.options.resolveOpts ?? {
       resolver: (0, import_ssi_sdk_ext3.getAgentResolver)(this.context, {
         uniresolverResolution: true,
@@ -1123,23 +985,7 @@ var OpSession = class _OpSession {
     if (!resolveOpts.subjectSyntaxTypesSupported || resolveOpts.subjectSyntaxTypesSupported.length === 0) {
       resolveOpts.subjectSyntaxTypesSupported = await this.getSupportedDIDMethods(true);
     }
-    const verification = {
-      presentationVerificationCallback: this.createPresentationVerificationCallback(this.context)
-    };
     const request = await this.getAuthorizationRequest();
-    const hasDefinitions = await this.hasPresentationDefinitions();
-    if (hasDefinitions) {
-      const totalInputDescriptors = request.presentationDefinitions?.reduce((sum, pd) => {
-        return sum + pd.definition.input_descriptors.length;
-      }, 0);
-      const totalVCs = args.verifiablePresentations ? this.countVCsInAllVPs(args.verifiablePresentations, args.hasher) : 0;
-      if (!request.presentationDefinitions || !args.verifiablePresentations || totalVCs !== totalInputDescriptors) {
-        throw Error(`Amount of presentations ${args.verifiablePresentations?.length}, doesn't match expected ${request.presentationDefinitions?.length}`);
-      } else if (!args.presentationSubmission) {
-        throw Error(`Presentation submission is required when verifiable presentations are required`);
-      }
-    }
-    const verifiablePresentations = args.verifiablePresentations ? args.verifiablePresentations.map((vp) => import_ssi_types.CredentialMapper.storedPresentationToOriginalFormat(vp)) : [];
     const op = await createOP({
       opOptions: {
         ...this.options,
@@ -1151,23 +997,16 @@ var OpSession = class _OpSession {
         wellknownDIDVerifyCallback: this.options.wellknownDIDVerifyCallback,
         supportedVersions: request.versions
       },
-      idOpts: args.responseSignerOpts,
+      idOpts: responseSignerOpts,
       context: this.context
     });
-    let issuer = args.responseSignerOpts.issuer;
+    let issuer = responseSignerOpts.issuer;
     const responseOpts = {
-      verification,
       issuer,
-      ...args.isFirstParty && {
-        isFirstParty: args.isFirstParty
+      ...isFirstParty && {
+        isFirstParty
       },
-      ...args.verifiablePresentations && {
-        presentationExchange: {
-          verifiablePresentations,
-          presentationSubmission: args.presentationSubmission
-        }
-      },
-      dcqlQuery: args.dcqlResponse
+      dcqlResponse
     };
     const authResponse = await op.createAuthorizationResponse(request, responseOpts);
     const response = await op.submitAuthorizationResponse(authResponse, await this.createJarmResponseCallback({
@@ -1179,24 +1018,6 @@ var OpSession = class _OpSession {
       return response;
     }
   }
-  countVCsInAllVPs(verifiablePresentations, hasher) {
-    return verifiablePresentations.reduce((sum, vp) => {
-      if (import_ssi_types.CredentialMapper.isMsoMdocDecodedPresentation(vp) || import_ssi_types.CredentialMapper.isMsoMdocOid4VPEncoded(vp)) {
-        return sum + 1;
-      }
-      const uvp = import_ssi_types.CredentialMapper.toUniformPresentation(vp, {
-        hasher: hasher ?? this.options.hasher
-      });
-      if (uvp.verifiableCredential?.length) {
-        return sum + uvp.verifiableCredential?.length;
-      }
-      const isSdJWT = import_ssi_types.CredentialMapper.isSdJwtDecodedCredential(uvp);
-      if (isSdJWT || uvp.verifiableCredential && !import_pex2.PEX.allowMultipleVCsPerPresentation(uvp.verifiableCredential)) {
-        return sum + 1;
-      }
-      return sum;
-    }, 0);
-  }
 };
 function convertDidMethod(didMethod, didPrefix) {
   if (didPrefix === false) {
@@ -1206,11 +1027,6 @@ function convertDidMethod(didMethod, didPrefix) {
 }
 __name(convertDidMethod, "convertDidMethod");
 
-// src/agent/DidAuthSiopOpAuthenticator.ts
-var import_pex4 = require("@sphereon/pex");
-var import_utils = require("@veramo/utils");
-var import_dcql3 = require("dcql");
-
 // src/machine/Siopv2Machine.ts
 var import_xstate = require("xstate");
 
@@ -1257,7 +1073,7 @@ var translate = Localization.translate;
 
 // src/machine/Siopv2Machine.ts
 var import_ssi_types3 = require("@sphereon/ssi-types");
-var logger2 = import_ssi_types3.Loggers.DEFAULT.get(LOGGER_NAMESPACE);
+var logger3 = import_ssi_types3.Loggers.DEFAULT.get(LOGGER_NAMESPACE);
 var Siopv2HasNoContactGuard = /* @__PURE__ */ __name((_ctx, _event) => {
   const { contact } = _ctx;
   return contact === void 0;
@@ -1278,7 +1094,7 @@ var Siopv2HasSelectableCredentialsAndContactGuard = /* @__PURE__ */ __name((_ctx
   if (!contact) {
     throw new Error("Missing contact request data in context");
   }
-  return authorizationRequestData.presentationDefinitions !== void 0;
+  return authorizationRequestData.dcqlQuery !== void 0;
 }, "Siopv2HasSelectableCredentialsAndContactGuard");
 var Siopv2CreateContactGuard = /* @__PURE__ */ __name((_ctx, _event) => {
   const { contactAlias, hasContactConsent } = _ctx;
@@ -1289,7 +1105,7 @@ var Siopv2HasSelectedRequiredCredentialsGuard = /* @__PURE__ */ __name((_ctx, _e
   if (authorizationRequestData === void 0) {
     throw new Error("Missing authorization request data in context");
   }
-  if (authorizationRequestData.presentationDefinitions === void 0 || authorizationRequestData.presentationDefinitions.length === 0) {
+  if (authorizationRequestData.dcqlQuery === void 0) {
     throw Error("No presentation definitions present");
   }
   return _ctx.selectedCredentials.length > 0;
@@ -1299,7 +1115,7 @@ var Siopv2IsSiopOnlyGuard = /* @__PURE__ */ __name((_ctx, _event) => {
   if (authorizationRequestData === void 0) {
     throw new Error("Missing authorization request data in context");
   }
-  return authorizationRequestData.presentationDefinitions === void 0;
+  return authorizationRequestData.dcqlQuery === void 0;
 }, "Siopv2IsSiopOnlyGuard");
 var Siopv2IsSiopWithOID4VPGuard = /* @__PURE__ */ __name((_ctx, _event) => {
   const { authorizationRequestData, selectableCredentialsMap } = _ctx;
@@ -1309,7 +1125,7 @@ var Siopv2IsSiopWithOID4VPGuard = /* @__PURE__ */ __name((_ctx, _event) => {
   if (!selectableCredentialsMap) {
     throw new Error("Missing selectableCredentialsMap in context");
   }
-  return authorizationRequestData.presentationDefinitions !== void 0;
+  return authorizationRequestData.dcqlQuery !== void 0;
 }, "Siopv2IsSiopWithOID4VPGuard");
 var createSiopv2Machine = /* @__PURE__ */ __name((opts) => {
   const { url, idOpts: idOpts2 } = opts;
@@ -1587,7 +1403,7 @@ var Siopv2Machine = class {
     __name(this, "Siopv2Machine");
   }
   static newInstance(opts) {
-    logger2.info("New Siopv2Machine instance");
+    logger3.info("New Siopv2Machine instance");
     const interpreter = (0, import_xstate.interpret)(createSiopv2Machine(opts).withConfig({
       services: {
         ...opts?.services
@@ -1615,7 +1431,7 @@ var Siopv2Machine = class {
       });
     }
     interpreter.onTransition((snapshot) => {
-      logger2.info("onTransition to new state", snapshot.value);
+      logger3.info("onTransition to new state", snapshot.value);
     });
     return {
       interpreter
@@ -1624,115 +1440,57 @@ var Siopv2Machine = class {
 };
 
 // src/services/Siopv2MachineService.ts
-var import_did_auth_siop4 = require("@sphereon/did-auth-siop");
-var import_pex3 = require("@sphereon/pex");
-var import_ssi_sdk_ext4 = require("@sphereon/ssi-sdk-ext.identifier-resolution");
+var import_ssi_sdk_ext4 = require("@sphereon/ssi-sdk-ext.did-utils");
+var import_ssi_sdk_ext5 = require("@sphereon/ssi-sdk-ext.identifier-resolution");
+var import_ssi_sdk4 = require("@sphereon/ssi-sdk.core");
 var import_ssi_sdk5 = require("@sphereon/ssi-sdk.credential-store");
-var import_ssi_sdk6 = require("@sphereon/ssi-sdk.data-store");
+var import_ssi_sdk6 = require("@sphereon/ssi-sdk.data-store-types");
 var import_ssi_types6 = require("@sphereon/ssi-types");
-var import_ssi_sdk_ext5 = require("@sphereon/ssi-sdk-ext.did-utils");
-var import_ssi_sdk7 = require("@sphereon/ssi-sdk.core");
 var import_dcql = require("dcql");
 
 // src/utils/dcql.ts
 var import_ssi_types5 = require("@sphereon/ssi-types");
+var import_did_auth_siop3 = require("@sphereon/did-auth-siop");
 
 // src/utils/CredentialUtils.ts
 var import_ssi_types4 = require("@sphereon/ssi-types");
-var getOriginalVerifiableCredential = /* @__PURE__ */ __name((credential) => {
-  if (isUniqueDigitalCredential(credential)) {
-    if (!credential.originalVerifiableCredential) {
-      throw new Error("originalVerifiableCredential is not defined in UniqueDigitalCredential");
-    }
-    return getCredentialFromProofOrWrapped(credential.originalVerifiableCredential);
-  }
-  return getCredentialFromProofOrWrapped(credential);
-}, "getOriginalVerifiableCredential");
-var getCredentialFromProofOrWrapped = /* @__PURE__ */ __name((cred, hasher) => {
-  if (typeof cred === "object" && "proof" in cred && "jwt" in cred.proof && import_ssi_types4.CredentialMapper.isSdJwtEncoded(cred.proof.jwt)) {
-    return cred.proof.jwt;
-  }
-  return import_ssi_types4.CredentialMapper.toWrappedVerifiableCredential(cred, {
-    hasher
-  }).original;
-}, "getCredentialFromProofOrWrapped");
 var isUniqueDigitalCredential = /* @__PURE__ */ __name((credential) => {
   return credential.digitalCredential !== void 0;
 }, "isUniqueDigitalCredential");
 
 // src/utils/dcql.ts
 function convertToDcqlCredentials(credential, hasher) {
-  let payload;
+  let originalVerifiableCredential;
   if (isUniqueDigitalCredential(credential)) {
     if (!credential.originalVerifiableCredential) {
       throw new Error("originalVerifiableCredential is not defined in UniqueDigitalCredential");
     }
-    payload = import_ssi_types5.CredentialMapper.decodeVerifiableCredential(credential.originalVerifiableCredential, hasher);
+    originalVerifiableCredential = import_ssi_types5.CredentialMapper.decodeVerifiableCredential(credential.originalVerifiableCredential, hasher);
   } else {
-    payload = import_ssi_types5.CredentialMapper.decodeVerifiableCredential(credential, hasher);
+    originalVerifiableCredential = import_ssi_types5.CredentialMapper.decodeVerifiableCredential(credential, hasher);
   }
-  if (!payload) {
+  if (!originalVerifiableCredential) {
     throw new Error("No payload found");
   }
-  if ("decodedPayload" in payload && payload.decodedPayload) {
-    payload = payload.decodedPayload;
-  }
-  if ("vct" in payload) {
-    return {
-      vct: payload.vct,
-      claims: payload,
-      credential_format: "vc+sd-jwt"
-    };
-  } else if ("docType" in payload && "namespaces" in payload) {
-    return {
-      docType: payload.docType,
-      namespaces: payload.namespaces,
-      claims: payload
-    };
-  } else {
-    return {
-      claims: payload,
-      credential_format: "jwt_vc_json"
-    };
+  if (import_ssi_types5.CredentialMapper.isJwtDecodedCredential(originalVerifiableCredential)) {
+    return import_did_auth_siop3.Dcql.toDcqlJwtCredential(import_ssi_types5.CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential));
+  } else if (import_ssi_types5.CredentialMapper.isSdJwtDecodedCredential(originalVerifiableCredential)) {
+    return import_did_auth_siop3.Dcql.toDcqlSdJwtCredential(import_ssi_types5.CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential));
+  } else if (import_ssi_types5.CredentialMapper.isMsoMdocDecodedCredential(originalVerifiableCredential)) {
+    return import_did_auth_siop3.Dcql.toDcqlMdocCredential(import_ssi_types5.CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential));
+  } else if (import_ssi_types5.CredentialMapper.isW3cCredential(originalVerifiableCredential)) {
+    return import_did_auth_siop3.Dcql.toDcqlJsonLdCredential(import_ssi_types5.CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential));
   }
+  throw Error(`Unable to map credential to DCQL credential. Credential: ${JSON.stringify(originalVerifiableCredential)}`);
 }
 __name(convertToDcqlCredentials, "convertToDcqlCredentials");
 
 // src/services/Siopv2MachineService.ts
-var logger3 = import_ssi_types6.Loggers.DEFAULT.get(LOGGER_NAMESPACE);
-var createEbsiIdentifier = /* @__PURE__ */ __name(async (agentContext) => {
-  logger3.log(`No EBSI key present yet. Creating a new one...`);
-  const { result: newIdentifier, created } = await (0, import_ssi_sdk_ext5.getOrCreatePrimaryIdentifier)(agentContext, {
-    method: import_ssi_sdk_ext5.SupportedDidMethodEnum.DID_KEY,
-    createOpts: {
-      options: {
-        codecName: "jwk_jcs-pub",
-        type: "Secp256r1"
-      }
-    }
-  });
-  logger3.log(`EBSI key created: ${newIdentifier.did}`);
-  if (created) {
-    await agentContext.agent.emit(Siopv2HolderEvent.IDENTIFIER_CREATED, {
-      result: newIdentifier
-    });
-  }
-  return await agentContext.agent.identifierManagedGetByDid({
-    identifier: newIdentifier.did
-  });
-}, "createEbsiIdentifier");
-var hasEbsiClient = /* @__PURE__ */ __name(async (authorizationRequest) => {
-  const clientId = await authorizationRequest.getMergedProperty("client_id");
-  const redirectUri = await authorizationRequest.getMergedProperty("redirect_uri");
-  return clientId?.toLowerCase().includes(".ebsi.eu") || redirectUri?.toLowerCase().includes(".ebsi.eu");
-}, "hasEbsiClient");
+var CLOCK_SKEW2 = 120;
+var logger4 = import_ssi_types6.Loggers.DEFAULT.get(LOGGER_NAMESPACE);
 var siopSendAuthorizationResponse = /* @__PURE__ */ __name(async (connectionType, args, context) => {
   const { agent } = context;
-  const agentContext = {
-    ...context,
-    agent: context.agent
-  };
-  let { idOpts: idOpts2, isFirstParty, hasher = import_ssi_sdk7.defaultHasher } = args;
+  const { credentials } = args;
   if (connectionType !== import_ssi_sdk6.ConnectionType.SIOPv2_OpenID4VP) {
     return Promise.reject(Error(`No supported authentication provider for type: ${connectionType}`));
   }
@@ -1740,252 +1498,154 @@ var siopSendAuthorizationResponse = /* @__PURE__ */ __name(async (connectionType
     sessionId: args.sessionId
   });
   const request = await session.getAuthorizationRequest();
-  const aud = await request.authorizationRequest.getMergedProperty("aud");
-  logger3.debug(`AUD: ${aud}`);
-  logger3.debug(JSON.stringify(request.authorizationRequest));
-  let presentationsAndDefs;
-  let presentationSubmission;
-  if (await session.hasPresentationDefinitions()) {
-    const oid4vp = await session.getOID4VP({
-      hasher
-    });
-    const credentialsAndDefinitions = args.verifiableCredentialsWithDefinition ? args.verifiableCredentialsWithDefinition : await oid4vp.filterCredentialsAgainstAllDefinitions(import_ssi_sdk6.CredentialRole.HOLDER);
-    const domain = await request.authorizationRequest.getMergedProperty("client_id") ?? request.issuer ?? (request.versions.includes(import_did_auth_siop4.SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1) ? "https://self-issued.me/v2/openid-vc" : "https://self-issued.me/v2");
-    logger3.log(`NONCE: ${session.nonce}, domain: ${domain}`);
-    const firstUniqueDC = credentialsAndDefinitions[0].credentials[0];
-    if (typeof firstUniqueDC !== "object" || !("digitalCredential" in firstUniqueDC)) {
-      return Promise.reject(Error("SiopMachine only supports UniqueDigitalCredentials for now"));
+  const aud = request.authorizationRequest.getMergedProperty("aud");
+  logger4.debug(`AUD: ${aud}`);
+  logger4.debug(JSON.stringify(request.authorizationRequest));
+  const domain = await request.authorizationRequest.getMergedProperty("client_id") ?? request.issuer ?? "https://self-issued.me/v2";
+  logger4.debug(`NONCE: ${session.nonce}, domain: ${domain}`);
+  const firstUniqueDC = credentials[0];
+  if (typeof firstUniqueDC !== "object" || !("digitalCredential" in firstUniqueDC)) {
+    return Promise.reject(Error("SiopMachine only supports UniqueDigitalCredentials for now"));
+  }
+  let identifier;
+  const digitalCredential = firstUniqueDC.digitalCredential;
+  const firstVC = firstUniqueDC.uniformVerifiableCredential;
+  let holder;
+  if (import_ssi_types6.CredentialMapper.isSdJwtDecodedCredential(firstVC)) {
+    holder = firstVC.decodedPayload.cnf?.jwk ? `did:jwk:${(0, import_ssi_sdk4.encodeJoseBlob)(firstVC.decodedPayload.cnf?.jwk)}#0` : firstVC.decodedPayload.sub;
+  } else {
+    holder = Array.isArray(firstVC.credentialSubject) ? firstVC.credentialSubject[0].id : firstVC.credentialSubject.id;
+  }
+  if (!digitalCredential.kmsKeyRef) {
+    if (!holder) {
+      return Promise.reject(`No holder found and no kmsKeyRef in DB. Cannot determine identifier to use`);
     }
-    let identifier;
-    const digitalCredential = firstUniqueDC.digitalCredential;
-    const firstVC = firstUniqueDC.uniformVerifiableCredential;
-    const holder = import_ssi_types6.CredentialMapper.isSdJwtDecodedCredential(firstVC) ? firstVC.decodedPayload.cnf?.jwk ? (
-      //doesn't apply to did:jwk only, as you can represent any DID key as a JWK. So whenever you encounter a JWK it doesn't mean it had to come from a did:jwk in the system. It just can always be represented as a did:jwk
-      `did:jwk:${(0, import_ssi_sdk7.encodeJoseBlob)(firstVC.decodedPayload.cnf?.jwk)}#0`
-    ) : firstVC.decodedPayload.sub : Array.isArray(firstVC.credentialSubject) ? firstVC.credentialSubject[0].id : firstVC.credentialSubject.id;
-    if (!digitalCredential.kmsKeyRef) {
-      if (!holder) {
-        return Promise.reject(`No holder found and no kmsKeyRef in DB. Cannot determine identifier to use`);
-      }
-      try {
-        identifier = await session.context.agent.identifierManagedGet({
-          identifier: holder
-        });
-      } catch (e) {
-        logger3.debug(`Holder DID not found: ${holder}`);
-        throw e;
-      }
-    } else if ((0, import_ssi_sdk_ext4.isOID4VCIssuerIdentifier)(digitalCredential.kmsKeyRef)) {
-      identifier = await session.context.agent.identifierManagedGetByOID4VCIssuer({
-        identifier: firstUniqueDC.digitalCredential.kmsKeyRef
+    try {
+      identifier = await session.context.agent.identifierManagedGet({
+        identifier: holder
       });
-    } else {
-      switch (digitalCredential.subjectCorrelationType) {
-        case "DID":
-          identifier = await session.context.agent.identifierManagedGetByDid({
-            identifier: digitalCredential.subjectCorrelationId ?? holder,
-            kmsKeyRef: digitalCredential.kmsKeyRef
-          });
-          break;
-        // TODO other implementations?
-        default:
-          if (digitalCredential.subjectCorrelationId?.startsWith("did:") || holder?.startsWith("did:")) {
-            identifier = await session.context.agent.identifierManagedGetByDid({
-              identifier: digitalCredential.subjectCorrelationId ?? holder,
-              kmsKeyRef: digitalCredential.kmsKeyRef
-            });
-          } else {
-            identifier = await session.context.agent.identifierManagedGetByKid({
-              identifier: digitalCredential.subjectCorrelationId ?? holder ?? digitalCredential.kmsKeyRef,
-              kmsKeyRef: digitalCredential.kmsKeyRef
-            });
-          }
-      }
+    } catch (e) {
+      logger4.debug(`Holder DID not found: ${holder}`);
+      throw e;
     }
-    if (identifier === void 0 && idOpts2 !== void 0 && await hasEbsiClient(request.authorizationRequest)) {
-      identifier = await createEbsiIdentifier(agentContext);
-    }
-    logger3.debug(`Identifier`, identifier);
-    presentationsAndDefs = await oid4vp.createVerifiablePresentations(import_ssi_sdk6.CredentialRole.HOLDER, credentialsAndDefinitions, {
-      idOpts: identifier,
-      proofOpts: {
-        nonce: session.nonce,
-        domain
-      }
+  } else if ((0, import_ssi_sdk_ext5.isOID4VCIssuerIdentifier)(digitalCredential.kmsKeyRef)) {
+    identifier = await session.context.agent.identifierManagedGetByOID4VCIssuer({
+      identifier: firstUniqueDC.digitalCredential.kmsKeyRef
     });
-    if (!presentationsAndDefs || presentationsAndDefs.length === 0) {
-      throw Error("No verifiable presentations could be created");
-    } else if (presentationsAndDefs.length > 1) {
-      throw Error(`Only one verifiable presentation supported for now. Got ${presentationsAndDefs.length}`);
-    }
-    idOpts2 = presentationsAndDefs[0].idOpts;
-    presentationSubmission = presentationsAndDefs[0].presentationSubmission;
-    logger3.log(`Definitions and locations:`, JSON.stringify(presentationsAndDefs?.[0]?.verifiablePresentations, null, 2));
-    logger3.log(`Presentation Submission:`, JSON.stringify(presentationSubmission, null, 2));
-    const mergedVerifiablePresentations = presentationsAndDefs?.flatMap((pd) => pd.verifiablePresentations) || [];
-    return await session.sendAuthorizationResponse({
-      ...presentationsAndDefs && {
-        verifiablePresentations: mergedVerifiablePresentations
-      },
-      ...presentationSubmission && {
-        presentationSubmission
-      },
-      // todo: Change issuer value in case we do not use identifier. Use key.meta.jwkThumbprint then
-      responseSignerOpts: idOpts2,
-      isFirstParty
-    });
-  } else if (request.dcqlQuery) {
-    if (args.verifiableCredentialsWithDefinition !== void 0 && args.verifiableCredentialsWithDefinition !== null) {
-      const vcs = args.verifiableCredentialsWithDefinition.flatMap((vcd) => vcd.credentials);
-      const domain = await request.authorizationRequest.getMergedProperty("client_id") ?? request.issuer ?? (request.versions.includes(import_did_auth_siop4.SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1) ? "https://self-issued.me/v2/openid-vc" : "https://self-issued.me/v2");
-      logger3.debug(`NONCE: ${session.nonce}, domain: ${domain}`);
-      const firstUniqueDC = vcs[0];
-      if (typeof firstUniqueDC !== "object" || !("digitalCredential" in firstUniqueDC)) {
-        return Promise.reject(Error("SiopMachine only supports UniqueDigitalCredentials for now"));
-      }
-      let identifier;
-      const digitalCredential = firstUniqueDC.digitalCredential;
-      const firstVC = firstUniqueDC.uniformVerifiableCredential;
-      const holder = import_ssi_types6.CredentialMapper.isSdJwtDecodedCredential(firstVC) ? firstVC.decodedPayload.cnf?.jwk ? (
-        //doesn't apply to did:jwk only, as you can represent any DID key as a JWK. So whenever you encounter a JWK it doesn't mean it had to come from a did:jwk in the system. It just can always be represented as a did:jwk
-        `did:jwk:${(0, import_ssi_sdk7.encodeJoseBlob)(firstVC.decodedPayload.cnf?.jwk)}#0`
-      ) : firstVC.decodedPayload.sub : Array.isArray(firstVC.credentialSubject) ? firstVC.credentialSubject[0].id : firstVC.credentialSubject.id;
-      if (!digitalCredential.kmsKeyRef) {
-        if (!holder) {
-          return Promise.reject(`No holder found and no kmsKeyRef in DB. Cannot determine identifier to use`);
-        }
-        try {
-          identifier = await session.context.agent.identifierManagedGet({
-            identifier: holder
-          });
-        } catch (e) {
-          logger3.debug(`Holder DID not found: ${holder}`);
-          throw e;
-        }
-      } else if ((0, import_ssi_sdk_ext4.isOID4VCIssuerIdentifier)(digitalCredential.kmsKeyRef)) {
-        identifier = await session.context.agent.identifierManagedGetByOID4VCIssuer({
-          identifier: firstUniqueDC.digitalCredential.kmsKeyRef
+  } else {
+    switch (digitalCredential.subjectCorrelationType) {
+      case "DID":
+        identifier = await session.context.agent.identifierManagedGetByDid({
+          identifier: digitalCredential.subjectCorrelationId ?? holder,
+          kmsKeyRef: digitalCredential.kmsKeyRef
         });
-      } else {
-        switch (digitalCredential.subjectCorrelationType) {
-          case "DID":
-            identifier = await session.context.agent.identifierManagedGetByDid({
-              identifier: digitalCredential.subjectCorrelationId ?? holder,
-              kmsKeyRef: digitalCredential.kmsKeyRef
-            });
-            break;
-          // TODO other implementations?
-          default:
-            identifier = await session.context.agent.identifierManagedGetByKid({
-              identifier: digitalCredential.subjectCorrelationId ?? holder ?? digitalCredential.kmsKeyRef,
-              kmsKeyRef: digitalCredential.kmsKeyRef
-            });
-        }
-      }
-      console.log(`Identifier`, identifier);
-      const dcqlRepresentations = [];
-      vcs.forEach((vc) => {
-        const rep = convertToDcqlCredentials(vc, args.hasher);
-        if (rep) {
-          dcqlRepresentations.push(rep);
-        }
-      });
-      const queryResult = import_dcql.DcqlQuery.query(request.dcqlQuery, dcqlRepresentations);
-      const presentation = {};
-      for (const [key, value] of Object.entries(queryResult.credential_matches)) {
-        const allMatches = Array.isArray(value) ? value : [
-          value
-        ];
-        allMatches.forEach((match) => {
-          if (match.success) {
-            const originalCredential = getOriginalVerifiableCredential(vcs[match.input_credential_index]);
-            if (!originalCredential) {
-              throw new Error(`Index ${match.input_credential_index} out of range in credentials array`);
-            }
-            presentation[key] = originalCredential["compactSdJwtVc"] !== void 0 ? originalCredential.compactSdJwtVc : originalCredential;
-          }
+        break;
+      // TODO other implementations?
+      default:
+        identifier = await session.context.agent.identifierManagedGetByKid({
+          identifier: digitalCredential.subjectCorrelationId ?? holder ?? digitalCredential.kmsKeyRef,
+          kmsKeyRef: digitalCredential.kmsKeyRef
         });
+    }
+  }
+  const dcqlCredentialsWithCredentials = new Map(credentials.map((vc) => [
+    convertToDcqlCredentials(vc),
+    vc
+  ]));
+  const queryResult = import_dcql.DcqlQuery.query(request.dcqlQuery, Array.from(dcqlCredentialsWithCredentials.keys()));
+  if (!queryResult.can_be_satisfied) {
+    return Promise.reject(Error("Credentials do not match required query request"));
+  }
+  const presentationContext = {
+    nonce: request.requestObject?.getPayload()?.nonce ?? session.nonce,
+    audience: domain,
+    agent: context.agent,
+    clockSkew: CLOCK_SKEW2,
+    hasher: args.hasher
+  };
+  const presentation = {};
+  const uniqueCredentials = Array.from(dcqlCredentialsWithCredentials.values());
+  for (const [key, value] of Object.entries(queryResult.credential_matches)) {
+    if (value.success) {
+      const matchedCredentials = value.valid_credentials.map((cred) => uniqueCredentials[cred.input_credential_index]);
+      const vc = matchedCredentials[0];
+      if (!vc) {
+        continue;
+      }
+      try {
+        const vp = await createVerifiablePresentationForFormat(vc, identifier, presentationContext);
+        presentation[key] = vp;
+      } catch (error) {
+        logger4.error(`Failed to create VP for credential ${key}:`, error);
+        throw error;
       }
-      const response = session.sendAuthorizationResponse({
-        responseSignerOpts: identifier,
-        ...{
-          dcqlQuery: {
-            dcqlPresentation: import_dcql.DcqlPresentation.parse(presentation)
-          }
-        }
-      });
-      logger3.debug(`Response: `, response);
-      return response;
     }
   }
-  throw Error("Presentation Definition or DCQL is required");
+  const dcqlPresentation = import_dcql.DcqlPresentation.parse(presentation);
+  const response = session.sendAuthorizationResponse({
+    responseSignerOpts: identifier,
+    dcqlResponse: {
+      dcqlPresentation
+    }
+  });
+  logger4.debug(`Response: `, response);
+  return response;
 }, "siopSendAuthorizationResponse");
-function buildPartialPD(inputDescriptor, presentationDefinition) {
-  return {
-    ...presentationDefinition,
-    input_descriptors: [
-      inputDescriptor
-    ]
-  };
-}
-__name(buildPartialPD, "buildPartialPD");
-var getSelectableCredentials = /* @__PURE__ */ __name(async (presentationDefinition, context) => {
+var getSelectableCredentials = /* @__PURE__ */ __name(async (dcqlQuery, context) => {
   const agentContext = {
     ...context,
     agent: context.agent
   };
   const { agent } = agentContext;
-  const pex = new import_pex3.PEX();
   const uniqueVerifiableCredentials = await agent.crsGetUniqueCredentials({
-    filter: (0, import_ssi_sdk5.verifiableCredentialForRoleFilter)(import_ssi_sdk6.CredentialRole.HOLDER)
+    filter: (0, import_ssi_sdk5.verifiableCredentialForRoleFilter)(import_ssi_types6.CredentialRole.HOLDER)
   });
-  const credentialBranding = await agent.ibGetCredentialBranding();
+  const branding = await agent.ibGetCredentialBranding();
+  const dcqlCredentialsWithCredentials = new Map(uniqueVerifiableCredentials.map((vc) => [
+    convertToDcqlCredentials(vc),
+    vc
+  ]));
+  const queryResult = import_dcql.DcqlQuery.query(dcqlQuery, Array.from(dcqlCredentialsWithCredentials.keys()));
+  const uniqueCredentials = Array.from(dcqlCredentialsWithCredentials.values());
   const selectableCredentialsMap = /* @__PURE__ */ new Map();
-  for (const inputDescriptor of presentationDefinition.input_descriptors) {
-    const partialPD = buildPartialPD(inputDescriptor, presentationDefinition);
-    const originalCredentials = uniqueVerifiableCredentials.map((uniqueVC) => {
-      return import_ssi_types6.CredentialMapper.storedCredentialToOriginalFormat(uniqueVC.originalVerifiableCredential);
-    });
-    const selectionResults = pex.selectFrom(partialPD, originalCredentials);
-    const selectableCredentials = [];
-    for (const selectedCredential of selectionResults.verifiableCredential || []) {
-      const filteredUniqueVC = uniqueVerifiableCredentials.find((uniqueVC) => {
-        const proof = uniqueVC.uniformVerifiableCredential.proof;
-        return Array.isArray(proof) ? proof.some((proofItem) => proofItem.jwt === selectedCredential) : proof.jwt === selectedCredential;
-      });
-      if (filteredUniqueVC) {
-        const filteredCredentialBrandings = credentialBranding.filter((cb) => cb.vcHash === filteredUniqueVC.hash);
-        const issuerPartyIdentity = await agent.cmGetContacts({
-          filter: [
-            {
-              identities: {
-                identifier: {
-                  correlationId: filteredUniqueVC.uniformVerifiableCredential.issuerDid
-                }
+  for (const [key, value] of Object.entries(queryResult.credential_matches)) {
+    if (!value.valid_credentials) {
+      continue;
+    }
+    const mapSelectableCredentialPromises = value.valid_credentials.map(async (cred) => {
+      const matchedCredential = uniqueCredentials[cred.input_credential_index];
+      const credentialBranding = branding.filter((cb) => cb.vcHash === matchedCredential.hash);
+      const issuerPartyIdentity = await agent.cmGetContacts({
+        filter: [
+          {
+            identities: {
+              identifier: {
+                correlationId: matchedCredential.uniformVerifiableCredential.issuerDid
               }
             }
-          ]
-        });
-        const subjectPartyIdentity = await agent.cmGetContacts({
-          filter: [
-            {
-              identities: {
-                identifier: {
-                  correlationId: filteredUniqueVC.uniformVerifiableCredential.subjectDid
-                }
+          }
+        ]
+      });
+      const subjectPartyIdentity = await agent.cmGetContacts({
+        filter: [
+          {
+            identities: {
+              identifier: {
+                correlationId: matchedCredential.uniformVerifiableCredential.subjectDid
               }
             }
-          ]
-        });
-        selectableCredentials.push({
-          credential: filteredUniqueVC,
-          credentialBranding: filteredCredentialBrandings[0]?.localeBranding,
-          issuerParty: issuerPartyIdentity?.[0],
-          subjectParty: subjectPartyIdentity?.[0]
-        });
-      }
-    }
-    selectableCredentialsMap.set(inputDescriptor.id, selectableCredentials);
+          }
+        ]
+      });
+      return {
+        credential: matchedCredential,
+        credentialBranding: credentialBranding[0]?.localeBranding,
+        issuerParty: issuerPartyIdentity?.[0],
+        subjectParty: subjectPartyIdentity?.[0]
+      };
+    });
+    const selectableCredentials = await Promise.all(mapSelectableCredentialPromises);
+    selectableCredentialsMap.set(key, selectableCredentials);
   }
   return selectableCredentialsMap;
 }, "getSelectableCredentials");
@@ -2009,7 +1669,7 @@ var translateCorrelationIdToName = /* @__PURE__ */ __name(async (correlationId,
 }, "translateCorrelationIdToName");
 
 // src/agent/DidAuthSiopOpAuthenticator.ts
-var logger4 = import_ssi_types7.Loggers.DEFAULT.options(LOGGER_NAMESPACE, {}).get(LOGGER_NAMESPACE);
+var logger5 = import_ssi_types7.Loggers.DEFAULT.options(LOGGER_NAMESPACE, {}).get(LOGGER_NAMESPACE);
 var didAuthSiopOpAuthenticatorMethods = [
   "cmGetContacts",
   "cmGetContact",
@@ -2026,7 +1686,7 @@ var DidAuthSiopOpAuthenticator = class {
   static {
     __name(this, "DidAuthSiopOpAuthenticator");
   }
-  schema = schema.IDidAuthSiopOpAuthenticator;
+  schema = plugin_schema_default.IDidAuthSiopOpAuthenticator;
   methods = {
     siopGetOPSession: this.siopGetOPSession.bind(this),
     siopRegisterOPSession: this.siopRegisterOPSession.bind(this),
@@ -2163,13 +1823,13 @@ var DidAuthSiopOpAuthenticator = class {
         hasher: this.hasher
       }
     }));
-    logger4.debug(`session: ${JSON.stringify(session.id, null, 2)}`);
+    logger5.debug(`session: ${JSON.stringify(session.id, null, 2)}`);
     const verifiedAuthorizationRequest = await session.getAuthorizationRequest();
     const clientName = verifiedAuthorizationRequest.registrationMetadataPayload?.client_name;
     const url = verifiedAuthorizationRequest.responseURI ?? (args.url.includes("request_uri") ? decodeURIComponent(args.url.split("?request_uri=")[1].trim()) : verifiedAuthorizationRequest.issuer ?? verifiedAuthorizationRequest.registrationMetadataPayload?.client_id);
-    const uri = url.includes("://") ? new URL(url) : void 0;
+    const uri = url?.includes("://") ? new URL(url) : void 0;
     const correlationId = uri?.hostname ?? await this.determineCorrelationId(uri, verifiedAuthorizationRequest, clientName, context);
-    const clientId = await verifiedAuthorizationRequest.authorizationRequest.getMergedProperty("client_id");
+    const clientId = verifiedAuthorizationRequest.authorizationRequest.getMergedProperty("client_id");
     return {
       issuer: verifiedAuthorizationRequest.issuer,
       correlationId,
@@ -2177,7 +1837,6 @@ var DidAuthSiopOpAuthenticator = class {
       uri,
       name: clientName,
       clientId,
-      presentationDefinitions: await verifiedAuthorizationRequest.authorizationRequest.containsResponseType("vp_token") || verifiedAuthorizationRequest.versions.every((version) => version <= import_did_auth_siop5.SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1) && verifiedAuthorizationRequest.presentationDefinitions && verifiedAuthorizationRequest.presentationDefinitions.length > 0 ? verifiedAuthorizationRequest.presentationDefinitions : void 0,
       dcqlQuery: verifiedAuthorizationRequest.dcqlQuery
     };
   }
@@ -2226,12 +1885,12 @@ var DidAuthSiopOpAuthenticator = class {
     if (correlationId) {
       const identity = {
         alias: correlationId,
-        origin: import_ssi_sdk8.IdentityOrigin.EXTERNAL,
+        origin: import_ssi_sdk7.IdentityOrigin.EXTERNAL,
         roles: [
-          import_ssi_sdk8.CredentialRole.ISSUER
+          import_ssi_types7.CredentialRole.ISSUER
         ],
         identifier: {
-          type: correlationId.startsWith("did:") ? import_ssi_sdk8.CorrelationIdentifierType.DID : import_ssi_sdk8.CorrelationIdentifierType.URL,
+          type: correlationId.startsWith("did:") ? import_ssi_sdk7.CorrelationIdentifierType.DID : import_ssi_sdk7.CorrelationIdentifierType.URL,
           correlationId
         }
       };
@@ -2243,7 +1902,7 @@ var DidAuthSiopOpAuthenticator = class {
         contactId: contact.id,
         identity: addedIdentity
       });
-      logger4.info(`Contact identity created: ${JSON.stringify(addedIdentity)}`);
+      logger5.info(`Contact identity created: ${JSON.stringify(addedIdentity)}`);
     }
   }
   async siopSendResponse(args, context) {
@@ -2254,75 +1913,14 @@ var DidAuthSiopOpAuthenticator = class {
     if (authorizationRequestData === void 0) {
       return Promise.reject(Error("Missing authorization request data in context"));
     }
-    const pex = new import_pex4.PEX({
-      hasher: this.hasher
-    });
-    const verifiableCredentialsWithDefinition = [];
-    const dcqlCredentialsWithCredentials = /* @__PURE__ */ new Map();
-    if (Array.isArray(authorizationRequestData.presentationDefinitions) && authorizationRequestData?.presentationDefinitions.length > 0) {
-      try {
-        authorizationRequestData.presentationDefinitions?.forEach((presentationDefinition) => {
-          const { areRequiredCredentialsPresent, verifiableCredential: verifiableCredentials } = pex.selectFrom(presentationDefinition.definition, selectedCredentials.map((udc) => udc.originalVerifiableCredential));
-          if (areRequiredCredentialsPresent !== import_pex4.Status.ERROR && verifiableCredentials) {
-            let uniqueDigitalCredentials = [];
-            uniqueDigitalCredentials = verifiableCredentials.map((vc) => {
-              const hash = typeof vc === "string" ? (0, import_utils.computeEntryHash)(vc.split("~"[0])) : (0, import_utils.computeEntryHash)(vc);
-              const udc = selectedCredentials.find((udc2) => udc2.hash == hash || udc2.originalVerifiableCredential == vc);
-              if (!udc) {
-                throw Error(`UniqueDigitalCredential could not be found in store. Either the credential is not present in the store or the hash is not correct.`);
-              }
-              return udc;
-            });
-            verifiableCredentialsWithDefinition.push({
-              definition: presentationDefinition,
-              credentials: uniqueDigitalCredentials
-            });
-          }
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
-      if (verifiableCredentialsWithDefinition.length === 0) {
-        return Promise.reject(Error("None of the selected credentials match any of the presentation definitions."));
-      }
-    } else if (authorizationRequestData.dcqlQuery) {
-      if (this.hasMDocCredentials(selectedCredentials) || this.hasSdJwtCredentials(selectedCredentials)) {
-        try {
-          selectedCredentials.forEach((vc) => {
-            if (this.isSdJwtCredential(vc)) {
-              const payload = vc.originalVerifiableCredential.decodedPayload;
-              const result = {
-                claims: payload,
-                vct: payload.vct,
-                credential_format: "vc+sd-jwt"
-              };
-              dcqlCredentialsWithCredentials.set(result, vc);
-            } else {
-              throw Error(`Invalid credential format: ${vc.digitalCredential.documentFormat}`);
-            }
-          });
-        } catch (e) {
-          return Promise.reject(e);
-        }
-        const dcqlPresentationRecord = {};
-        const queryResult = import_dcql3.DcqlQuery.query(authorizationRequestData.dcqlQuery, Array.from(dcqlCredentialsWithCredentials.keys()));
-        for (const [key, value] of Object.entries(queryResult.credential_matches)) {
-          if (value.success) {
-            dcqlPresentationRecord[key] = this.retrieveEncodedCredential(dcqlCredentialsWithCredentials.get(value.output));
-          }
-        }
-      }
-    }
-    const response = await siopSendAuthorizationResponse(import_ssi_sdk8.ConnectionType.SIOPv2_OpenID4VP, {
+    const response = await siopSendAuthorizationResponse(import_ssi_sdk7.ConnectionType.SIOPv2_OpenID4VP, {
       sessionId: didAuthConfig.sessionId,
       ...args.idOpts && {
         idOpts: args.idOpts
       },
-      ...authorizationRequestData.presentationDefinitions !== void 0 && {
-        verifiableCredentialsWithDefinition
-      },
       isFirstParty,
-      hasher: this.hasher
+      hasher: this.hasher,
+      credentials: selectedCredentials
     }, context);
     const contentType = response.headers.get("content-type") || "";
     let responseBody = null;
@@ -2333,39 +1931,21 @@ var DidAuthSiopOpAuthenticator = class {
     return {
       body: responseBody,
       url: response?.url,
-      queryParams: (0, import_did_auth_siop5.decodeUriAsJson)(response?.url)
+      queryParams: (0, import_did_auth_siop4.decodeUriAsJson)(response?.url)
     };
   }
-  hasMDocCredentials = /* @__PURE__ */ __name((credentials) => {
-    return credentials.some(this.isMDocCredential);
-  }, "hasMDocCredentials");
-  isMDocCredential = /* @__PURE__ */ __name((credential) => {
-    return credential.digitalCredential.documentFormat === import_ssi_sdk8.CredentialDocumentFormat.MSO_MDOC && credential.digitalCredential.documentType === import_ssi_sdk8.DocumentType.VC;
-  }, "isMDocCredential");
-  hasSdJwtCredentials = /* @__PURE__ */ __name((credentials) => {
-    return credentials.some(this.isSdJwtCredential);
-  }, "hasSdJwtCredentials");
-  isSdJwtCredential = /* @__PURE__ */ __name((credential) => {
-    return credential.digitalCredential.documentFormat === import_ssi_sdk8.CredentialDocumentFormat.SD_JWT && credential.digitalCredential.documentType === import_ssi_sdk8.DocumentType.VC;
-  }, "isSdJwtCredential");
-  retrieveEncodedCredential = /* @__PURE__ */ __name((credential) => {
-    return credential.originalVerifiableCredential !== void 0 && credential.originalVerifiableCredential !== null && credential?.originalVerifiableCredential?.compactSdJwtVc !== void 0 && credential?.originalVerifiableCredential?.compactSdJwtVc !== null ? credential.originalVerifiableCredential.compactSdJwtVc : credential.originalVerifiableCredential;
-  }, "retrieveEncodedCredential");
   async siopGetSelectableCredentials(args, context) {
     const { authorizationRequestData } = args;
-    if (!authorizationRequestData || !authorizationRequestData.presentationDefinitions || authorizationRequestData.presentationDefinitions.length === 0) {
-      return Promise.reject(Error("Missing required fields in arguments or context"));
+    if (!authorizationRequestData?.dcqlQuery) {
+      return Promise.reject(Error("Missing required dcql query in context"));
     }
-    if (authorizationRequestData.presentationDefinitions.length > 1) {
-      return Promise.reject(Error("Multiple presentation definitions present"));
-    }
-    return getSelectableCredentials(authorizationRequestData.presentationDefinitions[0].definition, context);
+    return getSelectableCredentials(authorizationRequestData?.dcqlQuery, context);
   }
 };
 
 // src/machine/CallbackStateListener.ts
 var import_ssi_types8 = require("@sphereon/ssi-types");
-var logger5 = import_ssi_types8.Loggers.DEFAULT.options("sphereon:siopv2-oid4vp:op-auth", {
+var logger6 = import_ssi_types8.Loggers.DEFAULT.options("sphereon:siopv2-oid4vp:op-auth", {
   defaultLogLevel: import_ssi_types8.LogLevel.DEBUG,
   methods: [
     import_ssi_types8.LogMethod.CONSOLE
@@ -2374,21 +1954,21 @@ var logger5 = import_ssi_types8.Loggers.DEFAULT.options("sphereon:siopv2-oid4vp:
 var OID4VPCallbackStateListener = /* @__PURE__ */ __name((callbacks) => {
   return async (oid4vciMachine, state) => {
     if (state._event.type === "internal") {
-      logger5.debug("oid4vpCallbackStateListener: internal event");
+      logger6.debug("oid4vpCallbackStateListener: internal event");
       return;
     }
-    logger5.info(`VP state listener state: ${JSON.stringify(state.value)}`);
+    logger6.info(`VP state listener state: ${JSON.stringify(state.value)}`);
     if (!callbacks || callbacks.size === 0) {
-      logger5.info(`VP no callbacks registered for state: ${JSON.stringify(state.value)}`);
+      logger6.info(`VP no callbacks registered for state: ${JSON.stringify(state.value)}`);
       return;
     }
     for (const [stateKey, callback] of callbacks) {
       if (state.matches(stateKey)) {
-        logger5.log(`VP state callback for state: ${JSON.stringify(state.value)}, will execute...`);
-        await callback(oid4vciMachine, state).then(() => logger5.log(`VP state callback executed for state: ${JSON.stringify(state.value)}`)).catch((error) => {
-          logger5.error(`VP state callback failed for state: ${JSON.stringify(state.value)}, error: ${JSON.stringify(error?.message)}, ${JSON.stringify(state.event)}`);
+        logger6.log(`VP state callback for state: ${JSON.stringify(state.value)}, will execute...`);
+        await callback(oid4vciMachine, state).then(() => logger6.log(`VP state callback executed for state: ${JSON.stringify(state.value)}`)).catch((error) => {
+          logger6.error(`VP state callback failed for state: ${JSON.stringify(state.value)}, error: ${JSON.stringify(error?.message)}, ${JSON.stringify(state.event)}`);
           if (error.stack) {
-            logger5.error(error.stack);
+            logger6.error(error.stack);
           }
         });
         break;
@@ -2398,12 +1978,12 @@ var OID4VPCallbackStateListener = /* @__PURE__ */ __name((callbacks) => {
 }, "OID4VPCallbackStateListener");
 
 // src/link-handler/index.ts
-var import_ssi_sdk9 = require("@sphereon/ssi-sdk.agent-config");
-var import_ssi_sdk10 = require("@sphereon/ssi-sdk.core");
-var import_ssi_sdk11 = require("@sphereon/ssi-sdk.xstate-machine-persistence");
+var import_ssi_sdk8 = require("@sphereon/ssi-sdk.agent-config");
+var import_ssi_sdk9 = require("@sphereon/ssi-sdk.core");
+var import_ssi_sdk10 = require("@sphereon/ssi-sdk.xstate-machine-persistence");
 var import_ssi_types9 = require("@sphereon/ssi-types");
-var logger6 = import_ssi_types9.Loggers.DEFAULT.options(LOGGER_NAMESPACE, {}).get(LOGGER_NAMESPACE);
-var Siopv2OID4VPLinkHandler = class extends import_ssi_sdk10.LinkHandlerAdapter {
+var logger7 = import_ssi_types9.Loggers.DEFAULT.options(LOGGER_NAMESPACE, {}).get(LOGGER_NAMESPACE);
+var Siopv2OID4VPLinkHandler = class extends import_ssi_sdk9.LinkHandlerAdapter {
   static {
     __name(this, "Siopv2OID4VPLinkHandler");
   }
@@ -2422,15 +2002,15 @@ var Siopv2OID4VPLinkHandler = class extends import_ssi_sdk10.LinkHandlerAdapter
     this.idOpts = args.idOpts;
   }
   async handle(url, opts) {
-    logger6.debug(`handling SIOP link: ${url}`);
+    logger7.debug(`handling SIOP link: ${url}`);
     const siopv2Machine = await this.context.agent.siopGetMachineInterpreter({
       url,
       idOpts: opts?.idOpts ?? this.idOpts,
       stateNavigationListener: this.stateNavigationListener
     });
     const interpreter = siopv2Machine.interpreter;
-    if (!this.noStateMachinePersistence && !opts?.machineState && (0, import_ssi_sdk9.contextHasPlugin)(this.context, "machineStatesFindActive")) {
-      const init = await (0, import_ssi_sdk11.interpreterStartOrResume)({
+    if (!this.noStateMachinePersistence && !opts?.machineState && (0, import_ssi_sdk8.contextHasPlugin)(this.context, "machineStatesFindActive")) {
+      const init = await (0, import_ssi_sdk10.interpreterStartOrResume)({
         interpreter,
         context: this.context,
         cleanupAllOtherInstances: true,
@@ -2438,14 +2018,11 @@ var Siopv2OID4VPLinkHandler = class extends import_ssi_sdk10.LinkHandlerAdapter
         singletonCheck: true,
         noRegistration: this.noStateMachinePersistence
       });
-      logger6.debug(`SIOP machine started for link: ${url}`, init);
+      logger7.debug(`SIOP machine started for link: ${url}`, init);
     } else {
       interpreter.start(opts?.machineState);
-      logger6.debug(`SIOP machine started for link: ${url}`);
+      logger7.debug(`SIOP machine started for link: ${url}`);
     }
   }
 };
-
-// src/index.ts
-var schema = require_plugin_schema();
 //# sourceMappingURL=index.cjs.map