core/vm: remove round from addDKG functions (#279)

* vendor: sync to latest core

* core/vm: remove addDKG functions

* core: fix conflict

5 files changed, 93 insertions, 129 deletions

diff --git a/core/rawdb/accessors_core_dkg_master_private_shares.go b/core/rawdb/accessors_core_dkg_master_private_shares.go
deleted file mode 100644
index 23b37f361..000000000
--- a/core/rawdb/accessors_core_dkg_master_private_shares.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package rawdb
-
-import (
-	"bytes"
-
-	coreDKG "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg"
-	"github.com/dexon-foundation/dexon/log"
-	"github.com/dexon-foundation/dexon/rlp"
-)
-
-func ReadCoreDKGMasterPrivateSharesRLP(db DatabaseReader, round uint64) rlp.RawValue {
-	data, _ := db.Get(coreDKGMasterPrivateSharesKey(round))
-	return data
-}
-
-func WriteCoreDKGMasterPrivateSharesRLP(db DatabaseWriter, round uint64, rlp rlp.RawValue) error {
-	err := db.Put(coreDKGMasterPrivateSharesKey(round), rlp)
-	if err != nil {
-		log.Crit("Failed to store core DKG private key", "err", err, "round", round)
-	}
-	return err
-}
-
-func ReadCoreDKGMasterPrivateShares(db DatabaseReader, round uint64) *coreDKG.PrivateKeyShares {
-	data := ReadCoreDKGMasterPrivateSharesRLP(db, round)
-	if len(data) == 0 {
-		return nil
-	}
-	shares := new(coreDKG.PrivateKeyShares)
-	if err := rlp.Decode(bytes.NewReader(data), shares); err != nil {
-		log.Error("Invalid core DKG master private shares RLP", "round", round, "err", err)
-		return nil
-	}
-	return shares
-}
-
-func WriteCoreDKGMasterPrivateShares(db DatabaseWriter, round uint64, shares *coreDKG.PrivateKeyShares) error {
-	data, err := rlp.EncodeToBytes(shares)
-	if err != nil {
-		log.Crit("Failed to RLP encode core DKG master private shares", "round", round, "err", err)
-		return err
-	}
-	return WriteCoreDKGMasterPrivateSharesRLP(db, round, data)
-}
diff --git a/core/rawdb/accessors_core_dkg_protocol.go b/core/rawdb/accessors_core_dkg_protocol.go
new file mode 100644
index 000000000..ba087b00d
--- /dev/null
+++ b/core/rawdb/accessors_core_dkg_protocol.go
@@ -0,0 +1,44 @@
+package rawdb
+
+import (
+	"bytes"
+
+	coreDb "github.com/dexon-foundation/dexon-consensus/core/db"
+	"github.com/dexon-foundation/dexon/log"
+	"github.com/dexon-foundation/dexon/rlp"
+)
+
+func ReadCoreDKGProtocolRLP(db DatabaseReader) rlp.RawValue {
+	data, _ := db.Get(coreDKGProtocolKey)
+	return data
+}
+
+func WriteCoreDKGProtocolRLP(db DatabaseWriter, rlp rlp.RawValue) error {
+	err := db.Put(coreDKGProtocolKey, rlp)
+	if err != nil {
+		log.Crit("Failed to store core DKG private key", "err", err)
+	}
+	return err
+}
+
+func ReadCoreDKGProtocol(db DatabaseReader) *coreDb.DKGProtocolInfo {
+	data := ReadCoreDKGProtocolRLP(db)
+	if len(data) == 0 {
+		return nil
+	}
+	protocol := new(coreDb.DKGProtocolInfo)
+	if err := rlp.Decode(bytes.NewReader(data), protocol); err != nil {
+		log.Error("Invalid core DKG protocol RLP", "err", err)
+		return nil
+	}
+	return protocol
+}
+
+func WriteCoreDKGProtocol(db DatabaseWriter, protocol *coreDb.DKGProtocolInfo) error {
+	data, err := rlp.EncodeToBytes(protocol)
+	if err != nil {
+		log.Crit("Failed to RLP encode core DKG protocol", "err", err)
+		return err
+	}
+	return WriteCoreDKGProtocolRLP(db, data)
+}
diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go
index b469468f4..8ca47676d 100644
--- a/core/rawdb/schema.go
+++ b/core/rawdb/schema.go
@@ -53,10 +53,10 @@ var (
 	txLookupPrefix  = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata
 	bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits
 
-	coreBlockPrefix                  = []byte("D")
-	coreDKGPrivateKeyPrefix          = []byte("DPK")
-	coreCompactionChainTipKey        = []byte("CoreChainTip")
-	coreDKGMasterPrivateSharesPrefix = []byte("CoreDKGPrv")
+	coreBlockPrefix           = []byte("D")
+	coreDKGPrivateKeyPrefix   = []byte("DPK")
+	coreCompactionChainTipKey = []byte("CoreChainTip")
+	coreDKGProtocolKey        = []byte("CoreDKGProtocol")
 
 	preimagePrefix = []byte("secure-key-")      // preimagePrefix + hash -> preimage
 	configPrefix   = []byte("ethereum-config-") // config prefix for the db
@@ -131,14 +131,6 @@ func coreDKGPrivateKeyKey(round uint64) []byte {
 	return ret
 }
 
-// coreDKGMasterPrivateSharesKey = coreDKGMasterPrivateSharesPrefix + round
-func coreDKGMasterPrivateSharesKey(round uint64) []byte {
-	ret := make([]byte, len(coreDKGMasterPrivateSharesPrefix)+8)
-	copy(ret, coreDKGMasterPrivateSharesPrefix)
-	binary.LittleEndian.PutUint64(ret[len(coreDKGMasterPrivateSharesPrefix):], round)
-	return ret
-}
-
 // bloomBitsKey = bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash
 func bloomBitsKey(bit uint, section uint64, hash common.Hash) []byte {
 	key := append(append(bloomBitsPrefix, make([]byte, 10)...), hash.Bytes()...)
diff --git a/core/vm/oracle_contract_abi.go b/core/vm/oracle_contract_abi.go
index cd037b068..e42e9266f 100644
--- a/core/vm/oracle_contract_abi.go
+++ b/core/vm/oracle_contract_abi.go
@@ -957,10 +957,6 @@ const GovernanceABIJSON = `
     "constant": false,
     "inputs": [
       {
-        "name": "Round",
-        "type": "uint256"
-      },
-      {
         "name": "Complaint",
         "type": "bytes"
       }
@@ -975,10 +971,6 @@ const GovernanceABIJSON = `
     "constant": false,
     "inputs": [
       {
-        "name": "Round",
-        "type": "uint256"
-      },
-      {
         "name": "PublicKey",
         "type": "bytes"
       }
@@ -993,10 +985,6 @@ const GovernanceABIJSON = `
     "constant": false,
     "inputs": [
       {
-        "name": "Round",
-        "type": "uint256"
-      },
-      {
         "name": "MPKReady",
         "type": "bytes"
       }
@@ -1011,10 +999,6 @@ const GovernanceABIJSON = `
     "constant": false,
     "inputs": [
       {
-        "name": "Round",
-        "type": "uint256"
-      },
-      {
         "name": "Finalize",
         "type": "bytes"
       }
diff --git a/core/vm/oracle_contracts.go b/core/vm/oracle_contracts.go
index c94d58b1f..c73bf401e 100644
--- a/core/vm/oracle_contracts.go
+++ b/core/vm/oracle_contracts.go
@@ -1355,11 +1355,7 @@ func (g *GovernanceContract) clearDKG() {
 	g.state.ResetDKGFinalizedsCount()
 }
 
-func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byte, error) {
-	if round.Uint64() != g.evm.Round.Uint64()+1 {
-		return nil, errExecutionReverted
-	}
-
+func (g *GovernanceContract) addDKGComplaint(comp []byte) ([]byte, error) {
 	caller := g.contract.Caller()
 	offset := g.state.NodesOffsetByNodeKeyAddress(caller)
 
@@ -1391,6 +1387,10 @@ func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byt
 	if g.state.DKGComplaintProposed(getDKGComplaintID(&dkgComplaint)) {
 		return nil, errExecutionReverted
 	}
+	round := big.NewInt(int64(dkgComplaint.Round))
+	if round.Uint64() != g.evm.Round.Uint64()+1 {
+		return nil, errExecutionReverted
+	}
 
 	if dkgComplaint.Reset != g.state.DKGResetCount(round).Uint64() {
 		return nil, errExecutionReverted
@@ -1439,7 +1439,12 @@ func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byt
 	return g.useGas(GovernanceActionGasCost)
 }
 
-func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) ([]byte, error) {
+func (g *GovernanceContract) addDKGMasterPublicKey(mpk []byte) ([]byte, error) {
+	var dkgMasterPK dkgTypes.MasterPublicKey
+	if err := rlp.DecodeBytes(mpk, &dkgMasterPK); err != nil {
+		return nil, errExecutionReverted
+	}
+	round := big.NewInt(int64(dkgMasterPK.Round))
 	if round.Uint64() != g.evm.Round.Uint64()+1 {
 		return nil, errExecutionReverted
 	}
@@ -1450,6 +1455,10 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) (
 		g.state.SetDKGRound(round)
 	}
 
+	if g.state.DKGMasterPublicKeyProposed(getDKGMasterPublicKeyID(&dkgMasterPK)) {
+		return nil, errExecutionReverted
+	}
+
 	caller := g.contract.Caller()
 	offset := g.state.NodesOffsetByNodeKeyAddress(caller)
 
@@ -1473,15 +1482,6 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) (
 		return nil, errExecutionReverted
 	}
 
-	var dkgMasterPK dkgTypes.MasterPublicKey
-	if err := rlp.DecodeBytes(mpk, &dkgMasterPK); err != nil {
-		return nil, errExecutionReverted
-	}
-
-	if g.state.DKGMasterPublicKeyProposed(getDKGMasterPublicKeyID(&dkgMasterPK)) {
-		return nil, errExecutionReverted
-	}
-
 	if dkgMasterPK.Reset != g.state.DKGResetCount(round).Uint64() {
 		return nil, errExecutionReverted
 	}
@@ -1501,17 +1501,17 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) (
 	return g.useGas(GovernanceActionGasCost)
 }
 
-func (g *GovernanceContract) addDKGMPKReady(round *big.Int, ready []byte) ([]byte, error) {
-	if round.Uint64() != g.evm.Round.Uint64()+1 {
-		return nil, errExecutionReverted
-	}
-
+func (g *GovernanceContract) addDKGMPKReady(ready []byte) ([]byte, error) {
 	caller := g.contract.Caller()
 
 	var dkgReady dkgTypes.MPKReady
 	if err := rlp.DecodeBytes(ready, &dkgReady); err != nil {
 		return nil, errExecutionReverted
 	}
+	round := big.NewInt(int64(dkgReady.Round))
+	if round.Uint64() != g.evm.Round.Uint64()+1 {
+		return nil, errExecutionReverted
+	}
 
 	if dkgReady.Reset != g.state.DKGResetCount(round).Uint64() {
 		return nil, errExecutionReverted
@@ -1535,17 +1535,17 @@ func (g *GovernanceContract) addDKGMPKReady(round *big.Int, ready []byte) ([]byt
 	return g.useGas(GovernanceActionGasCost)
 }
 
-func (g *GovernanceContract) addDKGFinalize(round *big.Int, finalize []byte) ([]byte, error) {
-	if round.Uint64() != g.evm.Round.Uint64()+1 {
-		return nil, errExecutionReverted
-	}
-
+func (g *GovernanceContract) addDKGFinalize(finalize []byte) ([]byte, error) {
 	caller := g.contract.Caller()
 
 	var dkgFinalize dkgTypes.Finalize
 	if err := rlp.DecodeBytes(finalize, &dkgFinalize); err != nil {
 		return nil, errExecutionReverted
 	}
+	round := big.NewInt(int64(dkgFinalize.Round))
+	if round.Uint64() != g.evm.Round.Uint64()+1 {
+		return nil, errExecutionReverted
+	}
 
 	if dkgFinalize.Reset != g.state.DKGResetCount(round).Uint64() {
 		return nil, errExecutionReverted
@@ -2036,41 +2036,29 @@ func (g *GovernanceContract) Run(evm *EVM, input []byte, contract *Contract) (re
 	// Dispatch method call.
 	switch method.Name {
 	case "addDKGComplaint":
-		args := struct {
-			Round     *big.Int
-			Complaint []byte
-		}{}
-		if err := method.Inputs.Unpack(&args, arguments); err != nil {
+		var Complaint []byte
+		if err := method.Inputs.Unpack(&Complaint, arguments); err != nil {
 			return nil, errExecutionReverted
 		}
-		return g.addDKGComplaint(args.Round, args.Complaint)
+		return g.addDKGComplaint(Complaint)
 	case "addDKGMasterPublicKey":
-		args := struct {
-			Round     *big.Int
-			PublicKey []byte
-		}{}
-		if err := method.Inputs.Unpack(&args, arguments); err != nil {
+		var PublicKey []byte
+		if err := method.Inputs.Unpack(&PublicKey, arguments); err != nil {
 			return nil, errExecutionReverted
 		}
-		return g.addDKGMasterPublicKey(args.Round, args.PublicKey)
+		return g.addDKGMasterPublicKey(PublicKey)
 	case "addDKGMPKReady":
-		args := struct {
-			Round    *big.Int
-			MPKReady []byte
-		}{}
-		if err := method.Inputs.Unpack(&args, arguments); err != nil {
+		var MPKReady []byte
+		if err := method.Inputs.Unpack(&MPKReady, arguments); err != nil {
 			return nil, errExecutionReverted
 		}
-		return g.addDKGMPKReady(args.Round, args.MPKReady)
+		return g.addDKGMPKReady(MPKReady)
 	case "addDKGFinalize":
-		args := struct {
-			Round    *big.Int
-			Finalize []byte
-		}{}
-		if err := method.Inputs.Unpack(&args, arguments); err != nil {
+		var Finalize []byte
+		if err := method.Inputs.Unpack(&Finalize, arguments); err != nil {
 			return nil, errExecutionReverted
 		}
-		return g.addDKGFinalize(args.Round, args.Finalize)
+		return g.addDKGFinalize(Finalize)
 	case "nodesLength":
 		res, err := method.Outputs.Pack(g.state.LenNodes())
 		if err != nil {
@@ -2469,13 +2457,13 @@ func PackProposeCRS(round uint64, signedCRS []byte) ([]byte, error) {
 	return data, nil
 }
 
-func PackAddDKGMasterPublicKey(round uint64, mpk *dkgTypes.MasterPublicKey) ([]byte, error) {
+func PackAddDKGMasterPublicKey(mpk *dkgTypes.MasterPublicKey) ([]byte, error) {
 	method := GovernanceABI.Name2Method["addDKGMasterPublicKey"]
 	encoded, err := rlp.EncodeToBytes(mpk)
 	if err != nil {
 		return nil, err
 	}
-	res, err := method.Inputs.Pack(big.NewInt(int64(round)), encoded)
+	res, err := method.Inputs.Pack(encoded)
 	if err != nil {
 		return nil, err
 	}
@@ -2483,13 +2471,13 @@ func PackAddDKGMasterPublicKey(round uint64, mpk *dkgTypes.MasterPublicKey) ([]b
 	return data, nil
 }
 
-func PackAddDKGMPKReady(round uint64, ready *dkgTypes.MPKReady) ([]byte, error) {
+func PackAddDKGMPKReady(ready *dkgTypes.MPKReady) ([]byte, error) {
 	method := GovernanceABI.Name2Method["addDKGMPKReady"]
 	encoded, err := rlp.EncodeToBytes(ready)
 	if err != nil {
 		return nil, err
 	}
-	res, err := method.Inputs.Pack(big.NewInt(int64(round)), encoded)
+	res, err := method.Inputs.Pack(encoded)
 	if err != nil {
 		return nil, err
 	}
@@ -2497,14 +2485,14 @@ func PackAddDKGMPKReady(round uint64, ready *dkgTypes.MPKReady) ([]byte, error)
 	return data, nil
 }
 
-func PackAddDKGComplaint(round uint64, complaint *dkgTypes.Complaint) ([]byte, error) {
+func PackAddDKGComplaint(complaint *dkgTypes.Complaint) ([]byte, error) {
 	method := GovernanceABI.Name2Method["addDKGComplaint"]
 	encoded, err := rlp.EncodeToBytes(complaint)
 	if err != nil {
 		return nil, err
 	}
 
-	res, err := method.Inputs.Pack(big.NewInt(int64(round)), encoded)
+	res, err := method.Inputs.Pack(encoded)
 	if err != nil {
 		return nil, err
 	}
@@ -2512,14 +2500,14 @@ func PackAddDKGComplaint(round uint64, complaint *dkgTypes.Complaint) ([]byte, e
 	return data, nil
 }
 
-func PackAddDKGFinalize(round uint64, final *dkgTypes.Finalize) ([]byte, error) {
+func PackAddDKGFinalize(final *dkgTypes.Finalize) ([]byte, error) {
 	method := GovernanceABI.Name2Method["addDKGFinalize"]
 	encoded, err := rlp.EncodeToBytes(final)
 	if err != nil {
 		return nil, err
 	}
 
-	res, err := method.Inputs.Pack(big.NewInt(int64(round)), encoded)
+	res, err := method.Inputs.Pack(encoded)
 	if err != nil {
 		return nil, err
 	}