Fix the presentation submission in the oid4vp-rs e2e test.

Cargo.toml

@@ -9,28 +9,28 @@ repository = "https://github.com/spruceid/oidc4vp-rs/"
 documentation = "https://docs.rs/oid4vp/"
 
 [features]
-reqwest = ["dep:reqwest"]
-p256 = ["dep:p256"]
+default = []
 
 [dependencies]
 anyhow = "1.0.75"
 async-trait = "0.1.73"
 base64 = "0.21.4"
-did-web = "0.2.2"
 http = "1.1.0"
+# NOTE: ssi-jwk uses syntax_json, but does not use the `serde_json` feature for serialization/deserialization.
+json-syntax = { version = "0.12.5", features = ["serde_json"] }
 jsonpath_lib = "0.3.0"
 jsonschema = "0.18.0"
 oid4vp-frontend = { version = "0.1.0", path = "oid4vp-frontend" }
-p256 = { version = "0.13.2", features = ["jwk"], optional = true }
-regex = "1.10.6"
-reqwest = { version = "0.12.5", features = ["rustls-tls"], optional = true }
+p256 = { version = "0.13.2", features = ["jwk"] }
+rand = { version = "0.8.5" }
+reqwest = { version = "0.12.5", features = ["rustls-tls"] }
 serde = "1.0.188"
-serde_cbor = "0.11.2"
 serde_json = "1.0.107"
-serde_qs = "0.12.0"
 serde_urlencoded = "0.7.1"
-ssi = "0.7"
-thiserror = "1.0.49"
+ssi-claims = "0.1.0"
+ssi-dids = "0.2.0"
+ssi-jwk = { version = "0.2.1", features = ["secp256r1"] }
+ssi-verification-methods = "0.1.1"
 tokio = "1.32.0"
 tracing = "0.1.37"
 url = { version = "2.4.1", features = ["serde"] }
@@ -40,7 +40,6 @@ x509-cert = "0.2.4"
 serde_path_to_error = "0.1.8"
 tokio = { version = "1.32.0", features = ["macros"] }
 did-method-key = "0.2"
-oid4vp = { path = ".", features = ["p256"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 uuid = { version = "1.2", features = ["v4", "serde", "js"] }

src/core/authorization_request/parameters.rs

@@ -1,7 +1,8 @@
-use std::fmt;
+use std::{fmt, ops::Deref};
 
 use crate::core::{
     object::{ParsingErrorContext, TypedParameter, UntypedObject},
+    presentation_definition::PresentationDefinition as PresentationDefinitionParsed,
     util::{base_request, AsyncHttpClient},
 };
 use anyhow::{bail, Context, Error, Ok};
@@ -193,7 +194,42 @@ impl TryFrom<Json> for ClientMetadataUri {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Nonce(pub String);
+pub struct Nonce(String);
+
+impl From<String> for Nonce {
+    fn from(value: String) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&str> for Nonce {
+    fn from(value: &str) -> Self {
+        Self(value.to_string())
+    }
+}
+
+impl Deref for Nonce {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for Nonce {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Nonce {
+    /// Crate a new `Nonce` with a random value of the given length.
+    pub fn random(rng: &mut impl rand::Rng, length: usize) -> Self {
+        use rand::distributions::{Alphanumeric, DistString};
+
+        Self(Alphanumeric.sample_string(rng, length))
+    }
+}
 
 impl TypedParameter for Nonce {
     const KEY: &'static str = "nonce";
@@ -432,25 +468,23 @@ impl From<State> for Json {
 #[derive(Debug, Clone)]
 pub struct PresentationDefinition {
     raw: Json,
-    parsed: crate::presentation_exchange::PresentationDefinition,
+    parsed: PresentationDefinitionParsed,
 }
 
 impl PresentationDefinition {
-    pub fn into_parsed(self) -> crate::presentation_exchange::PresentationDefinition {
+    pub fn into_parsed(self) -> PresentationDefinitionParsed {
         self.parsed
     }
 
-    pub fn parsed(&self) -> &crate::presentation_exchange::PresentationDefinition {
+    pub fn parsed(&self) -> &PresentationDefinitionParsed {
         &self.parsed
     }
 }
 
-impl TryFrom<crate::presentation_exchange::PresentationDefinition> for PresentationDefinition {
+impl TryFrom<PresentationDefinitionParsed> for PresentationDefinition {
     type Error = Error;
 
-    fn try_from(
-        parsed: crate::presentation_exchange::PresentationDefinition,
-    ) -> Result<Self, Self::Error> {
+    fn try_from(parsed: PresentationDefinitionParsed) -> Result<Self, Self::Error> {
         let raw = serde_json::to_value(parsed.clone())?;
         Ok(Self { raw, parsed })
     }

src/core/authorization_request/verification/did.rs

@@ -6,17 +6,18 @@ use crate::core::{
 use anyhow::{bail, Context, Result};
 use base64::prelude::*;
 use serde_json::{Map, Value as Json};
-use ssi::did_resolve::{resolve_key, DIDResolver};
+
+use ssi_jwk::JWKResolver;
 
 /// Default implementation of request validation for `client_id_scheme` `did`.
 pub async fn verify_with_resolver(
     wallet_metadata: &WalletMetadata,
     request_object: &AuthorizationRequestObject,
     request_jwt: String,
     trusted_dids: Option<&[String]>,
-    resolver: &dyn DIDResolver,
+    resolver: impl JWKResolver,
 ) -> Result<()> {
-    let (headers_b64, _, _) = ssi::jws::split_jws(&request_jwt)?;
+    let (headers_b64, _, _) = ssi_claims::jws::split_jws(&request_jwt)?;
 
     let headers_json_bytes = BASE64_URL_SAFE_NO_PAD
         .decode(headers_b64)
@@ -64,11 +65,12 @@ pub async fn verify_with_resolver(
         }
     }
 
-    let jwk = resolve_key(&kid, resolver)
+    let jwk = resolver
+        .fetch_public_jwk(Some(&kid))
         .await
-        .context("unable to resolve verification method from 'kid' header")?;
+        .context("unable to resolve key from verification method")?;
 
-    let _: Json = ssi::jwt::decode_verify(&request_jwt, &jwk)
+    let _: Json = ssi_claims::jwt::decode_verify(&request_jwt, &jwk)
         .context("request signature could not be verified")?;
 
     Ok(())

src/core/authorization_request/verification/mod.rs

@@ -105,9 +105,10 @@ pub(crate) async fn verify_request<W: Wallet + ?Sized>(
     wallet: &W,
     jwt: String,
 ) -> Result<AuthorizationRequestObject> {
-    let request: AuthorizationRequestObject = ssi::jwt::decode_unverified::<UntypedObject>(&jwt)
-        .context("unable to decode Authorization Request Object JWT")?
-        .try_into()?;
+    let request: AuthorizationRequestObject =
+        ssi_claims::jwt::decode_unverified::<UntypedObject>(&jwt)
+            .context("unable to decode Authorization Request Object JWT")?
+            .try_into()?;
 
     validate_request_against_metadata(wallet, &request).await?;
 

src/core/authorization_request/verification/verifier.rs

@@ -1,7 +1,5 @@
 use anyhow::Result;
-#[cfg(feature = "p256")]
 use anyhow::{bail, Error};
-#[cfg(feature = "p256")]
 use p256::ecdsa::signature::Verifier as _;
 use x509_cert::spki::SubjectPublicKeyInfoRef;
 
@@ -15,11 +13,9 @@ pub trait Verifier: Sized {
     fn verify(&self, payload: &[u8], signature: &[u8]) -> Result<()>;
 }
 
-#[cfg(feature = "p256")]
 #[derive(Debug, Clone)]
 pub struct P256Verifier(p256::ecdsa::VerifyingKey);
 
-#[cfg(feature = "p256")]
 impl Verifier for P256Verifier {
     fn from_spki(spki: SubjectPublicKeyInfoRef<'_>, algorithm: String) -> Result<Self> {
         if algorithm != "ES256" {

src/core/authorization_request/verification/x509_san.rs

@@ -28,7 +28,7 @@ pub fn validate<V: Verifier>(
     trusted_roots: Option<&[Certificate]>,
 ) -> Result<()> {
     let client_id = request_object.client_id().0.as_str();
-    let (headers_b64, body_b64, sig_b64) = ssi::jws::split_jws(&request_jwt)?;
+    let (headers_b64, body_b64, sig_b64) = ssi_claims::jws::split_jws(&request_jwt)?;
 
     let headers_json_bytes = BASE64_URL_SAFE_NO_PAD
         .decode(headers_b64)