robosats/control/tasks.py
Reckless_Satoshi 75f04579ed
Refactor models into a module (#481)
* Refactor models into a module

* Rename Profile model as Robot

* Underscore numeric literals
2023-05-01 10:30:53 +00:00

193 lines
7.4 KiB
Python

from celery import shared_task
@shared_task(name="do_accounting")
def do_accounting():
"""
Does all accounting from the beginning of time
"""
from datetime import timedelta
from decouple import config
from django.db.models import Sum
from django.utils import timezone
from api.models import LNPayment, MarketTick, OnchainPayment, Order, Robot
from control.models import AccountingDay
all_payments = LNPayment.objects.all()
all_ticks = MarketTick.objects.all()
today = timezone.now().date()
try:
last_accounted_day = AccountingDay.objects.latest("day").day.date()
accounted_yesterday = AccountingDay.objects.latest("day")
except Exception:
last_accounted_day = None
accounted_yesterday = None
if last_accounted_day == today:
return {"message": "no days to account for"}
elif last_accounted_day is not None:
initial_day = last_accounted_day + timedelta(days=1)
elif last_accounted_day is None:
initial_day = all_payments.earliest("created_at").created_at.date()
day = initial_day
result = {}
while day <= today:
day_payments = all_payments.filter(
created_at__gte=day, created_at__lte=day + timedelta(days=1)
)
day_onchain_payments = OnchainPayment.objects.filter(
created_at__gte=day, created_at__lte=day + timedelta(days=1)
)
day_ticks = all_ticks.filter(
timestamp__gte=day, timestamp__lte=day + timedelta(days=1)
)
# Coarse accounting based on LNpayment and OnchainPayment objects
contracted = day_ticks.aggregate(Sum("volume"))["volume__sum"]
num_contracts = day_ticks.count()
inflow = day_payments.filter(
type=LNPayment.Types.HOLD, status=LNPayment.Status.SETLED
).aggregate(Sum("num_satoshis"))["num_satoshis__sum"]
onchain_outflow = day_onchain_payments.filter(
status__in=[OnchainPayment.Status.MEMPO, OnchainPayment.Status.CONFI]
).aggregate(Sum("sent_satoshis"))["sent_satoshis__sum"]
onchain_outflow = 0 if onchain_outflow is None else int(onchain_outflow)
offchain_outflow = day_payments.filter(
type=LNPayment.Types.NORM, status=LNPayment.Status.SUCCED
).aggregate(Sum("num_satoshis"))["num_satoshis__sum"]
offchain_outflow = 0 if offchain_outflow is None else int(offchain_outflow)
routing_fees = day_payments.filter(
type=LNPayment.Types.NORM, status=LNPayment.Status.SUCCED
).aggregate(Sum("fee"))["fee__sum"]
mining_fees = day_onchain_payments.filter(
status__in=[OnchainPayment.Status.MEMPO, OnchainPayment.Status.CONFI]
).aggregate(Sum("mining_fee_sats"))["mining_fee_sats__sum"]
rewards_claimed = day_payments.filter(
type=LNPayment.Types.NORM,
concept=LNPayment.Concepts.WITHREWA,
status=LNPayment.Status.SUCCED,
).aggregate(Sum("num_satoshis"))["num_satoshis__sum"]
contracted = 0 if contracted is None else contracted
inflow = 0 if inflow is None else inflow
outflow = offchain_outflow + onchain_outflow
routing_fees = 0 if routing_fees is None else routing_fees
rewards_claimed = 0 if rewards_claimed is None else rewards_claimed
mining_fees = 0 if mining_fees is None else mining_fees
accounted_day = AccountingDay.objects.create(
day=day,
contracted=contracted,
num_contracts=num_contracts,
inflow=inflow,
outflow=outflow,
routing_fees=routing_fees,
mining_fees=mining_fees,
cashflow=inflow - outflow - routing_fees,
rewards_claimed=rewards_claimed,
)
# Fine Net Daily accounting based on orders
# Only account for orders where everything worked out right
payouts = day_payments.filter(
type=LNPayment.Types.NORM,
concept=LNPayment.Concepts.PAYBUYER,
status=LNPayment.Status.SUCCED,
)
escrows_settled = 0
payouts_paid = 0
costs = 0
for payout in payouts:
escrows_settled += int(payout.order_paid_LN.trade_escrow.num_satoshis)
payouts_paid += int(payout.num_satoshis)
costs += int(payout.fee)
# Same for orders that use onchain payments.
payouts_tx = day_onchain_payments.filter(
status__in=[OnchainPayment.Status.MEMPO, OnchainPayment.Status.CONFI]
)
for payout_tx in payouts_tx:
escrows_settled += int(payout_tx.order_paid_TX.trade_escrow.num_satoshis)
payouts_paid += int(payout_tx.sent_satoshis)
costs += int(payout_tx.mining_fee_sats)
# account for those orders where bonds were lost
# + Settled bonds / bond_split
bonds_settled = day_payments.filter(
type=LNPayment.Types.HOLD,
concept__in=[LNPayment.Concepts.TAKEBOND, LNPayment.Concepts.MAKEBOND],
status=LNPayment.Status.SETLED,
)
if len(bonds_settled) > 0:
collected_slashed_bonds = (
bonds_settled.aggregate(Sum("num_satoshis"))["num_satoshis__sum"]
) * float(config("SLASHED_BOND_REWARD_SPLIT"))
else:
collected_slashed_bonds = 0
accounted_day.net_settled = escrows_settled + collected_slashed_bonds
accounted_day.net_paid = payouts_paid + costs
accounted_day.net_balance = float(accounted_day.net_settled) - float(
accounted_day.net_paid
)
# Differential accounting based on change of outstanding states and disputes unreslved
if day == today:
pending_disputes = Order.objects.filter(
status__in=[Order.Status.DIS, Order.Status.WFR]
)
if len(pending_disputes) > 0:
outstanding_pending_disputes = 0
for order in pending_disputes:
outstanding_pending_disputes += order.payout.num_satoshis
else:
outstanding_pending_disputes = 0
accounted_day.outstanding_earned_rewards = Robot.objects.all().aggregate(
Sum("earned_rewards")
)["earned_rewards__sum"]
accounted_day.outstanding_pending_disputes = outstanding_pending_disputes
accounted_day.lifetime_rewards_claimed = Robot.objects.all().aggregate(
Sum("claimed_rewards")
)["claimed_rewards__sum"]
if accounted_yesterday is not None:
accounted_day.earned_rewards = (
accounted_day.outstanding_earned_rewards
- accounted_yesterday.outstanding_earned_rewards
)
accounted_day.disputes = (
outstanding_pending_disputes
- accounted_yesterday.outstanding_earned_rewards
)
# Close the loop
accounted_day.save()
accounted_yesterday = accounted_day
result[str(day)] = {
"contracted": contracted,
"inflow": inflow,
"outflow": outflow,
}
day = day + timedelta(days=1)
return result
@shared_task(name="compute_node_balance", ignore_result=True)
def compute_node_balance():
"""
Queries LND for channel and wallet balance
"""
from control.models import BalanceLog
BalanceLog.objects.create()
return