status-go/services/incentivisation/service.go

495 lines
12 KiB
Go
Raw Normal View History

package incentivisation
import (
"bytes"
"context"
"crypto/ecdsa"
"encoding/binary"
"encoding/hex"
"fmt"
"math/big"
"net"
"sort"
"time"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
gethcommon "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/rpc"
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/protocol/transport"
)
const (
gasLimit = 1001000
pingIntervalAllowance = 240
tickerInterval = 30
defaultTopic = "status-incentivisation-topic"
)
type Enode struct {
PublicKey []byte
IP net.IP
Port uint16
JoiningSession uint32
ActiveSession uint32
Active bool
}
func formatEnodeURL(publicKey string, ip string, port uint16) string {
return fmt.Sprintf("enode://%s:%s:%d", publicKey, ip, port)
}
func (n *Enode) toEnodeURL() string {
return formatEnodeURL(n.PublicKeyString(), n.IP.String(), n.Port)
}
func (n *Enode) PublicKeyString() string {
return hex.EncodeToString(n.PublicKey)
}
type ServiceConfig struct {
RPCEndpoint string
ContractAddress string
IP string
Port uint16
}
type Service struct {
w types.PublicWhisperAPI
whisperKeyID string
whisperSymKeyID string
whisperFilterID string
nodes map[string]*Enode
ticker *time.Ticker
quit chan struct{}
config *ServiceConfig
contract Contract
privateKey *ecdsa.PrivateKey
log log.Logger
// The first round we will not be voting, as we might have incomplete data
initialSession uint64
// The current session
currentSession uint64
whisperPings map[string][]uint32
}
// New returns a new incentivization Service
func New(prv *ecdsa.PrivateKey, w types.PublicWhisperAPI, config *ServiceConfig, contract Contract) *Service {
logger := log.New("package", "status-go/incentivisation/service")
return &Service{
w: w,
config: config,
privateKey: prv,
log: logger,
contract: contract,
nodes: make(map[string]*Enode),
whisperPings: make(map[string][]uint32),
}
}
// Protocols returns a new protocols list. In this case, there are none.
func (s *Service) Protocols() []p2p.Protocol {
return []p2p.Protocol{}
}
// APIs returns a list of new APIs.
func (s *Service) APIs() []rpc.API {
apis := []rpc.API{
{
Namespace: "incentivisation",
Version: "1.0",
Service: NewAPI(s),
Public: true,
},
}
return apis
}
// checkRegistered checks that a node is registered with the contract
func (s *Service) checkRegistered() error {
registered, err := s.registered()
if err != nil {
s.log.Error("error querying contract", "registered", err)
return err
}
if registered {
s.log.Debug("Already registered")
return nil
}
_, err = s.register()
if err != nil {
s.log.Error("error querying contract", "registered", err)
return err
}
return nil
}
// ensureSession checks if we are in a new session and updates the session if so
func (s *Service) ensureSession() (bool, error) {
session, err := s.GetCurrentSession()
if err != nil {
s.log.Error("failed to get current session", "err", err)
return false, err
}
if session != s.currentSession {
s.currentSession = session
return true, nil
}
return false, nil
}
// checkPings checks we have received the expected pings since it was last called
func (s *Service) checkPings() map[string]bool {
result := make(map[string]bool)
now := time.Now().Unix()
s.log.Debug("checking votes", "votes", s.whisperPings)
for enodeID, timestamps := range s.whisperPings {
result[enodeID] = true
if len(timestamps) < 2 {
s.log.Debug("Node failed check", "enodeID", enodeID)
result[enodeID] = false
continue
}
sort.Slice(timestamps, func(i, j int) bool { return timestamps[i] < timestamps[j] })
timestamps = append(timestamps, uint32(now))
for i := 1; i < len(timestamps); i++ {
if timestamps[i]-timestamps[i-1] > pingIntervalAllowance {
result[enodeID] = false
}
}
if result[enodeID] {
s.log.Debug("Node passed check", "enodeID", enodeID)
} else {
s.log.Debug("Node failed check", "enodeID", enodeID)
}
}
s.log.Debug("voting result", "result", result)
return result
}
// perform is the main loop, it posts a ping, registers with the contract, check the pings and votes
func (s *Service) perform() error {
hash, err := s.postPing()
if err != nil {
s.log.Error("Could not post ping", "err", err)
return err
}
s.log.Debug("Posted ping", "hash", hash)
err = s.FetchEnodes()
if err != nil {
return err
}
err = s.fetchMessages()
if err != nil {
return err
}
err = s.checkRegistered()
if err != nil {
s.log.Error("Could not check if node is registered with the contract", "err", err)
return err
}
// This actually updates the session
newSession, err := s.ensureSession()
if err != nil {
s.log.Error("Could not check session", "err", err)
return err
}
if !newSession {
s.log.Debug("Not a new session idling")
return nil
}
result := s.checkPings()
err = s.vote(result)
if err != nil {
s.log.Error("Could not vote", "err", err)
return err
}
// Reset whisper pings
s.whisperPings = make(map[string][]uint32)
return nil
}
// vote reports to the contract the decisions of the votes
func (s *Service) vote(result map[string]bool) error {
var behavingNodes []gethcommon.Address
var misbehavingNodes []gethcommon.Address
auth := s.auth()
for enodeIDString, passedCheck := range result {
enodeID, err := hex.DecodeString(enodeIDString)
if err != nil {
return err
}
if passedCheck {
behavingNodes = append(behavingNodes, publicKeyBytesToAddress(enodeID))
} else {
misbehavingNodes = append(misbehavingNodes, publicKeyBytesToAddress(enodeID))
}
}
_, err := s.contract.VoteSync(&bind.TransactOpts{
GasLimit: gasLimit,
From: auth.From,
Signer: auth.Signer,
}, behavingNodes, misbehavingNodes)
return err
}
func (s *Service) startTicker() {
s.ticker = time.NewTicker(tickerInterval * time.Second)
s.quit = make(chan struct{})
go func() {
for {
select {
case <-s.ticker.C:
err := s.perform()
if err != nil {
s.log.Error("could not execute tick", "err", err)
}
case <-s.quit:
s.ticker.Stop()
return
}
}
}()
}
func (s *Service) Start(server *p2p.Server) error {
s.log.Info("Incentivisation service started", "address", s.addressString(), "publickey", s.publicKeyString())
s.startTicker()
session, err := s.GetCurrentSession()
if err != nil {
return err
}
s.initialSession = session
s.currentSession = session
whisperKeyID, err := s.w.AddPrivateKey(context.TODO(), crypto.FromECDSA(s.privateKey))
if err != nil {
return err
}
s.whisperKeyID = whisperKeyID
whisperSymKeyID, err := s.w.GenerateSymKeyFromPassword(context.TODO(), defaultTopic)
if err != nil {
return err
}
s.whisperSymKeyID = whisperSymKeyID
criteria := types.Criteria{
SymKeyID: whisperSymKeyID,
Topics: []types.TopicType{toWhisperTopic(defaultTopic)},
}
filterID, err := s.w.NewMessageFilter(criteria)
if err != nil {
s.log.Error("could not create filter", "err", err)
return err
}
s.whisperFilterID = filterID
return nil
}
// Stop is run when a service is stopped.
func (s *Service) Stop() error {
s.log.Info("Incentivisation service stopped")
_, err := s.w.DeleteKeyPair(context.TODO(), s.whisperKeyID)
return err
}
func (s *Service) publicKeyBytes() []byte {
return crypto.FromECDSAPub(&s.privateKey.PublicKey)[1:]
}
func (s *Service) GetCurrentSession() (uint64, error) {
response, err := s.contract.GetCurrentSession(nil)
if err != nil {
s.log.Error("failed to get current session", "err", err)
return 0, err
}
return response.Uint64(), nil
}
func (s *Service) registered() (bool, error) {
response, err := s.contract.Registered(nil, s.publicKeyBytes())
if err != nil {
return false, err
}
return response, nil
}
func (s *Service) register() (bool, error) {
auth := s.auth()
ip, err := ip2Long(s.config.IP)
if err != nil {
return false, err
}
_, err = s.contract.RegisterNode(&bind.TransactOpts{
GasLimit: gasLimit,
From: auth.From,
Signer: auth.Signer,
}, s.publicKeyBytes(), ip, s.config.Port)
if err != nil {
return false, err
}
return true, nil
}
func (s *Service) FetchEnodes() error {
one := big.NewInt(1)
activeNodeCount, err := s.contract.ActiveNodeCount(nil)
if err != nil {
return err
}
s.log.Debug("fetched active node count", "count", activeNodeCount)
for i := big.NewInt(0); i.Cmp(activeNodeCount) < 0; i.Add(i, one) {
publicKey, ip, port, joiningSession, activeSession, err := s.contract.GetNode(nil, i)
if err != nil {
return err
}
node := &Enode{
PublicKey: publicKey,
IP: int2ip(ip),
Port: port,
JoiningSession: joiningSession,
ActiveSession: activeSession,
}
s.log.Debug("adding node", "node", node.toEnodeURL())
if node.PublicKeyString() != s.publicKeyString() {
s.nodes[node.PublicKeyString()] = node
}
}
inactiveNodeCount, err := s.contract.InactiveNodeCount(nil)
if err != nil {
return err
}
s.log.Debug("fetched inactive node count", "count", inactiveNodeCount)
for i := big.NewInt(0); i.Cmp(inactiveNodeCount) < 0; i.Add(i, one) {
publicKey, ip, port, joiningSession, activeSession, err := s.contract.GetInactiveNode(nil, i)
if err != nil {
return err
}
node := &Enode{
PublicKey: publicKey,
IP: int2ip(ip),
Port: port,
JoiningSession: joiningSession,
ActiveSession: activeSession,
}
s.log.Debug("adding node", "node", node.toEnodeURL())
if node.PublicKeyString() != s.publicKeyString() {
s.nodes[node.PublicKeyString()] = node
}
}
return nil
}
func (s *Service) publicKeyString() string {
return hex.EncodeToString(s.publicKeyBytes())
}
func (s *Service) addressString() string {
buf := crypto.Keccak256Hash(s.publicKeyBytes())
address := buf[12:]
return hex.EncodeToString(address)
}
// postPing publishes a whisper message
func (s *Service) postPing() (types.HexBytes, error) {
msg := transport.DefaultMessage()
msg.Topic = toWhisperTopic(defaultTopic)
enodeURL := formatEnodeURL(s.publicKeyString(), s.config.IP, s.config.Port)
payload, err := EncodeMessage(enodeURL, defaultTopic)
if err != nil {
return nil, err
}
msg.Payload = payload
2019-10-28 13:50:33 +00:00
msg.SigID = s.whisperKeyID
msg.SymKeyID = s.whisperSymKeyID
return s.w.Post(context.TODO(), msg)
}
// fetchMessages checks for whisper messages
func (s *Service) fetchMessages() error {
messages, err := s.w.GetFilterMessages(s.whisperFilterID)
if err != nil {
return err
}
for i := 0; i < len(messages); i++ {
signature := hex.EncodeToString(messages[i].Sig[1:])
timestamp := messages[i].Timestamp
if s.nodes[signature] != nil {
s.whisperPings[signature] = append(s.whisperPings[signature], timestamp)
}
}
return nil
}
func (s *Service) auth() *bind.TransactOpts {
return bind.NewKeyedTransactor(s.privateKey)
}
func ip2Long(ip string) (uint32, error) {
var long uint32
err := binary.Read(bytes.NewBuffer(net.ParseIP(ip).To4()), binary.BigEndian, &long)
if err != nil {
return 0, err
}
return long, nil
}
func toWhisperTopic(s string) types.TopicType {
return types.BytesToTopic(crypto.Keccak256([]byte(s)))
}
func int2ip(nn uint32) net.IP {
ip := make(net.IP, 4)
binary.BigEndian.PutUint32(ip, nn)
return ip
}
func publicKeyBytesToAddress(publicKey []byte) gethcommon.Address {
buf := crypto.Keccak256Hash(publicKey)
address := buf[12:]
return gethcommon.HexToAddress(hex.EncodeToString(address))
}