Surplus balances for peers (#870)

* Oversettle in debit and payment receive
* Surplus balances for peers, debug API addons (#972)
Additional helper endpoints for integration tests and overdraft safety for surpluses, Openapi update, Fixes

openapi/SwarmDebug.yaml

@@ -42,7 +42,7 @@ paths:
 
   '/balances':
     get:
-      summary: Get the balances with all known peers
+      summary: Get the balances with all known peers including prepaid services
       tags:
         - Balance
       responses:
@@ -59,7 +59,7 @@ paths:
 
   '/balances/{address}':
     get:
-      summary: Get the balances with a specific peer
+      summary: Get the balances with a specific peer including prepaid services
       tags:
         - Balance
       parameters:
@@ -71,7 +71,50 @@ paths:
           description: Swarm address of peer
       responses:
         '200':
-          description: Peer is known
+          description: Balance with the specific peer
+          content:
+            application/json:
+              schema:
+                $ref: 'SwarmCommon.yaml#/components/schemas/Balance'
+        '404':
+          $ref: 'SwarmCommon.yaml#/components/responses/404'
+        '500':
+           $ref: 'SwarmCommon.yaml#/components/responses/500'
+        default:
+          description: Default response
+ 
+  '/consumed':
+    get:
+      summary: Get the past due consumption balances with all known peers
+      tags:
+        - Balance
+      responses:
+        '200':
+          description: Own past due consumption balances with all known peers
+          content:
+            application/json:
+              schema:
+                $ref: 'SwarmCommon.yaml#/components/schemas/Balances'
+        '500':
+           $ref: 'SwarmCommon.yaml#/components/responses/500'
+        default:
+          description: Default response
+
+  '/consumed/{address}':
+    get:
+      summary: Get the past due consumption balance with a specific peer
+      tags:
+        - Balance
+      parameters:
+        - in: path
+          name: address
+          schema:
+            $ref: 'SwarmCommon.yaml#/components/schemas/SwarmAddress'
+          required: true
+          description: Swarm address of peer
+      responses:
+        '200':
+          description: Past-due consumption balance with the specific peer
           content:
             application/json:
               schema:

pkg/accounting/accounting_test.go

@@ -225,7 +225,7 @@ func TestAccountingOverflowReserve(t *testing.T) {
 	}
 }
 
-func TestAccountingOverflowNotifyPayment(t *testing.T) {
+func TestAccountingOverflowSurplusBalance(t *testing.T) {
 	logger := logging.New(ioutil.Discard, 0)
 
 	store := mock.NewStateStore()
@@ -241,11 +241,32 @@ func TestAccountingOverflowNotifyPayment(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	// Try Crediting a large amount to peer so balance is negative
-	err = acc.Credit(peer1Addr, math.MaxInt64)
+	// Try Debiting a large amount to peer so balance is large positive
+	err = acc.Debit(peer1Addr, testPaymentThresholdLarge-1)
 	if err != nil {
 		t.Fatal(err)
 	}
+	// Notify of incoming payment from same peer, so balance goes to 0 with surplusbalance 2
+	err = acc.NotifyPayment(peer1Addr, math.MaxInt64)
+	if err != nil {
+		t.Fatal("Unexpected overflow from  NotifyPayment")
+	}
+	// sanity check surplus balance
+	val, err := acc.SurplusBalance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Surplusbalance")
+	}
+	if val != 2 {
+		t.Fatal("Not expected surplus balance")
+	}
+	// sanity check balance
+	val, err = acc.Balance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Balance")
+	}
+	if val != 0 {
+		t.Fatal("Unexpected balance")
+	}
 	// Notify of incoming payment from same peer, further decreasing balance, this should overflow
 	err = acc.NotifyPayment(peer1Addr, math.MaxInt64)
 	if err == nil {
@@ -253,10 +274,44 @@ func TestAccountingOverflowNotifyPayment(t *testing.T) {
 	}
 	// If we had other error, assert fail
 	if !errors.Is(err, accounting.ErrOverflow) {
-		t.Fatalf("expected overflow error from Debit, got %v", err)
+		t.Fatal("Expected overflow error from NotifyPayment")
 	}
 
 }
+func TestAccountingOverflowNotifyPayment(t *testing.T) {
+	logger := logging.New(ioutil.Discard, 0)
+
+	store := mock.NewStateStore()
+	defer store.Close()
+
+	settlement := mockSettlement.NewSettlement()
+
+	acc, err := accounting.NewAccounting(testPaymentThresholdLarge, 0, 0, logger, store, settlement, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	peer1Addr, err := swarm.ParseHexAddress("00112233")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Try Crediting a large amount to peer so balance is negative
+	err = acc.Credit(peer1Addr, math.MaxInt64)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// NotifyPayment for peer should now fill the surplus balance
+	err = acc.NotifyPayment(peer1Addr, math.MaxInt64)
+	if err != nil {
+		t.Fatalf("Expected no error but got one: %v", err)
+	}
+
+	// Notify of incoming payment from same peer, further increasing the surplus balance into an overflow
+	err = acc.NotifyPayment(peer1Addr, 1)
+	if !errors.Is(err, accounting.ErrOverflow) {
+		t.Fatalf("expected overflow error from Debit, got %v", err)
+	}
+}
 
 func TestAccountingOverflowDebit(t *testing.T) {
 	logger := logging.New(ioutil.Discard, 0)
@@ -528,6 +583,113 @@ func TestAccountingCallSettlementEarly(t *testing.T) {
 	}
 }
 
+func TestAccountingSurplusBalance(t *testing.T) {
+	logger := logging.New(ioutil.Discard, 0)
+
+	store := mock.NewStateStore()
+	defer store.Close()
+
+	settlement := mockSettlement.NewSettlement()
+
+	acc, err := accounting.NewAccounting(testPaymentThreshold, 0, 0, logger, store, settlement, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	peer1Addr, err := swarm.ParseHexAddress("00112233")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Try Debiting a large amount to peer so balance is large positive
+	err = acc.Debit(peer1Addr, testPaymentThreshold-1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Notify of incoming payment from same peer, so balance goes to 0 with surplusbalance 2
+	err = acc.NotifyPayment(peer1Addr, testPaymentThreshold+1)
+	if err != nil {
+		t.Fatal("Unexpected overflow from doable NotifyPayment")
+	}
+	//sanity check surplus balance
+	val, err := acc.SurplusBalance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Surplusbalance")
+	}
+	if val != 2 {
+		t.Fatal("Not expected surplus balance")
+	}
+	//sanity check balance
+	val, err = acc.Balance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Balance")
+	}
+	if val != 0 {
+		t.Fatal("Not expected balance")
+	}
+	// Notify of incoming payment from same peer, so balance goes to 0 with surplusbalance 10002 (testpaymentthreshold+2)
+	err = acc.NotifyPayment(peer1Addr, testPaymentThreshold)
+	if err != nil {
+		t.Fatal("Unexpected error from NotifyPayment")
+	}
+	//sanity check surplus balance
+	val, err = acc.SurplusBalance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Surplusbalance")
+	}
+	if val != testPaymentThreshold+2 {
+		t.Fatal("Unexpected surplus balance")
+	}
+	//sanity check balance
+	val, err = acc.Balance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Balance")
+	}
+	if val != 0 {
+		t.Fatal("Not expected balance, expected 0")
+	}
+	// Debit for same peer, so balance stays 0 with surplusbalance decreasing to 2
+	err = acc.Debit(peer1Addr, testPaymentThreshold)
+	if err != nil {
+		t.Fatal("Unexpected error from Credit")
+	}
+	// samity check surplus balance
+	val, err = acc.SurplusBalance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Surplusbalance")
+	}
+	if val != 2 {
+		t.Fatal("Unexpected surplus balance")
+	}
+	//sanity check balance
+	val, err = acc.Balance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Balance")
+	}
+	if val != 0 {
+		t.Fatal("Not expected balance, expected 0")
+	}
+	// Debit for same peer, so balance goes to 9998 (testpaymentthreshold - 2) with surplusbalance decreasing to 0
+	err = acc.Debit(peer1Addr, testPaymentThreshold)
+	if err != nil {
+		t.Fatal("Unexpected error from NotifyPayment")
+	}
+	// samity check surplus balance
+	val, err = acc.SurplusBalance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Surplusbalance")
+	}
+	if val != 0 {
+		t.Fatal("Unexpected surplus balance")
+	}
+	//sanity check balance
+	val, err = acc.Balance(peer1Addr)
+	if err != nil {
+		t.Fatal("Error checking Balance")
+	}
+	if val != testPaymentThreshold-2 {
+		t.Fatal("Not expected balance, expected 0")
+	}
+}
+
 // TestAccountingNotifyPayment tests that payments adjust the balance and payment which put us into debt are rejected
 func TestAccountingNotifyPayment(t *testing.T) {
 	logger := logging.New(ioutil.Discard, 0)
@@ -562,8 +724,8 @@ func TestAccountingNotifyPayment(t *testing.T) {
 	}
 
 	err = acc.NotifyPayment(peer1Addr, debtAmount+testPaymentTolerance+1)
-	if err == nil {
-		t.Fatal("expected payment to be rejected")
+	if err != nil {
+		t.Fatal(err)
 	}
 }
 

pkg/accounting/mock/accounting.go

@@ -14,14 +14,18 @@ import (
 
 // Service is the mock Accounting service.
 type Service struct {
-	lock         sync.Mutex
-	balances     map[string]int64
-	reserveFunc  func(ctx context.Context, peer swarm.Address, price uint64) error
-	releaseFunc  func(peer swarm.Address, price uint64)
-	creditFunc   func(peer swarm.Address, price uint64) error
-	debitFunc    func(peer swarm.Address, price uint64) error
-	balanceFunc  func(swarm.Address) (int64, error)
-	balancesFunc func() (map[string]int64, error)
+	lock                    sync.Mutex
+	balances                map[string]int64
+	reserveFunc             func(ctx context.Context, peer swarm.Address, price uint64) error
+	releaseFunc             func(peer swarm.Address, price uint64)
+	creditFunc              func(peer swarm.Address, price uint64) error
+	debitFunc               func(peer swarm.Address, price uint64) error
+	balanceFunc             func(swarm.Address) (int64, error)
+	balancesFunc            func() (map[string]int64, error)
+	compensatedBalanceFunc  func(swarm.Address) (int64, error)
+	compensatedBalancesFunc func() (map[string]int64, error)
+
+	balanceSurplusFunc func(swarm.Address) (int64, error)
 }
 
 // WithReserveFunc sets the mock Reserve function
@@ -66,6 +70,27 @@ func WithBalancesFunc(f func() (map[string]int64, error)) Option {
 	})
 }
 
+// WithCompensatedBalanceFunc sets the mock Balance function
+func WithCompensatedBalanceFunc(f func(swarm.Address) (int64, error)) Option {
+	return optionFunc(func(s *Service) {
+		s.compensatedBalanceFunc = f
+	})
+}
+
+// WithCompensatedBalancesFunc sets the mock Balances function
+func WithCompensatedBalancesFunc(f func() (map[string]int64, error)) Option {
+	return optionFunc(func(s *Service) {
+		s.compensatedBalancesFunc = f
+	})
+}
+
+// WithBalanceSurplusFunc sets the mock SurplusBalance function
+func WithBalanceSurplusFunc(f func(swarm.Address) (int64, error)) Option {
+	return optionFunc(func(s *Service) {
+		s.balanceSurplusFunc = f
+	})
+}
+
 // NewAccounting creates the mock accounting implementation
 func NewAccounting(opts ...Option) accounting.Interface {
 	mock := new(Service)
@@ -131,6 +156,34 @@ func (s *Service) Balances() (map[string]int64, error) {
 	return s.balances, nil
 }
 
+// CompensatedBalance is the mock function wrapper that calls the set implementation
+func (s *Service) CompensatedBalance(peer swarm.Address) (int64, error) {
+	if s.compensatedBalanceFunc != nil {
+		return s.compensatedBalanceFunc(peer)
+	}
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return s.balances[peer.String()], nil
+}
+
+// CompensatedBalances is the mock function wrapper that calls the set implementation
+func (s *Service) CompensatedBalances() (map[string]int64, error) {
+	if s.compensatedBalancesFunc != nil {
+		return s.compensatedBalancesFunc()
+	}
+	return s.balances, nil
+}
+
+//
+func (s *Service) SurplusBalance(peer swarm.Address) (int64, error) {
+	if s.balanceFunc != nil {
+		return s.balanceSurplusFunc(peer)
+	}
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return 0, nil
+}
+
 // Option is the option passed to the mock accounting service
 type Option interface {
 	apply(*Service)

pkg/debugapi/balances.go

@@ -79,3 +79,53 @@ func (s *server) peerBalanceHandler(w http.ResponseWriter, r *http.Request) {
 		Balance: balance,
 	})
 }
+
+func (s *server) compensatedBalancesHandler(w http.ResponseWriter, r *http.Request) {
+	balances, err := s.Accounting.CompensatedBalances()
+	if err != nil {
+		jsonhttp.InternalServerError(w, errCantBalances)
+		s.Logger.Debugf("debug api: compensated balances: %v", err)
+		s.Logger.Error("debug api: can not get compensated balances")
+		return
+	}
+
+	balResponses := make([]balanceResponse, len(balances))
+	i := 0
+	for k := range balances {
+		balResponses[i] = balanceResponse{
+			Peer:    k,
+			Balance: balances[k],
+		}
+		i++
+	}
+
+	jsonhttp.OK(w, balancesResponse{Balances: balResponses})
+}
+
+func (s *server) compensatedPeerBalanceHandler(w http.ResponseWriter, r *http.Request) {
+	addr := mux.Vars(r)["peer"]
+	peer, err := swarm.ParseHexAddress(addr)
+	if err != nil {
+		s.Logger.Debugf("debug api: compensated balances peer: invalid peer address %s: %v", addr, err)
+		s.Logger.Errorf("debug api: compensated balances peer: invalid peer address %s", addr)
+		jsonhttp.NotFound(w, errInvaliAddress)
+		return
+	}
+
+	balance, err := s.Accounting.CompensatedBalance(peer)
+	if err != nil {
+		if errors.Is(err, accounting.ErrPeerNoBalance) {
+			jsonhttp.NotFound(w, errNoBalance)
+			return
+		}
+		s.Logger.Debugf("debug api: compensated balances peer: get peer %s balance: %v", peer.String(), err)
+		s.Logger.Errorf("debug api: compensated balances peer: can't get peer %s balance", peer.String())
+		jsonhttp.InternalServerError(w, errCantBalance)
+		return
+	}
+
+	jsonhttp.OK(w, balanceResponse{
+		Peer:    peer.String(),
+		Balance: balance,
+	})
+}

pkg/debugapi/balances_test.go

@@ -19,7 +19,7 @@ import (
 )
 
 func TestBalances(t *testing.T) {
-	balancesFunc := func() (ret map[string]int64, err error) {
+	compensatedBalancesFunc := func() (ret map[string]int64, err error) {
 		ret = make(map[string]int64)
 		ret["DEAD"] = 1000000000000000000
 		ret["BEEF"] = -100000000000000000
@@ -27,7 +27,7 @@ func TestBalances(t *testing.T) {
 		return ret, err
 	}
 	testServer := newTestServer(t, testServerOptions{
-		AccountingOpts: []mock.Option{mock.WithBalancesFunc(balancesFunc)},
+		AccountingOpts: []mock.Option{mock.WithCompensatedBalancesFunc(compensatedBalancesFunc)},
 	})
 
 	expected := &debugapi.BalancesResponse{
@@ -61,11 +61,11 @@ func TestBalances(t *testing.T) {
 
 func TestBalancesError(t *testing.T) {
 	wantErr := errors.New("ASDF")
-	balancesFunc := func() (ret map[string]int64, err error) {
+	compensatedBalancesFunc := func() (ret map[string]int64, err error) {
 		return nil, wantErr
 	}
 	testServer := newTestServer(t, testServerOptions{
-		AccountingOpts: []mock.Option{mock.WithBalancesFunc(balancesFunc)},
+		AccountingOpts: []mock.Option{mock.WithCompensatedBalancesFunc(compensatedBalancesFunc)},
 	})
 
 	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/balances", http.StatusInternalServerError,
@@ -78,11 +78,11 @@ func TestBalancesError(t *testing.T) {
 
 func TestBalancesPeers(t *testing.T) {
 	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
-	balanceFunc := func(swarm.Address) (int64, error) {
+	compensatedBalanceFunc := func(swarm.Address) (int64, error) {
 		return 1000000000000000000, nil
 	}
 	testServer := newTestServer(t, testServerOptions{
-		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+		AccountingOpts: []mock.Option{mock.WithCompensatedBalanceFunc(compensatedBalanceFunc)},
 	})
 
 	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/balances/"+peer, http.StatusOK,
@@ -96,11 +96,11 @@ func TestBalancesPeers(t *testing.T) {
 func TestBalancesPeersError(t *testing.T) {
 	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
 	wantErr := errors.New("Error")
-	balanceFunc := func(swarm.Address) (int64, error) {
+	compensatedBalanceFunc := func(swarm.Address) (int64, error) {
 		return 0, wantErr
 	}
 	testServer := newTestServer(t, testServerOptions{
-		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+		AccountingOpts: []mock.Option{mock.WithCompensatedBalanceFunc(compensatedBalanceFunc)},
 	})
 
 	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/balances/"+peer, http.StatusInternalServerError,
@@ -113,11 +113,11 @@ func TestBalancesPeersError(t *testing.T) {
 
 func TestBalancesPeersNoBalance(t *testing.T) {
 	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
-	balanceFunc := func(swarm.Address) (int64, error) {
+	compensatedBalanceFunc := func(swarm.Address) (int64, error) {
 		return 0, accounting.ErrPeerNoBalance
 	}
 	testServer := newTestServer(t, testServerOptions{
-		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+		AccountingOpts: []mock.Option{mock.WithCompensatedBalanceFunc(compensatedBalanceFunc)},
 	})
 
 	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/balances/"+peer, http.StatusNotFound,
@@ -170,3 +170,126 @@ func equalBalances(a, b *debugapi.BalancesResponse) bool {
 
 	return true
 }
+
+func TestConsumedBalances(t *testing.T) {
+	balancesFunc := func() (ret map[string]int64, err error) {
+		ret = make(map[string]int64)
+		ret["DEAD"] = 1000000000000000000
+		ret["BEEF"] = -100000000000000000
+		ret["PARTY"] = 0
+		return ret, err
+	}
+	testServer := newTestServer(t, testServerOptions{
+		AccountingOpts: []mock.Option{mock.WithBalancesFunc(balancesFunc)},
+	})
+
+	expected := &debugapi.BalancesResponse{
+		[]debugapi.BalanceResponse{
+			{
+				Peer:    "DEAD",
+				Balance: 1000000000000000000,
+			},
+			{
+				Peer:    "BEEF",
+				Balance: -100000000000000000,
+			},
+			{
+				Peer:    "PARTY",
+				Balance: 0,
+			},
+		},
+	}
+
+	// We expect a list of items unordered by peer:
+	var got *debugapi.BalancesResponse
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed", http.StatusOK,
+		jsonhttptest.WithUnmarshalJSONResponse(&got),
+	)
+
+	if !equalBalances(got, expected) {
+		t.Errorf("got balances: %v, expected: %v", got, expected)
+	}
+
+}
+
+func TestConsumedError(t *testing.T) {
+	wantErr := errors.New("ASDF")
+	balancesFunc := func() (ret map[string]int64, err error) {
+		return nil, wantErr
+	}
+	testServer := newTestServer(t, testServerOptions{
+		AccountingOpts: []mock.Option{mock.WithBalancesFunc(balancesFunc)},
+	})
+
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed", http.StatusInternalServerError,
+		jsonhttptest.WithExpectedJSONResponse(jsonhttp.StatusResponse{
+			Message: debugapi.ErrCantBalances,
+			Code:    http.StatusInternalServerError,
+		}),
+	)
+}
+
+func TestConsumedPeers(t *testing.T) {
+	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
+	balanceFunc := func(swarm.Address) (int64, error) {
+		return 1000000000000000000, nil
+	}
+	testServer := newTestServer(t, testServerOptions{
+		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+	})
+
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed/"+peer, http.StatusOK,
+		jsonhttptest.WithExpectedJSONResponse(debugapi.BalanceResponse{
+			Peer:    peer,
+			Balance: 1000000000000000000,
+		}),
+	)
+}
+
+func TestConsumedPeersError(t *testing.T) {
+	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
+	wantErr := errors.New("Error")
+	balanceFunc := func(swarm.Address) (int64, error) {
+		return 0, wantErr
+	}
+	testServer := newTestServer(t, testServerOptions{
+		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+	})
+
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed/"+peer, http.StatusInternalServerError,
+		jsonhttptest.WithExpectedJSONResponse(jsonhttp.StatusResponse{
+			Message: debugapi.ErrCantBalance,
+			Code:    http.StatusInternalServerError,
+		}),
+	)
+}
+
+func TestConsumedPeersNoBalance(t *testing.T) {
+	peer := "bff2c89e85e78c38bd89fca1acc996afb876c21bf5a8482ad798ce15f1c223fa"
+	balanceFunc := func(swarm.Address) (int64, error) {
+		return 0, accounting.ErrPeerNoBalance
+	}
+	testServer := newTestServer(t, testServerOptions{
+		AccountingOpts: []mock.Option{mock.WithBalanceFunc(balanceFunc)},
+	})
+
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed/"+peer, http.StatusNotFound,
+		jsonhttptest.WithExpectedJSONResponse(jsonhttp.StatusResponse{
+			Message: debugapi.ErrNoBalance,
+			Code:    http.StatusNotFound,
+		}),
+	)
+}
+
+func TestConsumedInvalidAddress(t *testing.T) {
+	peer := "bad peer address"
+
+	testServer := newTestServer(t, testServerOptions{})
+
+	jsonhttptest.Request(t, testServer.Client, http.MethodGet, "/consumed/"+peer, http.StatusNotFound,
+		jsonhttptest.WithExpectedJSONResponse(jsonhttp.StatusResponse{
+			Message: debugapi.ErrInvaliAddress,
+			Code:    http.StatusNotFound,
+		}),
+	)
+}

pkg/debugapi/router.go

@@ -84,16 +84,27 @@ func (s *server) setupRouting() {
 			web.FinalHandlerFunc(s.setWelcomeMessageHandler),
 		),
 	})
+
 	router.Handle("/balances", jsonhttp.MethodHandler{
-		"GET": http.HandlerFunc(s.balancesHandler),
+		"GET": http.HandlerFunc(s.compensatedBalancesHandler),
 	})
+
 	router.Handle("/balances/{peer}", jsonhttp.MethodHandler{
+		"GET": http.HandlerFunc(s.compensatedPeerBalanceHandler),
+	})
+
+	router.Handle("/consumed", jsonhttp.MethodHandler{
+		"GET": http.HandlerFunc(s.balancesHandler),
+	})
+
+	router.Handle("/consumed/{peer}", jsonhttp.MethodHandler{
 		"GET": http.HandlerFunc(s.peerBalanceHandler),
 	})
 
 	router.Handle("/settlements", jsonhttp.MethodHandler{
 		"GET": http.HandlerFunc(s.settlementsHandler),
 	})
+
 	router.Handle("/settlements/{peer}", jsonhttp.MethodHandler{
 		"GET": http.HandlerFunc(s.peerSettlementsHandler),
 	})