Add a dependency check for cadence imports

cmd/scaffold.go

@@ -1547,6 +1547,13 @@ func (fnb *FlowNodeBuilder) initFvmOptions() {
 			fvm.WithContractDeploymentRestricted(false),
 		)
 	}
+	// temporarily enable dependency check for testnet
+	if fnb.RootChainID == flow.Testnet {
+		vmOpts = append(vmOpts,
+			fvm.WithDependencyCheckEnabled(true),
+		)
+	}
+
 	fnb.FvmOptions = vmOpts
 }
 

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,50 @@ func (sys *SystemContracts) AccountsStorageCapacity(
 		},
 	)
 }
+
+var checkDependenciesSpec = 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{},
+		),
+	},
+}
+
+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(
+		checkDependenciesSpec,
+		[]cadence.Value{
+			cadence.NewArray(dependenciesAddresses),
+			cadence.NewArray(dependenciesNames),
+			cadence.NewArray(authorizersAddresses),
+		},
+	)
+}