Add a dependency check for cadecne imports

fvm/context.go

@@ -29,6 +29,7 @@ type Context struct {
 	// limits and set them to MaxUint64, effectively disabling these limits.
 	DisableMemoryAndInteractionLimits bool
 	EVMEnabled                        bool
+	DependencyCheckEnabled            bool
 	ComputationLimit                  uint64
 	MemoryLimit                       uint64
 	MaxStateKeySize                   uint64
@@ -193,6 +194,14 @@ func WithServiceEventCollectionEnabled() Option {
 	}
 }
 
+// WithDependencyCheckEnabled enables or disables the dependency check.
+func WithDependencyCheckEnabled(enabled bool) Option {
+	return func(ctx Context) Context {
+		ctx.DependencyCheckEnabled = enabled
+		return ctx
+	}
+}
+
 // WithBlocks sets the block storage provider for a virtual machine context.
 //
 // The VM uses the block storage provider to provide historical block information to

fvm/environment/env.go

@@ -3,10 +3,12 @@ package environment
 import (
 	"github.com/onflow/cadence"
 	"github.com/onflow/cadence/runtime"
+	"github.com/onflow/cadence/runtime/common"
 	"github.com/rs/zerolog"
 	otelTrace "go.opentelemetry.io/otel/trace"
 
 	reusableRuntime "github.com/onflow/flow-go/fvm/runtime"
+	"github.com/onflow/flow-go/fvm/storage/derived"
 	"github.com/onflow/flow-go/fvm/tracing"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/module/trace"
@@ -85,6 +87,10 @@ type Environment interface {
 	// Reset resets all stateful environment modules (e.g., ContractUpdater,
 	// EventEmitter) to initial state.
 	Reset()
+
+	GetProgramDependencies() (derived.ProgramDependencies, error)
+
+	CheckDependencies(dependencies []common.AddressLocation, auths []flow.Address) (cadence.Value, error)
 }
 
 type EnvironmentParams struct {

fvm/environment/programs.go

@@ -186,6 +186,14 @@ func (programs *Programs) DecodeArgument(
 	return v, err
 }
 
+func (programs *Programs) GetProgramDependencies() (derived.ProgramDependencies, error) {
+	top, err := programs.dependencyStack.top()
+	if err != nil {
+		return derived.ProgramDependencies{}, err
+	}
+	return top, nil
+}
+
 func (programs *Programs) cacheHit() {
 	programs.metrics.RuntimeTransactionProgramsCacheHit()
 }

fvm/environment/system_contracts.go

@@ -279,3 +279,48 @@ func (sys *SystemContracts) AccountsStorageCapacity(
 		},
 	)
 }
+
+func (sys *SystemContracts) CheckDependencies(
+	dependencies []common.AddressLocation,
+	authorizers []flow.Address,
+) (cadence.Value, error) {
+
+	dependenciesAddresses := make([]cadence.Value, len(dependencies))
+	dependenciesNames := make([]cadence.Value, len(dependencies))
+	for i, dep := range dependencies {
+		dependenciesAddresses[i] = cadence.BytesToAddress(dep.Address.Bytes())
+		dependenciesNames[i] = cadence.String(dep.Name)
+	}
+
+	authorizersAddresses := make([]cadence.Value, len(authorizers))
+	for i, auth := range authorizers {
+		authorizersAddresses[i] = cadence.BytesToAddress(auth.Bytes())
+	}
+
+	return sys.Invoke(
+		ContractFunctionSpec{
+			AddressFromChain: ServiceAddress,
+			LocationName:     systemcontracts.ContractNameServiceAccount,
+			FunctionName:     systemcontracts.ContractServiceAccountFunction_checkDependencies,
+			ArgumentTypes: []sema.Type{
+				sema.NewVariableSizedType(
+					nil,
+					&sema.AddressType{},
+				),
+				sema.NewVariableSizedType(
+					nil,
+					sema.StringType,
+				),
+				sema.NewVariableSizedType(
+					nil,
+					&sema.AddressType{},
+				),
+			},
+		},
+		[]cadence.Value{
+			cadence.NewArray(dependenciesAddresses),
+			cadence.NewArray(dependenciesNames),
+			cadence.NewArray(authorizersAddresses),
+		},
+	)
+}