wip

Cargo.toml

@@ -3,14 +3,6 @@ name = "route96"
 version = "0.4.0"
 edition = "2021"
 
-[[bin]]
-name = "void_cat_migrate"
-required-features = ["bin-void-cat-migrate"]
-
-[[bin]]
-name = "void_cat_forced_migrate"
-required-features = ["bin-void-cat-force-migrate"]
-
 [[bin]]
 name = "route96"
 path = "src/bin/main.rs"
@@ -19,22 +11,18 @@ path = "src/bin/main.rs"
 name = "route96"
 
 [features]
-default = ["nip96", "blossom", "analytics", "ranges", "react-ui"]
+default = ["nip96", "blossom", "analytics", "react-ui", "payments"]
 media-compression = ["dep:ffmpeg-rs-raw", "dep:libc"]
-labels = ["nip96", "dep:candle-core", "dep:candle-nn", "dep:candle-transformers"]
+labels = ["media-compression", "dep:candle-core", "dep:candle-nn", "dep:candle-transformers"]
 nip96 = ["media-compression"]
 blossom = []
-bin-void-cat-migrate = ["dep:sqlx-postgres"]
-bin-void-cat-force-migrate = ["dep:regex", "dep:nostr-cursor"]
-torrent-v2 = []
 analytics = []
-void-cat-redirects = ["dep:sqlx-postgres"]
-ranges = ["dep:http-range-header"]
 react-ui = []
+payments = ["dep:fedimint-tonic-lnd"]
 
 [dependencies]
 log = "0.4.21"
-nostr = "0.37.0"
+nostr = "0.39.0"
 pretty_env_logger = "0.5.0"
 rocket = { version = "0.5.1", features = ["json"] }
 tokio = { version = "1.37.0", features = ["rt", "rt-multi-thread", "macros"] }
@@ -45,21 +33,19 @@ uuid = { version = "1.8.0", features = ["v4", "serde"] }
 anyhow = "^1.0.82"
 sha2 = "0.10.8"
 sqlx = { version = "0.8.1", features = ["mysql", "runtime-tokio", "chrono", "uuid"] }
-config = { version = "0.14.0", features = ["yaml"] }
+config = { version = "0.15.7", features = ["yaml"] }
 chrono = { version = "0.4.38", features = ["serde"] }
-serde_with = { version = "3.8.1", features = ["hex"] }
-reqwest = { version = "0.12.8", features = ["stream"] }
+reqwest = { version = "0.12.8", features = ["stream", "http2"] }
 clap = { version = "4.5.18", features = ["derive"] }
 mime2ext = "0.1.53"
-infer = "0.16.0"
+infer = "0.19.0"
 tokio-util = { version = "0.7.13", features = ["io", "io-util"] }
+http-range-header = { version = "0.4.2" }
+base58 = "0.2.0"
 
 libc = { version = "0.2.153", optional = true }
 ffmpeg-rs-raw = { git = "https://git.v0l.io/Kieran/ffmpeg-rs-raw.git", rev = "a63b88ef3c8f58c7c0ac57d361d06ff0bb3ed385", optional = true }
 candle-core = { git = "https://git.v0l.io/huggingface/candle.git", tag = "0.8.1", optional = true }
 candle-nn = { git = "https://git.v0l.io/huggingface/candle.git", tag = "0.8.1", optional = true }
 candle-transformers = { git = "https://git.v0l.io/huggingface/candle.git", tag = "0.8.1", optional = true }
-sqlx-postgres = { version = "0.8.2", optional = true, features = ["chrono", "uuid"] }
-http-range-header = { version = "0.4.2", optional = true }
-nostr-cursor = { git = "https://git.v0l.io/Kieran/nostr_backup_proc.git", branch = "main", optional = true }
-regex = { version = "1.11.1", optional = true }
+fedimint-tonic-lnd = { version = "0.2.0", optional = true, default-features = false, features = ["invoicesrpc", "lightningrpc"] }

README.md

@@ -12,6 +12,7 @@ Image hosting service
   - [BUD-05](https://github.com/hzrd149/blossom/blob/master/buds/05.md)
   - [BUD-06](https://github.com/hzrd149/blossom/blob/master/buds/06.md)
   - [BUD-08](https://github.com/hzrd149/blossom/blob/master/buds/08.md)
+  - [BUD-10](https://github.com/hzrd149/blossom/pull/57)
 - Image compression to WebP
 - Blurhash calculation
 - AI image labeling ([ViT224](https://huggingface.co/google/vit-base-patch16-224))
@@ -45,4 +46,10 @@ docker run --rm -it \
 ```
 
 ### Manual
-See [install.md](docs/debian.md)
+See [install.md](docs/debian.md)
+
+## Blossom only mode (No FFMPEG)
+If you don't want to support NIP-96 or any media compression you can build like so:
+```bash
+cargo build --release --no-default-features --features blossom
+```

config.prod.yaml

@@ -1,17 +1,5 @@
-# Listen address for webserver
 listen: "0.0.0.0:8000"
-
-# Database connection string (MYSQL)
 database: "mysql://root:root@db:3306/route96"
-
-# Directory to store uploads
 storage_dir: "/app/data"
-
-# Maximum support filesize for uploading
 max_upload_bytes: 104857600
-
-# Public facing url
 public_url: "http://localhost:8000"
-
-# Whitelisted pubkeys, leave out to disable
-# whitelist: ["63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed"]

config.yaml

@@ -13,19 +13,37 @@ max_upload_bytes: 5e+9
 # Public facing url
 public_url: "http://localhost:8000"
 
-# Whitelisted pubkeys, leave out to disable
+# (Optional) Whitelisted pubkeys, leave out to disable
 # whitelist: ["63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed"]
 
-# Path for ViT(224) image model (https://huggingface.co/google/vit-base-patch16-224)
-vit_model:
-  model: "/home/kieran/Downloads/falcon_nsfw.safetensors"
-  config: "/home/kieran/Downloads/falcon_nsfw.json"
+# (Optional) Path for ViT(224) image model (https://huggingface.co/google/vit-base-patch16-224)
+# vit_model:
+#   model: "falcon_nsfw.safetensors"
+#   config: "falcon_nsfw.json"
 
-# Analytics support
+# (Optional) Analytics support
 # plausible_url: "https://plausible.com/"
 
-# Support legacy void
-# void_cat_database: "postgres://postgres:postgres@localhost:41911/void"
+# (Optional) Legacy file path for void.cat uploads
+# void_cat_files: "/my/void.cat/data"
 
-# Legacy file path for void.cat uploads
-# void_cat_files: "/my/void.cat/data"
+# (Optional) Payment system config
+payments:
+  # (Optional) Fiat currency used to track exchange rate along with invoices
+  # If [cost] is using a fiat currency, exchange rates will always be stored
+  # in that currency, so this config is not needed
+  fiat: "USD"
+  # LND node config
+  lnd:
+    endpoint: "https://127.0.0.1:10001"
+    tls: "/home/kieran/.polar/networks/3/volumes/lnd/alice/tls.cert"
+    macaroon: "/home/kieran/.polar/networks/3/volumes/lnd/alice/data/chain/bitcoin/regtest/admin.macaroon"
+  # Cost per unit (BTC/USD/EUR/AUD/CAD/JPY/GBP)
+  cost:
+    currency: "BTC"
+    amount: 0.00000100
+  # Unit metric used to calculate quote (GBSpace, GBEgress)
+  unit: "GBSpace"
+  # Billing interval (day / month / year)
+  interval:
+    month: 1

migrations/20250202135844_payments.sql

@@ -0,0 +1,22 @@
+-- Add migration script here
+alter table users
+    add column paid_until timestamp,
+    add column paid_size integer unsigned not null;
+
+create table payments
+(
+    payment_hash binary(32) not null primary key,
+    user_id      integer unsigned not null,
+    created      timestamp default current_timestamp,
+    amount       integer unsigned not null,
+    is_paid      bit(1) not null default 0,
+    days_value   integer unsigned not null,
+    size_value   integer unsigned not null,
+    settle_index integer unsigned,
+    rate         float,
+
+    constraint fk_payments_user_id
+        foreign key (user_id) references users (id)
+            on delete cascade
+            on update restrict
+);

src/background/media_metadata.rs

@@ -3,6 +3,7 @@ use crate::filesystem::FileStore;
 use crate::processing::probe_file;
 use anyhow::Result;
 use log::{error, info, warn};
+use tokio::sync::broadcast;
 
 pub struct MediaMetadata {
     db: Database,
@@ -14,12 +15,16 @@ impl MediaMetadata {
         Self { db, fs }
     }
 
-    pub async fn process(&mut self) -> Result<()> {
+    pub async fn process(&mut self, mut rx: broadcast::Receiver<()>) -> Result<()> {
         let to_migrate = self.db.get_missing_media_metadata().await?;
 
         info!("{} files are missing metadata", to_migrate.len());
 
         for file in to_migrate {
+            if rx.try_recv().is_ok() {
+                info!("Shutting down MediaMetadata process");
+                break;
+            }
             // probe file and update metadata
             let path = self.fs.get(&file.id);
             match probe_file(&path) {

src/background/mod.rs

@@ -1,24 +1,54 @@
 use crate::db::Database;
 use crate::filesystem::FileStore;
-use anyhow::Result;
-use log::info;
+use log::{error, info, warn};
+use tokio::sync::broadcast;
 use tokio::task::JoinHandle;
 
 #[cfg(feature = "media-compression")]
 mod media_metadata;
 
-pub fn start_background_tasks(db: Database, file_store: FileStore) -> Vec<JoinHandle<Result<()>>> {
+#[cfg(feature = "payments")]
+mod payments;
+
+pub fn start_background_tasks(
+    db: Database,
+    file_store: FileStore,
+    shutdown_rx: broadcast::Receiver<()>,
+    #[cfg(feature = "payments")] client: Option<fedimint_tonic_lnd::Client>,
+) -> Vec<JoinHandle<()>> {
     let mut ret = vec![];
 
     #[cfg(feature = "media-compression")]
     {
+        let db = db.clone();
+        let rx = shutdown_rx.resubscribe();
         ret.push(tokio::spawn(async move {
             info!("Starting MediaMetadata background task");
-            let mut m = media_metadata::MediaMetadata::new(db.clone(), file_store.clone());
-            m.process().await?;
-            info!("MediaMetadata background task completed");
-            Ok(())
+            let mut m = media_metadata::MediaMetadata::new(db, file_store.clone());
+            if let Err(e) = m.process(rx).await {
+                error!("MediaMetadata failed: {}", e);
+            } else {
+                info!("MediaMetadata background task completed");
+            }
         }));
     }
+    #[cfg(feature = "payments")]
+    {
+        if let Some(client) = client {
+            let db = db.clone();
+            let rx = shutdown_rx.resubscribe();
+            ret.push(tokio::spawn(async move {
+                info!("Starting PaymentsHandler background task");
+                let mut m = payments::PaymentsHandler::new(client, db);
+                if let Err(e) = m.process(rx).await {
+                    error!("PaymentsHandler failed: {}", e);
+                } else {
+                    info!("PaymentsHandler background task completed");
+                }
+            }));
+        } else {
+            warn!("Not starting PaymentsHandler, configuration missing")
+        }
+    }
     ret
 }

src/background/payments.rs

@@ -0,0 +1,71 @@
+use crate::db::Database;
+use anyhow::Result;
+use fedimint_tonic_lnd::lnrpc::invoice::InvoiceState;
+use fedimint_tonic_lnd::lnrpc::InvoiceSubscription;
+use fedimint_tonic_lnd::Client;
+use log::{error, info};
+use rocket::futures::StreamExt;
+use sqlx::Row;
+use tokio::sync::broadcast;
+
+pub struct PaymentsHandler {
+    client: Client,
+    database: Database,
+}
+
+impl PaymentsHandler {
+    pub fn new(client: Client, database: Database) -> Self {
+        PaymentsHandler { client, database }
+    }
+
+    pub async fn process(&mut self, mut rx: broadcast::Receiver<()>) -> Result<()> {
+        let start_idx = self.database.get_last_settle_index().await?;
+        let mut invoices = self
+            .client
+            .lightning()
+            .subscribe_invoices(InvoiceSubscription {
+                add_index: 0,
+                settle_index: start_idx,
+            })
+            .await?;
+        info!("Starting invoice subscription from {}", start_idx);
+
+        let invoices = invoices.get_mut();
+        loop {
+            tokio::select! {
+                Ok(_) = rx.recv() => {
+                    break;
+                }
+                Some(Ok(msg)) = invoices.next() => {
+                    if msg.state == InvoiceState::Settled as i32 {
+                        if let Ok(Some(mut p)) = self.database.get_payment(&msg.r_hash).await {
+                            p.settle_index = Some(msg.settle_index);
+                            p.is_paid = true;
+                            match self.database.complete_payment(&p).await {
+                                Ok(()) => info!(
+                                    "Successfully completed payment: {}",
+                                    hex::encode(&msg.r_hash)
+                                ),
+                                Err(e) => error!("Failed to complete payment: {}", e),
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Database {
+    async fn get_last_settle_index(&self) -> Result<u64> {
+        Ok(
+            sqlx::query("select max(settle_index) from payments where is_paid = true")
+                .fetch_one(&self.pool)
+                .await?
+                .try_get(0)
+                .unwrap_or(0),
+        )
+    }
+}

src/bin/main.rs

@@ -3,6 +3,8 @@ use std::net::{IpAddr, SocketAddr};
 use anyhow::Error;
 use clap::Parser;
 use config::Config;
+#[cfg(feature = "payments")]
+use fedimint_tonic_lnd::lnrpc::GetInfoRequest;
 use log::{error, info};
 use rocket::config::Ident;
 use rocket::data::{ByteUnit, Limits};
@@ -19,6 +21,7 @@ use route96::filesystem::FileStore;
 use route96::routes;
 use route96::routes::{get_blob, head_blob, root};
 use route96::settings::Settings;
+use tokio::sync::broadcast;
 
 #[derive(Parser, Debug)]
 #[command(version, about)]
@@ -73,7 +76,13 @@ async fn main() -> Result<(), Error> {
         .attach(Shield::new()) // disable
         .mount(
             "/",
-            routes![root, get_blob, head_blob, routes::void_cat_redirect, routes::void_cat_redirect_head],
+            routes![
+                root,
+                get_blob,
+                head_blob,
+                routes::void_cat_redirect,
+                routes::void_cat_redirect_head
+            ],
         )
         .mount("/admin", routes::admin_routes());
 
@@ -95,19 +104,47 @@ async fn main() -> Result<(), Error> {
     {
         rocket = rocket.mount("/", routes![routes::get_blob_thumb]);
     }
+    #[cfg(feature = "payments")]
+    let lnd = {
+        if let Some(lnd) = settings.payments.as_ref().map(|p| &p.lnd) {
+            let lnd = fedimint_tonic_lnd::connect(
+                lnd.endpoint.clone(),
+                lnd.tls.clone(),
+                lnd.macaroon.clone(),
+            )
+            .await?;
 
-    let jh = start_background_tasks(db, fs);
+            let info = {
+                let mut lnd = lnd.clone();
+                lnd.lightning().get_info(GetInfoRequest::default()).await?
+            };
+
+            info!(
+                "LND connected: {} v{}",
+                info.get_ref().alias,
+                info.get_ref().version
+            );
+            rocket = rocket
+                .manage(lnd.clone())
+                .mount("/", routes::payment::routes());
+            Some(lnd)
+        } else {
+            None
+        }
+    };
+
+    let (shutdown_tx, shutdown_rx) = broadcast::channel(1);
+    let jh = start_background_tasks(db, fs, shutdown_rx, lnd);
 
     if let Err(e) = rocket.launch().await {
         error!("Rocker error {}", e);
-        for j in jh {
-            let _ = j.await?;
-        }
-        Err(Error::from(e))
-    } else {
-        for j in jh {
-            let _ = j.await?;
-        }
-        Ok(())
     }
+    shutdown_tx
+        .send(())
+        .expect("Failed to send shutdown signal");
+
+    for j in jh {
+        j.await?;
+    }
+    Ok(())
 }

src/bin/void_cat_forced_migrate.rs

@@ -1,70 +0,0 @@
-use clap::Parser;
-use log::{info, warn};
-use nostr::serde_json;
-use nostr_cursor::cursor::NostrCursor;
-use regex::Regex;
-use rocket::futures::StreamExt;
-use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
-use tokio::fs::File;
-use tokio::io::AsyncWriteExt;
-use uuid::Uuid;
-
-#[derive(Parser, Debug)]
-#[command(version, about)]
-struct ProgramArgs {
-    /// Directory pointing to archives to scan
-    #[arg(short, long)]
-    pub archive: PathBuf,
-
-    /// Output path .csv
-    #[arg(short, long)]
-    pub output: PathBuf,
-}
-
-#[tokio::main]
-async fn main() -> Result<(), anyhow::Error> {
-    pretty_env_logger::init();
-
-    let args: ProgramArgs = ProgramArgs::parse();
-
-    let mut report: HashMap<String, HashSet<String>> = HashMap::new();
-
-    let mut binding = NostrCursor::new(args.archive);
-    let mut cursor = Box::pin(binding.walk());
-    let matcher = Regex::new(r"void\.cat/d/(\w+)")?;
-    while let Some(Ok(e)) = cursor.next().await {
-        if e.content.contains("void.cat") {
-            let links = matcher.captures_iter(&e.content).collect::<Vec<_>>();
-            for link in links {
-                let g = link.get(1).unwrap().as_str();
-                let base58 = if let Ok(b) = nostr::bitcoin::base58::decode(g) {
-                    b
-                } else {
-                    warn!("Invalid base58 id {}", g);
-                    continue;
-                };
-                let _uuid = if let Ok(u) = Uuid::from_slice_le(base58.as_slice()) {
-                    u
-                } else {
-                    warn!("Invalid uuid {}", g);
-                    continue;
-                };
-                info!("Got link: {} => {}", g, e.pubkey);
-                if let Some(ur) = report.get_mut(&e.pubkey) {
-                    ur.insert(g.to_string());
-                } else {
-                    report.insert(e.pubkey.clone(), HashSet::from([g.to_string()]));
-                }
-            }
-        }
-    }
-
-    let json = serde_json::to_string(&report)?;
-    File::create(args.output)
-        .await?
-        .write_all(json.as_bytes())
-        .await?;
-
-    Ok(())
-}

src/bin/void_cat_migrate.rs

@@ -1,147 +0,0 @@
-use anyhow::Error;
-use clap::Parser;
-use config::Config;
-use log::{info, warn};
-use nostr::bitcoin::base58;
-use route96::db::{Database, FileUpload};
-use route96::filesystem::FileStore;
-use route96::settings::Settings;
-use route96::void_db::VoidCatDb;
-use route96::void_file::VoidFile;
-use std::path::PathBuf;
-use tokio::io::{AsyncWriteExt, BufWriter};
-
-#[derive(Debug, Clone, clap::ValueEnum)]
-enum ArgOperation {
-    Migrate,
-    ExportNginxRedirects,
-}
-
-#[derive(Parser, Debug)]
-#[command(version, about)]
-struct Args {
-    /// Database connection string for void.cat DB
-    #[arg(long)]
-    pub database: String,
-
-    /// Path to filestore on void.cat
-    #[arg(long)]
-    pub data_path: String,
-
-    #[arg(long)]
-    pub operation: ArgOperation,
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    pretty_env_logger::init();
-
-    let builder = Config::builder()
-        .add_source(config::File::with_name("config.yaml"))
-        .add_source(config::Environment::with_prefix("APP"))
-        .build()?;
-
-    let settings: Settings = builder.try_deserialize()?;
-
-    let db = Database::new(&settings.database).await?;
-    let fs = FileStore::new(settings.clone());
-
-    let args: Args = Args::parse();
-
-    let db_void = VoidCatDb::connect(&args.database).await?;
-
-    match args.operation {
-        ArgOperation::Migrate => {
-            let mut page = 0;
-            loop {
-                let files = db_void.list_files(page).await?;
-                if files.is_empty() {
-                    break;
-                }
-                for f in files {
-                    if let Err(e) = migrate_file(&f, &db, &fs, &args).await {
-                        warn!("Failed to migrate file: {}, {}", &f.id, e);
-                    }
-                }
-                page += 1;
-            }
-        }
-        ArgOperation::ExportNginxRedirects => {
-            let path: PathBuf = args.data_path.parse()?;
-            let conf_path = &path.join("nginx.conf");
-            info!("Writing redirects to {}", conf_path.to_str().unwrap());
-            let mut fout = BufWriter::new(tokio::fs::File::create(conf_path).await?);
-            let mut page = 0;
-            loop {
-                let files = db_void.list_files(page).await?;
-                if files.is_empty() {
-                    break;
-                }
-                for f in files {
-                    let legacy_id = base58::encode(f.id.to_bytes_le().as_slice());
-                    let redirect = format!("location ^\\/d\\/{}(?:\\.\\w+)?$ {{\n\treturn 301 https://nostr.download/{};\n}}\n", &legacy_id, &f.digest);
-                    fout.write_all(redirect.as_bytes()).await?;
-                }
-                page += 1;
-            }
-        }
-    }
-
-    Ok(())
-}
-
-async fn migrate_file(
-    f: &VoidFile,
-    db: &Database,
-    fs: &FileStore,
-    args: &Args,
-) -> Result<(), Error> {
-    let pubkey_vec = hex::decode(&f.email)?;
-    let id_vec = hex::decode(&f.digest)?;
-
-    // copy file
-    let src_path = PathBuf::new()
-        .join(&args.data_path)
-        .join(VoidFile::map_to_path(&f.id));
-    let dst_path = fs.map_path(&id_vec);
-    if src_path.exists() && !dst_path.exists() {
-        info!(
-            "Copying file: {} from {} => {}",
-            &f.id,
-            src_path.to_str().unwrap(),
-            dst_path.to_str().unwrap()
-        );
-
-        tokio::fs::create_dir_all(dst_path.parent().unwrap()).await?;
-        tokio::fs::copy(src_path, dst_path).await?;
-    } else if dst_path.exists() {
-        info!("File already exists {}, continuing...", &f.id);
-    } else {
-        anyhow::bail!("Source file not found {}", src_path.to_str().unwrap());
-    }
-    let uid = db.upsert_user(&pubkey_vec).await?;
-    info!("Mapped user {} => {}", &f.email, uid);
-
-    let md: Option<Vec<&str>> = f.media_dimensions.as_ref().map(|s| s.split("x").collect());
-    let fu = FileUpload {
-        id: id_vec,
-        name: f.name.clone(),
-        size: f.size as u64,
-        mime_type: f.mime_type.clone(),
-        created: f.uploaded,
-        width: match &md {
-            Some(s) => Some(s[0].parse::<u32>()?),
-            None => None,
-        },
-        height: match &md {
-            Some(s) => Some(s[1].parse::<u32>()?),
-            None => None,
-        },
-        blur_hash: None,
-        alt: f.description.clone(),
-        duration: None,
-        bitrate: None,
-    };
-    db.add_file(&fu, uid).await?;
-    Ok(())
-}

src/db.rs

@@ -61,6 +61,10 @@ pub struct User {
     pub pubkey: Vec<u8>,
     pub created: DateTime<Utc>,
     pub is_admin: bool,
+    #[cfg(feature = "payments")]
+    pub paid_until: Option<DateTime<Utc>>,
+    #[cfg(feature = "payments")]
+    pub paid_size: u64,
 }
 
 #[cfg(feature = "labels")]
@@ -90,6 +94,20 @@ pub struct UserStats {
     pub total_size: u64,
 }
 
+#[cfg(feature = "payments")]
+#[derive(Clone, FromRow, Serialize)]
+pub struct Payment {
+    pub payment_hash: Vec<u8>,
+    pub user_id: u64,
+    pub created: DateTime<Utc>,
+    pub amount: u64,
+    pub is_paid: bool,
+    pub days_value: u64,
+    pub size_value: u64,
+    pub settle_index: Option<u64>,
+    pub rate: Option<f32>,
+}
+
 #[derive(Clone)]
 pub struct Database {
     pub(crate) pool: sqlx::pool::Pool<sqlx::mysql::MySql>,
@@ -270,3 +288,56 @@ impl Database {
         Ok((results, count))
     }
 }
+
+#[cfg(feature = "payments")]
+impl Database {
+    pub async fn insert_payment(&self, payment: &Payment) -> Result<(), Error> {
+        sqlx::query("insert into payments(payment_hash,user_id,amount,days_value,size_value,rate) values(?,?,?,?,?,?)")
+            .bind(&payment.payment_hash)
+            .bind(payment.user_id)
+            .bind(payment.amount)
+            .bind(payment.days_value)
+            .bind(payment.size_value)
+            .bind(payment.rate)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn get_payment(&self, payment_hash: &Vec<u8>) -> Result<Option<Payment>, Error> {
+        sqlx::query_as("select * from payments where payment_hash = ?")
+            .bind(payment_hash)
+            .fetch_optional(&self.pool)
+            .await
+    }
+
+    pub async fn get_user_payments(&self, uid: u64) -> Result<Vec<Payment>, Error> {
+        sqlx::query_as("select * from payments where user_id = ?")
+            .bind(uid)
+            .fetch_all(&self.pool)
+            .await
+    }
+
+    pub async fn complete_payment(&self, payment: &Payment) -> Result<(), Error> {
+        let mut tx = self.pool.begin().await?;
+
+        sqlx::query("update payments set is_paid = true, settle_index = ? where payment_hash = ?")
+            .bind(payment.settle_index)
+            .bind(&payment.payment_hash)
+            .execute(&mut *tx)
+            .await?;
+
+        // TODO: check space is not downgraded
+
+        sqlx::query("update users set paid_until = TIMESTAMPADD(DAY, ?, IFNULL(paid_until, current_timestamp)), paid_size = ? where id = ?")
+            .bind(payment.days_value)
+            .bind(payment.size_value)
+            .bind(payment.user_id)
+            .execute(&mut *tx)
+            .await?;
+
+        tx.commit().await?;
+
+        Ok(())
+    }
+}

src/filesystem.rs

@@ -1,6 +1,5 @@
 #[cfg(feature = "labels")]
 use crate::db::FileLabel;
-use crate::processing::can_compress;
 #[cfg(feature = "labels")]
 use crate::processing::labeling::label_frame;
 #[cfg(feature = "media-compression")]
@@ -18,6 +17,7 @@ use std::path::PathBuf;
 use tokio::fs::File;
 use tokio::io::{AsyncRead, AsyncReadExt};
 use uuid::Uuid;
+use crate::can_compress;
 
 #[derive(Clone)]
 pub enum FileSystemResult {
@@ -180,6 +180,7 @@ impl FileStore {
         }
     }
 
+    #[cfg(feature = "media-compression")]
     async fn compress_file(&self, input: &PathBuf, mime_type: &str) -> Result<NewFileResult> {
         let compressed_result = compress_file(input, mime_type, &self.temp_dir())?;
         #[cfg(feature = "labels")]

src/lib.rs

@@ -5,10 +5,14 @@ pub mod background;
 pub mod cors;
 pub mod db;
 pub mod filesystem;
+#[cfg(feature = "payments")]
+pub mod payments;
 #[cfg(feature = "media-compression")]
 pub mod processing;
 pub mod routes;
 pub mod settings;
-#[cfg(any(feature = "void-cat-redirects", feature = "bin-void-cat-migrate"))]
-pub mod void_db;
 pub mod void_file;
+
+pub fn can_compress(mime_type: &str) -> bool {
+    mime_type.starts_with("image/")
+}

src/payments.rs

@@ -0,0 +1,53 @@
+use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PaymentAmount {
+    pub currency: Currency,
+    pub amount: f32,
+}
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Currency {
+    BTC,
+    USD,
+    EUR,
+    GBP,
+    JPY,
+    CAD,
+    AUD,
+}
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum PaymentUnit {
+    GBSpace,
+    GBEgress,
+}
+
+impl PaymentUnit {
+    /// Get the total size from a number of units
+    pub fn to_size(&self, units: f32) -> u64 {
+        (1000f32 * 1000f32 * 1000f32 * units) as u64
+    }
+}
+
+impl Display for PaymentUnit {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PaymentUnit::GBSpace => write!(f, "GB Space"),
+            PaymentUnit::GBEgress => write!(f, "GB Egress"),
+        }
+    }
+}
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PaymentInterval {
+    Day(u16),
+    Month(u16),
+    Year(u16),
+}

src/processing/mod.rs

@@ -5,6 +5,7 @@ use ffmpeg_rs_raw::{Decoder, Demuxer, DemuxerInfo, Encoder, Scaler, StreamType,
 use std::path::{Path, PathBuf};
 use std::ptr;
 use uuid::Uuid;
+use crate::can_compress;
 
 #[cfg(feature = "labels")]
 pub mod labeling;
@@ -136,10 +137,6 @@ pub struct NewFileProcessorResult {
     pub bitrate: u32,
 }
 
-pub fn can_compress(mime_type: &str) -> bool {
-    mime_type.starts_with("image/")
-}
-
 pub fn compress_file(
     path: &Path,
     mime_type: &str,

src/routes/admin.rs

@@ -53,6 +53,10 @@ pub struct SelfUser {
     pub is_admin: bool,
     pub file_count: u64,
     pub total_size: u64,
+    #[cfg(feature = "payments")]
+    pub paid_until: u64,
+    #[cfg(feature = "payments")]
+    pub quota: u64,
 }
 
 #[derive(Serialize)]
@@ -77,6 +81,12 @@ async fn admin_get_self(auth: Nip98Auth, db: &State<Database>) -> AdminResponse<
                 is_admin: user.is_admin,
                 file_count: s.file_count,
                 total_size: s.total_size,
+                paid_until: if let Some(u) = &user.paid_until {
+                    u.timestamp() as u64
+                } else {
+                    0
+                },
+                quota: user.paid_size,
             })
         }
         Err(_) => AdminResponse::error("User not found"),

src/routes/mod.rs

@@ -10,6 +10,7 @@ pub use crate::routes::nip96::nip96_routes;
 use crate::settings::Settings;
 use crate::void_file::VoidFile;
 use anyhow::Error;
+use base58::FromBase58;
 use http_range_header::{parse_range_header, EndPosition, StartPosition};
 use log::{debug, warn};
 use nostr::Event;
@@ -33,6 +34,8 @@ mod blossom;
 mod nip96;
 
 mod admin;
+#[cfg(feature = "payments")]
+pub mod payment;
 
 pub struct FilePayload {
     pub file: File,
@@ -183,58 +186,44 @@ impl<'r> Responder<'r, 'static> for FilePayload {
         response.set_header(Header::new("cache-control", "max-age=31536000, immutable"));
 
         // handle ranges
-        #[cfg(feature = "ranges")]
-        {
-            const MAX_UNBOUNDED_RANGE: u64 = 1024 * 1024;
-            // only use range response for files > 1MiB
-            if self.info.size < MAX_UNBOUNDED_RANGE {
-                response.set_sized_body(None, self.file);
-            } else {
-                response.set_header(Header::new("accept-ranges", "bytes"));
-                if let Some(r) = request.headers().get("range").next() {
-                    if let Ok(ranges) = parse_range_header(r) {
-                        if ranges.ranges.len() > 1 {
-                            warn!(
-                                "Multipart ranges are not supported, fallback to non-range request"
-                            );
-                            response.set_streamed_body(self.file);
-                        } else {
-                            let single_range = ranges.ranges.first().unwrap();
-                            let range_start = match single_range.start {
-                                StartPosition::Index(i) => i,
-                                StartPosition::FromLast(i) => self.info.size - i,
-                            };
-                            let range_end = match single_range.end {
-                                EndPosition::Index(i) => i,
-                                EndPosition::LastByte => {
-                                    (range_start + MAX_UNBOUNDED_RANGE).min(self.info.size)
-                                }
-                            };
-                            let r_len = range_end - range_start;
-                            let r_body = RangeBody::new(self.file, range_start..range_end);
-
-                            response.set_status(Status::PartialContent);
-                            response.set_header(Header::new("content-length", r_len.to_string()));
-                            response.set_header(Header::new(
-                                "content-range",
-                                format!(
-                                    "bytes {}-{}/{}",
-                                    range_start,
-                                    range_end - 1,
-                                    self.info.size
-                                ),
-                            ));
-                            response.set_streamed_body(Box::pin(r_body));
-                        }
-                    }
-                } else {
-                    response.set_sized_body(None, self.file);
-                }
-            }
-        }
-        #[cfg(not(feature = "ranges"))]
-        {
+        const MAX_UNBOUNDED_RANGE: u64 = 1024 * 1024;
+        // only use range response for files > 1MiB
+        if self.info.size < MAX_UNBOUNDED_RANGE {
             response.set_sized_body(None, self.file);
+        } else {
+            response.set_header(Header::new("accept-ranges", "bytes"));
+            if let Some(r) = request.headers().get("range").next() {
+                if let Ok(ranges) = parse_range_header(r) {
+                    if ranges.ranges.len() > 1 {
+                        warn!("Multipart ranges are not supported, fallback to non-range request");
+                        response.set_streamed_body(self.file);
+                    } else {
+                        let single_range = ranges.ranges.first().unwrap();
+                        let range_start = match single_range.start {
+                            StartPosition::Index(i) => i,
+                            StartPosition::FromLast(i) => self.info.size - i,
+                        };
+                        let range_end = match single_range.end {
+                            EndPosition::Index(i) => i,
+                            EndPosition::LastByte => {
+                                (range_start + MAX_UNBOUNDED_RANGE).min(self.info.size)
+                            }
+                        };
+                        let r_len = range_end - range_start;
+                        let r_body = RangeBody::new(self.file, range_start..range_end);
+
+                        response.set_status(Status::PartialContent);
+                        response.set_header(Header::new("content-length", r_len.to_string()));
+                        response.set_header(Header::new(
+                            "content-range",
+                            format!("bytes {}-{}/{}", range_start, range_end - 1, self.info.size),
+                        ));
+                        response.set_streamed_body(Box::pin(r_body));
+                    }
+                }
+            } else {
+                response.set_sized_body(None, self.file);
+            }
         }
 
         if let Ok(ct) = ContentType::from_str(&self.info.mime_type) {
@@ -437,9 +426,7 @@ pub async fn void_cat_redirect(id: &str, settings: &State<Settings>) -> Option<N
         id
     };
     if let Some(base) = &settings.void_cat_files {
-        let uuid =
-            uuid::Uuid::from_slice_le(nostr::bitcoin::base58::decode(id).unwrap().as_slice())
-                .unwrap();
+        let uuid = uuid::Uuid::from_slice_le(id.from_base58().unwrap().as_slice()).unwrap();
         let f = base.join(VoidFile::map_to_path(&uuid));
         debug!("Legacy file map: {} => {}", id, f.display());
         if let Ok(f) = NamedFile::open(f).await {
@@ -459,8 +446,7 @@ pub async fn void_cat_redirect_head(id: &str) -> VoidCatFile {
     } else {
         id
     };
-    let uuid =
-        uuid::Uuid::from_slice_le(nostr::bitcoin::base58::decode(id).unwrap().as_slice()).unwrap();
+    let uuid = uuid::Uuid::from_slice_le(id.from_base58().unwrap().as_slice()).unwrap();
     VoidCatFile {
         status: Status::Ok,
         uuid: Header::new("X-UUID", uuid.to_string()),

src/routes/payment.rs

@@ -0,0 +1,131 @@
+use crate::auth::nip98::Nip98Auth;
+use crate::db::{Database, Payment};
+use crate::payments::{Currency, PaymentAmount, PaymentInterval, PaymentUnit};
+use crate::settings::Settings;
+use chrono::{Months, Utc};
+use fedimint_tonic_lnd::lnrpc::Invoice;
+use fedimint_tonic_lnd::Client;
+use log::{error, info};
+use rocket::serde::json::Json;
+use rocket::{routes, Route, State};
+use serde::{Deserialize, Serialize};
+use std::ops::{Add, Deref};
+
+pub fn routes() -> Vec<Route> {
+    routes![get_payment, req_payment]
+}
+
+#[derive(Deserialize, Serialize)]
+struct PaymentInfo {
+    /// Billing quota metric
+    pub unit: PaymentUnit,
+
+    /// Amount of time to bill units (GB/mo, Gb Egress/day etc.)
+    pub interval: PaymentInterval,
+
+    /// Value amount of payment
+    pub cost: PaymentAmount,
+}
+
+#[derive(Deserialize, Serialize)]
+struct PaymentRequest {
+    /// Number of units requested to make payment
+    pub units: f32,
+
+    /// Quantity of orders to make
+    pub quantity: u16,
+}
+
+#[derive(Deserialize, Serialize)]
+struct PaymentResponse {
+    pub pr: String,
+}
+
+#[rocket::get("/payment")]
+async fn get_payment(settings: &State<Settings>) -> Option<Json<PaymentInfo>> {
+    settings.payments.as_ref().map(|p| {
+        Json::from(PaymentInfo {
+            unit: p.unit.clone(),
+            interval: p.interval.clone(),
+            cost: p.cost.clone(),
+        })
+    })
+}
+
+#[rocket::post("/payment", data = "<req>", format = "json")]
+async fn req_payment(
+    auth: Nip98Auth,
+    db: &State<Database>,
+    settings: &State<Settings>,
+    lnd: &State<Client>,
+    req: Json<PaymentRequest>,
+) -> Result<Json<PaymentResponse>, String> {
+    let cfg = if let Some(p) = &settings.payments {
+        p
+    } else {
+        return Err("Payment not enabled, missing configuration option(s)".to_string());
+    };
+
+    let btc_amount = match cfg.cost.currency {
+        Currency::BTC => cfg.cost.amount,
+        _ => return Err("Currency not supported".to_string()),
+    };
+
+    let amount = btc_amount * req.units * req.quantity as f32;
+
+    let pubkey_vec = auth.event.pubkey.to_bytes().to_vec();
+    let uid = db
+        .upsert_user(&pubkey_vec)
+        .await
+        .map_err(|_| "Failed to get user account".to_string())?;
+
+    let mut lnd = lnd.deref().clone();
+    let c = lnd.lightning();
+    let msat = (amount * 1e11f32) as u64;
+    let memo = format!(
+        "{}x {} {} for {}",
+        req.quantity, req.units, cfg.unit, auth.event.pubkey
+    );
+    info!("Requesting {} msats: {}", msat, memo);
+    let invoice = c
+        .add_invoice(Invoice {
+            value_msat: msat as i64,
+            memo,
+            ..Default::default()
+        })
+        .await
+        .map_err(|e| e.message().to_string())?;
+
+    let days_value = match cfg.interval {
+        PaymentInterval::Day(d) => d as u64,
+        PaymentInterval::Month(m) => {
+            let now = Utc::now();
+            (now.add(Months::new(m as u32)) - now).num_days() as u64
+        }
+        PaymentInterval::Year(y) => {
+            let now = Utc::now();
+            (now.add(Months::new(12 * y as u32)) - now).num_days() as u64
+        }
+    };
+
+    let record = Payment {
+        payment_hash: invoice.get_ref().r_hash.clone(),
+        user_id: uid,
+        created: Default::default(),
+        amount: msat,
+        is_paid: false,
+        days_value,
+        size_value: cfg.unit.to_size(req.units),
+        settle_index: None,
+        rate: None,
+    };
+
+    if let Err(e) = db.insert_payment(&record).await {
+        error!("Failed to insert payment: {}", e);
+        return Err("Failed to insert payment".to_string());
+    }
+
+    Ok(Json(PaymentResponse {
+        pr: invoice.get_ref().payment_request.clone(),
+    }))
+}

src/settings.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "payments")]
+use crate::payments::{Currency, PaymentAmount, PaymentInterval, PaymentUnit};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
@@ -30,11 +32,12 @@ pub struct Settings {
     /// Analytics tracking
     pub plausible_url: Option<String>,
 
-    #[cfg(feature = "void-cat-redirects")]
-    pub void_cat_database: Option<String>,
-
     /// Path to void.cat uploads (files-v2)
     pub void_cat_files: Option<PathBuf>,
+
+    #[cfg(feature = "payments")]
+    /// Payment options for paid storage
+    pub payments: Option<PaymentConfig>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -42,3 +45,30 @@ pub struct VitModelConfig {
     pub model: PathBuf,
     pub config: PathBuf,
 }
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PaymentConfig {
+    /// LND connection details
+    pub lnd: LndConfig,
+
+    /// Pricing per unit
+    pub cost: PaymentAmount,
+
+    /// What metric to bill payments on
+    pub unit: PaymentUnit,
+
+    /// Billing interval time per unit
+    pub interval: PaymentInterval,
+
+    /// Fiat base currency to store exchange rates along with invoice
+    pub fiat: Option<Currency>,
+}
+
+#[cfg(feature = "payments")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LndConfig {
+    pub endpoint: String,
+    pub tls: PathBuf,
+    pub macaroon: PathBuf,
+}