410 lines
14 KiB
Python
410 lines
14 KiB
Python
# Description: This file contains the extensions API endpoints.
|
|
|
|
from http import HTTPStatus
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Depends, Request
|
|
from lnbits.core.crud import get_user
|
|
from lnbits.core.models import WalletTypeInfo
|
|
from lnbits.core.services import create_invoice
|
|
from lnbits.decorators import require_admin_key, require_invoice_key
|
|
from starlette.exceptions import HTTPException
|
|
|
|
from .crud import (
|
|
# DCA CRUD operations
|
|
create_dca_client,
|
|
get_dca_clients,
|
|
get_dca_client,
|
|
update_dca_client,
|
|
delete_dca_client,
|
|
create_deposit,
|
|
get_all_deposits,
|
|
get_deposit,
|
|
update_deposit_status,
|
|
get_client_balance_summary,
|
|
# Lamassu config CRUD operations
|
|
create_lamassu_config,
|
|
get_lamassu_config,
|
|
get_active_lamassu_config,
|
|
get_all_lamassu_configs,
|
|
update_lamassu_config,
|
|
update_config_test_result,
|
|
delete_lamassu_config,
|
|
# Lamassu transaction CRUD operations
|
|
get_all_lamassu_transactions,
|
|
get_lamassu_transaction
|
|
)
|
|
from .models import (
|
|
# DCA models
|
|
CreateDcaClientData, DcaClient, UpdateDcaClientData,
|
|
CreateDepositData, DcaDeposit, UpdateDepositStatusData,
|
|
ClientBalanceSummary,
|
|
CreateLamassuConfigData, LamassuConfig, UpdateLamassuConfigData,
|
|
StoredLamassuTransaction
|
|
)
|
|
|
|
satmachineclient_api_router = APIRouter()
|
|
|
|
|
|
###################################################
|
|
################ DCA API ENDPOINTS ################
|
|
###################################################
|
|
|
|
# DCA Client Endpoints
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/clients")
|
|
async def api_get_dca_clients(
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> list[DcaClient]:
|
|
"""Get all DCA clients"""
|
|
return await get_dca_clients()
|
|
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/clients/{client_id}")
|
|
async def api_get_dca_client(
|
|
client_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> DcaClient:
|
|
"""Get a specific DCA client"""
|
|
client = await get_dca_client(client_id)
|
|
if not client:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="DCA client not found."
|
|
)
|
|
return client
|
|
|
|
|
|
# Note: Client creation/update/delete will be handled by the DCA client extension
|
|
# Admin extension only reads existing clients and manages their deposits
|
|
|
|
# TEMPORARY: Test client creation endpoint (remove in production)
|
|
@satmachineclient_api_router.post("/api/v1/dca/clients", status_code=HTTPStatus.CREATED)
|
|
async def api_create_test_dca_client(
|
|
data: CreateDcaClientData,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
) -> DcaClient:
|
|
"""Create a test DCA client (temporary for testing)"""
|
|
return await create_dca_client(data)
|
|
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/clients/{client_id}/balance")
|
|
async def api_get_client_balance(
|
|
client_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> ClientBalanceSummary:
|
|
"""Get client balance summary"""
|
|
client = await get_dca_client(client_id)
|
|
if not client:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="DCA client not found."
|
|
)
|
|
|
|
return await get_client_balance_summary(client_id)
|
|
|
|
|
|
# DCA Deposit Endpoints
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/deposits")
|
|
async def api_get_deposits(
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> list[DcaDeposit]:
|
|
"""Get all deposits"""
|
|
return await get_all_deposits()
|
|
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/deposits/{deposit_id}")
|
|
async def api_get_deposit(
|
|
deposit_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> DcaDeposit:
|
|
"""Get a specific deposit"""
|
|
deposit = await get_deposit(deposit_id)
|
|
if not deposit:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Deposit not found."
|
|
)
|
|
return deposit
|
|
|
|
|
|
@satmachineclient_api_router.post("/api/v1/dca/deposits", status_code=HTTPStatus.CREATED)
|
|
async def api_create_deposit(
|
|
data: CreateDepositData,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
) -> DcaDeposit:
|
|
"""Create a new deposit"""
|
|
# Verify client exists
|
|
client = await get_dca_client(data.client_id)
|
|
if not client:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="DCA client not found."
|
|
)
|
|
|
|
return await create_deposit(data)
|
|
|
|
|
|
@satmachineclient_api_router.put("/api/v1/dca/deposits/{deposit_id}/status")
|
|
async def api_update_deposit_status(
|
|
deposit_id: str,
|
|
data: UpdateDepositStatusData,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
) -> DcaDeposit:
|
|
"""Update deposit status (e.g., confirm deposit)"""
|
|
deposit = await get_deposit(deposit_id)
|
|
if not deposit:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Deposit not found."
|
|
)
|
|
|
|
updated_deposit = await update_deposit_status(deposit_id, data)
|
|
if not updated_deposit:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Failed to update deposit."
|
|
)
|
|
return updated_deposit
|
|
|
|
|
|
# Transaction Polling Endpoints
|
|
|
|
@satmachineclient_api_router.post("/api/v1/dca/test-connection")
|
|
async def api_test_database_connection(
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
):
|
|
"""Test connection to Lamassu database with detailed reporting"""
|
|
try:
|
|
from .transaction_processor import transaction_processor
|
|
|
|
# Use the detailed test method
|
|
result = await transaction_processor.test_connection_detailed()
|
|
return result
|
|
|
|
except Exception as e:
|
|
return {
|
|
"success": False,
|
|
"message": f"Test connection error: {str(e)}",
|
|
"steps": [f"❌ Unexpected error: {str(e)}"],
|
|
"ssh_tunnel_used": False,
|
|
"ssh_tunnel_success": False,
|
|
"database_connection_success": False
|
|
}
|
|
|
|
|
|
@satmachineclient_api_router.post("/api/v1/dca/manual-poll")
|
|
async def api_manual_poll(
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
):
|
|
"""Manually trigger a poll of the Lamassu database"""
|
|
try:
|
|
from .transaction_processor import transaction_processor
|
|
from .crud import update_poll_start_time, update_poll_success_time
|
|
|
|
# Get database configuration
|
|
db_config = await transaction_processor.connect_to_lamassu_db()
|
|
if not db_config:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.SERVICE_UNAVAILABLE,
|
|
detail="Could not get Lamassu database configuration"
|
|
)
|
|
|
|
config_id = db_config["config_id"]
|
|
|
|
# Record manual poll start time
|
|
await update_poll_start_time(config_id)
|
|
|
|
# Fetch and process transactions via SSH
|
|
new_transactions = await transaction_processor.fetch_new_transactions(db_config)
|
|
|
|
transactions_processed = 0
|
|
for transaction in new_transactions:
|
|
await transaction_processor.process_transaction(transaction)
|
|
transactions_processed += 1
|
|
|
|
# Record successful manual poll completion
|
|
await update_poll_success_time(config_id)
|
|
|
|
return {
|
|
"success": True,
|
|
"transactions_processed": transactions_processed,
|
|
"message": f"Processed {transactions_processed} new transactions since last poll"
|
|
}
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
|
|
detail=f"Error during manual poll: {str(e)}"
|
|
)
|
|
|
|
|
|
@satmachineclient_api_router.post("/api/v1/dca/test-transaction")
|
|
async def api_test_transaction(
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
crypto_atoms: int = 103,
|
|
commission_percentage: float = 0.03,
|
|
discount: float = 0.0,
|
|
) -> dict:
|
|
"""Test transaction processing with simulated Lamassu transaction data"""
|
|
try:
|
|
from .transaction_processor import transaction_processor
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
|
|
# Create a mock transaction that mimics Lamassu database structure
|
|
mock_transaction = {
|
|
"transaction_id": str(uuid.uuid4())[:8], # Short ID for testing
|
|
"crypto_amount": crypto_atoms, # Total sats including commission
|
|
"fiat_amount": 100, # Mock fiat amount (100 centavos = 1 GTQ)
|
|
"commission_percentage": commission_percentage, # Already as decimal
|
|
"discount": discount,
|
|
"transaction_time": datetime.now(timezone.utc),
|
|
"crypto_code": "BTC",
|
|
"fiat_code": "GTQ",
|
|
"device_id": "test_device",
|
|
"status": "confirmed"
|
|
}
|
|
|
|
# Process the mock transaction through the complete DCA flow
|
|
await transaction_processor.process_transaction(mock_transaction)
|
|
|
|
# Calculate commission for response
|
|
if commission_percentage > 0:
|
|
effective_commission = commission_percentage * (100 - discount) / 100
|
|
base_crypto_atoms = int(crypto_atoms / (1 + effective_commission))
|
|
commission_amount_sats = crypto_atoms - base_crypto_atoms
|
|
else:
|
|
base_crypto_atoms = crypto_atoms
|
|
commission_amount_sats = 0
|
|
|
|
return {
|
|
"success": True,
|
|
"message": "Test transaction processed successfully",
|
|
"transaction_details": {
|
|
"transaction_id": mock_transaction["transaction_id"],
|
|
"total_amount_sats": crypto_atoms,
|
|
"base_amount_sats": base_crypto_atoms,
|
|
"commission_amount_sats": commission_amount_sats,
|
|
"commission_percentage": commission_percentage * 100, # Show as percentage
|
|
"effective_commission": effective_commission * 100 if commission_percentage > 0 else 0,
|
|
"discount": discount
|
|
}
|
|
}
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
|
|
detail=f"Error processing test transaction: {str(e)}"
|
|
)
|
|
|
|
|
|
# Lamassu Transaction Endpoints
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/transactions")
|
|
async def api_get_lamassu_transactions(
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> list[StoredLamassuTransaction]:
|
|
"""Get all processed Lamassu transactions"""
|
|
return await get_all_lamassu_transactions()
|
|
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/transactions/{transaction_id}")
|
|
async def api_get_lamassu_transaction(
|
|
transaction_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> StoredLamassuTransaction:
|
|
"""Get a specific Lamassu transaction with details"""
|
|
transaction = await get_lamassu_transaction(transaction_id)
|
|
if not transaction:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Lamassu transaction not found."
|
|
)
|
|
return transaction
|
|
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/transactions/{transaction_id}/distributions")
|
|
async def api_get_transaction_distributions(
|
|
transaction_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> list[dict]:
|
|
"""Get distribution details for a specific Lamassu transaction"""
|
|
# Get the stored transaction
|
|
transaction = await get_lamassu_transaction(transaction_id)
|
|
if not transaction:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Lamassu transaction not found."
|
|
)
|
|
|
|
# Get all DCA payments for this Lamassu transaction
|
|
from .crud import get_payments_by_lamassu_transaction, get_dca_client
|
|
payments = await get_payments_by_lamassu_transaction(transaction.lamassu_transaction_id)
|
|
|
|
# Enhance payments with client information
|
|
distributions = []
|
|
for payment in payments:
|
|
client = await get_dca_client(payment.client_id)
|
|
distributions.append({
|
|
"payment_id": payment.id,
|
|
"client_id": payment.client_id,
|
|
"client_username": client.username if client else None,
|
|
"client_user_id": client.user_id if client else None,
|
|
"amount_sats": payment.amount_sats,
|
|
"amount_fiat": payment.amount_fiat,
|
|
"exchange_rate": payment.exchange_rate,
|
|
"status": payment.status,
|
|
"created_at": payment.created_at
|
|
})
|
|
|
|
return distributions
|
|
|
|
|
|
# Lamassu Configuration Endpoints
|
|
|
|
@satmachineclient_api_router.get("/api/v1/dca/config")
|
|
async def api_get_lamassu_config(
|
|
wallet: WalletTypeInfo = Depends(require_invoice_key),
|
|
) -> Optional[LamassuConfig]:
|
|
"""Get active Lamassu database configuration"""
|
|
return await get_active_lamassu_config()
|
|
|
|
|
|
@satmachineclient_api_router.post("/api/v1/dca/config", status_code=HTTPStatus.CREATED)
|
|
async def api_create_lamassu_config(
|
|
data: CreateLamassuConfigData,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
) -> LamassuConfig:
|
|
"""Create/update Lamassu database configuration"""
|
|
return await create_lamassu_config(data)
|
|
|
|
|
|
@satmachineclient_api_router.put("/api/v1/dca/config/{config_id}")
|
|
async def api_update_lamassu_config(
|
|
config_id: str,
|
|
data: UpdateLamassuConfigData,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
) -> LamassuConfig:
|
|
"""Update Lamassu database configuration"""
|
|
config = await get_lamassu_config(config_id)
|
|
if not config:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Configuration not found."
|
|
)
|
|
|
|
updated_config = await update_lamassu_config(config_id, data)
|
|
if not updated_config:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Failed to update configuration."
|
|
)
|
|
return updated_config
|
|
|
|
|
|
@satmachineclient_api_router.delete("/api/v1/dca/config/{config_id}")
|
|
async def api_delete_lamassu_config(
|
|
config_id: str,
|
|
wallet: WalletTypeInfo = Depends(require_admin_key),
|
|
):
|
|
"""Delete Lamassu database configuration"""
|
|
config = await get_lamassu_config(config_id)
|
|
if not config:
|
|
raise HTTPException(
|
|
status_code=HTTPStatus.NOT_FOUND, detail="Configuration not found."
|
|
)
|
|
|
|
await delete_lamassu_config(config_id)
|
|
return {"message": "Configuration deleted successfully"}
|