diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md
index e69de29bb2..c5a3654bde 100644
--- a/.github/ISSUE_TEMPLATE/bug.md
+++ b/.github/ISSUE_TEMPLATE/bug.md
@@ -0,0 +1,28 @@
+---
+name: Report a bug
+about: Something with go-ethereum is not working as expected
+title: ''
+labels: 'type:bug'
+assignees: ''
+---
+
+#### System information
+
+Geth version: `geth version`
+OS & Version: Windows/Linux/OSX
+Commit hash : (if `develop`)
+
+#### Expected behaviour
+
+
+#### Actual behaviour
+
+
+#### Steps to reproduce the behaviour
+
+
+#### Backtrace
+
+````
+[backtrace]
+````
diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go
index b21d178d3b..b0b8853c43 100644
--- a/accounts/abi/bind/bind_test.go
+++ b/accounts/abi/bind/bind_test.go
@@ -1851,12 +1851,14 @@ func TestGolangBindings(t *testing.T) {
 	if out, err := replacer.CombinedOutput(); err != nil {
 		t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)
 	}
+
 	// Quorum - add package github.com/ConsenSys/quorum/crypto/secp256k1 that is defined as a standalone module
 	secp256Replacer := exec.Command(gocmd, "mod", "edit", "-replace", "github.com/ethereum/go-ethereum/crypto/secp256k1=github.com/ConsenSys/quorum/crypto/secp256k1@v0.0.0-20210223160031-6e8585c2a9ad") // Repo root
 	secp256Replacer.Dir = pkg
 	if out, err := secp256Replacer.CombinedOutput(); err != nil {
 		t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)
 	}
+	// End Quorum
 
 	tidier := exec.Command(gocmd, "mod", "tidy")
 	tidier.Dir = pkg
diff --git a/build/ci.go b/build/ci.go
index 9a2be5addc..69d1e92b9d 100644
--- a/build/ci.go
+++ b/build/ci.go
@@ -115,7 +115,6 @@ var (
 	}
 
 	// A debian package is created for all executables listed here.
-
 	debEthereum = debPackage{
 		Name:        "ethereum",
 		Version:     params.Version,
@@ -137,11 +136,12 @@ var (
 	// Note: disco is unsupported because it was officially deprecated on Launchpad.
 	// Note: eoan is unsupported because it was officially deprecated on Launchpad.
 	debDistroGoBoots = map[string]string{
-		"trusty": "golang-1.11",
-		"xenial": "golang-go",
-		"bionic": "golang-go",
-		"focal":  "golang-go",
-		"groovy": "golang-go",
+		"trusty":  "golang-1.11",
+		"xenial":  "golang-go",
+		"bionic":  "golang-go",
+		"focal":   "golang-go",
+		"groovy":  "golang-go",
+		"hirsute": "golang-go",
 	}
 
 	debGoBootPaths = map[string]string{
@@ -568,16 +568,17 @@ func doDebianSource(cmdline []string) {
 			build.MustRun(debuild)
 
 			var (
-				basename = fmt.Sprintf("%s_%s", meta.Name(), meta.VersionString())
-				source   = filepath.Join(*workdir, basename+".tar.xz")
-				dsc      = filepath.Join(*workdir, basename+".dsc")
-				changes  = filepath.Join(*workdir, basename+"_source.changes")
+				basename  = fmt.Sprintf("%s_%s", meta.Name(), meta.VersionString())
+				source    = filepath.Join(*workdir, basename+".tar.xz")
+				dsc       = filepath.Join(*workdir, basename+".dsc")
+				changes   = filepath.Join(*workdir, basename+"_source.changes")
+				buildinfo = filepath.Join(*workdir, basename+"_source.buildinfo")
 			)
 			if *signer != "" {
 				build.MustRunCommand("debsign", changes)
 			}
 			if *upload != "" {
-				ppaUpload(*workdir, *upload, *sshUser, []string{source, dsc, changes})
+				ppaUpload(*workdir, *upload, *sshUser, []string{source, dsc, changes, buildinfo})
 			}
 		}
 	}
diff --git a/cmd/geth/accountcmd_test.go b/cmd/geth/accountcmd_test.go
index 8a137ba5fd..c47d05e963 100644
--- a/cmd/geth/accountcmd_test.go
+++ b/cmd/geth/accountcmd_test.go
@@ -238,6 +238,7 @@ func TestUnlockFlagWrongPassword(t *testing.T) {
 	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "js", "testdata/empty.js")
+
 	defer geth.ExpectExit()
 	geth.Expect(`
 Unlocking account f466859ead1932d743d622cb74fc058882e8648a | Attempt 1/3
diff --git a/core/forkid/forkid_test.go b/core/forkid/forkid_test.go
index 87d64ed67f..a20598fa9d 100644
--- a/core/forkid/forkid_test.go
+++ b/core/forkid/forkid_test.go
@@ -43,24 +43,26 @@ func TestCreation(t *testing.T) {
 			params.MainnetChainConfig,
 			params.MainnetGenesisHash,
 			[]testcase{
-				{0, ID{Hash: checksumToBytes(0xfc64ec04), Next: 1150000}},       // Unsynced
-				{1149999, ID{Hash: checksumToBytes(0xfc64ec04), Next: 1150000}}, // Last Frontier block
-				{1150000, ID{Hash: checksumToBytes(0x97c2c34c), Next: 1920000}}, // First Homestead block
-				{1919999, ID{Hash: checksumToBytes(0x97c2c34c), Next: 1920000}}, // Last Homestead block
-				{1920000, ID{Hash: checksumToBytes(0x91d1f948), Next: 2463000}}, // First DAO block
-				{2462999, ID{Hash: checksumToBytes(0x91d1f948), Next: 2463000}}, // Last DAO block
-				{2463000, ID{Hash: checksumToBytes(0x7a64da13), Next: 2675000}}, // First Tangerine block
-				{2674999, ID{Hash: checksumToBytes(0x7a64da13), Next: 2675000}}, // Last Tangerine block
-				{2675000, ID{Hash: checksumToBytes(0x3edd5b10), Next: 4370000}}, // First Spurious block
-				{4369999, ID{Hash: checksumToBytes(0x3edd5b10), Next: 4370000}}, // Last Spurious block
-				{4370000, ID{Hash: checksumToBytes(0xa00bc324), Next: 7280000}}, // First Byzantium block
-				{7279999, ID{Hash: checksumToBytes(0xa00bc324), Next: 7280000}}, // Last Byzantium block
-				{7280000, ID{Hash: checksumToBytes(0x668db0af), Next: 9069000}}, // First and last Constantinople, first Petersburg block
-				{9068999, ID{Hash: checksumToBytes(0x668db0af), Next: 9069000}}, // Last Petersburg block
-				{9069000, ID{Hash: checksumToBytes(0x879d6e30), Next: 9200000}}, // First Istanbul and first Muir Glacier block
-				{9199999, ID{Hash: checksumToBytes(0x879d6e30), Next: 9200000}}, // Last Istanbul and first Muir Glacier block
-				{9200000, ID{Hash: checksumToBytes(0xe029e991), Next: 0}},       // First Muir Glacier block
-				{12243999, ID{Hash: checksumToBytes(0xe029e991), Next: 0}},      // Future Muir Glacier block
+				{0, ID{Hash: checksumToBytes(0xfc64ec04), Next: 1150000}},         // Unsynced
+				{1149999, ID{Hash: checksumToBytes(0xfc64ec04), Next: 1150000}},   // Last Frontier block
+				{1150000, ID{Hash: checksumToBytes(0x97c2c34c), Next: 1920000}},   // First Homestead block
+				{1919999, ID{Hash: checksumToBytes(0x97c2c34c), Next: 1920000}},   // Last Homestead block
+				{1920000, ID{Hash: checksumToBytes(0x91d1f948), Next: 2463000}},   // First DAO block
+				{2462999, ID{Hash: checksumToBytes(0x91d1f948), Next: 2463000}},   // Last DAO block
+				{2463000, ID{Hash: checksumToBytes(0x7a64da13), Next: 2675000}},   // First Tangerine block
+				{2674999, ID{Hash: checksumToBytes(0x7a64da13), Next: 2675000}},   // Last Tangerine block
+				{2675000, ID{Hash: checksumToBytes(0x3edd5b10), Next: 4370000}},   // First Spurious block
+				{4369999, ID{Hash: checksumToBytes(0x3edd5b10), Next: 4370000}},   // Last Spurious block
+				{4370000, ID{Hash: checksumToBytes(0xa00bc324), Next: 7280000}},   // First Byzantium block
+				{7279999, ID{Hash: checksumToBytes(0xa00bc324), Next: 7280000}},   // Last Byzantium block
+				{7280000, ID{Hash: checksumToBytes(0x668db0af), Next: 9069000}},   // First and last Constantinople, first Petersburg block
+				{9068999, ID{Hash: checksumToBytes(0x668db0af), Next: 9069000}},   // Last Petersburg block
+				{9069000, ID{Hash: checksumToBytes(0x879d6e30), Next: 9200000}},   // First Istanbul and first Muir Glacier block
+				{9199999, ID{Hash: checksumToBytes(0x879d6e30), Next: 9200000}},   // Last Istanbul and first Muir Glacier block
+				{9200000, ID{Hash: checksumToBytes(0xe029e991), Next: 12244000}},  // First Muir Glacier block
+				{12243999, ID{Hash: checksumToBytes(0xe029e991), Next: 12244000}}, // Last Muir Glacier block
+				{12244000, ID{Hash: checksumToBytes(0x0eb440f6), Next: 0}},        // First Berlin block
+				{20000000, ID{Hash: checksumToBytes(0x0eb440f6), Next: 0}},        // Future Berlin block
 			},
 		},
 		// Ropsten test cases
@@ -80,8 +82,10 @@ func TestCreation(t *testing.T) {
 				{6485845, ID{Hash: checksumToBytes(0xd6e2149b), Next: 6485846}}, // Last Petersburg block
 				{6485846, ID{Hash: checksumToBytes(0x4bc66396), Next: 7117117}}, // First Istanbul block
 				{7117116, ID{Hash: checksumToBytes(0x4bc66396), Next: 7117117}}, // Last Istanbul block
-				{7117117, ID{Hash: checksumToBytes(0x6727ef90), Next: 0}},       // First Muir Glacier block
-				{9812188, ID{Hash: checksumToBytes(0x6727ef90), Next: 0}},       // Future Muir Glacier block
+				{7117117, ID{Hash: checksumToBytes(0x6727ef90), Next: 9812189}}, // First Muir Glacier block
+				{9812188, ID{Hash: checksumToBytes(0x6727ef90), Next: 9812189}}, // Last Muir Glacier block
+				{9812189, ID{Hash: checksumToBytes(0xa157d377), Next: 0}},       // First Berlin block
+				{10000000, ID{Hash: checksumToBytes(0xa157d377), Next: 0}},      // Future Berlin block
 			},
 		},
 		// Rinkeby test cases
@@ -100,8 +104,10 @@ func TestCreation(t *testing.T) {
 				{4321233, ID{Hash: checksumToBytes(0xe49cab14), Next: 4321234}}, // Last Constantinople block
 				{4321234, ID{Hash: checksumToBytes(0xafec6b27), Next: 5435345}}, // First Petersburg block
 				{5435344, ID{Hash: checksumToBytes(0xafec6b27), Next: 5435345}}, // Last Petersburg block
-				{5435345, ID{Hash: checksumToBytes(0xcbdb8838), Next: 0}},       // First Istanbul block
-				{8290927, ID{Hash: checksumToBytes(0xcbdb8838), Next: 0}},       // Future Istanbul block
+				{5435345, ID{Hash: checksumToBytes(0xcbdb8838), Next: 8290928}}, // First Istanbul block
+				{8290927, ID{Hash: checksumToBytes(0xcbdb8838), Next: 8290928}}, // Last Istanbul block
+				{8290928, ID{Hash: checksumToBytes(0x6910c8bd), Next: 0}},       // First Berlin block
+				{10000000, ID{Hash: checksumToBytes(0x6910c8bd), Next: 0}},      // Future Berlin block
 			},
 		},
 		// Goerli test cases
@@ -111,8 +117,10 @@ func TestCreation(t *testing.T) {
 			[]testcase{
 				{0, ID{Hash: checksumToBytes(0xa3f5ab08), Next: 1561651}},       // Unsynced, last Frontier, Homestead, Tangerine, Spurious, Byzantium, Constantinople and first Petersburg block
 				{1561650, ID{Hash: checksumToBytes(0xa3f5ab08), Next: 1561651}}, // Last Petersburg block
-				{1561651, ID{Hash: checksumToBytes(0xc25efa5c), Next: 0}},       // First Istanbul block
-				{4460643, ID{Hash: checksumToBytes(0xc25efa5c), Next: 0}},       // Future Istanbul block
+				{1561651, ID{Hash: checksumToBytes(0xc25efa5c), Next: 4460644}}, // First Istanbul block
+				{4460643, ID{Hash: checksumToBytes(0xc25efa5c), Next: 4460644}}, // Last Istanbul block
+				{4460644, ID{Hash: checksumToBytes(0x757a1c47), Next: 0}},       // First Berlin block
+				{5000000, ID{Hash: checksumToBytes(0x757a1c47), Next: 0}},       // Future Berlin block
 			},
 		},
 	}
@@ -185,7 +193,7 @@ func TestValidation(t *testing.T) {
 		// Local is mainnet Petersburg, remote is Rinkeby Petersburg.
 		{7987396, ID{Hash: checksumToBytes(0xafec6b27), Next: 0}, ErrLocalIncompatibleOrStale},
 
-		// Local is mainnet Istanbul, far in the future. Remote announces Gopherium (non existing fork)
+		// Local is mainnet Berlin, far in the future. Remote announces Gopherium (non existing fork)
 		// at some future block 88888888, for itself, but past block for local. Local is incompatible.
 		//
 		// This case detects non-upgraded nodes with majority hash power (typical Ropsten mess).
diff --git a/core/state/statedb.go b/core/state/statedb.go
index 27b6b08a39..5f51096ffa 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -819,19 +819,19 @@ func (s *StateDB) Copy() *StateDB {
 
 	// Copy all the basic fields, initialize the memory ones
 	state := &StateDB{
-		db:   s.db,
-		trie: s.db.CopyTrie(s.trie),
+		db:                  s.db,
+		trie:                s.db.CopyTrie(s.trie),
+		stateObjects:        make(map[common.Address]*stateObject, size),
+		stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)),
+		stateObjectsDirty:   make(map[common.Address]struct{}, size),
+		refund:              s.refund,
+		logs:                make(map[common.Hash][]*types.Log, len(s.logs)),
+		logSize:             s.logSize,
+		preimages:           make(map[common.Hash][]byte, len(s.preimages)),
+		journal:             newJournal(),
+		hasher:              crypto.NewKeccakState(),
 		// Quorum - Privacy Enhancements
 		accountExtraDataTrie: s.db.CopyTrie(s.accountExtraDataTrie),
-		stateObjects:         make(map[common.Address]*stateObject, size),
-		stateObjectsPending:  make(map[common.Address]struct{}, len(s.stateObjectsPending)),
-		stateObjectsDirty:    make(map[common.Address]struct{}, size),
-		refund:               s.refund,
-		logs:                 make(map[common.Hash][]*types.Log, len(s.logs)),
-		logSize:              s.logSize,
-		preimages:            make(map[common.Hash][]byte, len(s.preimages)),
-		journal:              newJournal(),
-		hasher:               crypto.NewKeccakState(),
 	}
 
 	s.mutex.Lock()
diff --git a/core/state/trie_prefetcher.go b/core/state/trie_prefetcher.go
index 6a9552b05e..ce53eb6064 100644
--- a/core/state/trie_prefetcher.go
+++ b/core/state/trie_prefetcher.go
@@ -127,7 +127,7 @@ func (p *triePrefetcher) copy() *triePrefetcher {
 	// If the prefetcher is already a copy, duplicate the data
 	if p.fetches != nil {
 		for root, fetch := range p.fetches {
-			if nil != fetch {
+			if fetch != nil {
 				copy.fetches[root] = p.db.CopyTrie(fetch)
 			}
 		}
diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go
index b0df350b7e..f81f45e3a6 100644
--- a/core/state_prefetcher.go
+++ b/core/state_prefetcher.go
@@ -21,15 +21,16 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/ethereum/go-ethereum/core/mps"
-	"github.com/ethereum/go-ethereum/private"
-
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/params"
+
+	// Quorum
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/mps"
+	"github.com/ethereum/go-ethereum/private"
 )
 
 // statePrefetcher is a basic Prefetcher, which blindly executes a block on top
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 2e63402ff8..2f01a7cb31 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -550,7 +550,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if sizeLimit == 0 {
 		sizeLimit = DefaultTxPoolConfig.TransactionSizeLimit
 	}
-	// Reject transactions over 64KB (or manually set limit) to prevent DOS attacks
+	// Reject transactions over defined size to prevent DOS attacks
 	if float64(tx.Size()) > float64(sizeLimit*1024) {
 		return ErrOversizedData
 	}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 8e9c834e8a..9384bab35c 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -87,20 +87,6 @@ type TxData interface {
 	setSignatureValues(chainID, v, r, s *big.Int)
 }
 
-// Quorum
-
-func NewTxPrivacyMetadata(privacyFlag engine.PrivacyFlagType) *PrivacyMetadata {
-	return &PrivacyMetadata{
-		PrivacyFlag: privacyFlag,
-	}
-}
-
-func (tx *Transaction) SetTxPrivacyMetadata(pm *PrivacyMetadata) {
-	tx.privacyMetadata = pm
-}
-
-// End Quorum
-
 // EncodeRLP implements rlp.Encoder
 func (tx *Transaction) EncodeRLP(w io.Writer) error {
 	if tx.Type() == LegacyTxType {
@@ -186,6 +172,19 @@ func (tx *Transaction) UnmarshalBinary(b []byte) error {
 	return nil
 }
 
+// Quorum
+func NewTxPrivacyMetadata(privacyFlag engine.PrivacyFlagType) *PrivacyMetadata {
+	return &PrivacyMetadata{
+		PrivacyFlag: privacyFlag,
+	}
+}
+
+func (tx *Transaction) SetTxPrivacyMetadata(pm *PrivacyMetadata) {
+	tx.privacyMetadata = pm
+}
+
+// End Quorum
+
 // decodeTyped decodes a typed transaction from the canonical format.
 func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
 	if len(b) == 0 {
@@ -285,6 +284,7 @@ func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value
 // Nonce returns the sender account nonce of the transaction.
 func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
 
+// PrivacyMetadata returns the privacy metadata of the transaction. (Quorum)
 func (tx *Transaction) PrivacyMetadata() *PrivacyMetadata { return tx.privacyMetadata }
 
 // To returns the recipient address of the transaction.
@@ -322,6 +322,7 @@ func (tx *Transaction) GasPriceIntCmp(other *big.Int) int {
 	return tx.inner.gasPrice().Cmp(other)
 }
 
+// From returns the sender address of the transaction. (Quorum)
 func (tx *Transaction) From() common.Address {
 	if from, err := Sender(NewEIP2930Signer(tx.ChainId()), tx); err == nil {
 		return from
@@ -369,6 +370,7 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
 	return &Transaction{inner: cpy, time: tx.time}, nil
 }
 
+// String returns the string representation of the transaction. (Quorum)
 func (tx *Transaction) String() string {
 	var from, to string
 	v, r, s := tx.RawSignatureValues()
@@ -599,7 +601,8 @@ func (tx *Transaction) AsMessage(s Signer) (Message, error) {
 		data:       tx.Data(),
 		accessList: tx.AccessList(),
 		checkNonce: true,
-		isPrivate:  tx.IsPrivate(),
+		// Quorum
+		isPrivate: tx.IsPrivate(),
 	}
 
 	var err error
diff --git a/core/vm/contract.go b/core/vm/contract.go
index 915193d137..61dbd5007a 100644
--- a/core/vm/contract.go
+++ b/core/vm/contract.go
@@ -96,19 +96,6 @@ func (c *Contract) validJumpdest(dest *uint256.Int) bool {
 	return c.isCode(udest)
 }
 
-func (c *Contract) validJumpSubdest(udest uint64) bool {
-	// PC cannot go beyond len(code) and certainly can't be bigger than 63 bits.
-	// Don't bother checking for BEGINSUB in that case.
-	if int64(udest) < 0 || udest >= uint64(len(c.Code)) {
-		return false
-	}
-	// Only BEGINSUBs allowed for destinations
-	if OpCode(c.Code[udest]) != BEGINSUB {
-		return false
-	}
-	return c.isCode(udest)
-}
-
 // isCode returns true if the provided PC location is an actual opcode, as
 // opposed to a data-segment following a PUSHN operation.
 func (c *Contract) isCode(udest uint64) bool {
diff --git a/core/vm/eips.go b/core/vm/eips.go
index 962c0f14b1..0c8bf1792e 100644
--- a/core/vm/eips.go
+++ b/core/vm/eips.go
@@ -29,7 +29,6 @@ var activators = map[int]func(*JumpTable){
 	2200: enable2200,
 	1884: enable1884,
 	1344: enable1344,
-	2315: enable2315,
 }
 
 // EnableEIP enables the given EIP on the config.
@@ -108,34 +107,6 @@ func enable2200(jt *JumpTable) {
 	jt[SSTORE].dynamicGas = gasSStoreEIP2200
 }
 
-// enable2315 applies EIP-2315 (Simple Subroutines)
-// - Adds opcodes that jump to and return from subroutines
-func enable2315(jt *JumpTable) {
-	// New opcode
-	jt[BEGINSUB] = &operation{
-		execute:     opBeginSub,
-		constantGas: GasQuickStep,
-		minStack:    minStack(0, 0),
-		maxStack:    maxStack(0, 0),
-	}
-	// New opcode
-	jt[JUMPSUB] = &operation{
-		execute:     opJumpSub,
-		constantGas: GasSlowStep,
-		minStack:    minStack(1, 0),
-		maxStack:    maxStack(1, 0),
-		jumps:       true,
-	}
-	// New opcode
-	jt[RETURNSUB] = &operation{
-		execute:     opReturnSub,
-		constantGas: GasFastStep,
-		minStack:    minStack(0, 0),
-		maxStack:    maxStack(0, 0),
-		jumps:       true,
-	}
-}
-
 // enable2929 enables "EIP-2929: Gas cost increases for state access opcodes"
 // https://eips.ethereum.org/EIPS/eip-2929
 func enable2929(jt *JumpTable) {
diff --git a/core/vm/evm.go b/core/vm/evm.go
index 888f04d804..6680d56354 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -616,7 +616,7 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 	if evm.chainRules.IsEIP158 {
 		evm.StateDB.SetNonce(address, 1)
 	}
-	if nil != evm.currentTx && evm.currentTx.IsPrivate() && evm.currentTx.PrivacyMetadata() != nil {
+	if evm.currentTx != nil && evm.currentTx.IsPrivate() && evm.currentTx.PrivacyMetadata() != nil {
 		// for calls (reading contract state) or finding the affected contracts there is no transaction
 		if evm.currentTx.PrivacyMetadata().PrivacyFlag.IsNotStandardPrivate() {
 			pm := state.NewStatePrivacyMetadata(common.BytesToEncryptedPayloadHash(evm.currentTx.Data()), evm.currentTx.PrivacyMetadata().PrivacyFlag)
diff --git a/core/vm/gen_structlog.go b/core/vm/gen_structlog.go
index 44da014de9..ac04afe8b7 100644
--- a/core/vm/gen_structlog.go
+++ b/core/vm/gen_structlog.go
@@ -45,12 +45,6 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 			enc.Stack[k] = (*math.HexOrDecimal256)(v)
 		}
 	}
-	if s.ReturnStack != nil {
-		enc.ReturnStack = make([]math.HexOrDecimal64, len(s.ReturnStack))
-		for k, v := range s.ReturnStack {
-			enc.ReturnStack[k] = math.HexOrDecimal64(v)
-		}
-	}
 	enc.ReturnData = s.ReturnData
 	enc.Storage = s.Storage
 	enc.Depth = s.Depth
@@ -71,7 +65,6 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		Memory        *hexutil.Bytes              `json:"memory"`
 		MemorySize    *int                        `json:"memSize"`
 		Stack         []*math.HexOrDecimal256     `json:"stack"`
-		ReturnStack   []math.HexOrDecimal64       `json:"returnStack"`
 		ReturnData    *hexutil.Bytes              `json:"returnData"`
 		Storage       map[common.Hash]common.Hash `json:"-"`
 		Depth         *int                        `json:"depth"`
@@ -106,12 +99,6 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 			s.Stack[k] = (*big.Int)(v)
 		}
 	}
-	if dec.ReturnStack != nil {
-		s.ReturnStack = make([]uint32, len(dec.ReturnStack))
-		for k, v := range dec.ReturnStack {
-			s.ReturnStack[k] = uint32(v)
-		}
-	}
 	if dec.ReturnData != nil {
 		s.ReturnData = *dec.ReturnData
 	}
diff --git a/core/vm/instructions.go b/core/vm/instructions.go
index 8c4f6a2584..831737a30f 100644
--- a/core/vm/instructions.go
+++ b/core/vm/instructions.go
@@ -555,38 +555,6 @@ func opJumpdest(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) (
 	return nil, nil
 }
 
-func opBeginSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
-	return nil, ErrInvalidSubroutineEntry
-}
-
-func opJumpSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
-	if len(callContext.rstack.data) >= 1023 {
-		return nil, ErrReturnStackExceeded
-	}
-	pos := callContext.stack.pop()
-	if !pos.IsUint64() {
-		return nil, ErrInvalidJump
-	}
-	posU64 := pos.Uint64()
-	if !callContext.contract.validJumpSubdest(posU64) {
-		return nil, ErrInvalidJump
-	}
-	callContext.rstack.push(uint32(*pc))
-	*pc = posU64 + 1
-	return nil, nil
-}
-
-func opReturnSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
-	if len(callContext.rstack.data) == 0 {
-		return nil, ErrInvalidRetsub
-	}
-	// Other than the check that the return stack is not empty, there is no
-	// need to validate the pc from 'returns', since we only ever push valid
-	//values onto it via jumpsub.
-	*pc = uint64(callContext.rstack.pop()) + 1
-	return nil, nil
-}
-
 func opPc(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 	callContext.stack.push(new(uint256.Int).SetUint64(*pc))
 	return nil, nil
diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go
index c467dad40c..8b4a3bab5a 100644
--- a/core/vm/instructions_test.go
+++ b/core/vm/instructions_test.go
@@ -94,7 +94,6 @@ func testTwoOperandOp(t *testing.T, tests []TwoOperandTestcase, opFn executionFu
 	var (
 		env            = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
 		stack          = newstack()
-		rstack         = newReturnStack()
 		pc             = uint64(0)
 		evmInterpreter = env.interpreter.(*EVMInterpreter)
 	)
@@ -105,7 +104,7 @@ func testTwoOperandOp(t *testing.T, tests []TwoOperandTestcase, opFn executionFu
 		expected := new(uint256.Int).SetBytes(common.Hex2Bytes(test.Expected))
 		stack.push(x)
 		stack.push(y)
-		opFn(&pc, evmInterpreter, &callCtx{nil, stack, rstack, nil})
+		opFn(&pc, evmInterpreter, &callCtx{nil, stack, nil})
 		if len(stack.data) != 1 {
 			t.Errorf("Expected one item on stack after %v, got %d: ", name, len(stack.data))
 		}
@@ -220,7 +219,7 @@ func TestAddMod(t *testing.T) {
 		stack.push(z)
 		stack.push(y)
 		stack.push(x)
-		opAddmod(&pc, evmInterpreter, &callCtx{nil, stack, nil, nil})
+		opAddmod(&pc, evmInterpreter, &callCtx{nil, stack, nil})
 		actual := stack.pop()
 		if actual.Cmp(expected) != 0 {
 			t.Errorf("Testcase %d, expected  %x, got %x", i, expected, actual)
@@ -231,10 +230,10 @@ func TestAddMod(t *testing.T) {
 // getResult is a convenience function to generate the expected values
 func getResult(args []*twoOperandParams, opFn executionFunc) []TwoOperandTestcase {
 	var (
-		env           = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
-		stack, rstack = newstack(), newReturnStack()
-		pc            = uint64(0)
-		interpreter   = env.interpreter.(*EVMInterpreter)
+		env         = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
+		stack       = newstack()
+		pc          = uint64(0)
+		interpreter = env.interpreter.(*EVMInterpreter)
 	)
 	result := make([]TwoOperandTestcase, len(args))
 	for i, param := range args {
@@ -242,7 +241,7 @@ func getResult(args []*twoOperandParams, opFn executionFunc) []TwoOperandTestcas
 		y := new(uint256.Int).SetBytes(common.Hex2Bytes(param.y))
 		stack.push(x)
 		stack.push(y)
-		opFn(&pc, interpreter, &callCtx{nil, stack, rstack, nil})
+		opFn(&pc, interpreter, &callCtx{nil, stack, nil})
 		actual := stack.pop()
 		result[i] = TwoOperandTestcase{param.x, param.y, fmt.Sprintf("%064x", actual)}
 	}
@@ -282,7 +281,7 @@ func TestJsonTestcases(t *testing.T) {
 func opBenchmark(bench *testing.B, op executionFunc, args ...string) {
 	var (
 		env            = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
-		stack, rstack  = newstack(), newReturnStack()
+		stack          = newstack()
 		evmInterpreter = NewEVMInterpreter(env, env.vmConfig)
 	)
 
@@ -300,7 +299,7 @@ func opBenchmark(bench *testing.B, op executionFunc, args ...string) {
 			a.SetBytes(arg)
 			stack.push(a)
 		}
-		op(&pc, evmInterpreter, &callCtx{nil, stack, rstack, nil})
+		op(&pc, evmInterpreter, &callCtx{nil, stack, nil})
 		stack.pop()
 	}
 }
@@ -516,7 +515,7 @@ func BenchmarkOpIsZero(b *testing.B) {
 func TestOpMstore(t *testing.T) {
 	var (
 		env            = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
-		stack, rstack  = newstack(), newReturnStack()
+		stack          = newstack()
 		mem            = NewMemory()
 		evmInterpreter = NewEVMInterpreter(env, env.vmConfig)
 	)
@@ -526,12 +525,12 @@ func TestOpMstore(t *testing.T) {
 	pc := uint64(0)
 	v := "abcdef00000000000000abba000000000deaf000000c0de00100000000133700"
 	stack.pushN(*new(uint256.Int).SetBytes(common.Hex2Bytes(v)), *new(uint256.Int))
-	opMstore(&pc, evmInterpreter, &callCtx{mem, stack, rstack, nil})
+	opMstore(&pc, evmInterpreter, &callCtx{mem, stack, nil})
 	if got := common.Bytes2Hex(mem.GetCopy(0, 32)); got != v {
 		t.Fatalf("Mstore fail, got %v, expected %v", got, v)
 	}
 	stack.pushN(*new(uint256.Int).SetUint64(0x1), *new(uint256.Int))
-	opMstore(&pc, evmInterpreter, &callCtx{mem, stack, rstack, nil})
+	opMstore(&pc, evmInterpreter, &callCtx{mem, stack, nil})
 	if common.Bytes2Hex(mem.GetCopy(0, 32)) != "0000000000000000000000000000000000000000000000000000000000000001" {
 		t.Fatalf("Mstore failed to overwrite previous value")
 	}
@@ -540,7 +539,7 @@ func TestOpMstore(t *testing.T) {
 func BenchmarkOpMstore(bench *testing.B) {
 	var (
 		env            = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
-		stack, rstack  = newstack(), newReturnStack()
+		stack          = newstack()
 		mem            = NewMemory()
 		evmInterpreter = NewEVMInterpreter(env, env.vmConfig)
 	)
@@ -554,14 +553,14 @@ func BenchmarkOpMstore(bench *testing.B) {
 	bench.ResetTimer()
 	for i := 0; i < bench.N; i++ {
 		stack.pushN(*value, *memStart)
-		opMstore(&pc, evmInterpreter, &callCtx{mem, stack, rstack, nil})
+		opMstore(&pc, evmInterpreter, &callCtx{mem, stack, nil})
 	}
 }
 
 func BenchmarkOpSHA3(bench *testing.B) {
 	var (
 		env            = NewEVM(BlockContext{}, TxContext{}, nil, nil, params.TestChainConfig, Config{})
-		stack, rstack  = newstack(), newReturnStack()
+		stack          = newstack()
 		mem            = NewMemory()
 		evmInterpreter = NewEVMInterpreter(env, env.vmConfig)
 	)
@@ -573,7 +572,7 @@ func BenchmarkOpSHA3(bench *testing.B) {
 	bench.ResetTimer()
 	for i := 0; i < bench.N; i++ {
 		stack.pushN(*uint256.NewInt().SetUint64(32), *start)
-		opSha3(&pc, evmInterpreter, &callCtx{mem, stack, rstack, nil})
+		opSha3(&pc, evmInterpreter, &callCtx{mem, stack, nil})
 	}
 }
 
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index fae34258a3..06fd38ac5b 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -71,7 +71,6 @@ type Interpreter interface {
 type callCtx struct {
 	memory   *Memory
 	stack    *Stack
-	rstack   *ReturnStack
 	contract *Contract
 }
 
@@ -165,14 +164,12 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 	}
 
 	var (
-		op          OpCode             // current opcode
-		mem         = NewMemory()      // bound memory
-		stack       = newstack()       // local stack
-		returns     = newReturnStack() // local returns stack
+		op          OpCode        // current opcode
+		mem         = NewMemory() // bound memory
+		stack       = newstack()  // local stack
 		callContext = &callCtx{
 			memory:   mem,
 			stack:    stack,
-			rstack:   returns,
 			contract: contract,
 		}
 		// For optimisation reason we're using uint64 as the program counter.
@@ -191,7 +188,6 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 	// they are returned to the pools
 	defer func() {
 		returnStack(stack)
-		returnRStack(returns)
 	}()
 	contract.Input = input
 
@@ -199,9 +195,9 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		defer func() {
 			if err != nil {
 				if !logged {
-					in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, returns, in.returnData, contract, in.evm.depth, err)
+					in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, in.returnData, contract, in.evm.depth, err)
 				} else {
-					in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, returns, contract, in.evm.depth, err)
+					in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
 				}
 			}
 		}()
@@ -287,7 +283,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		}
 
 		if in.cfg.Debug {
-			in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stack, returns, in.returnData, contract, in.evm.depth, err)
+			in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stack, in.returnData, contract, in.evm.depth, err)
 			logged = true
 		}
 
diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go
index d831f9300f..7b61762456 100644
--- a/core/vm/jump_table.go
+++ b/core/vm/jump_table.go
@@ -66,7 +66,6 @@ type JumpTable [256]*operation
 // contantinople, istanbul, petersburg and berlin instructions.
 func newBerlinInstructionSet() JumpTable {
 	instructionSet := newIstanbulInstructionSet()
-	enable2315(&instructionSet) // Subroutines - https://eips.ethereum.org/EIPS/eip-2315
 	enable2929(&instructionSet) // Access lists for trie accesses https://eips.ethereum.org/EIPS/eip-2929
 	return instructionSet
 }
diff --git a/core/vm/logger.go b/core/vm/logger.go
index 962be6ec8e..41ce00ed01 100644
--- a/core/vm/logger.go
+++ b/core/vm/logger.go
@@ -70,7 +70,6 @@ type StructLog struct {
 	Memory        []byte                      `json:"memory"`
 	MemorySize    int                         `json:"memSize"`
 	Stack         []*big.Int                  `json:"stack"`
-	ReturnStack   []uint32                    `json:"returnStack"`
 	ReturnData    []byte                      `json:"returnData"`
 	Storage       map[common.Hash]common.Hash `json:"-"`
 	Depth         int                         `json:"depth"`
@@ -81,7 +80,6 @@ type StructLog struct {
 // overrides for gencodec
 type structLogMarshaling struct {
 	Stack       []*math.HexOrDecimal256
-	ReturnStack []math.HexOrDecimal64
 	Gas         math.HexOrDecimal64
 	GasCost     math.HexOrDecimal64
 	Memory      hexutil.Bytes
@@ -110,8 +108,8 @@ func (s *StructLog) ErrorString() string {
 // if you need to retain them beyond the current call.
 type Tracer interface {
 	CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error
-	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error
-	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error
+	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rData []byte, contract *Contract, depth int, err error) error
+	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
 	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
 }
 
@@ -148,7 +146,7 @@ func (l *StructLogger) CaptureStart(from common.Address, to common.Address, crea
 // CaptureState logs a new structured log message and pushes it out to the environment
 //
 // CaptureState also tracks SLOAD/SSTORE ops to track storage change.
-func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
+func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rData []byte, contract *Contract, depth int, err error) error {
 	// check if already accumulated the specified number of logs
 	if l.cfg.Limit != 0 && l.cfg.Limit <= len(l.logs) {
 		return errTraceLimitReached
@@ -167,11 +165,6 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 			stck[i] = new(big.Int).Set(item.ToBig())
 		}
 	}
-	var rstack []uint32
-	if !l.cfg.DisableStack && rStack != nil {
-		rstck := make([]uint32, len(rStack.data))
-		copy(rstck, rStack.data)
-	}
 	// Copy a snapshot of the current storage to a new container
 	var storage Storage
 	if !l.cfg.DisableStorage {
@@ -204,14 +197,14 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 		copy(rdata, rData)
 	}
 	// create a new snapshot of the EVM.
-	log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, rstack, rdata, storage, depth, env.StateDB.GetRefund(), err}
+	log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, rdata, storage, depth, env.StateDB.GetRefund(), err}
 	l.logs = append(l.logs, log)
 	return nil
 }
 
 // CaptureFault implements the Tracer interface to trace an execution fault
 // while running an opcode.
-func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
+func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
 	return nil
 }
 
@@ -252,12 +245,6 @@ func WriteTrace(writer io.Writer, logs []StructLog) {
 				fmt.Fprintf(writer, "%08d  %x\n", len(log.Stack)-i-1, math.PaddedBigBytes(log.Stack[i], 32))
 			}
 		}
-		if len(log.ReturnStack) > 0 {
-			fmt.Fprintln(writer, "ReturnStack:")
-			for i := len(log.Stack) - 1; i >= 0; i-- {
-				fmt.Fprintf(writer, "%08d  0x%x (%d)\n", len(log.Stack)-i-1, log.ReturnStack[i], log.ReturnStack[i])
-			}
-		}
 		if len(log.Memory) > 0 {
 			fmt.Fprintln(writer, "Memory:")
 			fmt.Fprint(writer, hex.Dump(log.Memory))
@@ -323,7 +310,7 @@ func (t *mdLogger) CaptureStart(from common.Address, to common.Address, create b
 	return nil
 }
 
-func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
+func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rData []byte, contract *Contract, depth int, err error) error {
 	fmt.Fprintf(t.out, "| %4d  | %10v  |  %3d |", pc, op, cost)
 
 	if !t.cfg.DisableStack {
@@ -334,14 +321,6 @@ func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64
 		}
 		b := fmt.Sprintf("[%v]", strings.Join(a, ","))
 		fmt.Fprintf(t.out, "%10v |", b)
-
-		// format return stack
-		a = a[:0]
-		for _, elem := range rStack.data {
-			a = append(a, fmt.Sprintf("%2d", elem))
-		}
-		b = fmt.Sprintf("[%v]", strings.Join(a, ","))
-		fmt.Fprintf(t.out, "%10v |", b)
 	}
 	fmt.Fprintf(t.out, "%10v |", env.StateDB.GetRefund())
 	fmt.Fprintln(t.out, "")
@@ -351,7 +330,7 @@ func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64
 	return nil
 }
 
-func (t *mdLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
+func (t *mdLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
 
 	fmt.Fprintf(t.out, "\nError: at pc=%d, op=%v: %v\n", pc, op, err)
 
diff --git a/core/vm/logger_json.go b/core/vm/logger_json.go
index 5f3f2c42f7..a27c261ed8 100644
--- a/core/vm/logger_json.go
+++ b/core/vm/logger_json.go
@@ -46,7 +46,7 @@ func (l *JSONLogger) CaptureStart(from common.Address, to common.Address, create
 }
 
 // CaptureState outputs state information on the logger.
-func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
+func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rData []byte, contract *Contract, depth int, err error) error {
 	log := StructLog{
 		Pc:            pc,
 		Op:            op,
@@ -68,7 +68,6 @@ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint
 			logstack[i] = item.ToBig()
 		}
 		log.Stack = logstack
-		log.ReturnStack = rStack.data
 	}
 	if !l.cfg.DisableReturnData {
 		log.ReturnData = rData
@@ -77,7 +76,7 @@ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint
 }
 
 // CaptureFault outputs state information on the logger.
-func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
+func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
 	return nil
 }
 
diff --git a/core/vm/logger_test.go b/core/vm/logger_test.go
index 774c07d1f4..e6be238f08 100644
--- a/core/vm/logger_test.go
+++ b/core/vm/logger_test.go
@@ -56,13 +56,12 @@ func TestStoreCapture(t *testing.T) {
 		logger   = NewStructLogger(nil)
 		mem      = NewMemory()
 		stack    = newstack()
-		rstack   = newReturnStack()
 		contract = NewContract(&dummyContractRef{}, &dummyContractRef{}, new(big.Int), 0)
 	)
 	stack.push(uint256.NewInt().SetUint64(1))
 	stack.push(uint256.NewInt())
 	var index common.Hash
-	logger.CaptureState(env, 0, SSTORE, 0, 0, mem, stack, rstack, nil, contract, 0, nil)
+	logger.CaptureState(env, 0, SSTORE, 0, 0, mem, stack, nil, contract, 0, nil)
 	if len(logger.storage[contract.Address()]) == 0 {
 		t.Fatalf("expected exactly 1 changed value on address %x, got %d", contract.Address(), len(logger.storage[contract.Address()]))
 	}
diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go
index da7b2ee4aa..b0adf37d0c 100644
--- a/core/vm/opcodes.go
+++ b/core/vm/opcodes.go
@@ -107,21 +107,18 @@ const (
 
 // 0x50 range - 'storage' and execution.
 const (
-	POP       OpCode = 0x50
-	MLOAD     OpCode = 0x51
-	MSTORE    OpCode = 0x52
-	MSTORE8   OpCode = 0x53
-	SLOAD     OpCode = 0x54
-	SSTORE    OpCode = 0x55
-	JUMP      OpCode = 0x56
-	JUMPI     OpCode = 0x57
-	PC        OpCode = 0x58
-	MSIZE     OpCode = 0x59
-	GAS       OpCode = 0x5a
-	JUMPDEST  OpCode = 0x5b
-	BEGINSUB  OpCode = 0x5c
-	RETURNSUB OpCode = 0x5d
-	JUMPSUB   OpCode = 0x5e
+	POP      OpCode = 0x50
+	MLOAD    OpCode = 0x51
+	MSTORE   OpCode = 0x52
+	MSTORE8  OpCode = 0x53
+	SLOAD    OpCode = 0x54
+	SSTORE   OpCode = 0x55
+	JUMP     OpCode = 0x56
+	JUMPI    OpCode = 0x57
+	PC       OpCode = 0x58
+	MSIZE    OpCode = 0x59
+	GAS      OpCode = 0x5a
+	JUMPDEST OpCode = 0x5b
 )
 
 // 0x60 range.
@@ -300,10 +297,6 @@ var opCodeToString = map[OpCode]string{
 	GAS:      "GAS",
 	JUMPDEST: "JUMPDEST",
 
-	BEGINSUB:  "BEGINSUB",
-	JUMPSUB:   "JUMPSUB",
-	RETURNSUB: "RETURNSUB",
-
 	// 0x60 range - push.
 	PUSH1:  "PUSH1",
 	PUSH2:  "PUSH2",
@@ -468,9 +461,6 @@ var stringToOp = map[string]OpCode{
 	"MSIZE":          MSIZE,
 	"GAS":            GAS,
 	"JUMPDEST":       JUMPDEST,
-	"BEGINSUB":       BEGINSUB,
-	"RETURNSUB":      RETURNSUB,
-	"JUMPSUB":        JUMPSUB,
 	"PUSH1":          PUSH1,
 	"PUSH2":          PUSH2,
 	"PUSH3":          PUSH3,
diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go
index b90a3543f2..732e7214b9 100644
--- a/core/vm/runtime/runtime_test.go
+++ b/core/vm/runtime/runtime_test.go
@@ -351,14 +351,14 @@ func (s *stepCounter) CaptureStart(from common.Address, to common.Address, creat
 	return nil
 }
 
-func (s *stepCounter) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, rData []byte, contract *vm.Contract, depth int, err error) error {
+func (s *stepCounter) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rData []byte, contract *vm.Contract, depth int, err error) error {
 	s.steps++
 	// Enable this for more output
 	//s.inner.CaptureState(env, pc, op, gas, cost, memory, stack, rStack, contract, depth, err)
 	return nil
 }
 
-func (s *stepCounter) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, contract *vm.Contract, depth int, err error) error {
+func (s *stepCounter) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error {
 	return nil
 }
 
@@ -366,227 +366,6 @@ func (s *stepCounter) CaptureEnd(output []byte, gasUsed uint64, t time.Duration,
 	return nil
 }
 
-func TestJumpSub1024Limit(t *testing.T) {
-	state, _ := state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
-	address := common.HexToAddress("0x0a")
-	// Code is
-	// 0 beginsub
-	// 1 push 0
-	// 3 jumpsub
-	//
-	// The code recursively calls itself. It should error when the returns-stack
-	// grows above 1023
-	state.SetCode(address, []byte{
-		byte(vm.PUSH1), 3,
-		byte(vm.JUMPSUB),
-		byte(vm.BEGINSUB),
-		byte(vm.PUSH1), 3,
-		byte(vm.JUMPSUB),
-	})
-	tracer := stepCounter{inner: vm.NewJSONLogger(nil, os.Stdout)}
-	// Enable 2315
-	_, _, err := Call(address, nil, &Config{State: state,
-		GasLimit:    20000,
-		ChainConfig: params.AllEthashProtocolChanges,
-		EVMConfig: vm.Config{
-			ExtraEips: []int{2315},
-			Debug:     true,
-			//Tracer:    vm.NewJSONLogger(nil, os.Stdout),
-			Tracer: &tracer,
-		}})
-	exp := "return stack limit reached"
-	if err.Error() != exp {
-		t.Fatalf("expected %v, got %v", exp, err)
-	}
-	if exp, got := 2048, tracer.steps; exp != got {
-		t.Fatalf("expected %d steps, got %d", exp, got)
-	}
-}
-
-func TestReturnSubShallow(t *testing.T) {
-	state, _ := state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
-	address := common.HexToAddress("0x0a")
-	// The code does returnsub without having anything on the returnstack.
-	// It should not panic, but just fail after one step
-	state.SetCode(address, []byte{
-		byte(vm.PUSH1), 5,
-		byte(vm.JUMPSUB),
-		byte(vm.RETURNSUB),
-		byte(vm.PC),
-		byte(vm.BEGINSUB),
-		byte(vm.RETURNSUB),
-		byte(vm.PC),
-	})
-	tracer := stepCounter{}
-
-	// Enable 2315
-	_, _, err := Call(address, nil, &Config{State: state,
-		GasLimit:    10000,
-		ChainConfig: params.AllEthashProtocolChanges,
-		EVMConfig: vm.Config{
-			ExtraEips: []int{2315},
-			Debug:     true,
-			Tracer:    &tracer,
-		}})
-
-	exp := "invalid retsub"
-	if err.Error() != exp {
-		t.Fatalf("expected %v, got %v", exp, err)
-	}
-	if exp, got := 4, tracer.steps; exp != got {
-		t.Fatalf("expected %d steps, got %d", exp, got)
-	}
-}
-
-// disabled -- only used for generating markdown
-func DisabledTestReturnCases(t *testing.T) {
-	cfg := &Config{
-		EVMConfig: vm.Config{
-			Debug:     true,
-			Tracer:    vm.NewMarkdownLogger(nil, os.Stdout),
-			ExtraEips: []int{2315},
-		},
-	}
-	// This should fail at first opcode
-	Execute([]byte{
-		byte(vm.RETURNSUB),
-		byte(vm.PC),
-		byte(vm.PC),
-	}, nil, cfg)
-
-	// Should also fail
-	Execute([]byte{
-		byte(vm.PUSH1), 5,
-		byte(vm.JUMPSUB),
-		byte(vm.RETURNSUB),
-		byte(vm.PC),
-		byte(vm.BEGINSUB),
-		byte(vm.RETURNSUB),
-		byte(vm.PC),
-	}, nil, cfg)
-
-	// This should complete
-	Execute([]byte{
-		byte(vm.PUSH1), 0x4,
-		byte(vm.JUMPSUB),
-		byte(vm.STOP),
-		byte(vm.BEGINSUB),
-		byte(vm.PUSH1), 0x9,
-		byte(vm.JUMPSUB),
-		byte(vm.RETURNSUB),
-		byte(vm.BEGINSUB),
-		byte(vm.RETURNSUB),
-	}, nil, cfg)
-}
-
-// DisabledTestEipExampleCases contains various testcases that are used for the
-// EIP examples
-// This test is disabled, as it's only used for generating markdown
-func DisabledTestEipExampleCases(t *testing.T) {
-	cfg := &Config{
-		EVMConfig: vm.Config{
-			Debug:     true,
-			Tracer:    vm.NewMarkdownLogger(nil, os.Stdout),
-			ExtraEips: []int{2315},
-		},
-	}
-	prettyPrint := func(comment string, code []byte) {
-		instrs := make([]string, 0)
-		it := asm.NewInstructionIterator(code)
-		for it.Next() {
-			if it.Arg() != nil && 0 < len(it.Arg()) {
-				instrs = append(instrs, fmt.Sprintf("%v 0x%x", it.Op(), it.Arg()))
-			} else {
-				instrs = append(instrs, fmt.Sprintf("%v", it.Op()))
-			}
-		}
-		ops := strings.Join(instrs, ", ")
-
-		fmt.Printf("%v\nBytecode: `0x%x` (`%v`)\n",
-			comment,
-			code, ops)
-		Execute(code, nil, cfg)
-	}
-
-	{ // First eip testcase
-		code := []byte{
-			byte(vm.PUSH1), 4,
-			byte(vm.JUMPSUB),
-			byte(vm.STOP),
-			byte(vm.BEGINSUB),
-			byte(vm.RETURNSUB),
-		}
-		prettyPrint("This should jump into a subroutine, back out and stop.", code)
-	}
-
-	{
-		code := []byte{
-			byte(vm.PUSH9), 0x00, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 4 + 8,
-			byte(vm.JUMPSUB),
-			byte(vm.STOP),
-			byte(vm.BEGINSUB),
-			byte(vm.PUSH1), 8 + 9,
-			byte(vm.JUMPSUB),
-			byte(vm.RETURNSUB),
-			byte(vm.BEGINSUB),
-			byte(vm.RETURNSUB),
-		}
-		prettyPrint("This should execute fine, going into one two depths of subroutines", code)
-	}
-	// TODO(@holiman) move this test into an actual test, which not only prints
-	// out the trace.
-	{
-		code := []byte{
-			byte(vm.PUSH9), 0x01, 0x00, 0x00, 0x00, 0x0, 0x00, 0x00, 0x00, 4 + 8,
-			byte(vm.JUMPSUB),
-			byte(vm.STOP),
-			byte(vm.BEGINSUB),
-			byte(vm.PUSH1), 8 + 9,
-			byte(vm.JUMPSUB),
-			byte(vm.RETURNSUB),
-			byte(vm.BEGINSUB),
-			byte(vm.RETURNSUB),
-		}
-		prettyPrint("This should fail, since the given location is outside of the "+
-			"code-range. The code is the same as previous example, except that the "+
-			"pushed location is `0x01000000000000000c` instead of `0x0c`.", code)
-	}
-	{
-		// This should fail at first opcode
-		code := []byte{
-			byte(vm.RETURNSUB),
-			byte(vm.PC),
-			byte(vm.PC),
-		}
-		prettyPrint("This should fail at first opcode, due to shallow `return_stack`", code)
-
-	}
-	{
-		code := []byte{
-			byte(vm.PUSH1), 5, // Jump past the subroutine
-			byte(vm.JUMP),
-			byte(vm.BEGINSUB),
-			byte(vm.RETURNSUB),
-			byte(vm.JUMPDEST),
-			byte(vm.PUSH1), 3, // Now invoke the subroutine
-			byte(vm.JUMPSUB),
-		}
-		prettyPrint("In this example. the JUMPSUB is on the last byte of code. When the "+
-			"subroutine returns, it should hit the 'virtual stop' _after_ the bytecode, "+
-			"and not exit with error", code)
-	}
-
-	{
-		code := []byte{
-			byte(vm.BEGINSUB),
-			byte(vm.RETURNSUB),
-			byte(vm.STOP),
-		}
-		prettyPrint("In this example, the code 'walks' into a subroutine, which is not "+
-			"allowed, and causes an error", code)
-	}
-}
-
 // benchmarkNonModifyingCode benchmarks code, but if the code modifies the
 // state, this should not be used, since it does not reset the state between runs.
 func benchmarkNonModifyingCode(gas uint64, code []byte, name string, b *testing.B) {
diff --git a/core/vm/stack.go b/core/vm/stack.go
index af27d6552c..c71d2653a5 100644
--- a/core/vm/stack.go
+++ b/core/vm/stack.go
@@ -98,34 +98,3 @@ func (st *Stack) Print() {
 	}
 	fmt.Println("#############")
 }
-
-var rStackPool = sync.Pool{
-	New: func() interface{} {
-		return &ReturnStack{data: make([]uint32, 0, 10)}
-	},
-}
-
-// ReturnStack is an object for basic return stack operations.
-type ReturnStack struct {
-	data []uint32
-}
-
-func newReturnStack() *ReturnStack {
-	return rStackPool.Get().(*ReturnStack)
-}
-
-func returnRStack(rs *ReturnStack) {
-	rs.data = rs.data[:0]
-	rStackPool.Put(rs)
-}
-
-func (st *ReturnStack) push(d uint32) {
-	st.data = append(st.data, d)
-}
-
-// A uint32 is sufficient as for code below 4.2G
-func (st *ReturnStack) pop() (ret uint32) {
-	ret = st.data[len(st.data)-1]
-	st.data = st.data[:len(st.data)-1]
-	return
-}
diff --git a/eth/filters/api.go b/eth/filters/api.go
index 6f32c36bee..1691fd2a04 100644
--- a/eth/filters/api.go
+++ b/eth/filters/api.go
@@ -309,7 +309,7 @@ func (api *PublicFilterAPI) NewFilter(ctx context.Context, crit FilterCriteria)
 	crit.PSI = psm.ID
 	logsSub, err := api.events.SubscribeLogs(ethereum.FilterQuery(crit), logs)
 	if err != nil {
-		return "", err
+		return rpc.ID(""), err
 	}
 
 	api.filtersMu.Lock()
diff --git a/eth/state_accessor.go b/eth/state_accessor.go
index 77def2f446..d15bf0825c 100644
--- a/eth/state_accessor.go
+++ b/eth/state_accessor.go
@@ -99,7 +99,9 @@ func (eth *Ethereum) stateAtBlock(block *types.Block, reexec uint64) (statedb *s
 		if err != nil {
 			return nil, nil, nil, err
 		}
-		if err := statedb.Reset(root); err != nil {
+		err = statedb.Reset(root)
+		// statedb, err = state.New(root, database, nil) // Quorum
+		if err != nil {
 			return nil, nil, nil, fmt.Errorf("state reset after block %d failed: %v", block.NumberU64(), err)
 		}
 
diff --git a/eth/sync.go b/eth/sync.go
index a79f4cf0a8..5cf4564a3d 100644
--- a/eth/sync.go
+++ b/eth/sync.go
@@ -336,6 +336,12 @@ func (h *handler) doSync(op *chainSyncOp) error {
 		log.Info("Fast sync complete, auto disabling")
 		atomic.StoreUint32(&h.fastSync, 0)
 	}
+	/* Disabled by Quorum
+	if atomic.LoadUint32(&h.snapSync) == 1 {
+		log.Info("Snap sync complete, auto disabling")
+		atomic.StoreUint32(&h.snapSync, 0)
+	}
+	*/
 	// If we've successfully finished a sync cycle and passed any required checkpoint,
 	// enable accepting transactions from the network.
 	head := h.chain.CurrentBlock()
diff --git a/eth/tracers/api.go b/eth/tracers/api.go
index 88ff455e31..56c657e5bd 100644
--- a/eth/tracers/api.go
+++ b/eth/tracers/api.go
@@ -77,7 +77,7 @@ type Backend interface {
 	GetBlockchain() *core.BlockChain
 }
 
-// API is the collection of tracing APIs statedb exposed over the private debugging endpoint.
+// API is the collection of tracing APIs exposed over the private debugging endpoint.
 type API struct {
 	backend Backend
 }
@@ -202,10 +202,11 @@ type txTraceResult struct {
 // blockTraceTask represents a single block trace task when an entire chain is
 // being traced.
 type blockTraceTask struct {
-	statedb        *state.StateDB   // Intermediate state prepped for tracing
-	privateStateDb *state.StateDB   // Quorum
-	block          *types.Block     // Block to trace the transactions from
-	results        []*txTraceResult // Trace results procudes by the task
+	statedb *state.StateDB   // Intermediate state prepped for tracing
+	block   *types.Block     // Block to trace the transactions from
+	results []*txTraceResult // Trace results procudes by the task
+	// Quorum
+	privateStateDb *state.StateDB
 }
 
 // blockTraceResult represets the results of tracing a single block when an entire
@@ -219,9 +220,10 @@ type blockTraceResult struct {
 // txTraceTask represents a single transaction trace task when an entire block
 // is being traced.
 type txTraceTask struct {
-	statedb        *state.StateDB // Intermediate state prepped for tracing
+	statedb *state.StateDB // Intermediate state prepped for tracing
+	index   int            // Transaction offset in the block
+	// Quorum
 	privateStateDb *state.StateDB
-	index          int // Transaction offset in the block
 }
 
 // TraceChain returns the structured logs created during the execution of EVM
@@ -362,22 +364,21 @@ func (api *API) traceChain(ctx context.Context, start, end *types.Block, config
 				break
 			}
 			// Send the block over to the concurrent tracers (if not in the fast-forward phase)
-			if number > start.NumberU64() {
-				txs := block.Transactions()
-				privateState, err := privateStateRepos[0].StatePSI(psm.ID)
-				if err != nil {
-					failed = err
-					break
-				}
-				select {
-				case tasks <- &blockTraceTask{statedb: states[int(number-start.NumberU64()-1)], privateStateDb: privateState.Copy(), block: block, results: make([]*txTraceResult, len(txs))}:
-				case <-notifier.Closed():
-					return
-				}
-				traced += uint64(len(txs))
+			if number <= start.NumberU64() { // Quorum
+				continue
 			}
-
-			// TODO(karalabe): Do we need the preimages? Won't they accumulate too much?
+			txs := block.Transactions()
+			privateState, err := privateStateRepos[0].StatePSI(psm.ID)
+			if err != nil {
+				failed = err
+				break
+			}
+			select {
+			case tasks <- &blockTraceTask{statedb: states[int(number-start.NumberU64()-1)], privateStateDb: privateState.Copy(), block: block, results: make([]*txTraceResult, len(txs))}:
+			case <-notifier.Closed():
+				return
+			}
+			traced += uint64(len(txs))
 		}
 	}()
 
diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index 80775caa8e..4c398edf34 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -544,7 +544,7 @@ func (jst *Tracer) CaptureStart(from common.Address, to common.Address, create b
 }
 
 // CaptureState implements the Tracer interface to trace a single step of VM execution.
-func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, rdata []byte, contract *vm.Contract, depth int, err error) error {
+func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rdata []byte, contract *vm.Contract, depth int, err error) error {
 	if jst.err == nil {
 		// Initialize the context if it wasn't done yet
 		if !jst.inited {
@@ -595,7 +595,7 @@ func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost
 
 // CaptureFault implements the Tracer interface to trace an execution fault
 // while running an opcode.
-func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, contract *vm.Contract, depth int, err error) error {
+func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error {
 	if jst.err == nil {
 		// Apart from the error, everything matches the previous invocation
 		jst.errorValue = new(string)
diff --git a/eth/tracers/tracer_test.go b/eth/tracers/tracer_test.go
index 2b4b813658..7d20193949 100644
--- a/eth/tracers/tracer_test.go
+++ b/eth/tracers/tracer_test.go
@@ -154,10 +154,10 @@ func TestHaltBetweenSteps(t *testing.T) {
 	env := vm.NewEVM(vm.BlockContext{BlockNumber: big.NewInt(1)}, vm.TxContext{}, db, db, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer})
 	contract := vm.NewContract(&account{}, &account{}, big.NewInt(0), 0)
 
-	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, nil, nil, contract, 0, nil)
+	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, nil, contract, 0, nil)
 	timeout := errors.New("stahp")
 	tracer.Stop(timeout)
-	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, nil, nil, contract, 0, nil)
+	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, nil, contract, 0, nil)
 
 	if _, err := tracer.GetResult(); err.Error() != timeout.Error() {
 		t.Errorf("Expected timeout error, got %v", err)
diff --git a/graphql/graphql_test.go b/graphql/graphql_test.go
index 747e0f00c5..a4349810f4 100644
--- a/graphql/graphql_test.go
+++ b/graphql/graphql_test.go
@@ -203,9 +203,8 @@ func TestGraphQL_BadRequest(t *testing.T) {
 	body := strings.NewReader("{\"query\": \"{bleh{number}}\",\"variables\": null}")
 	gqlReq, err := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/graphql", stack.HTTPEndpoint()), body)
 	if err != nil {
-		t.Error("could not issue new http request ", err)
+		t.Fatalf("could not post: %v", err)
 	}
-	gqlReq.Header.Set("Content-Type", "application/json")
 	// read from response
 	resp := doHTTPRequest(t, gqlReq)
 	bodyBytes, err := ioutil.ReadAll(resp.Body)
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index d6070ee296..52df5a3430 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -1647,18 +1647,19 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
 // Common code extracted from GetTransactionReceipt() to enable reuse
 func getTransactionReceiptCommonCode(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, hash common.Hash, index uint64, receipt *types.Receipt) (map[string]interface{}, error) {
 	fields := map[string]interface{}{
-		"blockHash":                  blockHash,
-		"blockNumber":                hexutil.Uint64(blockNumber),
-		"transactionHash":            hash,
-		"transactionIndex":           hexutil.Uint64(index),
-		"from":                       tx.From(),
-		"to":                         tx.To(),
-		"gasUsed":                    hexutil.Uint64(receipt.GasUsed),
-		"cumulativeGasUsed":          hexutil.Uint64(receipt.CumulativeGasUsed),
-		"contractAddress":            nil,
-		"logs":                       receipt.Logs,
-		"logsBloom":                  receipt.Bloom,
-		"type":                       hexutil.Uint(tx.Type()),
+		"blockHash":         blockHash,
+		"blockNumber":       hexutil.Uint64(blockNumber),
+		"transactionHash":   hash,
+		"transactionIndex":  hexutil.Uint64(index),
+		"from":              tx.From(),
+		"to":                tx.To(),
+		"gasUsed":           hexutil.Uint64(receipt.GasUsed),
+		"cumulativeGasUsed": hexutil.Uint64(receipt.CumulativeGasUsed),
+		"contractAddress":   nil,
+		"logs":              receipt.Logs,
+		"logsBloom":         receipt.Bloom,
+		"type":              hexutil.Uint(tx.Type()),
+		// Quorum
 		"isPrivacyMarkerTransaction": tx.IsPrivacyMarker(),
 	}
 
@@ -1867,7 +1868,7 @@ func (args *PrivateTxArgs) SetRawTransactionPrivateFrom(ctx context.Context, b B
 	return nil
 }
 
-// setDefaults is a helper function that fills in default values for unspecified tx fields.
+// setDefaults fills in default values for unspecified tx fields.
 func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
 	if args.GasPrice == nil {
 		price, err := b.SuggestPrice(ctx)
@@ -2032,6 +2033,7 @@ func SubmitTransaction(ctx context.Context, b Backend, tx *types.Transaction, pr
 	if err := b.SendTx(ctx, tx); err != nil {
 		return common.Hash{}, err
 	}
+
 	if tx.To() == nil {
 		addr := crypto.CreateAddress(from, tx.Nonce())
 		log.Info("Submitted contract creation", "hash", tx.Hash().Hex(), "from", from, "nonce", tx.Nonce(), "contract", addr.Hex(), "value", tx.Value())
@@ -2237,6 +2239,7 @@ func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, input
 func (s *PublicTransactionPoolAPI) SendRawPrivateTransaction(ctx context.Context, encodedTx hexutil.Bytes, args SendRawTxArgs) (common.Hash, error) {
 
 	tx := new(types.Transaction)
+	// if err := tx.UnmarshalBinary(encodedTx); err != nil { // Quorum
 	if err := rlp.DecodeBytes(encodedTx, tx); err != nil {
 		return common.Hash{}, err
 	}
diff --git a/internal/ethapi/backend.go b/internal/ethapi/backend.go
index 83fa55e016..a9e52e91fa 100644
--- a/internal/ethapi/backend.go
+++ b/internal/ethapi/backend.go
@@ -47,10 +47,9 @@ type Backend interface {
 	ChainDb() ethdb.Database
 	AccountManager() *accounts.Manager
 	ExtRPCEnabled() bool
-	CallTimeOut() time.Duration // Quorum
-	RPCGasCap() uint64          // global gas cap for eth_call over rpc: DoS protection
-	RPCTxFeeCap() float64       // global tx fee cap for all transaction related APIs
-	UnprotectedAllowed() bool   // allows only for EIP155 transactions.
+	RPCGasCap() uint64        // global gas cap for eth_call over rpc: DoS protection
+	RPCTxFeeCap() float64     // global tx fee cap for all transaction related APIs
+	UnprotectedAllowed() bool // allows only for EIP155 transactions.
 
 	// Blockchain API
 	SetHead(number uint64)
@@ -93,6 +92,7 @@ type Backend interface {
 	Engine() consensus.Engine
 
 	// Quorum
+	CallTimeOut() time.Duration
 	// AccountExtraDataStateGetterByNumber returns state getter at a given block height
 	AccountExtraDataStateGetterByNumber(ctx context.Context, number rpc.BlockNumber) (vm.AccountExtraDataStateGetter, error)
 	PSMR() mps.PrivateStateMetadataResolver
diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go
index b615ddd48a..2ce1a37118 100644
--- a/internal/web3ext/web3ext.go
+++ b/internal/web3ext/web3ext.go
@@ -18,22 +18,23 @@
 package web3ext
 
 var Modules = map[string]string{
-	"accounting":       AccountingJs,
-	"admin":            AdminJs,
-	"chequebook":       ChequebookJs,
-	"clique":           CliqueJs,
-	"ethash":           EthashJs,
-	"debug":            DebugJs,
-	"eth":              EthJs,
-	"miner":            MinerJs,
-	"net":              NetJs,
-	"personal":         PersonalJs,
-	"rpc":              RpcJs,
-	"shh":              ShhJs,
-	"swarmfs":          SwarmfsJs,
-	"txpool":           TxpoolJs,
-	"les":              LESJs,
-	"vflux":            VfluxJs,
+	"accounting": AccountingJs,
+	"admin":      AdminJs,
+	"chequebook": ChequebookJs,
+	"clique":     CliqueJs,
+	"ethash":     EthashJs,
+	"debug":      DebugJs,
+	"eth":        EthJs,
+	"miner":      MinerJs,
+	"net":        NetJs,
+	"personal":   PersonalJs,
+	"rpc":        RpcJs,
+	"shh":        ShhJs,
+	"swarmfs":    SwarmfsJs,
+	"txpool":     TxpoolJs,
+	"les":        LESJs,
+	"vflux":      VfluxJs,
+	// Quorum
 	"raft":             Raft_JS,
 	"istanbul":         Istanbul_JS,
 	"quorumPermission": QUORUM_NODE_JS,
diff --git a/les/api_backend.go b/les/api_backend.go
index d861e9ba76..d67f65ce55 100644
--- a/les/api_backend.go
+++ b/les/api_backend.go
@@ -180,8 +180,8 @@ func (b *LesApiBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
 
 func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, apiState vm.MinimalApiState, header *types.Header) (*vm.EVM, func() error, error) {
 	statedb := apiState.(*state.StateDB)
-	context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
 	txContext := core.NewEVMTxContext(msg)
+	context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
 	return vm.NewEVM(context, txContext, statedb, statedb, b.eth.chainConfig, vm.Config{}), statedb.Error, nil
 }
 
diff --git a/miner/worker.go b/miner/worker.go
index 72ccf52da6..a4c603106e 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -744,12 +744,13 @@ func (w *worker) makeCurrent(parent *types.Block, header *types.Header) error {
 	publicState.StartPrefetcher("miner")
 
 	env := &environment{
-		signer:           types.MakeSigner(w.chainConfig, header.Number),
-		state:            publicState,
-		ancestors:        mapset.NewSet(),
-		family:           mapset.NewSet(),
-		uncles:           mapset.NewSet(),
-		header:           header,
+		signer:    types.MakeSigner(w.chainConfig, header.Number),
+		state:     publicState,
+		ancestors: mapset.NewSet(),
+		family:    mapset.NewSet(),
+		uncles:    mapset.NewSet(),
+		header:    header,
+		// Quorum
 		privateStateRepo: privateStateRepo,
 	}
 	// when 08 is processed ancestors contain 07 (quick block)
@@ -996,7 +997,6 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
 	if parent.Time() >= uint64(timestamp) {
 		timestamp = int64(parent.Time() + 1)
 	}
-
 	num := parent.Number()
 	header := &types.Header{
 		ParentHash: parent.Hash(),
diff --git a/node/config.go b/node/config.go
index 7f5a7cc98d..af38061bad 100644
--- a/node/config.go
+++ b/node/config.go
@@ -203,11 +203,12 @@ type Config struct {
 	oldGethResourceWarning bool
 
 	// AllowUnprotectedTxs allows non EIP-155 protected transactions to be send over RPC.
-	AllowUnprotectedTxs bool             `toml:",omitempty"`
-	Plugins             *plugin.Settings `toml:",omitempty"`
-	// Quorum: EnableNodePermission comes from EnableNodePermissionFlag --permissioned.
-	EnableNodePermission bool `toml:",omitempty"`
-	EnableMultitenancy   bool `toml:",omitempty"` // comes from MultitenancyFlag flag
+	AllowUnprotectedTxs bool `toml:",omitempty"`
+
+	// Quorum
+	Plugins              *plugin.Settings `toml:",omitempty"`
+	EnableNodePermission bool             `toml:",omitempty"` // comes from EnableNodePermissionFlag --permissioned.
+	EnableMultitenancy   bool             `toml:",omitempty"` // comes from MultitenancyFlag flag
 }
 
 // IPCEndpoint resolves an IPC endpoint based on a configured value, taking into
diff --git a/params/config.go b/params/config.go
index c8f755ae6f..7897e6e056 100644
--- a/params/config.go
+++ b/params/config.go
@@ -70,6 +70,7 @@ var (
 		PetersburgBlock:     big.NewInt(7_280_000),
 		IstanbulBlock:       big.NewInt(9_069_000),
 		MuirGlacierBlock:    big.NewInt(9_200_000),
+		BerlinBlock:         big.NewInt(12_244_000),
 		Ethash:              new(EthashConfig),
 	}
 
@@ -109,6 +110,7 @@ var (
 		PetersburgBlock:     big.NewInt(4_939_394),
 		IstanbulBlock:       big.NewInt(6_485_846),
 		MuirGlacierBlock:    big.NewInt(7_117_117),
+		BerlinBlock:         big.NewInt(9_812_189),
 		Ethash:              new(EthashConfig),
 	}
 
@@ -148,6 +150,7 @@ var (
 		PetersburgBlock:     big.NewInt(4_321_234),
 		IstanbulBlock:       big.NewInt(5_435_345),
 		MuirGlacierBlock:    nil,
+		BerlinBlock:         big.NewInt(8_290_928),
 		Clique: &CliqueConfig{
 			Period: 15,
 			Epoch:  30000,
@@ -188,6 +191,7 @@ var (
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       big.NewInt(1_561_651),
 		MuirGlacierBlock:    nil,
+		BerlinBlock:         big.NewInt(4_460_644),
 		Clique: &CliqueConfig{
 			Period: 15,
 			Epoch:  30000,
@@ -1008,8 +1012,9 @@ type Rules struct {
 	IsHomestead, IsEIP150, IsEIP155, IsEIP158               bool
 	IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool
 	IsBerlin                                                bool
-	IsPrivacyEnhancementsEnabled                            bool // Quorum
-	IsPrivacyPrecompile                                     bool // Quorum
+	// Quorum
+	IsPrivacyEnhancementsEnabled bool
+	IsPrivacyPrecompile          bool
 }
 
 // Rules ensures c's ChainID is not nil.
@@ -1019,17 +1024,18 @@ func (c *ChainConfig) Rules(num *big.Int) Rules {
 		chainID = new(big.Int)
 	}
 	return Rules{
-		ChainID:                      new(big.Int).Set(chainID),
-		IsHomestead:                  c.IsHomestead(num),
-		IsEIP150:                     c.IsEIP150(num),
-		IsEIP155:                     c.IsEIP155(num),
-		IsEIP158:                     c.IsEIP158(num),
-		IsByzantium:                  c.IsByzantium(num),
-		IsConstantinople:             c.IsConstantinople(num),
-		IsPetersburg:                 c.IsPetersburg(num),
-		IsIstanbul:                   c.IsIstanbul(num),
-		IsBerlin:                     c.IsBerlin(num),
-		IsPrivacyEnhancementsEnabled: c.IsPrivacyEnhancementsEnabled(num), // Quorum
-		IsPrivacyPrecompile:          c.IsPrivacyPrecompile(num),          // Quorum
+		ChainID:          new(big.Int).Set(chainID),
+		IsHomestead:      c.IsHomestead(num),
+		IsEIP150:         c.IsEIP150(num),
+		IsEIP155:         c.IsEIP155(num),
+		IsEIP158:         c.IsEIP158(num),
+		IsByzantium:      c.IsByzantium(num),
+		IsConstantinople: c.IsConstantinople(num),
+		IsPetersburg:     c.IsPetersburg(num),
+		IsIstanbul:       c.IsIstanbul(num),
+		IsBerlin:         c.IsBerlin(num),
+		// Quorum
+		IsPrivacyEnhancementsEnabled: c.IsPrivacyEnhancementsEnabled(num),
+		IsPrivacyPrecompile:          c.IsPrivacyPrecompile(num),
 	}
 }
diff --git a/params/version.go b/params/version.go
index 120e124749..c88bfb8f88 100644
--- a/params/version.go
+++ b/params/version.go
@@ -23,7 +23,7 @@ import (
 const (
 	VersionMajor = 1        // Major version component of the current release
 	VersionMinor = 10       // Minor version component of the current release
-	VersionPatch = 0        // Patch version component of the current release
+	VersionPatch = 1        // Patch version component of the current release
 	VersionMeta  = "stable" // Version metadata to append to the version string
 
 	QuorumVersionMajor = 22
diff --git a/tests/testdata b/tests/testdata
index 7497b116a0..c600d7795a 160000
--- a/tests/testdata
+++ b/tests/testdata
@@ -1 +1 @@
-Subproject commit 7497b116a019beb26215cbea4028df068dea06be
+Subproject commit c600d7795aa2ea57a9c856fc79f72fc05b542124