2
Cargo.lock
generated
2
Cargo.lock
generated
@ -2009,6 +2009,7 @@ dependencies = [
|
||||
"fern",
|
||||
"futures",
|
||||
"hex",
|
||||
"hmac",
|
||||
"ipnetwork",
|
||||
"lettre",
|
||||
"lnvps_db",
|
||||
@ -2024,6 +2025,7 @@ dependencies = [
|
||||
"schemars",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"ssh-key",
|
||||
"ssh2",
|
||||
"tokio",
|
||||
|
@ -7,7 +7,7 @@ edition = "2021"
|
||||
name = "api"
|
||||
|
||||
[features]
|
||||
default = ["mikrotik", "nostr-dm", "proxmox", "lnd", "cloudflare"]
|
||||
default = ["mikrotik", "nostr-dm", "proxmox", "lnd", "cloudflare", "revolut"]
|
||||
mikrotik = ["dep:reqwest"]
|
||||
nostr-dm = ["dep:nostr-sdk"]
|
||||
proxmox = ["dep:reqwest", "dep:ssh2", "dep:tokio-tungstenite"]
|
||||
@ -15,6 +15,7 @@ libvirt = ["dep:virt"]
|
||||
lnd = ["dep:fedimint-tonic-lnd"]
|
||||
bitvora = ["dep:reqwest", "dep:tokio-stream"]
|
||||
cloudflare = ["dep:reqwest"]
|
||||
revolut = ["dep:reqwest", "dep:sha2", "dep:hmac"]
|
||||
|
||||
[dependencies]
|
||||
lnvps_db = { path = "lnvps_db" }
|
||||
@ -57,4 +58,8 @@ virt = { version = "0.4.2", optional = true }
|
||||
fedimint-tonic-lnd = { version = "0.2.0", default-features = false, features = ["invoicesrpc"], optional = true }
|
||||
|
||||
#bitvora
|
||||
tokio-stream = { version = "0.1.17", features = ["sync"], optional = true }
|
||||
tokio-stream = { version = "0.1.17", features = ["sync"], optional = true }
|
||||
|
||||
#revolut
|
||||
sha2 = { version = "0.10.8", optional = true }
|
||||
hmac = { version = "0.12.1", optional = true }
|
@ -5,6 +5,7 @@ lightning:
|
||||
cert: "/home/kieran/.polar/networks/2/volumes/lnd/alice/tls.cert"
|
||||
macaroon: "/home/kieran/.polar/networks/2/volumes/lnd/alice/data/chain/bitcoin/regtest/admin.macaroon"
|
||||
delete-after: 3
|
||||
public-url: "https://api.lnvps.net"
|
||||
provisioner:
|
||||
proxmox:
|
||||
read-only: false
|
||||
|
6
lnvps_db/migrations/20250310153305_fiat_payment.sql
Normal file
6
lnvps_db/migrations/20250310153305_fiat_payment.sql
Normal file
@ -0,0 +1,6 @@
|
||||
alter table vm_payment
|
||||
add column currency varchar(5) not null default 'BTC',
|
||||
add column payment_method smallint unsigned not null default 0,
|
||||
add column external_id varchar(255),
|
||||
change invoice external_data varchar (4096) NOT NULL,
|
||||
drop column settle_index;
|
@ -131,6 +131,9 @@ pub trait LNVpsDb: Sync + Send {
|
||||
/// Get VM payment by payment id
|
||||
async fn get_vm_payment(&self, id: &Vec<u8>) -> Result<VmPayment>;
|
||||
|
||||
/// Get VM payment by payment id
|
||||
async fn get_vm_payment_by_ext_id(&self, id: &str) -> Result<VmPayment>;
|
||||
|
||||
/// Update a VM payment record
|
||||
async fn update_vm_payment(&self, vm_payment: &VmPayment) -> Result<()>;
|
||||
|
||||
|
@ -1,8 +1,9 @@
|
||||
use anyhow::{anyhow, Result};
|
||||
use anyhow::{anyhow, bail, Result};
|
||||
use chrono::{DateTime, Utc};
|
||||
use sqlx::FromRow;
|
||||
use sqlx::{FromRow, Type};
|
||||
use std::fmt::{Display, Formatter};
|
||||
use std::path::PathBuf;
|
||||
use std::str::FromStr;
|
||||
use url::Url;
|
||||
|
||||
#[derive(FromRow, Clone, Debug)]
|
||||
@ -309,17 +310,53 @@ impl Display for VmIpAssignment {
|
||||
|
||||
#[derive(FromRow, Clone, Debug, Default)]
|
||||
pub struct VmPayment {
|
||||
/// Payment hash
|
||||
pub id: Vec<u8>,
|
||||
pub vm_id: u64,
|
||||
pub created: DateTime<Utc>,
|
||||
pub expires: DateTime<Utc>,
|
||||
pub amount: u64,
|
||||
pub invoice: String,
|
||||
pub currency: String,
|
||||
pub payment_method: PaymentMethod,
|
||||
/// External data (invoice / json)
|
||||
pub external_data: String,
|
||||
/// External id on other system
|
||||
pub external_id: Option<String>,
|
||||
pub is_paid: bool,
|
||||
/// Exchange rate
|
||||
/// TODO: handle other base currencies
|
||||
/// Exchange rate back to base currency (EUR)
|
||||
pub rate: f32,
|
||||
/// Number of seconds this payment will add to vm expiry
|
||||
pub time_value: u64,
|
||||
pub settle_index: Option<u64>,
|
||||
}
|
||||
|
||||
#[derive(Type, Clone, Copy, Debug, Default, PartialEq)]
|
||||
#[repr(u16)]
|
||||
pub enum PaymentMethod {
|
||||
#[default]
|
||||
Lightning,
|
||||
Revolut,
|
||||
Paypal,
|
||||
}
|
||||
|
||||
impl Display for PaymentMethod {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
PaymentMethod::Lightning => write!(f, "Lightning"),
|
||||
PaymentMethod::Revolut => write!(f, "Revolut"),
|
||||
PaymentMethod::Paypal => write!(f, "PayPal"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for PaymentMethod {
|
||||
type Err = anyhow::Error;
|
||||
|
||||
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
|
||||
match s {
|
||||
"lightning" => Ok(PaymentMethod::Lightning),
|
||||
"revolut" => Ok(PaymentMethod::Revolut),
|
||||
"paypal" => Ok(PaymentMethod::Paypal),
|
||||
_ => bail!("Unknown payment method: {}", s),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -387,16 +387,19 @@ impl LNVpsDb for LNVpsDbMysql {
|
||||
}
|
||||
|
||||
async fn insert_vm_payment(&self, vm_payment: &VmPayment) -> Result<()> {
|
||||
sqlx::query("insert into vm_payment(id,vm_id,created,expires,amount,invoice,time_value,is_paid,rate) values(?,?,?,?,?,?,?,?,?)")
|
||||
sqlx::query("insert into vm_payment(id,vm_id,created,expires,amount,currency,payment_method,time_value,is_paid,rate,external_id,external_data) values(?,?,?,?,?,?,?,?,?,?,?,?)")
|
||||
.bind(&vm_payment.id)
|
||||
.bind(vm_payment.vm_id)
|
||||
.bind(vm_payment.created)
|
||||
.bind(vm_payment.expires)
|
||||
.bind(vm_payment.amount)
|
||||
.bind(&vm_payment.invoice)
|
||||
.bind(&vm_payment.currency)
|
||||
.bind(&vm_payment.payment_method)
|
||||
.bind(vm_payment.time_value)
|
||||
.bind(vm_payment.is_paid)
|
||||
.bind(vm_payment.rate)
|
||||
.bind(&vm_payment.external_id)
|
||||
.bind(&vm_payment.external_data)
|
||||
.execute(&self.db)
|
||||
.await
|
||||
.map_err(Error::new)?;
|
||||
@ -411,6 +414,14 @@ impl LNVpsDb for LNVpsDbMysql {
|
||||
.map_err(Error::new)
|
||||
}
|
||||
|
||||
async fn get_vm_payment_by_ext_id(&self, id: &str) -> Result<VmPayment> {
|
||||
sqlx::query_as("select * from vm_payment where external_id=?")
|
||||
.bind(id)
|
||||
.fetch_one(&self.db)
|
||||
.await
|
||||
.map_err(Error::new)
|
||||
}
|
||||
|
||||
async fn update_vm_payment(&self, vm_payment: &VmPayment) -> Result<()> {
|
||||
sqlx::query("update vm_payment set is_paid = ? where id = ?")
|
||||
.bind(vm_payment.is_paid)
|
||||
@ -428,8 +439,7 @@ impl LNVpsDb for LNVpsDbMysql {
|
||||
|
||||
let mut tx = self.db.begin().await?;
|
||||
|
||||
sqlx::query("update vm_payment set is_paid = true, settle_index = ? where id = ?")
|
||||
.bind(vm_payment.settle_index)
|
||||
sqlx::query("update vm_payment set is_paid = true where id = ?")
|
||||
.bind(&vm_payment.id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
@ -446,7 +456,7 @@ impl LNVpsDb for LNVpsDbMysql {
|
||||
|
||||
async fn last_paid_invoice(&self) -> Result<Option<VmPayment>> {
|
||||
sqlx::query_as(
|
||||
"select * from vm_payment where is_paid = true order by settle_index desc limit 1",
|
||||
"select * from vm_payment where is_paid = true order by created desc limit 1",
|
||||
)
|
||||
.fetch_optional(&self.db)
|
||||
.await
|
||||
|
@ -10,4 +10,5 @@ pub fn routes() -> Vec<Route> {
|
||||
r
|
||||
}
|
||||
|
||||
pub use webhook::WebhookMessage;
|
||||
pub use webhook::WEBHOOK_BRIDGE;
|
||||
|
@ -1,16 +1,16 @@
|
||||
use crate::exchange::{alt_prices, Currency, CurrencyAmount, ExchangeRateService};
|
||||
use crate::provisioner::{PricingData, PricingEngine};
|
||||
use crate::provisioner::PricingEngine;
|
||||
use crate::status::VmState;
|
||||
use anyhow::{anyhow, bail, Context, Result};
|
||||
use anyhow::{anyhow, bail, Result};
|
||||
use chrono::{DateTime, Utc};
|
||||
use ipnetwork::IpNetwork;
|
||||
use lnvps_db::{
|
||||
LNVpsDb, Vm, VmCostPlan, VmCustomPricing, VmCustomPricingDisk, VmCustomTemplate, VmHost,
|
||||
VmHostRegion, VmTemplate,
|
||||
LNVpsDb, PaymentMethod, Vm, VmCostPlan, VmCustomPricing, VmCustomPricingDisk, VmCustomTemplate, VmHostRegion, VmTemplate,
|
||||
};
|
||||
use nostr::util::hex;
|
||||
use schemars::JsonSchema;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::HashMap;
|
||||
use std::str::FromStr;
|
||||
use std::sync::Arc;
|
||||
|
||||
@ -95,9 +95,9 @@ impl From<lnvps_db::DiskType> for DiskType {
|
||||
}
|
||||
}
|
||||
|
||||
impl Into<lnvps_db::DiskType> for DiskType {
|
||||
fn into(self) -> lnvps_db::DiskType {
|
||||
match self {
|
||||
impl From<DiskType> for lnvps_db::DiskType {
|
||||
fn from(val: DiskType) -> Self {
|
||||
match val {
|
||||
DiskType::HDD => lnvps_db::DiskType::HDD,
|
||||
DiskType::SSD => lnvps_db::DiskType::SSD,
|
||||
}
|
||||
@ -143,7 +143,7 @@ impl ApiTemplatesResponse {
|
||||
pub async fn expand_pricing(&mut self, rates: &Arc<dyn ExchangeRateService>) -> Result<()> {
|
||||
let rates = rates.list_rates().await?;
|
||||
|
||||
for mut template in &mut self.templates {
|
||||
for template in &mut self.templates {
|
||||
let list_price = CurrencyAmount(template.cost_plan.currency, template.cost_plan.amount);
|
||||
for alt_price in alt_prices(&rates, list_price) {
|
||||
template.cost_plan.other_price.push(ApiPrice {
|
||||
@ -335,8 +335,8 @@ impl ApiVmTemplate {
|
||||
cpu: template.cpu,
|
||||
memory: template.memory,
|
||||
disk_size: template.disk_size,
|
||||
disk_type: template.disk_type.clone().into(),
|
||||
disk_interface: template.disk_interface.clone().into(),
|
||||
disk_type: template.disk_type.into(),
|
||||
disk_interface: template.disk_interface.into(),
|
||||
cost_plan: ApiVmCostPlan {
|
||||
id: cost_plan.id,
|
||||
name: cost_plan.name.clone(),
|
||||
@ -468,14 +468,14 @@ impl From<lnvps_db::VmOsImage> for ApiVmOsImage {
|
||||
|
||||
#[derive(Serialize, Deserialize, JsonSchema)]
|
||||
pub struct ApiVmPayment {
|
||||
/// Payment hash hex
|
||||
pub id: String,
|
||||
pub vm_id: u64,
|
||||
pub created: DateTime<Utc>,
|
||||
pub expires: DateTime<Utc>,
|
||||
pub amount: u64,
|
||||
pub invoice: String,
|
||||
pub currency: String,
|
||||
pub is_paid: bool,
|
||||
pub data: ApiPaymentData,
|
||||
}
|
||||
|
||||
impl From<lnvps_db::VmPayment> for ApiVmPayment {
|
||||
@ -486,8 +486,64 @@ impl From<lnvps_db::VmPayment> for ApiVmPayment {
|
||||
created: value.created,
|
||||
expires: value.expires,
|
||||
amount: value.amount,
|
||||
invoice: value.invoice,
|
||||
currency: value.currency,
|
||||
is_paid: value.is_paid,
|
||||
data: match &value.payment_method {
|
||||
PaymentMethod::Lightning => ApiPaymentData::Lightning(value.external_data),
|
||||
PaymentMethod::Revolut => {
|
||||
#[derive(Deserialize)]
|
||||
struct RevolutData {
|
||||
pub token: String,
|
||||
}
|
||||
let data: RevolutData = serde_json::from_str(&value.external_data).unwrap();
|
||||
ApiPaymentData::Revolut { token: data.token }
|
||||
}
|
||||
PaymentMethod::Paypal => {
|
||||
todo!()
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, JsonSchema)]
|
||||
pub struct ApiPaymentInfo {
|
||||
pub name: ApiPaymentMethod,
|
||||
|
||||
#[serde(skip_serializing_if = "HashMap::is_empty")]
|
||||
pub metadata: HashMap<String, String>,
|
||||
|
||||
pub currencies: Vec<Currency>,
|
||||
}
|
||||
|
||||
/// Payment data related to the payment method
|
||||
#[derive(Serialize, Deserialize, JsonSchema)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum ApiPaymentData {
|
||||
/// Just an LN invoice
|
||||
Lightning(String),
|
||||
/// Revolut order data
|
||||
Revolut {
|
||||
/// Order token
|
||||
token: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum ApiPaymentMethod {
|
||||
#[default]
|
||||
Lightning,
|
||||
Revolut,
|
||||
Paypal,
|
||||
}
|
||||
|
||||
impl From<PaymentMethod> for ApiPaymentMethod {
|
||||
fn from(value: PaymentMethod) -> Self {
|
||||
match value {
|
||||
PaymentMethod::Lightning => ApiPaymentMethod::Lightning,
|
||||
PaymentMethod::Revolut => ApiPaymentMethod::Revolut,
|
||||
PaymentMethod::Paypal => ApiPaymentMethod::Paypal,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,19 +1,21 @@
|
||||
use crate::api::model::{
|
||||
AccountPatchRequest, ApiCustomTemplateDiskParam, ApiCustomTemplateParams, ApiCustomVmOrder,
|
||||
ApiCustomVmRequest, ApiPrice, ApiTemplatesResponse, ApiUserSshKey, ApiVmHostRegion,
|
||||
ApiVmIpAssignment, ApiVmOsImage, ApiVmPayment, ApiVmStatus, ApiVmTemplate, CreateSshKey,
|
||||
CreateVmRequest, VMPatchRequest,
|
||||
AccountPatchRequest, ApiCustomTemplateParams, ApiCustomVmOrder,
|
||||
ApiCustomVmRequest, ApiPaymentInfo, ApiPaymentMethod, ApiPrice, ApiTemplatesResponse,
|
||||
ApiUserSshKey, ApiVmIpAssignment, ApiVmOsImage, ApiVmPayment, ApiVmStatus,
|
||||
ApiVmTemplate, CreateSshKey, CreateVmRequest, VMPatchRequest,
|
||||
};
|
||||
use crate::exchange::ExchangeRateService;
|
||||
use crate::exchange::{Currency, ExchangeRateService};
|
||||
use crate::host::{get_host_client, FullVmInfo, TimeSeries, TimeSeriesData};
|
||||
use crate::nip98::Nip98Auth;
|
||||
use crate::provisioner::{HostCapacityService, LNVpsProvisioner, PricingEngine};
|
||||
use crate::settings::Settings;
|
||||
use crate::status::{VmState, VmStateCache};
|
||||
use crate::worker::WorkJob;
|
||||
use anyhow::{Context, Result};
|
||||
use anyhow::Result;
|
||||
use futures::future::join_all;
|
||||
use lnvps_db::{IpRange, LNVpsDb, VmCustomPricing, VmCustomPricingDisk, VmCustomTemplate};
|
||||
use lnvps_db::{
|
||||
IpRange, LNVpsDb, PaymentMethod, VmCustomPricing, VmCustomPricingDisk, VmCustomTemplate,
|
||||
};
|
||||
use nostr::util::hex;
|
||||
use rocket::futures::{SinkExt, StreamExt};
|
||||
use rocket::serde::json::Json;
|
||||
@ -26,6 +28,7 @@ use schemars::JsonSchema;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use ssh_key::PublicKey;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::str::FromStr;
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
@ -48,7 +51,8 @@ pub fn routes() -> Vec<Route> {
|
||||
v1_patch_vm,
|
||||
v1_time_series,
|
||||
v1_custom_template_calc,
|
||||
v1_create_custom_vm_order
|
||||
v1_create_custom_vm_order,
|
||||
v1_get_payment_methods
|
||||
]
|
||||
}
|
||||
|
||||
@ -143,7 +147,7 @@ async fn vm_to_status(
|
||||
.map(|i| (i.id, i))
|
||||
.collect();
|
||||
|
||||
let template = ApiVmTemplate::from_vm(&db, &vm).await?;
|
||||
let template = ApiVmTemplate::from_vm(db, &vm).await?;
|
||||
Ok(ApiVmStatus {
|
||||
id: vm.id,
|
||||
created: vm.created,
|
||||
@ -309,7 +313,7 @@ async fn v1_list_vm_templates(
|
||||
})
|
||||
.collect();
|
||||
let custom_templates: Vec<VmCustomPricing> =
|
||||
join_all(regions.iter().map(|(k, _)| db.list_custom_pricing(*k)))
|
||||
join_all(regions.keys().map(|k| db.list_custom_pricing(*k)))
|
||||
.await
|
||||
.into_iter()
|
||||
.filter_map(|r| r.ok())
|
||||
@ -344,8 +348,7 @@ async fn v1_list_vm_templates(
|
||||
.into_iter()
|
||||
.filter_map(|t| {
|
||||
let region = regions.get(&t.region_id)?;
|
||||
Some(
|
||||
ApiCustomTemplateParams::from(
|
||||
ApiCustomTemplateParams::from(
|
||||
&t,
|
||||
&custom_template_disks,
|
||||
region,
|
||||
@ -353,8 +356,7 @@ async fn v1_list_vm_templates(
|
||||
max_memory,
|
||||
max_disk,
|
||||
)
|
||||
.ok()?,
|
||||
)
|
||||
.ok()
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
@ -376,7 +378,7 @@ async fn v1_custom_template_calc(
|
||||
|
||||
let price = PricingEngine::get_custom_vm_cost_amount(db, 0, &template).await?;
|
||||
ApiData::ok(ApiPrice {
|
||||
currency: price.currency.clone(),
|
||||
currency: price.currency,
|
||||
amount: price.total(),
|
||||
})
|
||||
}
|
||||
@ -484,12 +486,13 @@ async fn v1_create_vm_order(
|
||||
|
||||
/// Renew(Extend) a VM
|
||||
#[openapi(tag = "VM")]
|
||||
#[get("/api/v1/vm/<id>/renew")]
|
||||
#[get("/api/v1/vm/<id>/renew?<method>")]
|
||||
async fn v1_renew_vm(
|
||||
auth: Nip98Auth,
|
||||
db: &State<Arc<dyn LNVpsDb>>,
|
||||
provisioner: &State<Arc<LNVpsProvisioner>>,
|
||||
id: u64,
|
||||
method: Option<&str>,
|
||||
) -> ApiResult<ApiVmPayment> {
|
||||
let pubkey = auth.event.pubkey.to_bytes();
|
||||
let uid = db.upsert_user(&pubkey).await?;
|
||||
@ -498,7 +501,14 @@ async fn v1_renew_vm(
|
||||
return ApiData::err("VM does not belong to you");
|
||||
}
|
||||
|
||||
let rsp = provisioner.renew(id).await?;
|
||||
let rsp = provisioner
|
||||
.renew(
|
||||
id,
|
||||
method
|
||||
.and_then(|m| PaymentMethod::from_str(m).ok())
|
||||
.unwrap_or(PaymentMethod::Lightning),
|
||||
)
|
||||
.await?;
|
||||
ApiData::ok(rsp.into())
|
||||
}
|
||||
|
||||
@ -596,6 +606,26 @@ async fn v1_time_series(
|
||||
ApiData::ok(client.get_time_series_data(&vm, TimeSeries::Hourly).await?)
|
||||
}
|
||||
|
||||
#[openapi(tag = "Payment")]
|
||||
#[get("/api/v1/payment/methods")]
|
||||
async fn v1_get_payment_methods(settings: &State<Settings>) -> ApiResult<Vec<ApiPaymentInfo>> {
|
||||
let mut ret = vec![ApiPaymentInfo {
|
||||
name: ApiPaymentMethod::Lightning,
|
||||
metadata: HashMap::new(),
|
||||
currencies: vec![Currency::BTC],
|
||||
}];
|
||||
#[cfg(feature = "revolut")]
|
||||
if let Some(r) = &settings.revolut {
|
||||
ret.push(ApiPaymentInfo {
|
||||
name: ApiPaymentMethod::Revolut,
|
||||
metadata: HashMap::from([("pubkey".to_string(), r.public_key.to_string())]),
|
||||
currencies: vec![Currency::EUR, Currency::USD],
|
||||
})
|
||||
}
|
||||
|
||||
ApiData::ok(ret)
|
||||
}
|
||||
|
||||
/// Get payment status (for polling)
|
||||
#[openapi(tag = "Payment")]
|
||||
#[get("/api/v1/payment/<id>")]
|
||||
|
@ -6,23 +6,35 @@ use std::collections::HashMap;
|
||||
use std::sync::LazyLock;
|
||||
use tokio::sync::broadcast;
|
||||
|
||||
/// Messaging bridge for webhooks to other parts of the system (bitvora)
|
||||
/// Messaging bridge for webhooks to other parts of the system (bitvora/revout)
|
||||
pub static WEBHOOK_BRIDGE: LazyLock<WebhookBridge> = LazyLock::new(WebhookBridge::new);
|
||||
|
||||
pub fn routes() -> Vec<Route> {
|
||||
if cfg!(feature = "bitvora") {
|
||||
routes![bitvora_webhook]
|
||||
} else {
|
||||
routes![]
|
||||
}
|
||||
let mut routes = vec![];
|
||||
|
||||
#[cfg(feature = "bitvora")]
|
||||
routes.append(&mut routes![bitvora_webhook]);
|
||||
|
||||
#[cfg(feature = "revolut")]
|
||||
routes.append(&mut routes![revolut_webhook]);
|
||||
|
||||
routes
|
||||
}
|
||||
|
||||
#[cfg(feature = "bitvora")]
|
||||
#[post("/api/v1/webhook/bitvora", data = "<req>")]
|
||||
async fn bitvora_webhook(req: WebhookMessage) -> Status {
|
||||
WEBHOOK_BRIDGE.send(req);
|
||||
Status::Ok
|
||||
}
|
||||
|
||||
#[cfg(feature = "revolut")]
|
||||
#[post("/api/v1/webhook/revolut", data = "<req>")]
|
||||
async fn revolut_webhook(req: WebhookMessage) -> Status {
|
||||
WEBHOOK_BRIDGE.send(req);
|
||||
Status::Ok
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct WebhookMessage {
|
||||
pub body: Vec<u8>,
|
||||
|
@ -6,8 +6,8 @@ use lnvps::api;
|
||||
use lnvps::cors::CORS;
|
||||
use lnvps::data_migration::run_data_migrations;
|
||||
use lnvps::exchange::{DefaultRateCache, ExchangeRateService};
|
||||
use lnvps::invoice::InvoiceHandler;
|
||||
use lnvps::lightning::get_node;
|
||||
use lnvps::payments::listen_all_payments;
|
||||
use lnvps::settings::Settings;
|
||||
use lnvps::status::VmStateCache;
|
||||
use lnvps::worker::{WorkJob, Worker};
|
||||
@ -20,7 +20,6 @@ use std::net::{IpAddr, SocketAddr};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::time::sleep;
|
||||
|
||||
#[derive(Parser)]
|
||||
#[clap(about, version, author)]
|
||||
@ -37,7 +36,7 @@ struct Args {
|
||||
#[rocket::main]
|
||||
async fn main() -> Result<(), Error> {
|
||||
let log_level = std::env::var("RUST_LOG")
|
||||
.unwrap_or_else(|_| "info".to_string()) // Default to "info" if not set
|
||||
.unwrap_or_else(|_| "info".to_string())
|
||||
.to_lowercase();
|
||||
|
||||
let max_level = match log_level.as_str() {
|
||||
@ -47,7 +46,7 @@ async fn main() -> Result<(), Error> {
|
||||
"warn" => LevelFilter::Warn,
|
||||
"error" => LevelFilter::Error,
|
||||
"off" => LevelFilter::Off,
|
||||
_ => LevelFilter::Info,
|
||||
_ => LevelFilter::Debug,
|
||||
};
|
||||
|
||||
let args = Args::parse();
|
||||
@ -121,15 +120,10 @@ async fn main() -> Result<(), Error> {
|
||||
}
|
||||
}
|
||||
});
|
||||
let mut handler = InvoiceHandler::new(node.clone(), db.clone(), sender.clone());
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
if let Err(e) = handler.listen().await {
|
||||
error!("invoice-error: {}", e);
|
||||
}
|
||||
sleep(Duration::from_secs(5)).await;
|
||||
}
|
||||
});
|
||||
|
||||
// setup payment handlers
|
||||
listen_all_payments(&settings, node.clone(), db.clone(), sender.clone())?;
|
||||
|
||||
// request work every 30s to check vm status
|
||||
let sender_clone = sender.clone();
|
||||
tokio::spawn(async move {
|
||||
|
@ -28,17 +28,17 @@ impl DataMigration for DnsDataMigration {
|
||||
|
||||
for vm in vms {
|
||||
let mut ips = db.list_vm_ip_assignments(vm.id).await?;
|
||||
for mut ip in &mut ips {
|
||||
for ip in &mut ips {
|
||||
let mut did_change = false;
|
||||
if ip.dns_forward.is_none() {
|
||||
let rec = BasicRecord::forward(&ip)?;
|
||||
let rec = BasicRecord::forward(ip)?;
|
||||
let r = dns.add_record(&rec).await?;
|
||||
ip.dns_forward = Some(r.name);
|
||||
ip.dns_forward_ref = r.id;
|
||||
did_change = true;
|
||||
}
|
||||
if ip.dns_reverse.is_none() {
|
||||
let rec = BasicRecord::reverse_to_fwd(&ip)?;
|
||||
let rec = BasicRecord::reverse_to_fwd(ip)?;
|
||||
let r = dns.add_record(&rec).await?;
|
||||
ip.dns_reverse = Some(r.value);
|
||||
ip.dns_reverse_ref = r.id;
|
||||
|
@ -14,8 +14,12 @@ pub struct Cloudflare {
|
||||
impl Cloudflare {
|
||||
pub fn new(token: &str, reverse_zone_id: &str, forward_zone_id: &str) -> Cloudflare {
|
||||
Self {
|
||||
api: JsonApi::token("https://api.cloudflare.com", &format!("Bearer {}", token), false)
|
||||
.unwrap(),
|
||||
api: JsonApi::token(
|
||||
"https://api.cloudflare.com",
|
||||
&format!("Bearer {}", token),
|
||||
false,
|
||||
)
|
||||
.unwrap(),
|
||||
reverse_zone_id: reverse_zone_id.to_owned(),
|
||||
forward_zone_id: forward_zone_id.to_owned(),
|
||||
}
|
||||
|
@ -1,10 +1,10 @@
|
||||
use anyhow::{anyhow, ensure, Context, Error, Result};
|
||||
use anyhow::{anyhow, ensure, Result};
|
||||
use lnvps_db::async_trait;
|
||||
use log::info;
|
||||
use rocket::serde::Deserialize;
|
||||
use schemars::JsonSchema;
|
||||
use serde::Serialize;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::collections::HashMap;
|
||||
use std::fmt::{Display, Formatter};
|
||||
use std::str::FromStr;
|
||||
use std::sync::Arc;
|
||||
@ -62,6 +62,12 @@ pub struct TickerRate(pub Ticker, pub f32);
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct CurrencyAmount(pub Currency, pub f32);
|
||||
|
||||
impl CurrencyAmount {
|
||||
pub fn from_u64(currency: Currency, amount: u64) -> Self {
|
||||
CurrencyAmount(currency, amount as f32 / 100.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl TickerRate {
|
||||
pub fn can_convert(&self, currency: Currency) -> bool {
|
||||
currency == self.0 .0 || currency == self.0 .1
|
||||
@ -99,7 +105,7 @@ pub fn alt_prices(rates: &Vec<TickerRate>, source: CurrencyAmount) -> Vec<Curren
|
||||
let mut ret2 = vec![];
|
||||
for y in rates.iter() {
|
||||
for x in ret.iter() {
|
||||
if let Ok(r1) = y.convert(x.clone()) {
|
||||
if let Ok(r1) = y.convert(*x) {
|
||||
if r1.0 != source.0 {
|
||||
ret2.push(r1);
|
||||
}
|
||||
|
25
src/fiat/mod.rs
Normal file
25
src/fiat/mod.rs
Normal file
@ -0,0 +1,25 @@
|
||||
/// Fiat payment integrations
|
||||
use crate::exchange::CurrencyAmount;
|
||||
use anyhow::Result;
|
||||
use rocket::serde::{Deserialize, Serialize};
|
||||
use std::future::Future;
|
||||
use std::pin::Pin;
|
||||
|
||||
#[cfg(feature = "revolut")]
|
||||
mod revolut;
|
||||
#[cfg(feature = "revolut")]
|
||||
pub use revolut::*;
|
||||
|
||||
pub trait FiatPaymentService: Send + Sync {
|
||||
fn create_order(
|
||||
&self,
|
||||
description: &str,
|
||||
amount: CurrencyAmount,
|
||||
) -> Pin<Box<dyn Future<Output = Result<FiatPaymentInfo>> + Send>>;
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct FiatPaymentInfo {
|
||||
pub external_id: String,
|
||||
pub raw_data: String,
|
||||
}
|
154
src/fiat/revolut.rs
Normal file
154
src/fiat/revolut.rs
Normal file
@ -0,0 +1,154 @@
|
||||
use crate::exchange::{Currency, CurrencyAmount};
|
||||
use crate::fiat::{FiatPaymentInfo, FiatPaymentService};
|
||||
use crate::json_api::JsonApi;
|
||||
use crate::settings::RevolutConfig;
|
||||
use anyhow::{bail, Result};
|
||||
use chrono::{DateTime, Utc};
|
||||
use reqwest::header::{HeaderMap, ACCEPT, AUTHORIZATION};
|
||||
use reqwest::{Client, Method};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::future::Future;
|
||||
use std::pin::Pin;
|
||||
|
||||
pub struct RevolutApi {
|
||||
api: JsonApi,
|
||||
}
|
||||
|
||||
impl RevolutApi {
|
||||
pub fn new(config: RevolutConfig) -> Result<Self> {
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(AUTHORIZATION, format!("Bearer {}", config.token).parse()?);
|
||||
headers.insert(ACCEPT, "application/json".parse()?);
|
||||
headers.insert("Revolut-Api-Version", config.api_version.parse()?);
|
||||
|
||||
let client = Client::builder().default_headers(headers).build()?;
|
||||
Ok(Self {
|
||||
api: JsonApi {
|
||||
client,
|
||||
base: config
|
||||
.url
|
||||
.unwrap_or("https://merchant.revolut.com".to_string())
|
||||
.parse()?,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn list_webhooks(&self) -> Result<Vec<RevolutWebhook>> {
|
||||
self.api.get("/api/1.0/webhooks").await
|
||||
}
|
||||
|
||||
pub async fn delete_webhook(&self, webhook_id: &str) -> Result<()> {
|
||||
self.api
|
||||
.req_status(
|
||||
Method::DELETE,
|
||||
&format!("/api/1.0/webhooks/{}", webhook_id),
|
||||
(),
|
||||
)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn create_webhook(
|
||||
&self,
|
||||
url: &str,
|
||||
events: Vec<RevolutWebhookEvent>,
|
||||
) -> Result<RevolutWebhook> {
|
||||
self.api
|
||||
.post(
|
||||
"/api/1.0/webhooks",
|
||||
CreateWebhookRequest {
|
||||
url: url.to_string(),
|
||||
events,
|
||||
},
|
||||
)
|
||||
.await
|
||||
}
|
||||
}
|
||||
|
||||
impl FiatPaymentService for RevolutApi {
|
||||
fn create_order(
|
||||
&self,
|
||||
description: &str,
|
||||
amount: CurrencyAmount,
|
||||
) -> Pin<Box<dyn Future<Output = Result<FiatPaymentInfo>> + Send>> {
|
||||
let api = self.api.clone();
|
||||
let desc = description.to_string();
|
||||
Box::pin(async move {
|
||||
let rsp: CreateOrderResponse = api
|
||||
.post(
|
||||
"/api/orders",
|
||||
CreateOrderRequest {
|
||||
currency: amount.0.to_string(),
|
||||
amount: match amount.0 {
|
||||
Currency::BTC => bail!("Bitcoin amount not allowed for fiat payments"),
|
||||
Currency::EUR => (amount.1 * 100.0).floor() as u64,
|
||||
Currency::USD => (amount.1 * 100.0).floor() as u64,
|
||||
},
|
||||
description: Some(desc),
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(FiatPaymentInfo {
|
||||
raw_data: serde_json::to_string(&rsp)?,
|
||||
external_id: rsp.id,
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Serialize)]
|
||||
pub struct CreateOrderRequest {
|
||||
pub amount: u64,
|
||||
pub currency: String,
|
||||
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub description: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct CreateOrderResponse {
|
||||
pub id: String,
|
||||
pub token: String,
|
||||
pub state: PaymentState,
|
||||
pub created_at: DateTime<Utc>,
|
||||
pub updated_at: DateTime<Utc>,
|
||||
pub description: Option<String>,
|
||||
pub amount: u64,
|
||||
pub currency: String,
|
||||
pub outstanding_amount: u64,
|
||||
pub checkout_url: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum PaymentState {
|
||||
Pending,
|
||||
Processing,
|
||||
Authorised,
|
||||
Completed,
|
||||
Cancelled,
|
||||
Failed,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct RevolutWebhook {
|
||||
pub id: String,
|
||||
pub url: String,
|
||||
pub events: Vec<RevolutWebhookEvent>,
|
||||
pub signing_secret: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
|
||||
pub enum RevolutWebhookEvent {
|
||||
OrderAuthorised,
|
||||
OrderCompleted,
|
||||
OrderCancelled,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct CreateWebhookRequest {
|
||||
pub url: String,
|
||||
pub events: Vec<RevolutWebhookEvent>,
|
||||
}
|
@ -34,7 +34,7 @@ impl VmHostClient for LibVirt {
|
||||
todo!()
|
||||
}
|
||||
|
||||
async fn configure_vm(&self, vm: &Vm) -> anyhow::Result<()> {
|
||||
async fn configure_vm(&self, vm: &FullVmInfo) -> anyhow::Result<()> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
|
@ -1,10 +1,11 @@
|
||||
use anyhow::bail;
|
||||
use log::debug;
|
||||
use reqwest::header::{HeaderMap, AUTHORIZATION};
|
||||
use reqwest::header::{HeaderMap, ACCEPT, AUTHORIZATION};
|
||||
use reqwest::{Client, Method, Url};
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde::Serialize;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct JsonApi {
|
||||
pub client: Client,
|
||||
pub base: Url,
|
||||
@ -14,6 +15,7 @@ impl JsonApi {
|
||||
pub fn token(base: &str, token: &str, allow_invalid_certs: bool) -> anyhow::Result<Self> {
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(AUTHORIZATION, token.parse()?);
|
||||
headers.insert(ACCEPT, "application/json".parse()?);
|
||||
|
||||
let client = Client::builder()
|
||||
.danger_accept_invalid_certs(allow_invalid_certs)
|
||||
@ -59,7 +61,6 @@ impl JsonApi {
|
||||
.client
|
||||
.request(method.clone(), self.base.join(path)?)
|
||||
.header("Content-Type", "application/json")
|
||||
.header("Accept", "application/json")
|
||||
.body(body)
|
||||
.send()
|
||||
.await?;
|
||||
@ -73,4 +74,31 @@ impl JsonApi {
|
||||
bail!("{} {}: {}: {}", method, path, status, &text);
|
||||
}
|
||||
}
|
||||
|
||||
/// Make a request and only return the status code
|
||||
pub async fn req_status<R: Serialize>(
|
||||
&self,
|
||||
method: Method,
|
||||
path: &str,
|
||||
body: R,
|
||||
) -> anyhow::Result<u16> {
|
||||
let body = serde_json::to_string(&body)?;
|
||||
debug!(">> {} {}: {}", method.clone(), path, &body);
|
||||
let rsp = self
|
||||
.client
|
||||
.request(method.clone(), self.base.join(path)?)
|
||||
.header("Content-Type", "application/json")
|
||||
.body(body)
|
||||
.send()
|
||||
.await?;
|
||||
let status = rsp.status();
|
||||
let text = rsp.text().await?;
|
||||
#[cfg(debug_assertions)]
|
||||
debug!("<< {}", text);
|
||||
if status.is_success() {
|
||||
Ok(status.as_u16())
|
||||
} else {
|
||||
bail!("{} {}: {}: {}", method, path, status, &text);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,12 +1,14 @@
|
||||
pub mod api;
|
||||
pub mod cors;
|
||||
pub mod data_migration;
|
||||
pub mod dns;
|
||||
pub mod exchange;
|
||||
pub mod fiat;
|
||||
pub mod host;
|
||||
pub mod invoice;
|
||||
pub mod json_api;
|
||||
pub mod lightning;
|
||||
pub mod nip98;
|
||||
pub mod payments;
|
||||
pub mod provisioner;
|
||||
pub mod router;
|
||||
pub mod settings;
|
||||
@ -14,6 +16,6 @@ pub mod settings;
|
||||
pub mod ssh_client;
|
||||
pub mod status;
|
||||
pub mod worker;
|
||||
pub mod data_migration;
|
||||
|
||||
#[cfg(test)]
|
||||
pub mod mocks;
|
||||
|
@ -17,7 +17,7 @@ impl BitvoraNode {
|
||||
pub fn new(api_token: &str, webhook_secret: &str) -> Self {
|
||||
let auth = format!("Bearer {}", api_token);
|
||||
Self {
|
||||
api: JsonApi::token("https://api.bitvora.com/", &auth).unwrap(),
|
||||
api: JsonApi::token("https://api.bitvora.com/", &auth, false).unwrap(),
|
||||
webhook_secret: webhook_secret.to_string(),
|
||||
}
|
||||
}
|
||||
|
@ -78,7 +78,6 @@ impl LightningNode for LndNode {
|
||||
Ok(m) => {
|
||||
if m.state == InvoiceState::Settled as i32 {
|
||||
InvoiceUpdate::Settled {
|
||||
settle_index: m.settle_index,
|
||||
payment_hash: hex::encode(m.r_hash),
|
||||
}
|
||||
} else {
|
||||
|
@ -40,7 +40,6 @@ pub enum InvoiceUpdate {
|
||||
Error(String),
|
||||
Settled {
|
||||
payment_hash: String,
|
||||
settle_index: u64,
|
||||
},
|
||||
}
|
||||
|
||||
|
12
src/mocks.rs
12
src/mocks.rs
@ -518,11 +518,18 @@ impl LNVpsDb for MockDb {
|
||||
.clone())
|
||||
}
|
||||
|
||||
async fn get_vm_payment_by_ext_id(&self, id: &str) -> anyhow::Result<VmPayment> {
|
||||
let p = self.payments.lock().await;
|
||||
Ok(p.iter()
|
||||
.find(|p| p.external_id == Some(id.to_string()))
|
||||
.context("no vm_payment")?
|
||||
.clone())
|
||||
}
|
||||
|
||||
async fn update_vm_payment(&self, vm_payment: &VmPayment) -> anyhow::Result<()> {
|
||||
let mut p = self.payments.lock().await;
|
||||
if let Some(p) = p.iter_mut().find(|p| p.id == *vm_payment.id) {
|
||||
p.is_paid = vm_payment.is_paid.clone();
|
||||
p.settle_index = vm_payment.settle_index.clone();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@ -539,7 +546,8 @@ impl LNVpsDb for MockDb {
|
||||
async fn last_paid_invoice(&self) -> anyhow::Result<Option<VmPayment>> {
|
||||
let p = self.payments.lock().await;
|
||||
Ok(p.iter()
|
||||
.max_by(|a, b| a.settle_index.cmp(&b.settle_index))
|
||||
.filter(|p| p.is_paid)
|
||||
.max_by(|a, b| a.created.cmp(&b.created))
|
||||
.map(|v| v.clone()))
|
||||
}
|
||||
|
||||
|
@ -98,7 +98,7 @@ impl<'r> FromRequest<'r> for Nip98Auth {
|
||||
}
|
||||
let auth = Nip98Auth::from_base64(&auth[6..]).unwrap();
|
||||
match auth.check(
|
||||
request.uri().to_string().as_str(),
|
||||
request.uri().path().to_string().as_str(),
|
||||
request.method().as_str(),
|
||||
) {
|
||||
Ok(_) => Outcome::Success(auth),
|
||||
|
@ -8,13 +8,13 @@ use rocket::futures::StreamExt;
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
pub struct InvoiceHandler {
|
||||
pub struct NodeInvoiceHandler {
|
||||
node: Arc<dyn LightningNode>,
|
||||
db: Arc<dyn LNVpsDb>,
|
||||
tx: UnboundedSender<WorkJob>,
|
||||
}
|
||||
|
||||
impl InvoiceHandler {
|
||||
impl NodeInvoiceHandler {
|
||||
pub fn new(
|
||||
node: Arc<dyn LightningNode>,
|
||||
db: Arc<dyn LNVpsDb>,
|
||||
@ -23,9 +23,8 @@ impl InvoiceHandler {
|
||||
Self { node, tx, db }
|
||||
}
|
||||
|
||||
async fn mark_paid(&self, settle_index: u64, id: &Vec<u8>) -> Result<()> {
|
||||
let mut p = self.db.get_vm_payment(id).await?;
|
||||
p.settle_index = Some(settle_index);
|
||||
async fn mark_paid(&self, id: &Vec<u8>) -> Result<()> {
|
||||
let p = self.db.get_vm_payment(id).await?;
|
||||
self.db.vm_payment_paid(&p).await?;
|
||||
|
||||
info!("VM payment {} for {}, paid", hex::encode(p.id), p.vm_id);
|
||||
@ -47,12 +46,9 @@ impl InvoiceHandler {
|
||||
let mut handler = self.node.subscribe_invoices(from_ph).await?;
|
||||
while let Some(msg) = handler.next().await {
|
||||
match msg {
|
||||
InvoiceUpdate::Settled {
|
||||
payment_hash,
|
||||
settle_index,
|
||||
} => {
|
||||
InvoiceUpdate::Settled { payment_hash } => {
|
||||
let r_hash = hex::decode(payment_hash)?;
|
||||
if let Err(e) = self.mark_paid(settle_index, &r_hash).await {
|
||||
if let Err(e) = self.mark_paid(&r_hash).await {
|
||||
error!("{}", e);
|
||||
}
|
||||
}
|
56
src/payments/mod.rs
Normal file
56
src/payments/mod.rs
Normal file
@ -0,0 +1,56 @@
|
||||
use crate::lightning::LightningNode;
|
||||
use crate::payments::invoice::NodeInvoiceHandler;
|
||||
use crate::settings::Settings;
|
||||
use crate::worker::WorkJob;
|
||||
use anyhow::Result;
|
||||
use lnvps_db::LNVpsDb;
|
||||
use log::error;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
use tokio::time::sleep;
|
||||
|
||||
mod invoice;
|
||||
#[cfg(feature = "revolut")]
|
||||
mod revolut;
|
||||
|
||||
pub fn listen_all_payments(
|
||||
settings: &Settings,
|
||||
node: Arc<dyn LightningNode>,
|
||||
db: Arc<dyn LNVpsDb>,
|
||||
sender: UnboundedSender<WorkJob>,
|
||||
) -> Result<()> {
|
||||
let mut handler = NodeInvoiceHandler::new(node.clone(), db.clone(), sender.clone());
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
if let Err(e) = handler.listen().await {
|
||||
error!("invoice-error: {}", e);
|
||||
}
|
||||
sleep(Duration::from_secs(30)).await;
|
||||
}
|
||||
});
|
||||
|
||||
#[cfg(feature = "revolut")]
|
||||
{
|
||||
|
||||
use crate::payments::revolut::RevolutPaymentHandler;
|
||||
if let Some(r) = &settings.revolut {
|
||||
let mut handler = RevolutPaymentHandler::new(
|
||||
r.clone(),
|
||||
&settings.public_url,
|
||||
db.clone(),
|
||||
sender.clone(),
|
||||
)?;
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
if let Err(e) = handler.listen().await {
|
||||
error!("revolut-error: {}", e);
|
||||
}
|
||||
sleep(Duration::from_secs(30)).await;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
129
src/payments/revolut.rs
Normal file
129
src/payments/revolut.rs
Normal file
@ -0,0 +1,129 @@
|
||||
use crate::api::{WebhookMessage, WEBHOOK_BRIDGE};
|
||||
use crate::fiat::{RevolutApi, RevolutWebhookEvent};
|
||||
use crate::settings::RevolutConfig;
|
||||
use crate::worker::WorkJob;
|
||||
use anyhow::{anyhow, bail, Context, Result};
|
||||
use hmac::{Hmac, Mac};
|
||||
use lnvps_db::LNVpsDb;
|
||||
use log::{error, info, warn};
|
||||
use reqwest::Url;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
pub struct RevolutPaymentHandler {
|
||||
api: RevolutApi,
|
||||
db: Arc<dyn LNVpsDb>,
|
||||
sender: UnboundedSender<WorkJob>,
|
||||
public_url: String,
|
||||
}
|
||||
|
||||
impl RevolutPaymentHandler {
|
||||
pub fn new(
|
||||
settings: RevolutConfig,
|
||||
public_url: &str,
|
||||
db: Arc<dyn LNVpsDb>,
|
||||
sender: UnboundedSender<WorkJob>,
|
||||
) -> Result<Self> {
|
||||
Ok(Self {
|
||||
api: RevolutApi::new(settings)?,
|
||||
public_url: public_url.to_string(),
|
||||
db,
|
||||
sender,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn listen(&mut self) -> Result<()> {
|
||||
let this_webhook = Url::parse(&self.public_url)?.join("/api/v1/webhook/revolut")?;
|
||||
let webhooks = self.api.list_webhooks().await?;
|
||||
for wh in webhooks {
|
||||
info!("Deleting old webhook: {} {}", wh.id, wh.url);
|
||||
self.api.delete_webhook(&wh.id).await?
|
||||
}
|
||||
info!("Setting up webhook for '{}'", this_webhook);
|
||||
let wh = self
|
||||
.api
|
||||
.create_webhook(
|
||||
this_webhook.as_str(),
|
||||
vec![
|
||||
RevolutWebhookEvent::OrderCompleted,
|
||||
RevolutWebhookEvent::OrderAuthorised,
|
||||
],
|
||||
)
|
||||
.await?;
|
||||
|
||||
let secret = wh.signing_secret.context("Signing secret is missing")?;
|
||||
// listen to events
|
||||
let mut listenr = WEBHOOK_BRIDGE.listen();
|
||||
while let Ok(m) = listenr.recv().await {
|
||||
let body: RevolutWebhook = serde_json::from_slice(m.body.as_slice())?;
|
||||
info!("Received webhook {:?}", body);
|
||||
if let Err(e) = verify_webhook(&secret, &m) {
|
||||
error!("Signature verification failed: {}", e);
|
||||
continue;
|
||||
}
|
||||
|
||||
if let RevolutWebhookEvent::OrderCompleted = body.event {
|
||||
if let Err(e) = self.try_complete_payment(&body.order_id).await {
|
||||
error!("Failed to complete order: {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn try_complete_payment(&self, ext_id: &str) -> Result<()> {
|
||||
let p = self.db.get_vm_payment_by_ext_id(ext_id).await?;
|
||||
self.db.vm_payment_paid(&p).await?;
|
||||
self.sender.send(WorkJob::CheckVm { vm_id: p.vm_id })?;
|
||||
info!("VM payment {} for {}, paid", hex::encode(p.id), p.vm_id);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
type HmacSha256 = Hmac<sha2::Sha256>;
|
||||
fn verify_webhook(secret: &str, msg: &WebhookMessage) -> Result<()> {
|
||||
let sig = msg
|
||||
.headers
|
||||
.get("revolut-signature")
|
||||
.ok_or_else(|| anyhow!("Missing Revolut-Signature header"))?;
|
||||
let timestamp = msg
|
||||
.headers
|
||||
.get("revolut-request-timestamp")
|
||||
.ok_or_else(|| anyhow!("Missing Revolut-Request-Timestamp header"))?;
|
||||
|
||||
// check if any signatures match
|
||||
for sig in sig.split(",") {
|
||||
let mut sig_split = sig.split("=");
|
||||
let (version, code) = (
|
||||
sig_split.next().context("Invalid signature format")?,
|
||||
sig_split.next().context("Invalid signature format")?,
|
||||
);
|
||||
let mut mac = HmacSha256::new_from_slice(secret.as_bytes())?;
|
||||
mac.update(version.as_bytes());
|
||||
mac.update(b".");
|
||||
mac.update(timestamp.as_bytes());
|
||||
mac.update(b".");
|
||||
mac.update(msg.body.as_slice());
|
||||
let result = mac.finalize().into_bytes();
|
||||
|
||||
if hex::encode(result) == code {
|
||||
return Ok(());
|
||||
} else {
|
||||
warn!(
|
||||
"Invalid signature found {} != {}",
|
||||
code,
|
||||
hex::encode(result)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
bail!("No valid signature found!");
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
struct RevolutWebhook {
|
||||
pub event: RevolutWebhookEvent,
|
||||
pub order_id: String,
|
||||
pub merchant_order_ext_ref: Option<String>,
|
||||
}
|
@ -1,5 +1,6 @@
|
||||
use crate::dns::{BasicRecord, DnsServer};
|
||||
use crate::exchange::{ExchangeRateService, Ticker};
|
||||
use crate::exchange::{Currency, CurrencyAmount, ExchangeRateService};
|
||||
use crate::fiat::FiatPaymentService;
|
||||
use crate::host::{get_host_client, FullVmInfo};
|
||||
use crate::lightning::{AddInvoiceRequest, LightningNode};
|
||||
use crate::provisioner::{
|
||||
@ -8,8 +9,11 @@ use crate::provisioner::{
|
||||
use crate::router::{ArpEntry, Router};
|
||||
use crate::settings::{NetworkAccessPolicy, NetworkPolicy, ProvisionerConfig, Settings};
|
||||
use anyhow::{bail, ensure, Context, Result};
|
||||
use chrono::{Days, Months, Utc};
|
||||
use lnvps_db::{DiskType, LNVpsDb, Vm, VmCostPlanIntervalType, VmCustomTemplate, VmIpAssignment, VmPayment};
|
||||
use chrono::Utc;
|
||||
use lnvps_db::{
|
||||
LNVpsDb, PaymentMethod, Vm, VmCustomTemplate, VmIpAssignment,
|
||||
VmPayment,
|
||||
};
|
||||
use log::{info, warn};
|
||||
use nostr::util::hex;
|
||||
use std::ops::Add;
|
||||
@ -28,6 +32,7 @@ pub struct LNVpsProvisioner {
|
||||
|
||||
router: Option<Arc<dyn Router>>,
|
||||
dns: Option<Arc<dyn DnsServer>>,
|
||||
revolut: Option<Arc<dyn FiatPaymentService>>,
|
||||
|
||||
network_policy: NetworkPolicy,
|
||||
provisioner_config: ProvisionerConfig,
|
||||
@ -46,6 +51,7 @@ impl LNVpsProvisioner {
|
||||
rates,
|
||||
router: settings.get_router().expect("router config"),
|
||||
dns: settings.get_dns().expect("dns config"),
|
||||
revolut: settings.get_revolut().expect("revolut config"),
|
||||
network_policy: settings.network_policy,
|
||||
provisioner_config: settings.provisioner,
|
||||
read_only: settings.read_only,
|
||||
@ -255,7 +261,9 @@ impl LNVpsProvisioner {
|
||||
|
||||
// TODO: cache capacity somewhere
|
||||
let cap = HostCapacityService::new(self.db.clone());
|
||||
let host = cap.get_host_for_template(template.region_id, &template).await?;
|
||||
let host = cap
|
||||
.get_host_for_template(template.region_id, &template)
|
||||
.await?;
|
||||
|
||||
let pick_disk = if let Some(hd) = host.disks.first() {
|
||||
hd
|
||||
@ -308,7 +316,9 @@ impl LNVpsProvisioner {
|
||||
|
||||
// TODO: cache capacity somewhere
|
||||
let cap = HostCapacityService::new(self.db.clone());
|
||||
let host = cap.get_host_for_template(pricing.region_id, &template).await?;
|
||||
let host = cap
|
||||
.get_host_for_template(pricing.region_id, &template)
|
||||
.await?;
|
||||
|
||||
let pick_disk = if let Some(hd) = host.disks.first() {
|
||||
hd
|
||||
@ -345,40 +355,83 @@ impl LNVpsProvisioner {
|
||||
}
|
||||
|
||||
/// Create a renewal payment
|
||||
pub async fn renew(&self, vm_id: u64) -> Result<VmPayment> {
|
||||
pub async fn renew(&self, vm_id: u64, method: PaymentMethod) -> Result<VmPayment> {
|
||||
let pe = PricingEngine::new(self.db.clone(), self.rates.clone());
|
||||
|
||||
let price = pe.get_vm_cost(vm_id).await?;
|
||||
let price = pe.get_vm_cost(vm_id, method).await?;
|
||||
match price {
|
||||
CostResult::Existing(p) => Ok(p),
|
||||
CostResult::New {
|
||||
msats,
|
||||
amount,
|
||||
currency,
|
||||
time_value,
|
||||
new_expiry,
|
||||
rate,
|
||||
} => {
|
||||
const INVOICE_EXPIRE: u64 = 600;
|
||||
info!("Creating invoice for {vm_id} for {} sats", msats / 1000);
|
||||
let invoice = self
|
||||
.node
|
||||
.add_invoice(AddInvoiceRequest {
|
||||
memo: Some(format!("VM renewal {vm_id} to {new_expiry}")),
|
||||
amount: msats,
|
||||
expire: Some(INVOICE_EXPIRE as u32),
|
||||
})
|
||||
.await?;
|
||||
let vm_payment = VmPayment {
|
||||
id: hex::decode(invoice.payment_hash)?,
|
||||
vm_id,
|
||||
created: Utc::now(),
|
||||
expires: Utc::now().add(Duration::from_secs(INVOICE_EXPIRE)),
|
||||
amount: msats,
|
||||
invoice: invoice.pr,
|
||||
time_value,
|
||||
is_paid: false,
|
||||
rate,
|
||||
settle_index: None,
|
||||
let desc = format!("VM renewal {vm_id} to {new_expiry}");
|
||||
let vm_payment = match method {
|
||||
PaymentMethod::Lightning => {
|
||||
ensure!(
|
||||
currency == Currency::BTC,
|
||||
"Cannot create invoices for non-BTC currency"
|
||||
);
|
||||
const INVOICE_EXPIRE: u64 = 600;
|
||||
info!("Creating invoice for {vm_id} for {} sats", amount / 1000);
|
||||
let invoice = self
|
||||
.node
|
||||
.add_invoice(AddInvoiceRequest {
|
||||
memo: Some(desc),
|
||||
amount,
|
||||
expire: Some(INVOICE_EXPIRE as u32),
|
||||
})
|
||||
.await?;
|
||||
VmPayment {
|
||||
id: hex::decode(invoice.payment_hash)?,
|
||||
vm_id,
|
||||
created: Utc::now(),
|
||||
expires: Utc::now().add(Duration::from_secs(INVOICE_EXPIRE)),
|
||||
amount,
|
||||
currency: currency.to_string(),
|
||||
payment_method: method,
|
||||
time_value,
|
||||
is_paid: false,
|
||||
rate,
|
||||
external_data: invoice.pr,
|
||||
external_id: None,
|
||||
}
|
||||
}
|
||||
PaymentMethod::Revolut => {
|
||||
let rev = if let Some(r) = &self.revolut {
|
||||
r
|
||||
} else {
|
||||
bail!("Revolut not configured")
|
||||
};
|
||||
ensure!(
|
||||
currency != Currency::BTC,
|
||||
"Cannot create revolut orders for BTC currency"
|
||||
);
|
||||
let order = rev
|
||||
.create_order(&desc, CurrencyAmount::from_u64(currency, amount))
|
||||
.await?;
|
||||
let new_id: [u8; 32] = rand::random();
|
||||
VmPayment {
|
||||
id: new_id.to_vec(),
|
||||
vm_id,
|
||||
created: Utc::now(),
|
||||
expires: Utc::now().add(Duration::from_secs(3600)),
|
||||
amount,
|
||||
currency: currency.to_string(),
|
||||
payment_method: method,
|
||||
time_value,
|
||||
is_paid: false,
|
||||
rate,
|
||||
external_data: order.raw_data,
|
||||
external_id: Some(order.external_id),
|
||||
}
|
||||
}
|
||||
PaymentMethod::Paypal => todo!(),
|
||||
};
|
||||
|
||||
self.db.insert_vm_payment(&vm_payment).await?;
|
||||
|
||||
Ok(vm_payment)
|
||||
@ -443,6 +496,7 @@ mod tests {
|
||||
Settings {
|
||||
listen: None,
|
||||
db: "".to_string(),
|
||||
public_url: "http://localhost:8000".to_string(),
|
||||
lightning: LightningConfig::LND {
|
||||
url: "".to_string(),
|
||||
cert: Default::default(),
|
||||
@ -480,6 +534,7 @@ mod tests {
|
||||
reverse_zone_id: "456".to_string(),
|
||||
}),
|
||||
nostr: None,
|
||||
revolut: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -59,4 +59,4 @@ impl Template for VmCustomTemplate {
|
||||
fn disk_interface(&self) -> DiskInterface {
|
||||
self.disk_interface
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,8 +1,10 @@
|
||||
use crate::exchange::{Currency, ExchangeRateService, Ticker};
|
||||
use anyhow::{bail, Context, Result};
|
||||
use crate::exchange::{Currency, CurrencyAmount, ExchangeRateService, Ticker, TickerRate};
|
||||
use anyhow::{bail, Result};
|
||||
use chrono::{DateTime, Days, Months, TimeDelta, Utc};
|
||||
use ipnetwork::IpNetwork;
|
||||
use lnvps_db::{LNVpsDb, Vm, VmCostPlan, VmCostPlanIntervalType, VmCustomTemplate, VmPayment};
|
||||
use lnvps_db::{
|
||||
LNVpsDb, PaymentMethod, Vm, VmCostPlan, VmCostPlanIntervalType, VmCustomTemplate, VmPayment,
|
||||
};
|
||||
use log::info;
|
||||
use std::ops::Add;
|
||||
use std::str::FromStr;
|
||||
@ -28,22 +30,22 @@ impl PricingEngine {
|
||||
}
|
||||
|
||||
/// Get VM cost (for renewal)
|
||||
pub async fn get_vm_cost(&self, vm_id: u64) -> Result<CostResult> {
|
||||
pub async fn get_vm_cost(&self, vm_id: u64, method: PaymentMethod) -> Result<CostResult> {
|
||||
let vm = self.db.get_vm(vm_id).await?;
|
||||
|
||||
// Reuse existing payment until expired
|
||||
let payments = self.db.list_vm_payment(vm.id).await?;
|
||||
if let Some(px) = payments
|
||||
.into_iter()
|
||||
.find(|p| p.expires > Utc::now() && !p.is_paid)
|
||||
.find(|p| p.expires > Utc::now() && !p.is_paid && p.payment_method == method)
|
||||
{
|
||||
return Ok(CostResult::Existing(px));
|
||||
}
|
||||
|
||||
if vm.template_id.is_some() {
|
||||
Ok(self.get_template_vm_cost(&vm).await?)
|
||||
Ok(self.get_template_vm_cost(&vm, method).await?)
|
||||
} else {
|
||||
Ok(self.get_custom_vm_cost(&vm).await?)
|
||||
Ok(self.get_custom_vm_cost(&vm, method).await?)
|
||||
}
|
||||
}
|
||||
|
||||
@ -101,7 +103,7 @@ impl PricingEngine {
|
||||
})
|
||||
}
|
||||
|
||||
async fn get_custom_vm_cost(&self, vm: &Vm) -> Result<CostResult> {
|
||||
async fn get_custom_vm_cost(&self, vm: &Vm, method: PaymentMethod) -> Result<CostResult> {
|
||||
let template_id = if let Some(i) = vm.custom_template_id {
|
||||
i
|
||||
} else {
|
||||
@ -114,26 +116,32 @@ impl PricingEngine {
|
||||
|
||||
// custom templates are always 1-month intervals
|
||||
let time_value = (vm.expires.add(Months::new(1)) - vm.expires).num_seconds() as u64;
|
||||
let (cost_msats, rate) = self.get_msats_amount(price.currency, price.total()).await?;
|
||||
let (currency, amount, rate) = self
|
||||
.get_amount_and_rate(CurrencyAmount(price.currency, price.total()), method)
|
||||
.await?;
|
||||
Ok(CostResult::New {
|
||||
msats: cost_msats,
|
||||
amount,
|
||||
currency,
|
||||
rate,
|
||||
time_value,
|
||||
new_expiry: vm.expires.add(TimeDelta::seconds(time_value as i64)),
|
||||
})
|
||||
}
|
||||
|
||||
async fn get_msats_amount(&self, currency: Currency, amount: f32) -> Result<(u64, f32)> {
|
||||
async fn get_ticker(&self, currency: Currency) -> Result<TickerRate> {
|
||||
let ticker = Ticker(Currency::BTC, currency);
|
||||
let rate = if let Some(r) = self.rates.get_rate(ticker).await {
|
||||
r
|
||||
if let Some(r) = self.rates.get_rate(ticker).await {
|
||||
Ok(TickerRate(ticker, r))
|
||||
} else {
|
||||
bail!("No exchange rate found")
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
let cost_btc = amount / rate;
|
||||
async fn get_msats_amount(&self, amount: CurrencyAmount) -> Result<(u64, f32)> {
|
||||
let rate = self.get_ticker(amount.0).await?;
|
||||
let cost_btc = amount.1 / rate.1;
|
||||
let cost_msats = (cost_btc as f64 * Self::BTC_SATS) as u64 * 1000;
|
||||
Ok((cost_msats, rate))
|
||||
Ok((cost_msats, rate.1))
|
||||
}
|
||||
|
||||
fn next_template_expire(vm: &Vm, cost_plan: &VmCostPlan) -> u64 {
|
||||
@ -150,7 +158,7 @@ impl PricingEngine {
|
||||
(next_expire - vm.expires).num_seconds() as u64
|
||||
}
|
||||
|
||||
async fn get_template_vm_cost(&self, vm: &Vm) -> Result<CostResult> {
|
||||
async fn get_template_vm_cost(&self, vm: &Vm, method: PaymentMethod) -> Result<CostResult> {
|
||||
let template_id = if let Some(i) = vm.template_id {
|
||||
i
|
||||
} else {
|
||||
@ -159,20 +167,36 @@ impl PricingEngine {
|
||||
let template = self.db.get_vm_template(template_id).await?;
|
||||
let cost_plan = self.db.get_cost_plan(template.cost_plan_id).await?;
|
||||
|
||||
let (cost_msats, rate) = self
|
||||
.get_msats_amount(
|
||||
cost_plan.currency.parse().expect("Invalid currency"),
|
||||
cost_plan.amount,
|
||||
)
|
||||
let currency = cost_plan.currency.parse().expect("Invalid currency");
|
||||
let (currency, amount, rate) = self
|
||||
.get_amount_and_rate(CurrencyAmount(currency, cost_plan.amount), method)
|
||||
.await?;
|
||||
let time_value = Self::next_template_expire(&vm, &cost_plan);
|
||||
let time_value = Self::next_template_expire(vm, &cost_plan);
|
||||
Ok(CostResult::New {
|
||||
msats: cost_msats,
|
||||
amount,
|
||||
currency,
|
||||
rate,
|
||||
time_value,
|
||||
new_expiry: vm.expires.add(TimeDelta::seconds(time_value as i64)),
|
||||
})
|
||||
}
|
||||
|
||||
async fn get_amount_and_rate(
|
||||
&self,
|
||||
list_price: CurrencyAmount,
|
||||
method: PaymentMethod,
|
||||
) -> Result<(Currency, u64, f32)> {
|
||||
Ok(match (list_price.0, method) {
|
||||
(c, PaymentMethod::Lightning) if c != Currency::BTC => {
|
||||
let new_price = self.get_msats_amount(list_price).await?;
|
||||
(Currency::BTC, new_price.0, new_price.1)
|
||||
}
|
||||
(cur, PaymentMethod::Revolut) if cur != Currency::BTC => {
|
||||
(cur, (list_price.1 * 100.0).ceil() as u64, 1.0)
|
||||
}
|
||||
(c, m) => bail!("Cannot create payment for method {} and currency {}", m, c),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
@ -181,8 +205,10 @@ pub enum CostResult {
|
||||
Existing(VmPayment),
|
||||
/// A new payment can be created with the specified amount
|
||||
New {
|
||||
/// The cost in milli-sats
|
||||
msats: u64,
|
||||
/// The cost
|
||||
amount: u64,
|
||||
/// Currency
|
||||
currency: Currency,
|
||||
/// The exchange rate used to calculate the price
|
||||
rate: f32,
|
||||
/// The time to extend the vm expiry in seconds
|
||||
@ -292,14 +318,14 @@ mod tests {
|
||||
let db: Arc<dyn LNVpsDb> = Arc::new(db);
|
||||
|
||||
let pe = PricingEngine::new(db.clone(), rates);
|
||||
let price = pe.get_vm_cost(1).await?;
|
||||
let price = pe.get_vm_cost(1, PaymentMethod::Lightning).await?;
|
||||
let plan = MockDb::mock_cost_plan();
|
||||
match price {
|
||||
CostResult::Existing(_) => bail!("??"),
|
||||
CostResult::New { msats, .. } => {
|
||||
CostResult::New { amount, .. } => {
|
||||
let expect_price = (plan.amount / MOCK_RATE * 1.0e11) as u64;
|
||||
assert_eq!(expect_price, msats);
|
||||
assert_eq!(expect_price, amount);
|
||||
}
|
||||
_ => bail!("??"),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
@ -1,5 +1,6 @@
|
||||
use crate::dns::DnsServer;
|
||||
use crate::exchange::ExchangeRateService;
|
||||
use crate::fiat::FiatPaymentService;
|
||||
use crate::lightning::LightningNode;
|
||||
use crate::provisioner::LNVpsProvisioner;
|
||||
use crate::router::Router;
|
||||
@ -12,9 +13,15 @@ use std::sync::Arc;
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub struct Settings {
|
||||
/// Listen address for http server
|
||||
pub listen: Option<String>,
|
||||
|
||||
/// MYSQL connection string
|
||||
pub db: String,
|
||||
|
||||
/// Public URL mapping to this service
|
||||
pub public_url: String,
|
||||
|
||||
/// Lightning node config for creating LN payments
|
||||
pub lightning: LightningConfig,
|
||||
|
||||
@ -42,6 +49,9 @@ pub struct Settings {
|
||||
|
||||
/// Nostr config for sending DMs
|
||||
pub nostr: Option<NostrConfig>,
|
||||
|
||||
/// Config for accepting revolut payments
|
||||
pub revolut: Option<RevolutConfig>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
@ -168,6 +178,15 @@ pub struct QemuConfig {
|
||||
pub kvm: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "kebab-case")]
|
||||
pub struct RevolutConfig {
|
||||
pub url: Option<String>,
|
||||
pub api_version: String,
|
||||
pub token: String,
|
||||
pub public_key: String,
|
||||
}
|
||||
|
||||
impl Settings {
|
||||
pub fn get_provisioner(
|
||||
&self,
|
||||
@ -226,4 +245,12 @@ impl Settings {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_revolut(&self) -> Result<Option<Arc<dyn FiatPaymentService>>> {
|
||||
match &self.revolut {
|
||||
#[cfg(feature = "revolut")]
|
||||
Some(c) => Ok(Some(Arc::new(crate::fiat::RevolutApi::new(c.clone())?))),
|
||||
_ => Ok(None),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
Reference in New Issue
Block a user