Merge pull request #10 from pubky/ln_verification_unique_ids

Ln verification do not use payment_hash as verification identifier

Author: 86667

Cargo.lock

@@ -20,18 +20,18 @@ hex = "0.4"
 regex = "1.11"
 reqwest = { version = "0.12", features = ["json"] }
 reqwest-websocket = "0.5.1"
-sea-query = { version = "0.32.6", features = [ "with-chrono", "postgres-array" ]}
-sea-query-binder = { version = "0.7.0", features = [ "with-chrono", "runtime-tokio", "sqlx-postgres", "postgres-array" ] }
+sea-query = { version = "0.32.6", features = [ "with-chrono", "postgres-array", "with-uuid" ]}
+sea-query-binder = { version = "0.7.0", features = [ "with-chrono", "runtime-tokio", "sqlx-postgres", "postgres-array", "with-uuid" ] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0"
-sqlx = { version = "0.8.6", features = [ "runtime-tokio", "postgres", "chrono", "tls-rustls" ] }
+sqlx = { version = "0.8.6", features = [ "runtime-tokio", "postgres", "chrono", "tls-rustls", "uuid" ] }
 thiserror = "2.0.12"
 tokio = { version = "1.48.0", features = ["full"] }
 tower-http = { version = "0.6.2", features = ["cors", "trace"] }
 tracing = "0.1.41"
 tracing-subscriber = "0.3.20"
 url = "2.5.7"
-uuid = { version = "1.18.1", features = ["v4"] }
+uuid = { version = "1.18.1", features = ["v4", "serde"] }
 
 [dev-dependencies]
 axum-test = "18"

Cargo.toml

@@ -13,11 +13,18 @@ impl MigrationTrait for M20251216CreateLnVerification {
         let statement = Table::create()
             .table("lightning_verifications")
             .if_not_exists()
+            .col(
+                ColumnDef::new("id")
+                    .uuid()
+                    .not_null()
+                    .primary_key()
+                    .default(sea_query::Expr::cust("gen_random_uuid()")),
+            )
             .col(
                 ColumnDef::new("payment_hash")
                     .char_len(64)
                     .not_null()
-                    .primary_key(),
+                    .unique_key(),
             ) // 64 hex characters
             .col(ColumnDef::new("amount_sat").integer().not_null())
             .col(ColumnDef::new("signup_code").text().null())

src/infrastructure/sql/migrations/m20251216_create_ln_verification.rs

@@ -13,9 +13,9 @@ use crate::{
     EnvConfig,
     infrastructure::http::HttpServerError,
     ln_verification::{
-        app_state::AppState, error::LnVerificationError,
-        invoice_background_syncer::InvoiceBackgroundSyncer, payment_hash::PaymentHash,
-        phoenixd_api::PhoenixdAPI, service::LnVerificationService,
+        VerificationId, app_state::AppState, error::LnVerificationError,
+        invoice_background_syncer::InvoiceBackgroundSyncer, phoenixd_api::PhoenixdAPI,
+        service::LnVerificationService,
     },
     shared::HomeserverAdminAPI,
 };
@@ -53,6 +53,7 @@ pub async fn router(
         .route("/", post(create_verification_handler))
         .route("/{id}", get(get_verification_handler))
         .route("/{id}/await", get(await_verification_handler))
+        .route("/price", get(get_price_handler))
         .with_state(state))
 }
 
@@ -61,9 +62,9 @@ async fn create_verification_handler(
     State(state): State<AppState>,
 ) -> Result<Json<CreateVerificationResponse>, LnVerificationError> {
     let (verification, invoice) = state.ln_service.create_verification().await?;
-    tracing::info!("Created verification {}", verification.payment_hash);
+    tracing::info!("Created verification {}", verification.id);
     let response = CreateVerificationResponse {
-        id: verification.payment_hash,
+        id: verification.id,
         bolt11_invoice: invoice.invoice,
         amount_sat: invoice.requested_sat,
         expires_at: invoice.expires_at.timestamp_millis(),
@@ -74,7 +75,7 @@ async fn create_verification_handler(
 /// Get a Lightning Network verification handler
 async fn get_verification_handler(
     State(state): State<AppState>,
-    Path(id): Path<PaymentHash>,
+    Path(id): Path<VerificationId>,
 ) -> Response {
     let verification = match state.ln_service.get_verification(&id).await {
         Ok(Some(verification)) => verification,
@@ -91,7 +92,7 @@ async fn get_verification_handler(
 /// Await for a Lightning Network verification to be finalized handler
 async fn await_verification_handler(
     State(state): State<AppState>,
-    Path(id): Path<PaymentHash>,
+    Path(id): Path<VerificationId>,
 ) -> impl IntoResponse {
     let mut verification = match state.ln_service.get_verification(&id).await {
         Ok(Some(verification)) => verification,
@@ -115,7 +116,7 @@ async fn await_verification_handler(
             }
             Err(e) => return e.into_response(),
         };
-        tracing::info!("Awaited verification {}", verification.payment_hash);
+        tracing::info!("Awaited verification {}", verification.id);
     };
 
     Json(GetVerificationResponse::from_entity(
@@ -125,10 +126,17 @@ async fn await_verification_handler(
     .into_response()
 }
 
+/// Get the configured Lightning invoice price handler
+async fn get_price_handler(State(state): State<AppState>) -> Json<GetPriceResponse> {
+    Json(GetPriceResponse {
+        amount_sat: state.ln_service.get_price_sat(),
+    })
+}
+
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateVerificationResponse {
-    id: PaymentHash,
+    id: VerificationId,
     bolt11_invoice: String,
     amount_sat: u64,
     expires_at: i64,
@@ -137,7 +145,7 @@ pub struct CreateVerificationResponse {
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetVerificationResponse {
-    id: PaymentHash,
+    id: VerificationId,
     amount_sat: u64,
     expires_at: i64,
     is_paid: bool,
@@ -153,7 +161,7 @@ impl GetVerificationResponse {
     ) -> Self {
         let is_paid = entity.is_finalised();
         Self {
-            id: entity.payment_hash,
+            id: entity.id,
             amount_sat: entity.amount_sat as u64,
             expires_at: entity.expires_at.and_utc().timestamp_millis(),
             is_paid,
@@ -164,6 +172,12 @@ impl GetVerificationResponse {
     }
 }
 
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetPriceResponse {
+    amount_sat: u64,
+}
+
 impl IntoResponse for LnVerificationError {
     fn into_response(self) -> Response {
         let status = match self {

src/ln_verification/http.rs

@@ -1,8 +1,8 @@
 use std::time::Duration;
 
 use crate::ln_verification::{
-    LightningVerificationEntity, error::LnVerificationError, payment_hash::PaymentHash,
-    phoenixd_api::PhoenixdAPI, service::LnVerificationService,
+    LightningVerificationEntity, VerificationId, error::LnVerificationError,
+    payment_hash::PaymentHash, phoenixd_api::PhoenixdAPI, service::LnVerificationService,
 };
 
 use futures_util::TryStreamExt;
@@ -13,7 +13,7 @@ use tokio::sync::broadcast;
 pub struct InvoiceBackgroundSyncer {
     service: LnVerificationService,
     phoenixd_api: PhoenixdAPI,
-    verification_completed_tx: broadcast::Sender<PaymentHash>,
+    verification_completed_tx: broadcast::Sender<VerificationId>,
 }
 
 impl InvoiceBackgroundSyncer {
@@ -29,23 +29,23 @@ impl InvoiceBackgroundSyncer {
 
     /// Subscribe to finalized verification events.
     /// Returns a receiver that will receive notifications whenever a verification is finalized.
-    pub fn subscribe(&self) -> broadcast::Receiver<PaymentHash> {
+    pub fn subscribe(&self) -> broadcast::Receiver<VerificationId> {
         self.verification_completed_tx.subscribe()
     }
 
     /// Await the payment to be finalized.
     /// Returns Ok(Some(LightningVerificationEntity)) if the payment was finalized, Ok(None) if the timeout was reached.
     pub async fn wait_for_payment(
         &self,
-        payment_hash: &PaymentHash,
+        id: &VerificationId,
         timeout: Duration,
     ) -> Result<Option<LightningVerificationEntity>, LnVerificationError> {
         let future = async {
             let mut receiver = self.subscribe();
             loop {
                 match receiver.recv().await {
-                    Ok(finalized_payment_hash) if finalized_payment_hash == *payment_hash => break,
-                    Ok(_) => continue, // Different payment hash, keep waiting
+                    Ok(finalized_id) if finalized_id == *id => break,
+                    Ok(_) => continue, // Different verification ID, keep waiting
                     Err(broadcast::error::RecvError::Lagged(n)) => {
                         tracing::warn!("Broadcast receiver lagged by {} messages", n);
                         continue;
@@ -63,7 +63,7 @@ impl InvoiceBackgroundSyncer {
             Err(_) => return Ok(None),
         };
 
-        self.service.get_verification(payment_hash).await
+        self.service.get_verification(id).await
     }
 
     /// Sync an invoice.
@@ -75,10 +75,8 @@ impl InvoiceBackgroundSyncer {
             Some(verification) => verification,
             None => return Ok(()),
         };
-        tracing::info!("Verification {} finalised", newly_finalised.payment_hash);
-        let _ = self
-            .verification_completed_tx
-            .send(newly_finalised.payment_hash);
+        tracing::info!("Verification {} finalised", newly_finalised.id);
+        let _ = self.verification_completed_tx.send(newly_finalised.id);
         Ok(())
     }
 

src/ln_verification/invoice_background_syncer.rs

@@ -6,5 +6,7 @@ mod payment_hash;
 mod phoenixd_api;
 mod repository;
 mod service;
+mod verification_id;
 pub use http::router;
 pub use repository::*;
+pub use verification_id::*;

src/ln_verification/mod.rs

@@ -1,10 +1,16 @@
-use crate::{infrastructure::sql::UnifiedExecutor, ln_verification::payment_hash::PaymentHash};
+use crate::{
+    infrastructure::sql::UnifiedExecutor,
+    ln_verification::{payment_hash::PaymentHash, verification_id::VerificationId},
+};
 use chrono::NaiveDateTime;
 use sea_query::{Expr, PostgresQueryBuilder, Query};
 use sea_query_binder::SqlxBinder;
 
 #[derive(Debug, Clone, sqlx::FromRow)]
 pub struct LightningVerificationEntity {
+    pub id: VerificationId,
+    #[allow(dead_code)]
+    // Stored for data integrity and testing. Sync operations use payment_hash from phoenixd API responses
     pub payment_hash: PaymentHash,
     pub amount_sat: i32,
     pub expires_at: NaiveDateTime,
@@ -65,6 +71,46 @@ impl LnVerificationRepository {
         Ok(verification)
     }
 
+    /// Get a verification by its public ID (for API requests)
+    ///
+    /// # Arguments
+    /// * `id` - The verification ID
+    /// * `executor` - The executor to use to execute the query
+    ///
+    /// # Returns
+    /// * `LightningVerificationEntity` - The verification record
+    ///
+    /// # Errors
+    /// * `sqlx::Error` - If the query fails
+    pub async fn get_verification_by_id<'a>(
+        id: &VerificationId,
+        executor: &mut UnifiedExecutor<'a>,
+    ) -> Result<Option<LightningVerificationEntity>, sqlx::Error> {
+        let statement = Query::select()
+            .columns([
+                "id",
+                "payment_hash",
+                "amount_sat",
+                "created_at",
+                "expires_at",
+                "finalised_at",
+                "signup_code",
+            ])
+            .from(TABLE_NAME)
+            .and_where(Expr::col("id").eq(*id.as_uuid()))
+            .to_owned();
+        let (query, values) = statement.build_sqlx(PostgresQueryBuilder);
+        let con = executor.get_con().await?;
+        let verification: LightningVerificationEntity =
+            match sqlx::query_as_with(&query, values).fetch_one(con).await {
+                Ok(verification) => verification,
+                Err(sqlx::Error::RowNotFound) => return Ok(None),
+                Err(e) => return Err(e),
+            };
+
+        Ok(Some(verification))
+    }
+
     /// Get a verification by payment hash
     ///
     /// # Arguments
@@ -82,6 +128,7 @@ impl LnVerificationRepository {
     ) -> Result<Option<LightningVerificationEntity>, sqlx::Error> {
         let statement = Query::select()
             .columns([
+                "id",
                 "payment_hash",
                 "amount_sat",
                 "created_at",
@@ -316,4 +363,39 @@ mod tests {
                 .unwrap();
         assert_eq!(timestamp, Some(veri1.created_at));
     }
+
+    #[sqlx::test]
+    async fn test_get_verification_by_id(pool: PgPool) {
+        let db = SqlDb::test(pool).await;
+        let payment_hash = PaymentHash::random();
+        let expires_at = Utc::now().naive_utc();
+        let veri = LnVerificationRepository::create_verification(
+            &payment_hash,
+            1000,
+            expires_at,
+            &mut db.pool().into(),
+        )
+        .await
+        .unwrap();
+
+        // Should be able to get by ID
+        let veri_by_id =
+            LnVerificationRepository::get_verification_by_id(&veri.id, &mut db.pool().into())
+                .await
+                .unwrap()
+                .unwrap();
+
+        assert_eq!(veri_by_id.id, veri.id);
+        assert_eq!(veri_by_id.payment_hash, payment_hash);
+        assert_eq!(veri_by_id.amount_sat, 1000);
+
+        // Non-existent ID should return None
+        let non_existent = LnVerificationRepository::get_verification_by_id(
+            &VerificationId::random(),
+            &mut db.pool().into(),
+        )
+        .await
+        .unwrap();
+        assert!(non_existent.is_none());
+    }
 }