oracle.go 6.41 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// Copyright 2019 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

17 18 19 20
// Package checkpointoracle is a wrapper of checkpoint oracle contract with
// additional rules defined. This package can be used both in LES client or
// server side for offering oracle related APIs.
package checkpointoracle
21 22 23

import (
	"encoding/binary"
24
	"sync"
25
	"sync/atomic"
26
	"time"
27 28 29 30 31 32 33 34 35

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/contracts/checkpointoracle"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/log"
	"github.com/ethereum/go-ethereum/params"
)

36 37 38 39
// CheckpointOracle is responsible for offering the latest stable checkpoint
// generated and announced by the contract admins on-chain. The checkpoint can
// be verified by clients locally during the checkpoint syncing.
type CheckpointOracle struct {
40 41 42
	config   *params.CheckpointOracleConfig
	contract *checkpointoracle.CheckpointOracle

43 44
	running  int32                                 // Flag whether the contract backend is set or not
	getLocal func(uint64) params.TrustedCheckpoint // Function used to retrieve local checkpoint
45 46 47 48 49

	checkMu              sync.Mutex                // Mutex to sync access to the fields below
	lastCheckTime        time.Time                 // Time we last checked the checkpoint
	lastCheckPoint       *params.TrustedCheckpoint // The last stable checkpoint
	lastCheckPointHeight uint64                    // The height of last stable checkpoint
50 51
}

52 53 54
// New creates a checkpoint oracle handler with given configs and callback.
func New(config *params.CheckpointOracleConfig, getLocal func(uint64) params.TrustedCheckpoint) *CheckpointOracle {
	return &CheckpointOracle{
55 56 57 58 59
		config:   config,
		getLocal: getLocal,
	}
}

60 61 62 63
// Start binds the contract backend, initializes the oracle instance
// and marks the status as available.
func (oracle *CheckpointOracle) Start(backend bind.ContractBackend) {
	contract, err := checkpointoracle.NewCheckpointOracle(oracle.config.Address, backend)
64 65 66 67
	if err != nil {
		log.Error("Oracle contract binding failed", "err", err)
		return
	}
68
	if !atomic.CompareAndSwapInt32(&oracle.running, 0, 1) {
69 70 71
		log.Error("Already bound and listening to registrar")
		return
	}
72
	oracle.contract = contract
73 74
}

75 76 77
// IsRunning returns an indicator whether the oracle is running.
func (oracle *CheckpointOracle) IsRunning() bool {
	return atomic.LoadInt32(&oracle.running) == 1
78 79
}

80 81 82 83 84 85
// Contract returns the underlying raw checkpoint oracle contract.
func (oracle *CheckpointOracle) Contract() *checkpointoracle.CheckpointOracle {
	return oracle.contract
}

// StableCheckpoint returns the stable checkpoint which was generated by local
86
// indexers and announced by trusted signers.
87
func (oracle *CheckpointOracle) StableCheckpoint() (*params.TrustedCheckpoint, uint64) {
88 89 90 91 92 93
	oracle.checkMu.Lock()
	defer oracle.checkMu.Unlock()
	if time.Since(oracle.lastCheckTime) < 1*time.Minute {
		return oracle.lastCheckPoint, oracle.lastCheckPointHeight
	}
	// Look it up properly
94
	// Retrieve the latest checkpoint from the contract, abort if empty
95
	latest, hash, height, err := oracle.contract.Contract().GetLatestCheckpoint(nil)
96
	oracle.lastCheckTime = time.Now()
97
	if err != nil || (latest == 0 && hash == [32]byte{}) {
98 99 100
		oracle.lastCheckPointHeight = 0
		oracle.lastCheckPoint = nil
		return oracle.lastCheckPoint, oracle.lastCheckPointHeight
101
	}
102
	local := oracle.getLocal(latest)
103 104 105 106 107 108 109

	// The following scenarios may occur:
	//
	// * local node is out of sync so that it doesn't have the
	//   checkpoint which registered in the contract.
	// * local checkpoint doesn't match with the registered one.
	//
110 111
	// In both cases, no stable checkpoint will be returned.
	if local.HashEqual(hash) {
112 113
		oracle.lastCheckPointHeight = height.Uint64()
		oracle.lastCheckPoint = &local
114
		return oracle.lastCheckPoint, oracle.lastCheckPointHeight
115 116 117 118
	}
	return nil, 0
}

119
// VerifySigners recovers the signer addresses according to the signature and
120
// checks whether there are enough approvals to finalize the checkpoint.
121
func (oracle *CheckpointOracle) VerifySigners(index uint64, hash [32]byte, signatures [][]byte) (bool, []common.Address) {
122
	// Short circuit if the given signatures doesn't reach the threshold.
123
	if len(signatures) < int(oracle.config.Threshold) {
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
		return false, nil
	}
	var (
		signers []common.Address
		checked = make(map[common.Address]struct{})
	)
	for i := 0; i < len(signatures); i++ {
		if len(signatures[i]) != 65 {
			continue
		}
		// EIP 191 style signatures
		//
		// Arguments when calculating hash to validate
		// 1: byte(0x19) - the initial 0x19 byte
		// 2: byte(0) - the version byte (data with intended validator)
		// 3: this - the validator address
		// --  Application specific data
		// 4 : checkpoint section_index (uint64)
		// 5 : checkpoint hash (bytes32)
		//     hash = keccak256(checkpoint_index, section_head, cht_root, bloom_root)
		buf := make([]byte, 8)
		binary.BigEndian.PutUint64(buf, index)
146
		data := append([]byte{0x19, 0x00}, append(oracle.config.Address.Bytes(), append(buf, hash[:]...)...)...)
147 148 149 150 151 152 153 154 155 156
		signatures[i][64] -= 27 // Transform V from 27/28 to 0/1 according to the yellow paper for verification.
		pubkey, err := crypto.Ecrecover(crypto.Keccak256(data), signatures[i])
		if err != nil {
			return false, nil
		}
		var signer common.Address
		copy(signer[:], crypto.Keccak256(pubkey[1:])[12:])
		if _, exist := checked[signer]; exist {
			continue
		}
157
		for _, s := range oracle.config.Signers {
158 159 160 161 162 163
			if s == signer {
				signers = append(signers, signer)
				checked[signer] = struct{}{}
			}
		}
	}
164
	threshold := oracle.config.Threshold
165 166 167 168 169 170
	if uint64(len(signers)) < threshold {
		log.Warn("Not enough signers to approve checkpoint", "signers", len(signers), "threshold", threshold)
		return false, nil
	}
	return true, signers
}