core: vm: finish implementing state helper

1 files changed, 206 insertions, 23 deletions

diff --git a/core/vm/governance.go b/core/vm/governance.go
index ee2c11f1a..368895690 100644
--- a/core/vm/governance.go
+++ b/core/vm/governance.go
@@ -452,9 +452,106 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) (
 
 // State manipulation helper fro the governance contract.
 type StateHelper struct {
+	Address common.Address
 	StateDB StateDB
 }
 
+func (s *StateHelper) getState(loc common.Hash) common.Hash {
+	return s.StateDB.GetState(s.Address, loc)
+}
+
+func (s *StateHelper) setState(loc common.Hash, val common.Hash) {
+	s.StateDB.SetState(s.Address, loc, val)
+}
+
+func (s *StateHelper) getStateBigInt(loc *big.Int) *big.Int {
+	res := s.StateDB.GetState(s.Address, common.BigToHash(loc))
+	return new(big.Int).SetBytes(res.Bytes())
+}
+
+func (s *StateHelper) setStateBigInt(loc *big.Int, val *big.Int) {
+	s.setState(common.BigToHash(loc), common.BigToHash(val))
+}
+
+func (s *StateHelper) getSlotLoc(loc *big.Int) *big.Int {
+	return new(big.Int).SetBytes(crypto.Keccak256(common.BigToHash(loc).Bytes()))
+}
+
+func (s *StateHelper) getMapLoc(pos *big.Int, key []byte) *big.Int {
+	return new(big.Int).SetBytes(crypto.Keccak256(
+		key, common.BigToHash(pos).Bytes()))
+}
+
+func (s *StateHelper) readBytes(loc *big.Int) []byte {
+	// length of the dynamic array (bytes).
+	rawLength := s.getStateBigInt(loc)
+	lengthByte := new(big.Int).Mod(rawLength, big.NewInt(256))
+
+	// bytes length <= 31, lengthByte % 2 == 0
+	// return the high 31 bytes.
+	if new(big.Int).Mod(lengthByte, big.NewInt(2)).Cmp(big.NewInt(0)) == 0 {
+		length := new(big.Int).Div(lengthByte, big.NewInt(2)).Uint64()
+		return rawLength.Bytes()[:length]
+	}
+
+	// actual length = (rawLength - 1) / 2
+	length := new(big.Int).Div(new(big.Int).Sub(rawLength, big.NewInt(1)), big.NewInt(2)).Uint64()
+
+	// data address.
+	dataLoc := s.getSlotLoc(loc)
+
+	// read continiously for length bytes.
+	carry := int64(0)
+	if length%32 > 0 {
+		carry = 1
+	}
+	chunks := int64(length/32) + carry
+	var data []byte
+	for i := int64(0); i < chunks; i++ {
+		loc = new(big.Int).Add(dataLoc, big.NewInt(i))
+		data = append(data, s.getState(common.BigToHash(loc)).Bytes()...)
+	}
+	data = data[:length]
+	return data
+}
+
+func (s *StateHelper) writeBytes(loc *big.Int, data []byte) {
+	length := int64(len(data))
+
+	// short bytes (length <= 31)
+	if length < 32 {
+		data2 := append([]byte(nil), data...)
+		data2 = append(data2, byte(length*2))
+		s.setState(common.BigToHash(loc), common.BytesToHash(data2))
+		return
+	}
+
+	// write 2 * length + 1
+	storedLength := new(big.Int).Add(new(big.Int).Mul(
+		big.NewInt(length), big.NewInt(2)), big.NewInt(1))
+	s.setStateBigInt(loc, storedLength)
+	// write data chunck.
+	dataLoc := s.getSlotLoc(loc)
+	carry := int64(0)
+	if length%32 > 0 {
+		carry = 1
+	}
+	chunks := length/32 + carry
+	for i := int64(0); i < chunks; i++ {
+		loc = new(big.Int).Add(dataLoc, big.NewInt(i))
+		maxLoc := (i + 1) * 32
+		if maxLoc > length {
+			maxLoc = length
+		}
+		data2 := data[i*32 : maxLoc]
+		// Right pad with zeros
+		for len(data2) < 32 {
+			data2 = append(data2, byte(0))
+		}
+		s.setState(common.BigToHash(loc), common.BytesToHash(data2))
+	}
+}
+
 // struct Node {
 //     address owner;
 //     bytes publicKey;
@@ -470,108 +567,194 @@ type nodeInfo struct {
 }
 
 func (s *StateHelper) nodesLength() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(0))
 }
 func (s *StateHelper) node(index *big.Int) *nodeInfo {
+	node := new(nodeInfo)
+
+	arrayBaseLoc := s.getSlotLoc(big.NewInt(0))
+	elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(index, big.NewInt(3)))
+
+	// owner.
+	loc := elementBaseLoc
+	node.owner = common.BytesToAddress(s.getState(common.BigToHash(elementBaseLoc)).Bytes())
+
+	// publicKey.
+	loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
+	node.publicKey = s.readBytes(loc)
+
+	// staked.
+	loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
+	node.staked = s.getStateBigInt(loc)
+
 	return nil
 }
 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.updateNode(arrayLength, n)
 }
 func (s *StateHelper) updateNode(index *big.Int, n *nodeInfo) {
+	arrayBaseLoc := s.getSlotLoc(big.NewInt(0))
+	elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(index, big.NewInt(3)))
+
+	// owner.
+	loc := elementBaseLoc
+	s.setState(common.BigToHash(loc), n.owner.Hash())
+
+	// publicKey.
+	loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
+	s.writeBytes(loc, n.publicKey)
+
+	// staked.
+	loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
+	s.setStateBigInt(loc, n.staked)
 }
 
 // 1: mapping(address => uint256) public offset;
 func (s *StateHelper) offset(addr common.Address) *big.Int {
-	return nil
+	loc := s.getMapLoc(big.NewInt(1), 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())
+	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())
+	s.setStateBigInt(loc, big.NewInt(0))
 }
 
 // 2: mapping(uint256 => bytes32) public crs;
 func (s *StateHelper) crs(round *big.Int) common.Hash {
-	return common.Hash{}
+	loc := s.getMapLoc(big.NewInt(2), common.BigToHash(round).Bytes())
+	return s.getState(common.BigToHash(loc))
 }
-func (s *StateHelper) putCRS(round *big.Int, crs []byte) common.Hash {
-	return common.Hash{}
+func (s *StateHelper) putCRS(round *big.Int, crs common.Hash) {
+	loc := s.getMapLoc(big.NewInt(2), common.BigToHash(round).Bytes())
+	s.setState(common.BigToHash(loc), crs)
 }
 
 // 3: mapping(uint256 => bytes[]) public DKGMasterPublicKeys;
 func (s *StateHelper) dkgMasterPublicKeys(round *big.Int) [][]byte {
-	return nil
+	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
 }
 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)
 }
 
 // 4: mapping(uint256 => bytes[]) public DKGComplaints;
 func (s *StateHelper) dkgComplaints(round *big.Int) [][]byte {
-	return nil
+	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
 }
 func (s *StateHelper) addDKGComplaint(round *big.Int, complaint []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, complaint)
 }
 
 // 5: uint256 public round;
 func (s *StateHelper) round() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(5))
 }
 func (s *StateHelper) incRound() *big.Int {
-	return nil
+	newRound := new(big.Int).Add(s.round(), big.NewInt(1))
+	s.setStateBigInt(big.NewInt(5), newRound)
+	return newRound
 }
 
 // 6: address public governanceMultisig;
 func (s *StateHelper) governanceMultisig() common.Address {
-	return common.Address{}
+	val := s.getState(common.BigToHash(big.NewInt(6)))
+	return common.BytesToAddress(val.Bytes())
 }
 
 // 7: uint256 public numChains;
 func (s *StateHelper) numChains() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(7))
 }
 
 // 8: uint256 public lambdaBA;
 func (s *StateHelper) lambdaBA() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(8))
 }
 
 // 9: uint256 public lambdaDKG;
 func (s *StateHelper) lambdaDKG() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(9))
 }
 
 // 10: uint256 public k;
 func (s *StateHelper) k() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(10))
 }
 
 // 11: uint256 public phiRatio;  // stored as PhiRatio * 10^6
 func (s *StateHelper) phiRatio() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(11))
 }
 
 // 12: uint256 public numNotarySet;
 func (s *StateHelper) numNotarySet() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(12))
 }
 
 // 13: uint256 public numDKGSet;
 func (s *StateHelper) numDKGSet() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(13))
 }
 
 // 14: uint256 public roundInterval
 func (s *StateHelper) roundInterval() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(14))
 }
 
 // 15: uint256 public minBlockInterval
 func (s *StateHelper) minBlockInterval() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(15))
 }
 
 // 16: uint256 public maxBlockInterval
 func (s *StateHelper) maxBlockInterval() *big.Int {
-	return nil
+	return s.getStateBigInt(big.NewInt(16))
 }
 
 type GovernanceContract struct {
@@ -583,7 +766,7 @@ type GovernanceContract struct {
 func NewGovernanceContract(evm *EVM, contract *Contract) *GovernanceContract {
 	return &GovernanceContract{
 		evm:      evm,
-		state:    StateHelper{evm.StateDB},
+		state:    StateHelper{contract.Address(), evm.StateDB},
 		contract: contract,
 	}
 }
@@ -615,7 +798,7 @@ func (g *GovernanceContract) stake(publicKey []byte) ([]byte, error) {
 func (g *GovernanceContract) unstake() ([]byte, error) {
 	caller := g.contract.Caller()
 	offset := g.state.offset(caller)
-	if offset == nil {
+	if offset.Cmp(big.NewInt(0)) < 0 {
 		return nil, errExecutionReverted
 	}
 
@@ -691,7 +874,7 @@ func (g *GovernanceContract) proposeCRS(round *big.Int, signedCRS []byte) ([]byt
 	// Save new CRS into state and increase round.
 	newCRS := crypto.Keccak256(signedCRS)
 	g.state.incRound()
-	g.state.putCRS(round, newCRS)
+	g.state.putCRS(round, common.BytesToHash(newCRS))
 
 	return nil, nil
 }