Fix audit issues, disable state connector after Durango

Author: mboben

coreth/consensus/dummy/consensus.go

@@ -126,6 +126,21 @@ func (self *DummyEngine) verifyHeaderGasFields(config *params.ChainConfig, heade
 				if header.GasLimit != params.SgbApricotPhase5GasLimit {
 					return fmt.Errorf("expected gas limit to be %d in ApricotPhase5 but found %d", params.SgbApricotPhase5GasLimit, header.GasLimit)
 				}
+			} else if config.IsApricotPhase1(header.Time) {
+				if header.GasLimit != params.ApricotPhase1GasLimit {
+					return fmt.Errorf("expected gas limit to be %d in ApricotPhase1, but found %d", params.ApricotPhase1GasLimit, header.GasLimit)
+				}
+			} else {
+				// Verify that the gas limit remains within allowed bounds
+				diff := int64(parent.GasLimit) - int64(header.GasLimit)
+				if diff < 0 {
+					diff *= -1
+				}
+				limit := parent.GasLimit / params.GasLimitBoundDivisor
+
+				if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit {
+					return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit)
+				}
 			}
 		} else {
 			if config.IsApricotPhase1(header.Time) {

coreth/core/governance_settings.go

@@ -303,9 +303,12 @@ func (st *StateTransition) UpdateInitialAirdropAddress(chainID *big.Int, timesta
 	}
 	initialAirdropAddress := GetInitialAirdropContractAddress(chainID, timestamp)
 	targetAidropAddress := GetTargetAirdropContractAddress(chainID, timestamp)
-	airdropBalance := st.state.GetBalance(initialAirdropAddress)
-	st.state.SubBalance(initialAirdropAddress, airdropBalance)
-	st.state.AddBalance(targetAidropAddress, airdropBalance)
+
+	if initialAirdropAddress != targetAidropAddress {
+		airdropBalance := st.state.GetBalance(initialAirdropAddress)
+		st.state.SubBalance(initialAirdropAddress, airdropBalance)
+		st.state.AddBalance(targetAidropAddress, airdropBalance)
+	}
 	return nil
 }
 
@@ -322,8 +325,11 @@ func (st *StateTransition) UpdateDistributionAddress(chainID *big.Int, timestamp
 	}
 	distributionAddress := GetDistributionContractAddress(chainID, timestamp)
 	targetDistributionAddress := GetTargetDistributionContractAddress(chainID, timestamp)
-	distributionBalance := st.state.GetBalance(distributionAddress)
-	st.state.SubBalance(distributionAddress, distributionBalance)
-	st.state.AddBalance(targetDistributionAddress, distributionBalance)
+
+	if distributionAddress != targetDistributionAddress {
+		distributionBalance := st.state.GetBalance(distributionAddress)
+		st.state.SubBalance(distributionAddress, distributionBalance)
+		st.state.AddBalance(targetDistributionAddress, distributionBalance)
+	}
 	return nil
 }

coreth/core/state_connector.go

@@ -54,8 +54,8 @@ var (
 		AddValue(params.LocalChainID, GetStateConnectorIsActivatedAndCalledLocal)
 )
 
-func GetStateConnectorIsActivatedAndCalled(chainID *big.Int, blockTime uint64, to common.Address) bool {
-	return stateConnectorActivationVariants.GetValue(chainID)(blockTime, to)
+func GetStateConnectorIsActivatedAndCalled(isDurango bool, chainID *big.Int, blockTime uint64, to common.Address) bool {
+	return !isDurango && stateConnectorActivationVariants.GetValue(chainID)(blockTime, to)
 }
 
 func GetStateConnectorIsActivatedAndCalledFlare(blockTime uint64, to common.Address) bool {

coreth/core/state_transition.go

@@ -475,10 +475,10 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 		st.state.SetNonce(msg.From, st.state.GetNonce(sender.Address())+1)
 		ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), msg.Data, st.gasRemaining, msg.Value)
 		if vmerr == nil && chainID != nil {
-			if isSongbird {
-				handleSongbirdTransitionDbContracts(st, chainID, timestamp, msg, ret)
-			} else {
-				handleFlareTransitionDbContracts(st, chainID, timestamp, msg, ret)
+			if isSongbird { // Songbird, Coston, Local (Songbird)
+				handleSongbirdTransitionDbContracts(st, rules.IsDurango, chainID, timestamp, msg, ret)
+			} else if isFlare { // Flare, Coston2, Local (Flare)
+				handleFlareTransitionDbContracts(st, rules.IsDurango, chainID, timestamp, msg, ret)
 			}
 		}
 	}
@@ -514,8 +514,8 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	}, nil
 }
 
-func handleSongbirdTransitionDbContracts(st *StateTransition, chainID *big.Int, timestamp uint64, msg *Message, ret []byte) {
-	if GetStateConnectorIsActivatedAndCalled(chainID, timestamp, *msg.To) &&
+func handleSongbirdTransitionDbContracts(st *StateTransition, isDurango bool, chainID *big.Int, timestamp uint64, msg *Message, ret []byte) {
+	if GetStateConnectorIsActivatedAndCalled(isDurango, chainID, timestamp, *msg.To) &&
 		len(msg.Data) >= 36 && len(ret) == 32 &&
 		bytes.Equal(msg.Data[0:4], SubmitAttestationSelector(chainID, timestamp)) &&
 		binary.BigEndian.Uint64(ret[24:32]) > 0 {
@@ -525,12 +525,12 @@ func handleSongbirdTransitionDbContracts(st *StateTransition, chainID *big.Int,
 	}
 }
 
-func handleFlareTransitionDbContracts(st *StateTransition, chainID *big.Int, timestamp uint64, msg *Message, ret []byte) {
+func handleFlareTransitionDbContracts(st *StateTransition, isDurango bool, chainID *big.Int, timestamp uint64, msg *Message, ret []byte) {
 	if st.evm.Context.Coinbase != common.HexToAddress("0x0100000000000000000000000000000000000000") {
 		return
 	}
 
-	if GetStateConnectorIsActivatedAndCalled(chainID, timestamp, *msg.To) &&
+	if GetStateConnectorIsActivatedAndCalled(isDurango, chainID, timestamp, *msg.To) &&
 		len(msg.Data) >= 36 && len(ret) == 32 &&
 		bytes.Equal(msg.Data[0:4], SubmitAttestationSelector(chainID, timestamp)) &&
 		binary.BigEndian.Uint64(ret[24:32]) > 0 {

coreth/plugin/evm/block_verification.go

@@ -128,6 +128,13 @@ func (v blockValidator) SyntacticVerify(b *Block, rules params.Rules) error {
 					)
 
 				}
+			} else if rules.IsApricotPhase1 {
+				if ethHeader.GasLimit != params.ApricotPhase1GasLimit {
+					return fmt.Errorf(
+						"expected gas limit to be %d after apricot phase 1 but got %d",
+						params.ApricotPhase1GasLimit, ethHeader.GasLimit,
+					)
+				}
 			}
 		} else {
 			if rules.IsApricotPhase1 {