mem fixes for vm. Changed uncle inclusion tests

core/block_processor.go

@@ -294,32 +294,38 @@ func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error {
 func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error {
 	reward := new(big.Int).Set(BlockReward)
 
-	knownUncles := set.New()
-	for _, uncle := range parent.Uncles() {
-		knownUncles.Add(string(uncle.Hash()))
+	ancestors := set.New()
+	for _, ancestor := range sm.bc.GetAncestors(block, 6) {
+		ancestors.Add(string(ancestor.Hash()))
 	}
 
-	nonces := ethutil.NewSet(block.Header().Nonce)
+	uncles := set.New()
+	uncles.Add(string(block.Hash()))
 	for _, uncle := range block.Uncles() {
-		if nonces.Include(uncle.Nonce) {
+		if uncles.Has(string(uncle.Hash())) {
 			// Error not unique
 			return UncleError("Uncle not unique")
 		}
+		uncles.Add(string(uncle.Hash()))
 
+		if !ancestors.Has(uncle.ParentHash) {
+			return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
+		}
+
+		/*
 			uncleParent := sm.bc.GetBlock(uncle.ParentHash)
 			if uncleParent == nil {
 				return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
 			}
 
-		if uncleParent.Header().Number.Cmp(new(big.Int).Sub(parent.Header().Number, big.NewInt(6))) < 0 {
+			if uncleParent.Number().Cmp(new(big.Int).Sub(parent.Number(), big.NewInt(6))) < 0 {
 				return UncleError("Uncle too old")
 			}
 
 			if knownUncles.Has(string(uncle.Hash())) {
 				return UncleError("Uncle in chain")
 			}
-
-		nonces.Insert(uncle.Nonce)
+		*/
 
 		r := new(big.Int)
 		r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))

core/chain_manager.go

@@ -262,6 +262,28 @@ func (self *ChainManager) GetBlock(hash []byte) *types.Block {
 	return &block
 }
 
+func (self *ChainManager) GetUnclesInChain(block *types.Block, length int) (uncles []*types.Header) {
+	for i := 0; block != nil && i < length; i++ {
+		uncles = append(uncles, block.Uncles()...)
+		block = self.GetBlock(block.ParentHash())
+	}
+
+	return
+}
+
+func (self *ChainManager) GetAncestors(block *types.Block, length int) (blocks []*types.Block) {
+	for i := 0; i < length; i++ {
+		block = self.GetBlock(block.ParentHash())
+		if block == nil {
+			break
+		}
+
+		blocks = append(blocks, block)
+	}
+
+	return
+}
+
 func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block {
 	self.mu.RLock()
 	defer self.mu.RUnlock()

vm/stack.go

@@ -142,6 +142,10 @@ func (m *Memory) Resize(size uint64) {
 }
 
 func (m *Memory) Get(offset, size int64) []byte {
+	if size == 0 {
+		return nil
+	}
+
 	if len(m.store) > int(offset) {
 		end := int(math.Min(float64(len(m.store)), float64(offset+size)))