From 94ea114c5888736397c41730019798d78b58fd83 Mon Sep 17 00:00:00 2001 From: Wei-Ning Huang Date: Tue, 9 Oct 2018 12:29:49 +0800 Subject: core: vm: refactor and add DKGFinalizeds related implementations --- core/vm/governance.go | 394 ++++++++++++++++++++++++++++++++++++++------------ dex/governance.go | 13 +- dex/network.go | 4 +- 3 files changed, 313 insertions(+), 98 deletions(-) diff --git a/core/vm/governance.go b/core/vm/governance.go index e9e57c4c9..105b77832 100644 --- a/core/vm/governance.go +++ b/core/vm/governance.go @@ -217,6 +217,29 @@ const abiJSON = ` "stateMutability": "view", "type": "function" }, + { + "constant": true, + "inputs": [ + { + "name": "", + "type": "uint256" + }, + { + "name": "", + "type": "address" + } + ], + "name": "dkgFinalizeds", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, { "constant": true, "inputs": [], @@ -259,6 +282,25 @@ const abiJSON = ` "stateMutability": "view", "type": "function" }, + { + "constant": true, + "inputs": [ + { + "name": "", + "type": "uint256" + } + ], + "name": "dkgFinalizedsCount", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, { "constant": false, "inputs": [ @@ -323,6 +365,24 @@ const abiJSON = ` "stateMutability": "nonpayable", "type": "function" }, + { + "constant": false, + "inputs": [ + { + "name": "Round", + "type": "uint256" + }, + { + "name": "Complaint", + "type": "bytes" + } + ], + "name": "addDKGComplaint", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, { "constant": false, "inputs": [ @@ -349,11 +409,11 @@ const abiJSON = ` "type": "uint256" }, { - "name": "Complaint", + "name": "Finalize", "type": "bytes" } ], - "name": "addDKGComplaint", + "name": "addDKGFinalize", "outputs": [], "payable": false, "stateMutability": "nonpayable", @@ -403,6 +463,10 @@ func init() { } } +func nodeIDToAddress(nodeID types.NodeID) common.Address { + return common.BytesToAddress(nodeID.Bytes()[12:]) +} + type configParams struct { NumChains uint32 LambdaBA uint64 @@ -454,6 +518,15 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) ( return nil, errExecutionReverted } return g.proposeCRS(signedCRS) + case "addDKGComplaint": + args := struct { + Round *big.Int + Complaint []byte + }{} + if err := method.Inputs.Unpack(&args, arguments); err != nil { + return nil, errExecutionReverted + } + return g.addDKGComplaint(args.Round, args.Complaint) case "addDKGMasterPublicKey": args := struct { Round *big.Int @@ -463,15 +536,19 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) ( return nil, errExecutionReverted } return g.addDKGMasterPublicKey(args.Round, args.PublicKey) - case "addDKGComplaint": + case "addDKGFinalize": args := struct { - Round *big.Int - Complaint []byte + Round *big.Int + Finalize []byte }{} if err := method.Inputs.Unpack(&args, arguments); err != nil { return nil, errExecutionReverted } - return g.addDKGComplaint(args.Round, args.Complaint) + return g.addDKGFinalize(args.Round, args.Finalize) + + // -------------------------------- + // Solidity auto generated methods. + // -------------------------------- case "dkgComplaints": round, index := new(big.Int), new(big.Int) @@ -489,6 +566,29 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) ( return nil, errExecutionReverted } return res, nil + case "dkgFinalizeds": + round, addr := new(big.Int), common.Address{} + args := []interface{}{&round, &addr} + if err := method.Inputs.Unpack(&args, arguments); err != nil { + return nil, errExecutionReverted + } + finalized := g.state.dkgFinalized(round, addr) + res, err := method.Outputs.Pack(finalized) + if err != nil { + return nil, errExecutionReverted + } + return res, nil + case "dkgFinalizedsCount": + round := new(big.Int) + if err := method.Inputs.Unpack(&round, arguments); err != nil { + return nil, errExecutionReverted + } + count := g.state.dkgFinalizedsCount(round) + res, err := method.Outputs.Pack(count) + if err != nil { + return nil, errExecutionReverted + } + return res, nil case "dkgMasterPublicKeys": round, index := new(big.Int), new(big.Int) args := []interface{}{&round, &index} @@ -595,6 +695,28 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) ( return nil, nil } +// Storage position enums. +const ( + nodesLoc = iota + offsetLoc + crsLoc + dkgMasterPublicKeysLoc + dkgComplaintsLoc + dkgFinailizedLoc + dkgFinalizedsCountLoc + governanceMultisigLoc + numChainsLoc + lambdaBALoc + lambdaDKGLoc + kLoc + phiRatioLoc + notarySetSizeLoc + dkgSetSizeLoc + roundIntervalLoc + minBlockIntervalLoc + maxBlockIntervalLoc +) + // State manipulation helper fro the governance contract. type StateHelper struct { Address common.Address @@ -701,13 +823,43 @@ func (s *StateHelper) writeBytes(loc *big.Int, data []byte) { } } +func (s *StateHelper) read2DByteArray(pos, index *big.Int) [][]byte { + baseLoc := s.getSlotLoc(pos) + loc := new(big.Int).Add(baseLoc, index) + + arrayLength := s.getStateBigInt(loc) + dataLoc := s.getSlotLoc(loc) + + data := [][]byte{} + for i := int64(0); i < int64(arrayLength.Uint64()); i++ { + elementLoc := new(big.Int).Add(dataLoc, big.NewInt(i)) + data = append(data, s.readBytes(elementLoc)) + } + + return data +} +func (s *StateHelper) appendTo2DByteArray(pos, index *big.Int, data []byte) { + // Find the loc of the last element. + baseLoc := s.getSlotLoc(pos) + loc := new(big.Int).Add(baseLoc, index) + + // increase length by 1. + arrayLength := s.getStateBigInt(loc) + s.setStateBigInt(loc, new(big.Int).Add(arrayLength, big.NewInt(1))) + + // write element. + dataLoc := s.getSlotLoc(loc) + elementLoc := new(big.Int).Add(dataLoc, arrayLength) + s.writeBytes(elementLoc, data) +} + // struct Node { // address owner; // bytes publicKey; // uint256 staked; // } // -// 0: Node[] nodes; +// Node[] nodes; type nodeInfo struct { owner common.Address @@ -716,12 +868,12 @@ type nodeInfo struct { } func (s *StateHelper) nodesLength() *big.Int { - return s.getStateBigInt(big.NewInt(0)) + return s.getStateBigInt(big.NewInt(nodesLoc)) } func (s *StateHelper) node(index *big.Int) *nodeInfo { node := new(nodeInfo) - arrayBaseLoc := s.getSlotLoc(big.NewInt(0)) + arrayBaseLoc := s.getSlotLoc(big.NewInt(nodesLoc)) elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(index, big.NewInt(3))) // owner. @@ -741,12 +893,12 @@ func (s *StateHelper) node(index *big.Int) *nodeInfo { func (s *StateHelper) pushNode(n *nodeInfo) { // increase length by 1 arrayLength := s.nodesLength() - s.setStateBigInt(big.NewInt(0), new(big.Int).Add(arrayLength, big.NewInt(1))) + s.setStateBigInt(big.NewInt(nodesLoc), new(big.Int).Add(arrayLength, big.NewInt(1))) s.updateNode(arrayLength, n) } func (s *StateHelper) updateNode(index *big.Int, n *nodeInfo) { - arrayBaseLoc := s.getSlotLoc(big.NewInt(0)) + arrayBaseLoc := s.getSlotLoc(big.NewInt(nodesLoc)) elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(index, big.NewInt(3))) // owner. @@ -762,148 +914,137 @@ func (s *StateHelper) updateNode(index *big.Int, n *nodeInfo) { s.setStateBigInt(loc, n.staked) } -// 1: mapping(address => uint256) public offset; +// mapping(address => uint256) public offset; func (s *StateHelper) offset(addr common.Address) *big.Int { - loc := s.getMapLoc(big.NewInt(1), addr.Bytes()) + loc := s.getMapLoc(big.NewInt(offsetLoc), addr.Bytes()) return new(big.Int).Sub(s.getStateBigInt(loc), big.NewInt(1)) } func (s *StateHelper) putOffset(addr common.Address, offset *big.Int) { - loc := s.getMapLoc(big.NewInt(1), addr.Bytes()) + loc := s.getMapLoc(big.NewInt(offsetLoc), addr.Bytes()) s.setStateBigInt(loc, new(big.Int).Add(offset, big.NewInt(1))) } func (s *StateHelper) deleteOffset(addr common.Address) { - loc := s.getMapLoc(big.NewInt(1), addr.Bytes()) + loc := s.getMapLoc(big.NewInt(offsetLoc), addr.Bytes()) s.setStateBigInt(loc, big.NewInt(0)) } -// 2: bytes32[] public crs; +// bytes32[] public crs; func (s *StateHelper) lenCRS() *big.Int { - return s.getStateBigInt(big.NewInt(2)) + return s.getStateBigInt(big.NewInt(crsLoc)) } func (s *StateHelper) crs(index *big.Int) common.Hash { - baseLoc := s.getSlotLoc(big.NewInt(2)) - loc := new(big.Int).Add(baseLoc, new(big.Int).Mul(index, big.NewInt(32))) + baseLoc := s.getSlotLoc(big.NewInt(crsLoc)) + loc := new(big.Int).Add(baseLoc, index) return s.getState(common.BigToHash(loc)) } func (s *StateHelper) pushCRS(crs common.Hash) { // increase length by 1. - length := s.getStateBigInt(big.NewInt(2)) - s.setStateBigInt(big.NewInt(2), new(big.Int).Add(length, big.NewInt(1))) + length := s.getStateBigInt(big.NewInt(crsLoc)) + s.setStateBigInt(big.NewInt(crsLoc), new(big.Int).Add(length, big.NewInt(1))) - baseLoc := s.getSlotLoc(big.NewInt(2)) - loc := new(big.Int).Add(baseLoc, new(big.Int).Mul(length, big.NewInt(32))) + baseLoc := s.getSlotLoc(big.NewInt(crsLoc)) + loc := new(big.Int).Add(baseLoc, length) s.setState(common.BigToHash(loc), crs) } -// 3: mapping(uint256 => bytes[]) public dkgMasterPublicKeys; +// bytes[][] public dkgMasterPublicKeys; func (s *StateHelper) dkgMasterPublicKeys(round *big.Int) [][]byte { - loc := s.getMapLoc(big.NewInt(3), common.BigToHash(round).Bytes()) - - arrayLength := s.getStateBigInt(loc) - dataLoc := s.getSlotLoc(loc) - - data := make([][]byte, arrayLength.Uint64()) - for i := int64(0); i < int64(arrayLength.Uint64()); i++ { - elementLoc := new(big.Int).Add(dataLoc, big.NewInt(i)) - data = append(data, s.readBytes(elementLoc)) - } - return data + return s.read2DByteArray(big.NewInt(dkgMasterPublicKeysLoc), round) } func (s *StateHelper) pushDKGMasterPublicKey(round *big.Int, pk []byte) { - loc := s.getMapLoc(big.NewInt(3), common.BigToHash(round).Bytes()) - - // increase length by 1. - arrayLength := s.getStateBigInt(loc) - s.setStateBigInt(loc, new(big.Int).Add(arrayLength, big.NewInt(1))) - - // write element. - dataLoc := s.getSlotLoc(loc) - elementLoc := new(big.Int).Add(dataLoc, arrayLength) - s.writeBytes(elementLoc, pk) + s.appendTo2DByteArray(big.NewInt(dkgMasterPublicKeysLoc), round, pk) } -// 4: mapping(uint256 => bytes[]) public dkgComplaints; +// bytes[][] public dkgComplaints; func (s *StateHelper) dkgComplaints(round *big.Int) [][]byte { - loc := s.getMapLoc(big.NewInt(4), common.BigToHash(round).Bytes()) - - arrayLength := s.getStateBigInt(loc) - dataLoc := s.getSlotLoc(loc) - - data := make([][]byte, arrayLength.Uint64()) - for i := int64(0); i < int64(arrayLength.Uint64()); i++ { - elementLoc := new(big.Int).Add(dataLoc, big.NewInt(i)) - data = append(data, s.readBytes(elementLoc)) - } - return data + return s.read2DByteArray(big.NewInt(dkgComplaintsLoc), round) } func (s *StateHelper) pushDKGComplaint(round *big.Int, complaint []byte) { - loc := s.getMapLoc(big.NewInt(4), common.BigToHash(round).Bytes()) + s.appendTo2DByteArray(big.NewInt(dkgComplaintsLoc), round, complaint) +} - // increase length by 1. - arrayLength := s.getStateBigInt(loc) - s.setStateBigInt(loc, new(big.Int).Add(arrayLength, big.NewInt(1))) +// mapping(address => bool)[] public dkgFinalized; +func (s *StateHelper) dkgFinalized(round *big.Int, addr common.Address) bool { + baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinailizedLoc)), round) + mapLoc := s.getMapLoc(baseLoc, addr.Bytes()) + return s.getStateBigInt(mapLoc).Cmp(big.NewInt(0)) != 0 +} +func (s *StateHelper) putDKGFinalized(round *big.Int, addr common.Address, finalized bool) { + baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinailizedLoc)), round) + mapLoc := s.getMapLoc(baseLoc, addr.Bytes()) + res := big.NewInt(0) + if finalized { + res = big.NewInt(1) + } + s.setStateBigInt(mapLoc, res) +} - // write element. - dataLoc := s.getSlotLoc(loc) - elementLoc := new(big.Int).Add(dataLoc, arrayLength) - s.writeBytes(elementLoc, complaint) +// uint256[] public dkgFinalizedsCount; +func (s *StateHelper) dkgFinalizedsCount(round *big.Int) *big.Int { + loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedsCountLoc)), round) + return s.getStateBigInt(loc) +} +func (s *StateHelper) incDKGFinalizedsCount(round *big.Int) { + loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedsCountLoc)), round) + count := s.getStateBigInt(loc) + s.setStateBigInt(loc, new(big.Int).Add(count, big.NewInt(1))) } -// 5: address public governanceMultisig; +// address public governanceMultisig; func (s *StateHelper) governanceMultisig() common.Address { - val := s.getState(common.BigToHash(big.NewInt(5))) + val := s.getState(common.BigToHash(big.NewInt(governanceMultisigLoc))) return common.BytesToAddress(val.Bytes()) } -// 6: uint256 public numChains; +// uint256 public numChains; func (s *StateHelper) numChains() *big.Int { - return s.getStateBigInt(big.NewInt(6)) + return s.getStateBigInt(big.NewInt(numChainsLoc)) } -// 7: uint256 public lambdaBA; +// uint256 public lambdaBA; func (s *StateHelper) lambdaBA() *big.Int { - return s.getStateBigInt(big.NewInt(7)) + return s.getStateBigInt(big.NewInt(lambdaBALoc)) } -// 8: uint256 public lambdaDKG; +// uint256 public lambdaDKG; func (s *StateHelper) lambdaDKG() *big.Int { - return s.getStateBigInt(big.NewInt(8)) + return s.getStateBigInt(big.NewInt(lambdaDKGLoc)) } -// 9: uint256 public k; +// uint256 public k; func (s *StateHelper) k() *big.Int { - return s.getStateBigInt(big.NewInt(9)) + return s.getStateBigInt(big.NewInt(kLoc)) } -// 10: uint256 public phiRatio; // stored as PhiRatio * 10^6 +// uint256 public phiRatio; // stored as PhiRatio * 10^6 func (s *StateHelper) phiRatio() *big.Int { - return s.getStateBigInt(big.NewInt(10)) + return s.getStateBigInt(big.NewInt(phiRatioLoc)) } -// 11: uint256 public notarySetSize; +// uint256 public notarySetSize; func (s *StateHelper) notarySetSize() *big.Int { - return s.getStateBigInt(big.NewInt(11)) + return s.getStateBigInt(big.NewInt(notarySetSizeLoc)) } -// 12: uint256 public dkgSetSize; +// uint256 public dkgSetSize; func (s *StateHelper) dkgSetSize() *big.Int { - return s.getStateBigInt(big.NewInt(12)) + return s.getStateBigInt(big.NewInt(dkgSetSizeLoc)) } -// 13: uint256 public roundInterval +// uint256 public roundInterval func (s *StateHelper) roundInterval() *big.Int { - return s.getStateBigInt(big.NewInt(13)) + return s.getStateBigInt(big.NewInt(roundIntervalLoc)) } -// 14: uint256 public minBlockInterval +// uint256 public minBlockInterval func (s *StateHelper) minBlockInterval() *big.Int { - return s.getStateBigInt(big.NewInt(14)) + return s.getStateBigInt(big.NewInt(minBlockIntervalLoc)) } -// 15: uint256 public maxBlockInterval +// uint256 public maxBlockInterval func (s *StateHelper) maxBlockInterval() *big.Int { - return s.getStateBigInt(big.NewInt(15)) + return s.getStateBigInt(big.NewInt(maxBlockIntervalLoc)) } // GovernanceContract represents the governance contract of DEXCON. @@ -1046,9 +1187,54 @@ func (g *GovernanceContract) proposeCRS(signedCRS []byte) ([]byte, error) { return nil, nil } +func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byte, error) { + caller := g.contract.Caller() + + // Finalized caller is not allowed to propose complaint. + if g.state.dkgFinalized(round, caller) { + g.penalize() + return nil, errExecutionReverted + } + + // Calculate 2f + threshold := new(big.Int).Mul( + big.NewInt(2), + new(big.Int).Div(g.state.dkgSetSize(), big.NewInt(3))) + + // If 2f + 1 of DKG set is finalized, one can not propose complaint anymore. + if g.state.dkgFinalizedsCount(round).Cmp(threshold) > 0 { + return nil, errExecutionReverted + } + + var dkgComplaint types.DKGComplaint + if err := rlp.DecodeBytes(comp, &dkgComplaint); err != nil { + g.penalize() + return nil, errExecutionReverted + } + verified, _ := core.VerifyDKGComplaintSignature(&dkgComplaint) + if !verified { + g.penalize() + return nil, errExecutionReverted + } + + // Verify that the message is sent from the caller. + signer := nodeIDToAddress(dkgComplaint.ProposerID) + if signer != caller { + g.penalize() + return nil, errExecutionReverted + } + + g.state.pushDKGComplaint(round, comp) + + // Set this to relatively high to prevent spamming + g.contract.UseGas(10000000) + return nil, nil +} + func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, pk []byte) ([]byte, error) { caller := g.contract.Caller() offset := g.state.offset(caller) + // Can not add dkg mpk if not staked. if offset.Cmp(big.NewInt(0)) < 0 { return nil, errExecutionReverted @@ -1065,6 +1251,13 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, pk []byte) ([ return nil, errExecutionReverted } + // Verify that the message is sent from the caller. + signer := nodeIDToAddress(dkgMasterPK.ProposerID) + if signer != caller { + g.penalize() + return nil, errExecutionReverted + } + g.state.pushDKGMasterPublicKey(round, pk) // DKG operation is expensive. @@ -1072,20 +1265,33 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, pk []byte) ([ return nil, nil } -func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byte, error) { - var dkgComplaint types.DKGComplaint - if err := rlp.DecodeBytes(comp, &dkgComplaint); err != nil { +func (g *GovernanceContract) addDKGFinalize(round *big.Int, finalize []byte) ([]byte, error) { + caller := g.contract.Caller() + + var dkgFinalize types.DKGFinalize + if err := rlp.DecodeBytes(finalize, &dkgFinalize); err != nil { + g.penalize() return nil, errExecutionReverted } - verified, _ := core.VerifyDKGComplaintSignature(&dkgComplaint) + verified, _ := core.VerifyDKGFinalizeSignature(&dkgFinalize) if !verified { g.penalize() return nil, errExecutionReverted } - g.state.pushDKGComplaint(round, comp) + // Verify that the message is sent from the caller. + signer := nodeIDToAddress(dkgFinalize.ProposerID) + if signer != caller { + g.penalize() + return nil, errExecutionReverted + } - // Set this to relatively high to prevent spamming - g.contract.UseGas(10000000) + if !g.state.dkgFinalized(round, caller) { + g.state.putDKGFinalized(round, caller, true) + g.state.incDKGFinalizedsCount(round) + } + + // DKG operation is expensive. + g.contract.UseGas(100000) return nil, nil } diff --git a/dex/governance.go b/dex/governance.go index 5ee307b88..e990f32f3 100644 --- a/dex/governance.go +++ b/dex/governance.go @@ -35,7 +35,7 @@ func (d *DexconGovernance) NodeSet(round uint64) []crypto.PublicKey { } // AddDKGComplaint adds a DKGComplaint. -func (d *DexconGovernance) AddDKGComplaint(complaint *types.DKGComplaint) { +func (d *DexconGovernance) AddDKGComplaint(round uint64, complaint *types.DKGComplaint) { } // DKGComplaints gets all the DKGComplaints of round. @@ -44,10 +44,19 @@ func (d *DexconGovernance) DKGComplaints(round uint64) []*types.DKGComplaint { } // AddDKGMasterPublicKey adds a DKGMasterPublicKey. -func (d *DexconGovernance) AddDKGMasterPublicKey(masterPublicKey *types.DKGMasterPublicKey) { +func (d *DexconGovernance) AddDKGMasterPublicKey(round uint64, masterPublicKey *types.DKGMasterPublicKey) { } // DKGMasterPublicKeys gets all the DKGMasterPublicKey of round. func (d *DexconGovernance) DKGMasterPublicKeys(round uint64) []*types.DKGMasterPublicKey { return nil } + +// AddDKGFinalize adds a DKG finalize message. +func (d *DexconGovernance) AddDKGFinalize(round uint64, final *types.DKGFinalize) { +} + +// IsDKGFinal checks if DKG is final. +func (d *DexconGovernance) IsDKGFinal(round uint64) bool { + return false +} diff --git a/dex/network.go b/dex/network.go index b19b46147..24ef2cc63 100644 --- a/dex/network.go +++ b/dex/network.go @@ -39,8 +39,8 @@ func (n *DexconNetwork) BroadcastDKGPartialSignature( psig *types.DKGPartialSignature) { } -// BroadcastRandomnessRequest broadcasts rand request to DKG set. -func (n *DexconNetwork) BroadcastRandomnessRequest(randRequest *types.AgreementResult) { +// BroadcastAgreementResult broadcasts rand request to DKG set. +func (n *DexconNetwork) BroadcastAgreementResult(randRequest *types.AgreementResult) { } -- cgit