[client & types] implement Waypoint and ValidatorChangeProof

The client is able to learn validator set from the server (via a trusted Waypoint).
No need to specify a trusted peers list anymore.

Author: the729

client/accumulator.go

@@ -24,23 +24,23 @@ to restore the known-version state.
 package client
 
 import (
-	"encoding/hex"
+	"fmt"
 	"sync"
 
-	"github.com/the729/go-libra/crypto/sha3libra"
 	"github.com/the729/go-libra/generated/pbac"
+	"github.com/the729/go-libra/types"
 	"github.com/the729/go-libra/types/proof/accumulator"
-	"github.com/the729/go-libra/types/validator"
 )
 
 // Client is a Libra client.
 // It has a gRPC client to a Libra RPC server, with public keys to trusted peers.
 type Client struct {
-	closeFunc func()
-	ac        pbac.AdmissionControlClient
-	verifier  validator.Verifier
-	acc       *accumulator.Accumulator
-	accMu     sync.RWMutex
+	closeFunc    func()
+	ac           pbac.AdmissionControlClient
+	verifier     types.LedgerInfoVerifier
+	acc          *accumulator.Accumulator
+	accMu        sync.RWMutex
+	lastWaypoint string
 }
 
 // New creates a new Libra Client.
@@ -50,22 +50,18 @@ type Client struct {
 //
 // For use with Javascript, ServerAddr is in http://host:port format. TrustedPeer is a TOML formated
 // text of the trusted peers config.
-func New(ServerAddr, TrustedPeer string) (*Client, error) {
+func New(ServerAddr, Waypoint string) (*Client, error) {
+	return NewFromState(ServerAddr, &ClientState{Waypoint: Waypoint})
+}
+
+func NewFromState(ServerAddr string, state *ClientState) (*Client, error) {
 	c := &Client{}
-	if err := c.loadTrustedPeers(TrustedPeer); err != nil {
-		return nil, err
+	if err := c.SetState(state); err != nil {
+		return nil, fmt.Errorf("invalid state: %v", err)
 	}
 	if err := c.connect(ServerAddr); err != nil {
 		return nil, err
 	}
-
-	genesisHash, _ := hex.DecodeString("c7f50b86fdbb6857333afc6c3450ed61871a9c788ec6818e741cfbd1be08faad")
-	c.acc = &accumulator.Accumulator{
-		Hasher:             sha3libra.NewTransactionAccumulator(),
-		FrozenSubtreeRoots: [][]byte{genesisHash},
-		NumLeaves:          1,
-	}
-
 	return c, nil
 }
 
@@ -75,3 +71,9 @@ func (c *Client) Close() {
 		c.closeFunc()
 	}
 }
+
+// GetLatestWaypoint returns the latest waypoint string that this client has
+// reached.
+func (c *Client) GetLatestWaypoint() string {
+	return c.lastWaypoint
+}

client/client.go

@@ -7,9 +7,7 @@ import (
 
 	"google.golang.org/grpc"
 
-	"github.com/the729/go-libra/config"
 	"github.com/the729/go-libra/generated/pbac"
-	"github.com/the729/go-libra/types/validator"
 )
 
 func (c *Client) connect(server string) error {
@@ -22,16 +20,3 @@ func (c *Client) connect(server string) error {
 	c.ac = pbac.NewAdmissionControlClient(conn)
 	return nil
 }
-
-func (c *Client) loadTrustedPeers(file string) error {
-	peerconf, err := config.LoadTrustedPeersFromFile(file)
-	if err != nil {
-		return fmt.Errorf("load conf err: %v", err)
-	}
-	verifier, err := validator.NewConsensusVerifier(peerconf)
-	if err != nil {
-		return fmt.Errorf("new verifier err: %v", err)
-	}
-	c.verifier = verifier
-	return nil
-}

client/client_go.go

@@ -3,27 +3,10 @@
 package client
 
 import (
-	"fmt"
-
-	"github.com/the729/go-libra/config"
 	"github.com/the729/go-libra/generated/pbac"
-	"github.com/the729/go-libra/types/validator"
 )
 
 func (c *Client) connect(server string) error {
 	c.ac = pbac.NewAdmissionControlClient(server)
 	return nil
 }
-
-func (c *Client) loadTrustedPeers(tomlData string) error {
-	peerconf, err := config.LoadTrustedPeers(tomlData)
-	if err != nil {
-		return fmt.Errorf("load conf err: %v", err)
-	}
-	verifier, err := validator.NewConsensusVerifier(peerconf)
-	if err != nil {
-		return fmt.Errorf("new verifier err: %v", err)
-	}
-	c.verifier = verifier
-	return nil
-}

client/client_js.go

@@ -40,7 +40,35 @@ func (c *Client) verifyLedgerInfoAndConsistency(
 
 	li := &types.LedgerInfoWithSignatures{}
 	li.FromProto(resp.LedgerInfoWithSigs)
-	pli, err := li.Verify(c.verifier)
+
+	verifier := c.verifier
+	lastWaypoint := ""
+	if verifier.EpochChangeVerificationRequired(li.Epoch) {
+		vcp := &types.ValidatorChangeProof{}
+		if err := vcp.FromProto(resp.ValidatorChangeProof); err != nil {
+			return nil, fmt.Errorf("validator change proof invalid: %v", err)
+		}
+		epochChangeLI, err := vcp.Verify(verifier)
+		if err != nil {
+			return nil, fmt.Errorf("validator change proof verification error: %v", err)
+		}
+		if epochChangeLI.GetVersion() == 0 {
+			// this is the genesis block, update accumulator
+			numLeaves = 1
+			frozenSubtreeRoots = [][]byte{epochChangeLI.GetTransactionAccumulatorHash()}
+		}
+		v, err := epochChangeLI.ToVerifier()
+		if err != nil {
+			return nil, err
+		}
+
+		// log.Printf("Ledger info verifier updated, epoch = %d", epochChangeLI.GetEpochNum()+1)
+
+		verifier = v
+		lastWaypointB, _ := (&types.Waypoint{}).FromProvenLedgerInfo(epochChangeLI).MarshalText()
+		lastWaypoint = string(lastWaypointB)
+	}
+	pli, err := li.Verify(verifier)
 	if err != nil {
 		return nil, fmt.Errorf("ledger info verification failed: %v", err)
 	}
@@ -52,10 +80,15 @@ func (c *Client) verifyLedgerInfoAndConsistency(
 	if err != nil {
 		return nil, fmt.Errorf("ledger not consistent with known version: %v", err)
 	}
+
 	c.accMu.Lock()
 	if numLeaves > c.acc.NumLeaves {
 		c.acc.FrozenSubtreeRoots, c.acc.NumLeaves = frozenSubtreeRoots, numLeaves
 	}
+	if lastWaypoint != "" {
+		c.verifier = verifier
+		c.lastWaypoint = lastWaypoint
+	}
 	c.accMu.Unlock()
 
 	return pli, nil

client/query_ledger.go

@@ -0,0 +1,123 @@
+package client
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/the729/go-libra/crypto/sha3libra"
+	"github.com/the729/go-libra/types"
+	"github.com/the729/go-libra/types/proof/accumulator"
+)
+
+type HashValue []byte
+
+func (h *HashValue) UnmarshalText(txt []byte) error {
+	data, err := hex.DecodeString(string(txt))
+	if err != nil {
+		return fmt.Errorf("hash value decode error: %v", err)
+	}
+	*h = data
+	return nil
+}
+
+func (h HashValue) MarshalText() (text []byte, err error) {
+	return []byte(hex.EncodeToString(h)), nil
+}
+
+type ClientState struct {
+	Waypoint     string             `toml:"waypoint" json:"waypoint"`
+	ValidatorSet types.ValidatorSet `toml:"validator_set" json:"validator_set,omitempty"`
+	Epoch        uint64             `toml:"epoch" json:"epoch"`
+	KnownVersion uint64             `toml:"known_version" json:"known_version"`
+	Subtrees     []HashValue        `toml:"subtrees" json:"subtrees"`
+}
+
+func (c *Client) GetState() *ClientState {
+	c.accMu.RLock()
+	defer c.accMu.RUnlock()
+
+	cs := &ClientState{}
+	cs.Waypoint = c.lastWaypoint
+	if vv, ok := c.verifier.(*types.ValidatorVerifier); ok {
+		cs.ValidatorSet, cs.Epoch = vv.ToValidatorSet()
+	}
+	cs.KnownVersion = c.acc.NumLeaves - 1
+	cs.Subtrees = cloneSubtrees2(c.acc.FrozenSubtreeRoots)
+
+	return cs
+}
+
+func (c *Client) SetState(cs *ClientState) error {
+	var verifier types.LedgerInfoVerifier
+	if len(cs.ValidatorSet) > 0 {
+		vv := &types.ValidatorVerifier{}
+		if err := vv.FromValidatorSet(cs.ValidatorSet, cs.Epoch); err != nil {
+			return fmt.Errorf("restore validator set error: %v", err)
+		}
+		verifier = vv
+	} else if cs.Waypoint == "insecure" {
+		verifier = &types.ValidatorVerifier{}
+		println("Warning: INSECURE! No waypoint or validator set specified.")
+	} else {
+		wp := &types.Waypoint{}
+		if err := wp.UnmarshalText([]byte(cs.Waypoint)); err != nil {
+			return fmt.Errorf("restore waypoint error: %v", err)
+		}
+		verifier = wp
+	}
+
+	acc := &accumulator.Accumulator{
+		Hasher:             sha3libra.NewTransactionAccumulator(),
+		FrozenSubtreeRoots: cloneSubtrees1(cs.Subtrees),
+		NumLeaves:          cs.KnownVersion + 1,
+	}
+	if _, err := acc.RootHash(); err != nil {
+		return fmt.Errorf("known accumulator invalid: %v", err)
+	}
+
+	c.accMu.Lock()
+	defer c.accMu.Unlock()
+	c.acc = acc
+	c.verifier = verifier
+	c.lastWaypoint = cs.Waypoint
+	return nil
+}
+
+func cloneSubtrees(in [][]byte) [][]byte {
+	if in == nil {
+		return nil
+	}
+	out := make([][]byte, 0, len(in))
+	for _, h := range in {
+		h1 := make([]byte, len(h))
+		copy(h1, h)
+		out = append(out, h1)
+	}
+	return out
+}
+
+func cloneSubtrees1(in []HashValue) [][]byte {
+	if in == nil {
+		return nil
+	}
+	out := make([][]byte, 0, len(in))
+	for _, h := range in {
+		h1 := make([]byte, len(h))
+		copy(h1, h)
+		out = append(out, h1)
+	}
+	return out
+}
+
+func cloneSubtrees2(in [][]byte) []HashValue {
+	if in == nil {
+		return nil
+	}
+	out := make([]HashValue, 0, len(in))
+	for _, h := range in {
+		h1 := make([]byte, len(h))
+		copy(h1, h)
+		out = append(out, HashValue(h1))
+	}
+	return out
+}