Supporting documents for Mural payouts (#4721)

* wip: gotenberg

* Generate and provide supporting docs for Mural payouts

* Correct docs

* shear

* update cargo lock because r-a complains otherwise

* Remove local Gotenberg queue and use Redis instead

* Store platform_id in database correctly

* Address PR comments

* Fix up CI

* fix rebase

* Add timeout to default env vars

Author: aecsocket

Cargo.toml

@@ -249,6 +249,7 @@ redundant_clone = "warn"
 redundant_feature_names = "warn"
 redundant_type_annotations = "warn"
 todo = "warn"
+too_many_arguments = "allow"
 uninlined_format_args = "warn"
 unnested_or_patterns = "warn"
 wildcard_dependencies = "warn"

apps/labrinth/.env.docker-compose

@@ -144,6 +144,7 @@ ANROK_API_URL=none
 
 GOTENBERG_URL=http://labrinth-gotenberg:13000
 GOTENBERG_CALLBACK_BASE=http://host.docker.internal:8000/_internal/gotenberg
+GOTENBERG_TIMEOUT=30000
 
 ARCHON_URL=none
 

apps/labrinth/.env.local

@@ -19,7 +19,10 @@ MEILISEARCH_KEY=modrinth
 REDIS_URL=redis://localhost
 REDIS_MAX_CONNECTIONS=10000
 
-BIND_ADDR=127.0.0.1:8000
+# Must bind to broadcast, not localhost, because some
+# Docker services (Gotenberg) must be able to reach the backend
+# from a different network interface
+BIND_ADDR=0.0.0.0:8000
 SELF_ADDR=http://127.0.0.1:8000
 
 MODERATION_SLACK_WEBHOOK=
@@ -145,6 +148,7 @@ ANROK_API_URL=none
 
 GOTENBERG_URL=http://localhost:13000
 GOTENBERG_CALLBACK_BASE=http://host.docker.internal:8000/_internal/gotenberg
+GOTENBERG_TIMEOUT=30000
 
 ARCHON_URL=none
 

apps/labrinth/src/database/redis.rs

@@ -5,7 +5,10 @@ use dashmap::DashMap;
 use deadpool_redis::{Config, Runtime};
 use futures::future::Either;
 use prometheus::{IntGauge, Registry};
-use redis::{Cmd, ExistenceCheck, SetExpiry, SetOptions, cmd};
+use redis::{
+    AsyncTypedCommands, Cmd, ExistenceCheck, SetExpiry, SetOptions,
+    ToRedisArgs, cmd,
+};
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -680,6 +683,30 @@ impl RedisConnection {
 
         Ok(())
     }
+
+    pub async fn lpush(
+        &mut self,
+        namespace: &str,
+        key: &str,
+        value: impl ToRedisArgs + Send + Sync,
+    ) -> Result<(), DatabaseError> {
+        let key = format!("{}_{namespace}:{key}", self.meta_namespace);
+        self.connection.lpush(key, value).await?;
+        Ok(())
+    }
+
+    pub async fn brpop(
+        &mut self,
+        namespace: &str,
+        key: &str,
+        timeout: Option<f64>,
+    ) -> Result<Option<[String; 2]>, DatabaseError> {
+        let key = format!("{}_{namespace}:{key}", self.meta_namespace);
+        // a timeout of 0 is infinite
+        let timeout = timeout.unwrap_or(0.0);
+        let values = self.connection.brpop(key, timeout).await?;
+        Ok(values)
+    }
 }
 
 #[derive(Serialize, Deserialize)]

apps/labrinth/src/lib.rs

@@ -503,6 +503,7 @@ pub fn check_env_vars() -> bool {
 
     failed |= check_var::<String>("GOTENBERG_URL");
     failed |= check_var::<String>("GOTENBERG_CALLBACK_BASE");
+    failed |= check_var::<String>("GOTENBERG_TIMEOUT");
 
     failed |= check_var::<String>("STRIPE_API_KEY");
     failed |= check_var::<String>("STRIPE_WEBHOOK_SECRET");

apps/labrinth/src/main.rs

@@ -153,8 +153,8 @@ async fn main() -> std::io::Result<()> {
     let email_queue =
         EmailQueue::init(pool.clone(), redis_pool.clone()).unwrap();
 
-    let gotenberg_client =
-        GotenbergClient::from_env().expect("Failed to create Gotenberg client");
+    let gotenberg_client = GotenbergClient::from_env(redis_pool.clone())
+        .expect("Failed to create Gotenberg client");
 
     if let Some(task) = args.run_background_task {
         info!("Running task {task:?} and exiting");

apps/labrinth/src/queue/payouts/mod.rs

@@ -726,7 +726,7 @@ impl PayoutsQueue {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct PayoutFees {
     /// Fee which is taken by the underlying method we're using.
     ///

apps/labrinth/src/queue/payouts/mural.rs

@@ -1,13 +1,18 @@
 use ariadne::ids::UserId;
+use chrono::Utc;
 use eyre::{Result, eyre};
 use muralpay::{MuralError, TokenFeeRequest};
-use rust_decimal::Decimal;
+use rust_decimal::{Decimal, prelude::ToPrimitive};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    queue::payouts::{AccountBalance, PayoutsQueue},
+    database::models::DBPayoutId,
+    queue::payouts::{AccountBalance, PayoutFees, PayoutsQueue},
     routes::ApiError,
-    util::error::Context,
+    util::{
+        error::Context,
+        gotenberg::{GotenbergClient, PaymentStatement},
+    },
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
@@ -54,10 +59,13 @@ impl PayoutsQueue {
 
     pub async fn create_muralpay_payout_request(
         &self,
+        payout_id: DBPayoutId,
         user_id: UserId,
-        amount: muralpay::TokenAmount,
+        gross_amount: Decimal,
+        fees: PayoutFees,
         payout_details: MuralPayoutRequest,
         recipient_info: muralpay::PayoutRecipientInfo,
+        gotenberg: &GotenbergClient,
     ) -> Result<muralpay::PayoutRequest, ApiError> {
         let muralpay = self.muralpay.load();
         let muralpay = muralpay
@@ -86,11 +94,71 @@ impl PayoutsQueue {
             }
         };
 
+        // Mural takes `fees.method_fee` off the top of the amount we tell them to send
+        let sent_to_method = gross_amount - fees.platform_fee;
+        // ..so the net is `gross - platform_fee - method_fee`
+        let net_amount = gross_amount - fees.total_fee();
+
+        let recipient_address = recipient_info.physical_address();
+        let recipient_email = recipient_info.email().to_string();
+        let gross_amount_cents = gross_amount * Decimal::from(100);
+        let net_amount_cents = net_amount * Decimal::from(100);
+        let fees_cents = fees.total_fee() * Decimal::from(100);
+        let address_line_3 = format!(
+            "{}, {}, {}",
+            recipient_address.city,
+            recipient_address.state,
+            recipient_address.zip
+        );
+
+        let payment_statement = PaymentStatement {
+            payment_id: payout_id.into(),
+            recipient_address_line_1: Some(recipient_address.address1.clone()),
+            recipient_address_line_2: recipient_address.address2.clone(),
+            recipient_address_line_3: Some(address_line_3),
+            recipient_email,
+            payment_date: Utc::now(),
+            gross_amount_cents: gross_amount_cents
+                .to_i64()
+                .wrap_internal_err_with(|| eyre!("gross amount of cents `{gross_amount_cents}` cannot be expressed as an `i64`"))?,
+            net_amount_cents: net_amount_cents
+                .to_i64()
+                .wrap_internal_err_with(|| eyre!("net amount of cents `{net_amount_cents}` cannot be expressed as an `i64`"))?,
+            fees_cents: fees_cents
+                .to_i64()
+                .wrap_internal_err_with(|| eyre!("fees amount of cents `{fees_cents}` cannot be expressed as an `i64`"))?,
+            currency_code: "USD".into(),
+        };
+        let payment_statement_doc = gotenberg
+            .wait_for_payment_statement(&payment_statement)
+            .await
+            .wrap_internal_err("failed to generate payment statement")?;
+
+        // TODO
+        // std::fs::write(
+        //     "/tmp/modrinth-payout-statement.pdf",
+        //     base64::Engine::decode(
+        //         &base64::engine::general_purpose::STANDARD,
+        //         &payment_statement_doc.body,
+        //     )
+        //     .unwrap(),
+        // )
+        // .unwrap();
+
         let payout = muralpay::CreatePayout {
-            amount,
+            amount: muralpay::TokenAmount {
+                token_amount: sent_to_method,
+                token_symbol: muralpay::USDC.into(),
+            },
             payout_details,
             recipient_info,
-            supporting_details: None,
+            supporting_details: Some(muralpay::SupportingDetails {
+                supporting_document: Some(format!(
+                    "data:application/pdf;base64,{}",
+                    payment_statement_doc.body
+                )),
+                payout_purpose: Some(muralpay::PayoutPurpose::VendorPayment),
+            }),
         };
 
         let payout_request = muralpay
@@ -103,7 +171,9 @@ impl PayoutsQueue {
             .await
             .map_err(|err| match err {
                 MuralError::Api(err) => ApiError::Request(err.into()),
-                err => ApiError::Internal(err.into()),
+                err => ApiError::Internal(
+                    eyre!(err).wrap_err("failed to create payout request"),
+                ),
             })?;
 
         // try to immediately execute the payout request...