1// Copyright (C) 2021 Storj Labs, Inc.
2// See LICENSE for copying information.
3
4package multinode
5
6import (
7	"context"
8	"time"
9
10	"go.uber.org/zap"
11
12	"storj.io/common/rpc/rpcstatus"
13	"storj.io/storj/private/multinodepb"
14	"storj.io/storj/storagenode/apikeys"
15	"storj.io/storj/storagenode/payouts"
16	"storj.io/storj/storagenode/payouts/estimatedpayouts"
17)
18
19var _ multinodepb.DRPCPayoutServer = (*PayoutEndpoint)(nil)
20var _ multinodepb.DRPCPayoutsServer = (*PayoutEndpoint)(nil)
21
22// PayoutEndpoint implements multinode payouts endpoint.
23//
24// architecture: Endpoint
25type PayoutEndpoint struct {
26	multinodepb.DRPCPayoutUnimplementedServer
27	multinodepb.DRPCPayoutsUnimplementedServer
28
29	log              *zap.Logger
30	apiKeys          *apikeys.Service
31	db               payouts.DB
32	service          *payouts.Service
33	estimatedPayouts *estimatedpayouts.Service
34}
35
36// NewPayoutEndpoint creates new multinode payouts endpoint.
37func NewPayoutEndpoint(log *zap.Logger, apiKeys *apikeys.Service, db payouts.DB, estimatedPayouts *estimatedpayouts.Service, service *payouts.Service) *PayoutEndpoint {
38	return &PayoutEndpoint{
39		log:              log,
40		apiKeys:          apiKeys,
41		db:               db,
42		service:          service,
43		estimatedPayouts: estimatedPayouts,
44	}
45}
46
47// Earned returns total earned amount.
48func (payout *PayoutEndpoint) Earned(ctx context.Context, req *multinodepb.EarnedRequest) (_ *multinodepb.EarnedResponse, err error) {
49	defer mon.Task()(&ctx)(&err)
50
51	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
52		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
53	}
54
55	earned, err := payout.db.GetTotalEarned(ctx)
56	if err != nil {
57		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
58	}
59
60	return &multinodepb.EarnedResponse{
61		Total: earned,
62	}, nil
63}
64
65// EarnedSatellite returns total earned amount per satellite.
66func (payout *PayoutEndpoint) EarnedSatellite(ctx context.Context, req *multinodepb.EarnedSatelliteRequest) (_ *multinodepb.EarnedSatelliteResponse, err error) {
67	defer mon.Task()(&ctx)(&err)
68
69	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
70		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
71	}
72
73	var resp multinodepb.EarnedSatelliteResponse
74
75	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
76	if err != nil {
77		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
78	}
79
80	for _, id := range satelliteIDs {
81		earned, err := payout.db.GetEarnedAtSatellite(ctx, id)
82		if err != nil {
83			return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
84		}
85
86		resp.EarnedSatellite = append(resp.EarnedSatellite, &multinodepb.EarnedSatellite{
87			Total:       earned,
88			SatelliteId: id,
89		})
90	}
91
92	return &resp, nil
93}
94
95// EstimatedPayout returns estimated earnings for current month from all satellites.
96func (payout *PayoutEndpoint) EstimatedPayout(ctx context.Context, req *multinodepb.EstimatedPayoutRequest) (_ *multinodepb.EstimatedPayoutResponse, err error) {
97	defer mon.Task()(&ctx)(&err)
98
99	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
100		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
101	}
102
103	estimated, err := payout.estimatedPayouts.GetAllSatellitesEstimatedPayout(ctx, time.Now())
104	if err != nil {
105		return &multinodepb.EstimatedPayoutResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
106	}
107
108	return &multinodepb.EstimatedPayoutResponse{EstimatedEarnings: estimated.CurrentMonthExpectations}, nil
109}
110
111// EstimatedPayoutSatellite returns estimated earnings for current month from specific satellite.
112func (payout *PayoutEndpoint) EstimatedPayoutSatellite(ctx context.Context, req *multinodepb.EstimatedPayoutSatelliteRequest) (_ *multinodepb.EstimatedPayoutSatelliteResponse, err error) {
113	defer mon.Task()(&ctx)(&err)
114
115	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
116		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
117	}
118
119	estimated, err := payout.estimatedPayouts.GetSatelliteEstimatedPayout(ctx, req.SatelliteId, time.Now())
120	if err != nil {
121		return &multinodepb.EstimatedPayoutSatelliteResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
122	}
123
124	return &multinodepb.EstimatedPayoutSatelliteResponse{EstimatedEarnings: estimated.CurrentMonthExpectations}, nil
125}
126
127// Summary returns all satellites all time payout summary.
128func (payout *PayoutEndpoint) Summary(ctx context.Context, req *multinodepb.SummaryRequest) (_ *multinodepb.SummaryResponse, err error) {
129	defer mon.Task()(&ctx)(&err)
130
131	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
132		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
133	}
134
135	var totalPaid, totalHeld int64
136
137	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
138	if err != nil {
139		return &multinodepb.SummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
140	}
141
142	for _, id := range satelliteIDs {
143		paid, held, err := payout.db.GetSatelliteSummary(ctx, id)
144		if err != nil {
145			return &multinodepb.SummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
146		}
147
148		totalHeld += held
149		totalPaid += paid
150	}
151
152	return &multinodepb.SummaryResponse{PayoutInfo: &multinodepb.PayoutInfo{Paid: totalPaid, Held: totalHeld}}, nil
153}
154
155// SummaryPeriod returns all satellites period payout summary.
156func (payout *PayoutEndpoint) SummaryPeriod(ctx context.Context, req *multinodepb.SummaryPeriodRequest) (_ *multinodepb.SummaryPeriodResponse, err error) {
157	defer mon.Task()(&ctx)(&err)
158
159	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
160		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
161	}
162
163	var totalPaid, totalHeld int64
164
165	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
166	if err != nil {
167		return &multinodepb.SummaryPeriodResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
168	}
169
170	for _, id := range satelliteIDs {
171		paid, held, err := payout.db.GetSatellitePeriodSummary(ctx, id, req.Period)
172		if err != nil {
173			return &multinodepb.SummaryPeriodResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
174		}
175
176		totalHeld += held
177		totalPaid += paid
178	}
179
180	return &multinodepb.SummaryPeriodResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
181}
182
183// SummarySatellite returns satellite all time payout summary.
184func (payout *PayoutEndpoint) SummarySatellite(ctx context.Context, req *multinodepb.SummarySatelliteRequest) (_ *multinodepb.SummarySatelliteResponse, err error) {
185	defer mon.Task()(&ctx)(&err)
186
187	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
188		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
189	}
190
191	var totalPaid, totalHeld int64
192
193	totalPaid, totalHeld, err = payout.db.GetSatelliteSummary(ctx, req.SatelliteId)
194	if err != nil {
195		return &multinodepb.SummarySatelliteResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
196	}
197
198	return &multinodepb.SummarySatelliteResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
199}
200
201// SummarySatellitePeriod returns satellite period payout summary.
202func (payout *PayoutEndpoint) SummarySatellitePeriod(ctx context.Context, req *multinodepb.SummarySatellitePeriodRequest) (_ *multinodepb.SummarySatellitePeriodResponse, err error) {
203	defer mon.Task()(&ctx)(&err)
204
205	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
206		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
207	}
208
209	var totalPaid, totalHeld int64
210
211	totalPaid, totalHeld, err = payout.db.GetSatellitePeriodSummary(ctx, req.SatelliteId, req.Period)
212	if err != nil {
213		return &multinodepb.SummarySatellitePeriodResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
214	}
215
216	return &multinodepb.SummarySatellitePeriodResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
217}
218
219// Undistributed returns total undistributed amount.
220func (payout *PayoutEndpoint) Undistributed(ctx context.Context, req *multinodepb.UndistributedRequest) (_ *multinodepb.UndistributedResponse, err error) {
221	defer mon.Task()(&ctx)(&err)
222
223	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
224		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
225	}
226
227	earned, err := payout.db.GetUndistributed(ctx)
228	if err != nil {
229		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
230	}
231
232	return &multinodepb.UndistributedResponse{Total: earned}, nil
233}
234
235// PaystubSatellite returns summed amounts of all values from paystubs from all satellites.
236func (payout *PayoutEndpoint) PaystubSatellite(ctx context.Context, req *multinodepb.PaystubSatelliteRequest) (_ *multinodepb.PaystubSatelliteResponse, err error) {
237	defer mon.Task()(&ctx)(&err)
238
239	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
240		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
241	}
242
243	paystub, err := payout.db.GetSatellitePaystubs(ctx, req.SatelliteId)
244	if err != nil {
245		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
246	}
247
248	return &multinodepb.PaystubSatelliteResponse{Paystub: &multinodepb.Paystub{
249		UsageAtRest:    paystub.UsageAtRest,
250		UsageGet:       paystub.UsageGet,
251		UsageGetRepair: paystub.UsageGetRepair,
252		UsageGetAudit:  paystub.UsageGetAudit,
253		CompAtRest:     paystub.CompAtRest,
254		CompGet:        paystub.CompGet,
255		CompGetRepair:  paystub.CompGetRepair,
256		CompGetAudit:   paystub.CompGetAudit,
257		Held:           paystub.Held,
258		Paid:           paystub.Paid,
259		Distributed:    paystub.Distributed,
260		Disposed:       paystub.Disposed,
261	}}, nil
262}
263
264// Paystub returns summed amounts of all values from paystubs from all satellites.
265func (payout *PayoutEndpoint) Paystub(ctx context.Context, req *multinodepb.PaystubRequest) (_ *multinodepb.PaystubResponse, err error) {
266	defer mon.Task()(&ctx)(&err)
267
268	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
269		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
270	}
271
272	paystub, err := payout.db.GetPaystubs(ctx)
273	if err != nil {
274		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
275	}
276
277	return &multinodepb.PaystubResponse{Paystub: &multinodepb.Paystub{
278		UsageAtRest:    paystub.UsageAtRest,
279		UsageGet:       paystub.UsageGet,
280		UsageGetRepair: paystub.UsageGetRepair,
281		UsageGetAudit:  paystub.UsageGetAudit,
282		CompAtRest:     paystub.CompAtRest,
283		CompGet:        paystub.CompGet,
284		CompGetRepair:  paystub.CompGetRepair,
285		CompGetAudit:   paystub.CompGetAudit,
286		Held:           paystub.Held,
287		Paid:           paystub.Paid,
288		Distributed:    paystub.Distributed,
289		Disposed:       paystub.Disposed,
290	}}, nil
291}
292
293// PaystubPeriod returns summed amounts of all values from paystubs from all satellites for specific period.
294func (payout *PayoutEndpoint) PaystubPeriod(ctx context.Context, req *multinodepb.PaystubPeriodRequest) (_ *multinodepb.PaystubPeriodResponse, err error) {
295	defer mon.Task()(&ctx)(&err)
296
297	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
298		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
299	}
300
301	paystub, err := payout.db.GetPeriodPaystubs(ctx, req.Period)
302	if err != nil {
303		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
304	}
305
306	return &multinodepb.PaystubPeriodResponse{Paystub: &multinodepb.Paystub{
307		UsageAtRest:    paystub.UsageAtRest,
308		UsageGet:       paystub.UsageGet,
309		UsageGetRepair: paystub.UsageGetRepair,
310		UsageGetAudit:  paystub.UsageGetAudit,
311		CompAtRest:     paystub.CompAtRest,
312		CompGet:        paystub.CompGet,
313		CompGetRepair:  paystub.CompGetRepair,
314		CompGetAudit:   paystub.CompGetAudit,
315		Held:           paystub.Held,
316		Paid:           paystub.Paid,
317		Distributed:    paystub.Distributed,
318		Disposed:       paystub.Disposed,
319	}}, nil
320}
321
322// PaystubSatellitePeriod returns summed amounts of all values from paystubs from all satellites for specific period.
323func (payout *PayoutEndpoint) PaystubSatellitePeriod(ctx context.Context, req *multinodepb.PaystubSatellitePeriodRequest) (_ *multinodepb.PaystubSatellitePeriodResponse, err error) {
324	defer mon.Task()(&ctx)(&err)
325
326	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
327		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
328	}
329
330	paystub, err := payout.db.GetSatellitePeriodPaystubs(ctx, req.Period, req.SatelliteId)
331	if err != nil {
332		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
333	}
334
335	return &multinodepb.PaystubSatellitePeriodResponse{Paystub: &multinodepb.Paystub{
336		UsageAtRest:    paystub.UsageAtRest,
337		UsageGet:       paystub.UsageGet,
338		UsageGetRepair: paystub.UsageGetRepair,
339		UsageGetAudit:  paystub.UsageGetAudit,
340		CompAtRest:     paystub.CompAtRest,
341		CompGet:        paystub.CompGet,
342		CompGetRepair:  paystub.CompGetRepair,
343		CompGetAudit:   paystub.CompGetAudit,
344		Held:           paystub.Held,
345		Paid:           paystub.Paid,
346		Distributed:    paystub.Distributed,
347		Disposed:       paystub.Disposed,
348	}}, nil
349}
350
351// HeldAmountHistory returns held amount history for all satellites.
352func (payout *PayoutEndpoint) HeldAmountHistory(ctx context.Context, req *multinodepb.HeldAmountHistoryRequest) (_ *multinodepb.HeldAmountHistoryResponse, err error) {
353	defer mon.Task()(&ctx)(&err)
354
355	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
356		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
357	}
358
359	heldHistory, err := payout.service.HeldAmountHistory(ctx)
360	if err != nil {
361		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
362	}
363
364	resp := new(multinodepb.HeldAmountHistoryResponse)
365
366	for _, satelliteHeldHistory := range heldHistory {
367		var pbHeldAmount []*multinodepb.HeldAmountHistoryResponse_HeldAmount
368
369		for _, heldAmount := range satelliteHeldHistory.HeldAmounts {
370			pbHeldAmount = append(pbHeldAmount, &multinodepb.HeldAmountHistoryResponse_HeldAmount{
371				Period: heldAmount.Period,
372				Amount: heldAmount.Amount,
373			})
374		}
375
376		resp.History = append(resp.History, &multinodepb.HeldAmountHistoryResponse_HeldAmountHistory{
377			SatelliteId: satelliteHeldHistory.SatelliteID,
378			HeldAmounts: pbHeldAmount,
379		})
380	}
381
382	return resp, nil
383}
384
385// PeriodPaystub returns summed amounts of all values from paystubs from all satellites for specific period.
386func (payout *PayoutEndpoint) PeriodPaystub(ctx context.Context, req *multinodepb.PeriodPaystubRequest) (_ *multinodepb.PeriodPaystubResponse, err error) {
387	defer mon.Task()(&ctx)(&err)
388
389	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
390		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
391	}
392
393	paystub, err := payout.db.GetPeriodPaystubs(ctx, req.Period)
394	if err != nil {
395		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
396	}
397
398	return &multinodepb.PeriodPaystubResponse{Paystub: &multinodepb.Paystub{
399		UsageAtRest:    paystub.UsageAtRest,
400		UsageGet:       paystub.UsageGet,
401		UsageGetRepair: paystub.UsageGetRepair,
402		UsageGetAudit:  paystub.UsageGetAudit,
403		CompAtRest:     paystub.CompAtRest,
404		CompGet:        paystub.CompGet,
405		CompGetRepair:  paystub.CompGetRepair,
406		CompGetAudit:   paystub.CompGetAudit,
407		Held:           paystub.Held,
408		Paid:           paystub.Paid,
409		Distributed:    paystub.Distributed,
410		Disposed:       paystub.Disposed,
411	}}, nil
412}
413
414// EarnedPerSatellite returns total earned amount per satellite.
415func (payout *PayoutEndpoint) EarnedPerSatellite(ctx context.Context, req *multinodepb.EarnedPerSatelliteRequest) (_ *multinodepb.EarnedPerSatelliteResponse, err error) {
416	defer mon.Task()(&ctx)(&err)
417
418	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
419		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
420	}
421
422	var resp multinodepb.EarnedPerSatelliteResponse
423	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
424	if err != nil {
425		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
426	}
427
428	for _, id := range satelliteIDs {
429		earned, err := payout.db.GetEarnedAtSatellite(ctx, id)
430		if err != nil {
431			return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
432		}
433
434		resp.EarnedSatellite = append(resp.EarnedSatellite, &multinodepb.EarnedSatellite{
435			Total:       earned,
436			SatelliteId: id,
437		})
438	}
439
440	return &resp, nil
441}
442
443// EstimatedPayoutTotal returns estimated earnings for current month from all satellites.
444func (payout *PayoutEndpoint) EstimatedPayoutTotal(ctx context.Context, req *multinodepb.EstimatedPayoutTotalRequest) (_ *multinodepb.EstimatedPayoutTotalResponse, err error) {
445	defer mon.Task()(&ctx)(&err)
446
447	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
448		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
449	}
450
451	estimated, err := payout.estimatedPayouts.GetAllSatellitesEstimatedPayout(ctx, time.Now())
452	if err != nil {
453		return &multinodepb.EstimatedPayoutTotalResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
454	}
455
456	return &multinodepb.EstimatedPayoutTotalResponse{EstimatedEarnings: estimated.CurrentMonthExpectations}, nil
457}
458
459// AllSatellitesSummary returns all satellites all time payout summary.
460func (payout *PayoutEndpoint) AllSatellitesSummary(ctx context.Context, req *multinodepb.AllSatellitesSummaryRequest) (_ *multinodepb.AllSatellitesSummaryResponse, err error) {
461	defer mon.Task()(&ctx)(&err)
462
463	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
464		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
465	}
466
467	var totalPaid, totalHeld int64
468	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
469	if err != nil {
470		return &multinodepb.AllSatellitesSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
471	}
472
473	for _, id := range satelliteIDs {
474		paid, held, err := payout.db.GetSatelliteSummary(ctx, id)
475		if err != nil {
476			return &multinodepb.AllSatellitesSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
477		}
478
479		totalHeld += held
480		totalPaid += paid
481	}
482
483	return &multinodepb.AllSatellitesSummaryResponse{PayoutInfo: &multinodepb.PayoutInfo{Paid: totalPaid, Held: totalHeld}}, nil
484}
485
486// AllSatellitesPeriodSummary returns all satellites period payout summary.
487func (payout *PayoutEndpoint) AllSatellitesPeriodSummary(ctx context.Context, req *multinodepb.AllSatellitesPeriodSummaryRequest) (_ *multinodepb.AllSatellitesPeriodSummaryResponse, err error) {
488	defer mon.Task()(&ctx)(&err)
489
490	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
491		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
492	}
493
494	var totalPaid, totalHeld int64
495	satelliteIDs, err := payout.db.GetPayingSatellitesIDs(ctx)
496	if err != nil {
497		return &multinodepb.AllSatellitesPeriodSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
498	}
499
500	for _, id := range satelliteIDs {
501		paid, held, err := payout.db.GetSatellitePeriodSummary(ctx, id, req.Period)
502		if err != nil {
503			return &multinodepb.AllSatellitesPeriodSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
504		}
505
506		totalHeld += held
507		totalPaid += paid
508	}
509
510	return &multinodepb.AllSatellitesPeriodSummaryResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
511}
512
513// SatelliteSummary returns satellite all time payout summary.
514func (payout *PayoutEndpoint) SatelliteSummary(ctx context.Context, req *multinodepb.SatelliteSummaryRequest) (_ *multinodepb.SatelliteSummaryResponse, err error) {
515	defer mon.Task()(&ctx)(&err)
516
517	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
518		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
519	}
520
521	var totalPaid, totalHeld int64
522
523	totalPaid, totalHeld, err = payout.db.GetSatelliteSummary(ctx, req.SatelliteId)
524	if err != nil {
525		return &multinodepb.SatelliteSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
526	}
527
528	return &multinodepb.SatelliteSummaryResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
529}
530
531// SatellitePeriodSummary returns satellite period payout summary.
532func (payout *PayoutEndpoint) SatellitePeriodSummary(ctx context.Context, req *multinodepb.SatellitePeriodSummaryRequest) (_ *multinodepb.SatellitePeriodSummaryResponse, err error) {
533	defer mon.Task()(&ctx)(&err)
534
535	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
536		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
537	}
538
539	var totalPaid, totalHeld int64
540
541	totalPaid, totalHeld, err = payout.db.GetSatellitePeriodSummary(ctx, req.SatelliteId, req.Period)
542	if err != nil {
543		return &multinodepb.SatellitePeriodSummaryResponse{}, rpcstatus.Wrap(rpcstatus.Internal, err)
544	}
545
546	return &multinodepb.SatellitePeriodSummaryResponse{PayoutInfo: &multinodepb.PayoutInfo{Held: totalHeld, Paid: totalPaid}}, nil
547}
548
549// SatellitePaystub returns summed amounts of all values from paystubs from all satellites.
550func (payout *PayoutEndpoint) SatellitePaystub(ctx context.Context, req *multinodepb.SatellitePaystubRequest) (_ *multinodepb.SatellitePaystubResponse, err error) {
551	defer mon.Task()(&ctx)(&err)
552
553	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
554		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
555	}
556
557	paystub, err := payout.db.GetSatellitePaystubs(ctx, req.SatelliteId)
558	if err != nil {
559		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
560	}
561
562	return &multinodepb.SatellitePaystubResponse{Paystub: &multinodepb.Paystub{
563		UsageAtRest:    paystub.UsageAtRest,
564		UsageGet:       paystub.UsageGet,
565		UsageGetRepair: paystub.UsageGetRepair,
566		UsageGetAudit:  paystub.UsageGetAudit,
567		CompAtRest:     paystub.CompAtRest,
568		CompGet:        paystub.CompGet,
569		CompGetRepair:  paystub.CompGetRepair,
570		CompGetAudit:   paystub.CompGetAudit,
571		Held:           paystub.Held,
572		Paid:           paystub.Paid,
573		Distributed:    paystub.Distributed,
574		Disposed:       paystub.Disposed,
575	}}, nil
576}
577
578// SatellitePeriodPaystub returns summed amounts of all values from paystubs from all satellites for specific period.
579func (payout *PayoutEndpoint) SatellitePeriodPaystub(ctx context.Context, req *multinodepb.SatellitePeriodPaystubRequest) (_ *multinodepb.SatellitePeriodPaystubResponse, err error) {
580	defer mon.Task()(&ctx)(&err)
581
582	if err = authenticate(ctx, payout.apiKeys, req.GetHeader()); err != nil {
583		return nil, rpcstatus.Wrap(rpcstatus.Unauthenticated, err)
584	}
585
586	paystub, err := payout.db.GetSatellitePeriodPaystubs(ctx, req.Period, req.SatelliteId)
587	if err != nil {
588		return nil, rpcstatus.Wrap(rpcstatus.Internal, err)
589	}
590
591	return &multinodepb.SatellitePeriodPaystubResponse{Paystub: &multinodepb.Paystub{
592		UsageAtRest:    paystub.UsageAtRest,
593		UsageGet:       paystub.UsageGet,
594		UsageGetRepair: paystub.UsageGetRepair,
595		UsageGetAudit:  paystub.UsageGetAudit,
596		CompAtRest:     paystub.CompAtRest,
597		CompGet:        paystub.CompGet,
598		CompGetRepair:  paystub.CompGetRepair,
599		CompGetAudit:   paystub.CompGetAudit,
600		Held:           paystub.Held,
601		Paid:           paystub.Paid,
602		Distributed:    paystub.Distributed,
603		Disposed:       paystub.Disposed,
604	}}, nil
605}
606