feat: add VerificationState to agent_store (#36)

* refactor: move `ApplicationState` to `agent_shared`

* feat: add `agent_verification`

* style: rename `AuthorizationRequestTestFramework` to `ConnectionTestFramework`

* refactor: remove `ApplicationState` struct and replace it for a tuple

* fix: remove `ConnectionNotificationSent`

Instead of using the `VerificationServices` for sending connection notifications
we will probably need to utilize a `Query` that will function as an
outgoing adapter.

* feat: add `VerificationState` to `ApplicationState`

* feat: add `authorization_request` and `connection` tables to `init.sql`

agent_api_rest/Cargo.toml

@@ -7,27 +7,34 @@ rust-version.workspace = true
 [dependencies]
 agent_issuance = { path = "../agent_issuance" }
 agent_shared = { path = "../agent_shared" }
+agent_verification = { path = "../agent_verification" }
 
 axum.workspace = true
 axum-auth = "0.7"
 axum-macros = "0.4"
 http-api-problem = "0.57"
 hyper = { version = "1.2" }
+oid4vc-core.workspace = true
 oid4vci.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+siopv2.workspace = true
 tower-http.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
-uuid = { version = "1.4", features = ["v4", "fast-rng", "serde"] }
+uuid.workspace = true
 
 [dev-dependencies]
 agent_shared = { path = "../agent_shared", features = ["test"] }
 agent_store = { path = "../agent_store" }
+agent_verification = { path = "../agent_verification", features = ["test"] }
 
+futures.workspace = true
 lazy_static.workspace = true
 mime = { version = "0.3" }
 oid4vc-core.workspace = true
+oid4vc-manager.workspace = true
+serde_urlencoded = "0.7"
 tokio.workspace = true
 tower = { version = "0.4" }
 tracing-test.workspace = true

agent_api_rest/src/issuance/credential_issuer/credential.rs

@@ -92,6 +92,7 @@ mod tests {
     use super::*;
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -103,10 +104,11 @@ mod tests {
     #[tracing_test::traced_test]
     async fn test_credential_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         credentials(&mut app).await;
         let pre_authorized_code = offers(&mut app).await;

agent_api_rest/src/issuance/credential_issuer/token.rs

@@ -62,6 +62,7 @@ pub mod tests {
     use super::*;
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -102,10 +103,11 @@ pub mod tests {
     #[tokio::test]
     async fn test_token_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         credentials(&mut app).await;
         let pre_authorized_code = offers(&mut app).await;

agent_api_rest/src/issuance/credential_issuer/well_known/oauth_authorization_server.rs

@@ -28,6 +28,7 @@ mod tests {
     use super::*;
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -69,10 +70,11 @@ mod tests {
     #[tokio::test]
     async fn test_oauth_authorization_server_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         let _authorization_server_metadata = oauth_authorization_server(&mut app).await;
     }

agent_api_rest/src/issuance/credential_issuer/well_known/openid_credential_issuer.rs

@@ -29,6 +29,7 @@ mod tests {
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_shared::{config, UrlAppendHelpers};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -105,10 +106,11 @@ mod tests {
     #[tokio::test]
     async fn test_oauth_authorization_server_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         let _credential_issuer_metadata = openid_credential_issuer(&mut app).await;
     }

agent_api_rest/src/issuance/credentials.rs

@@ -104,6 +104,7 @@ pub mod tests {
     };
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -178,17 +179,7 @@ pub mod tests {
                     .method(http::Method::GET)
                     .uri(get_credentials_endpoint)
                     .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
-                    .body(Body::from(
-                        serde_json::to_vec(&json!({
-                            "subjectId": SUBJECT_ID,
-                            "credential": {
-                                "credentialSubject": {
-                                "first_name": "Ferris",
-                                "last_name": "Rustacean"
-                            }},
-                        }))
-                        .unwrap(),
-                    ))
+                    .body(Body::empty())
                     .unwrap(),
             )
             .await
@@ -204,10 +195,11 @@ pub mod tests {
     #[tokio::test]
     async fn test_credentials_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         credentials(&mut app).await;
     }

agent_api_rest/src/issuance/offers.rs

@@ -64,6 +64,7 @@ pub mod tests {
     use super::*;
     use agent_issuance::{startup_commands::startup_commands, state::initialize};
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::{
         body::Body,
         http::{self, Request},
@@ -117,10 +118,11 @@ pub mod tests {
     #[tokio::test]
     async fn test_offers_endpoint() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         initialize(&issuance_state, startup_commands(BASE_URL.clone())).await;
 
-        let mut app = app((issuance_state, ()));
+        let mut app = app((issuance_state, verification_state));
 
         credentials(&mut app).await;
         let _pre_authorized_code = offers(&mut app).await;

agent_api_rest/src/lib.rs

@@ -2,6 +2,7 @@ mod issuance;
 
 use agent_issuance::state::IssuanceState;
 use agent_shared::{config, ConfigError};
+use agent_verification::state::VerificationState;
 use axum::{
     body::Bytes,
     extract::MatchedPath,
@@ -22,7 +23,7 @@ use issuance::offers::offers;
 use tower_http::trace::TraceLayer;
 use tracing::{info_span, Span};
 
-pub type ApplicationState = (IssuanceState, ());
+pub type ApplicationState = (IssuanceState, VerificationState);
 
 pub fn app(state: ApplicationState) -> Router {
     let base_path = get_base_path();
@@ -96,6 +97,7 @@ fn get_base_path() -> Result<String, ConfigError> {
 #[cfg(test)]
 mod tests {
     use agent_store::in_memory;
+    use agent_verification::services::test_utils::test_verification_services;
     use axum::routing::post;
     use oid4vci::credential_issuer::{
         credential_issuer_metadata::CredentialIssuerMetadata, credentials_supported::CredentialsSupportedObject,
@@ -145,9 +147,10 @@ mod tests {
     #[should_panic]
     async fn test_base_path_routes() {
         let issuance_state = in_memory::issuance_state().await;
+        let verification_state = in_memory::verification_state(test_verification_services()).await;
 
         std::env::set_var("AGENT_APPLICATION_BASE_PATH", "unicore");
-        let router = app((issuance_state, ()));
+        let router = app((issuance_state, verification_state));
 
         let _ = router.route("/auth/token", post(handler));
     }

agent_application/Cargo.toml

@@ -9,6 +9,7 @@ agent_issuance = { path = "../agent_issuance" }
 agent_api_rest = { path = "../agent_api_rest" }
 agent_shared = { path = "../agent_shared" }
 agent_store = { path = "../agent_store" }
+agent_verification = { path = "../agent_verification" }
 
 axum.workspace = true
 lazy_static.workspace = true

agent_application/docker/db/init.sql

@@ -50,6 +50,21 @@ CREATE TABLE server_config
     PRIMARY KEY (view_id)
 );
 
+CREATE TABLE authorization_request
+(
+    view_id           text                        NOT NULL,
+    version           bigint CHECK (version >= 0) NOT NULL,
+    payload           json                        NOT NULL,
+    PRIMARY KEY (view_id)
+);
+
+CREATE TABLE connection
+(
+    view_id           text                        NOT NULL,
+    version           bigint CHECK (version >= 0) NOT NULL,
+    payload           json                        NOT NULL,
+    PRIMARY KEY (view_id)
+);
 
 CREATE USER demo_user WITH ENCRYPTED PASSWORD 'demo_pass';
 GRANT ALL PRIVILEGES ON DATABASE postgres TO demo_user;

agent_application/src/main.rs

@@ -1,7 +1,10 @@
+use std::sync::Arc;
+
 use agent_api_rest::app;
 use agent_issuance::{startup_commands::startup_commands, state::initialize};
-use agent_shared::config;
+use agent_shared::{config, secret_manager::secret_manager};
 use agent_store::{in_memory, postgres};
+use agent_verification::services::VerificationServices;
 use tracing::info;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
@@ -18,9 +21,16 @@ async fn main() {
         _ => tracing_subscriber.with(tracing_subscriber::fmt::layer()).init(),
     }
 
-    let issuance_state = match config!("event_store").unwrap().as_str() {
-        "postgres" => postgres::issuance_state().await,
-        _ => in_memory::issuance_state().await,
+    let verification_services = Arc::new(VerificationServices::new(Arc::new(secret_manager().await)));
+    let (issuance_state, verification_state) = match config!("event_store").unwrap().as_str() {
+        "postgres" => (
+            postgres::issuance_state().await,
+            postgres::verification_state(verification_services).await,
+        ),
+        _ => (
+            in_memory::issuance_state().await,
+            in_memory::verification_state(verification_services).await,
+        ),
     };
 
     let url = config!("url").expect("AGENT_APPLICATION_URL is not set");
@@ -35,5 +45,7 @@ async fn main() {
 
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3033").await.unwrap();
     info!("listening on {}", listener.local_addr().unwrap());
-    axum::serve(listener, app((issuance_state, ()))).await.unwrap();
+    axum::serve(listener, app((issuance_state, verification_state)))
+        .await
+        .unwrap();
 }

agent_issuance/Cargo.toml

@@ -12,7 +12,7 @@ async-trait.workspace = true
 axum.workspace = true
 cqrs-es.workspace = true
 derivative = "2.2"
-futures = "0.3"
+futures.workspace = true
 jsonschema = "0.17"
 jsonwebtoken = "8.2"
 oid4vci.workspace = true

agent_secret_manager/Cargo.toml

@@ -11,7 +11,7 @@ anyhow = "1.0"
 async-trait = "0.1"
 cqrs-es = "0.4.2"
 did_manager.workspace = true
-futures = "0.3"
+futures.workspace = true
 log = "0.4"
 oid4vc-core.workspace = true
 serde.workspace = true

agent_shared/src/lib.rs

@@ -2,10 +2,8 @@ pub mod application_state;
 pub mod config;
 pub mod generic_query;
 pub mod handlers;
-pub mod url_utils;
-
-#[cfg(feature = "test")]
 pub mod secret_manager;
+pub mod url_utils;
 
 pub use ::config::ConfigError;
 use rand::Rng;

agent_store/Cargo.toml

@@ -7,8 +7,9 @@ rust-version.workspace = true
 [dependencies]
 agent_issuance = { path = "../agent_issuance" }
 agent_shared = { path = "../agent_shared" }
+agent_verification = { path = "../agent_verification" }
 
-cqrs-es = "0.4.2"
+cqrs-es.workspace = true
 postgres-es = "0.4.10"
 
 async-trait = "0.1"