Expose minimum required version to cadence interface

fvm/environment/derived_data_invalidator.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/onflow/flow-go/fvm/storage/derived"
 	"github.com/onflow/flow-go/fvm/storage/snapshot"
+	"github.com/onflow/flow-go/model/flow"
 )
 
 type ContractUpdate struct {
@@ -26,6 +27,8 @@ type DerivedDataInvalidator struct {
 	ContractUpdates
 
 	MeterParamOverridesUpdated bool
+
+	CurrentVersionBoundaryUpdated bool
 }
 
 var _ derived.TransactionInvalidator = DerivedDataInvalidator{}
@@ -34,12 +37,16 @@ func NewDerivedDataInvalidator(
 	contractUpdates ContractUpdates,
 	executionSnapshot *snapshot.ExecutionSnapshot,
 	meterStateRead *snapshot.ExecutionSnapshot,
+	serviceAddress flow.Address,
 ) DerivedDataInvalidator {
 	return DerivedDataInvalidator{
 		ContractUpdates: contractUpdates,
 		MeterParamOverridesUpdated: meterParamOverridesUpdated(
 			executionSnapshot,
 			meterStateRead),
+		CurrentVersionBoundaryUpdated: currentVersionBoundaryUpdated(
+			serviceAddress,
+			meterStateRead),
 	}
 }
 
@@ -69,6 +76,26 @@ func meterParamOverridesUpdated(
 	return false
 }
 
+// currentVersionBoundaryUpdated returns true if the current version boundary
+// should be invalidated. Currently, this will trigger on any change to the
+// service account, which will trigger at least once per block. This is ok for now as
+// the meterParamOverrides also trigger on every block.
+func currentVersionBoundaryUpdated(
+	serviceAddress flow.Address,
+	executionSnapshot *snapshot.ExecutionSnapshot,
+) bool {
+	serviceAccount := string(serviceAddress.Bytes())
+
+	for registerId := range executionSnapshot.WriteSet {
+		// The meter param override values are stored in the service account.
+		if registerId.Owner == serviceAccount {
+			return true
+		}
+	}
+
+	return false
+}
+
 func (invalidator DerivedDataInvalidator) ProgramInvalidator() derived.ProgramInvalidator {
 	return ProgramInvalidator{invalidator}
 }
@@ -77,6 +104,10 @@ func (invalidator DerivedDataInvalidator) MeterParamOverridesInvalidator() deriv
 	return MeterParamOverridesInvalidator{invalidator}
 }
 
+func (invalidator DerivedDataInvalidator) CurrentVersionBoundaryInvalidator() derived.CurrentVersionBoundaryInvalidator {
+	return CurrentVersionBoundaryInvalidator{invalidator}
+}
+
 type ProgramInvalidator struct {
 	DerivedDataInvalidator
 }
@@ -139,3 +170,21 @@ func (invalidator MeterParamOverridesInvalidator) ShouldInvalidateEntry(
 ) bool {
 	return invalidator.MeterParamOverridesUpdated
 }
+
+type CurrentVersionBoundaryInvalidator struct {
+	DerivedDataInvalidator
+}
+
+func (invalidator CurrentVersionBoundaryInvalidator) ShouldInvalidateEntries() bool {
+	return invalidator.CurrentVersionBoundaryUpdated
+}
+
+func (invalidator CurrentVersionBoundaryInvalidator) ShouldInvalidateEntry(
+	_ struct{},
+	_ flow.VersionBoundary,
+	_ *snapshot.ExecutionSnapshot,
+) bool {
+	// If the meter params are updated
+	// the current version boundary derived data table becomes invalid.
+	return invalidator.MeterParamOverridesUpdated || invalidator.CurrentVersionBoundaryUpdated
+}

fvm/environment/derived_data_invalidator_test.go

@@ -3,6 +3,8 @@ package environment_test
 import (
 	"testing"
 
+	"github.com/onflow/flow-go/fvm/systemcontracts"
+
 	"github.com/onflow/cadence/common"
 	"github.com/stretchr/testify/require"
 
@@ -296,10 +298,13 @@ func TestMeterParamOverridesUpdated(t *testing.T) {
 			},
 		}
 
+		sc := systemcontracts.SystemContractsForChain(flow.Testnet)
+
 		invalidator := environment.NewDerivedDataInvalidator(
 			environment.ContractUpdates{},
 			snapshot,
-			meterStateRead)
+			meterStateRead,
+			sc.FlowServiceAccount.Address)
 		require.Equal(t, expected, invalidator.MeterParamOverridesUpdated)
 	}
 

fvm/environment/env.go

@@ -62,6 +62,8 @@ type Environment interface {
 		error,
 	)
 
+	GetCurrentVersionBoundary() (cadence.Value, error)
+
 	// AccountInfo
 	GetAccount(address flow.Address) (*flow.Account, error)
 	GetAccountKeys(address flow.Address) ([]flow.AccountPublicKey, error)

fvm/environment/facade_env.go

@@ -37,6 +37,7 @@ type facadeEnvironment struct {
 	ValueStore
 
 	*SystemContracts
+	MinimumRequiredVersion
 
 	UUIDGenerator
 	AccountLocalIDGenerator
@@ -103,6 +104,12 @@ func newFacadeEnvironment(
 		),
 
 		SystemContracts: systemContracts,
+		MinimumRequiredVersion: NewMinimumRequiredVersion(
+			tracer,
+			meter,
+			txnState,
+			params,
+		),
 
 		UUIDGenerator: NewUUIDGenerator(
 			tracer,
@@ -293,6 +300,9 @@ func (env *facadeEnvironment) addParseRestrictedChecks() {
 	env.RandomSourceHistoryProvider = NewParseRestrictedRandomSourceHistoryProvider(
 		env.txnState,
 		env.RandomSourceHistoryProvider)
+	env.MinimumRequiredVersion = NewParseRestrictedMinimumRequiredVersion(
+		env.txnState,
+		env.MinimumRequiredVersion)
 	env.UUIDGenerator = NewParseRestrictedUUIDGenerator(
 		env.txnState,
 		env.UUIDGenerator)

fvm/environment/meter.go

@@ -55,6 +55,7 @@ const (
 	_
 	ComputationKindEVMEncodeABI
 	ComputationKindEVMDecodeABI
+	ComputationKindMinimumRequiredVersion
 )
 
 // MainnetExecutionEffortWeights are the execution effort weights as they are

fvm/environment/minimum_required_version.go

@@ -0,0 +1,190 @@
+package environment
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/coreos/go-semver/semver"
+
+	"github.com/onflow/flow-go/fvm/storage"
+	"github.com/onflow/flow-go/fvm/storage/state"
+	"github.com/onflow/flow-go/fvm/tracing"
+	"github.com/onflow/flow-go/model/convert"
+	"github.com/onflow/flow-go/model/flow"
+	"github.com/onflow/flow-go/module/trace"
+)
+
+// MinimumRequiredVersion returns the minimum required cadence version for the current environment
+// in semver format.
+type MinimumRequiredVersion interface {
+	MinimumRequiredVersion() (string, error)
+}
+
+type ParseRestrictedMinimumRequiredVersion struct {
+	txnState state.NestedTransactionPreparer
+	impl     MinimumRequiredVersion
+}
+
+func NewParseRestrictedMinimumRequiredVersion(
+	txnState state.NestedTransactionPreparer,
+	impl MinimumRequiredVersion,
+) MinimumRequiredVersion {
+	return ParseRestrictedMinimumRequiredVersion{
+		txnState: txnState,
+		impl:     impl,
+	}
+}
+
+func (p ParseRestrictedMinimumRequiredVersion) MinimumRequiredVersion() (string, error) {
+	return parseRestrict1Ret(
+		p.txnState,
+		trace.FVMEnvRandom,
+		p.impl.MinimumRequiredVersion)
+}
+
+type minimumRequiredVersion struct {
+	tracer tracing.TracerSpan
+	meter  Meter
+
+	txnState  storage.TransactionPreparer
+	envParams EnvironmentParams
+}
+
+func NewMinimumRequiredVersion(
+	tracer tracing.TracerSpan,
+	meter Meter,
+	txnState storage.TransactionPreparer,
+	envParams EnvironmentParams,
+) MinimumRequiredVersion {
+	return minimumRequiredVersion{
+		tracer: tracer,
+		meter:  meter,
+
+		txnState:  txnState,
+		envParams: envParams,
+	}
+}
+
+func (c minimumRequiredVersion) MinimumRequiredVersion() (string, error) {
+	tracerSpan := c.tracer.StartExtensiveTracingChildSpan(
+		trace.FVMEnvMinimumRequiredVersion)
+	defer tracerSpan.End()
+
+	err := c.meter.MeterComputation(ComputationKindMinimumRequiredVersion, 1)
+	if err != nil {
+		return "", fmt.Errorf("get MinimumRequiredVersion failed: %w", err)
+	}
+
+	value, err := c.txnState.GetCurrentVersionBoundary(
+		c.txnState,
+		NewCurrentVersionBoundaryComputer(
+			tracerSpan,
+			c.envParams,
+			c.txnState,
+		),
+	)
+	if err != nil {
+		return "", fmt.Errorf("get MinimumRequiredVersion failed: %w", err)
+	}
+
+	version, err := c.mapToCadenceVersion(value.Version)
+
+	if err != nil {
+		return "", fmt.Errorf("get MinimumRequiredVersion failed: %w", err)
+	}
+
+	return version, nil
+}
+
+func (c minimumRequiredVersion) mapToCadenceVersion(version string) (string, error) {
+	semVer, err := semver.NewVersion(version)
+	if err != nil {
+		// TODO: return a better error
+		return "", fmt.Errorf("failed to map FVM version to cadence version: %w", err)
+	}
+
+	// return 0.0.0 if there is no mapping for the version
+	var cadenceVersion = semver.Version{}
+
+	greaterThanOrEqualTo := func(version semver.Version, versionToCompare semver.Version) bool {
+		return version.Compare(versionToCompare) >= 0
+	}
+
+	for _, entry := range fvmToCadenceVersionMapping {
+		if greaterThanOrEqualTo(*semVer, entry.FlowGoVersion) {
+			cadenceVersion = entry.CadenceVersion
+		} else {
+			break
+		}
+	}
+
+	return cadenceVersion.String(), nil
+}
+
+type VersionMapEntry struct {
+	FlowGoVersion  semver.Version
+	CadenceVersion semver.Version
+}
+
+// FVMToCadenceVersionMapping is a hardcoded mapping between FVM versions and Cadence versions.
+// Entries are only needed for cadence versions where cadence intends to switch behaviour
+// based on the version.
+// This should be ordered.
+var fvmToCadenceVersionMapping = []VersionMapEntry{
+	{
+		FlowGoVersion:  *semver.New("0.37.0"),
+		CadenceVersion: *semver.New("1.0.0"),
+	},
+}
+
+func SetFVMToCadenceVersionMappingForTestingOnly(mapping []VersionMapEntry) {
+	fvmToCadenceVersionMapping = mapping
+}
+
+var _ MinimumRequiredVersion = (*minimumRequiredVersion)(nil)
+
+type CurrentVersionBoundaryComputer struct {
+	tracerSpan tracing.TracerSpan
+	envParams  EnvironmentParams
+	txnState   storage.TransactionPreparer
+}
+
+func NewCurrentVersionBoundaryComputer(
+	tracerSpan tracing.TracerSpan,
+	envParams EnvironmentParams,
+	txnState storage.TransactionPreparer,
+) CurrentVersionBoundaryComputer {
+	return CurrentVersionBoundaryComputer{
+		tracerSpan: tracerSpan,
+		envParams:  envParams,
+		txnState:   txnState,
+	}
+}
+
+func (computer CurrentVersionBoundaryComputer) Compute(
+	_ state.NestedTransactionPreparer,
+	_ struct{},
+) (
+	flow.VersionBoundary,
+	error,
+) {
+	env := NewScriptEnv(
+		context.Background(),
+		computer.tracerSpan,
+		computer.envParams,
+		computer.txnState)
+
+	value, err := env.GetCurrentVersionBoundary()
+
+	if err != nil {
+		return flow.VersionBoundary{}, fmt.Errorf("could not get current version boundary: %w", err)
+	}
+
+	boundary, err := convert.VersionBoundary(value)
+
+	if err != nil {
+		return flow.VersionBoundary{}, fmt.Errorf("could not parse current version boundary: %w", err)
+	}
+
+	return boundary, nil
+}