Merge pull request #4358 from onflow/bastian/fix-compiler-contract-deployment-transfer

[Compiler] Fix transfer during contract deployment with arguments

Author: turbolent

runtime/deployment_test.go

@@ -24,11 +24,13 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/onflow/atree"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/crypto/sha3"
 
 	"github.com/onflow/cadence"
+	"github.com/onflow/cadence/bbq/vm"
 	"github.com/onflow/cadence/common"
 	"github.com/onflow/cadence/interpreter"
 	. "github.com/onflow/cadence/runtime"
@@ -365,3 +367,136 @@ func TestRuntimeTransactionWithContractDeployment(t *testing.T) {
 		})
 	})
 }
+
+func TestRuntimeContractDeploymentInitializerArgument(t *testing.T) {
+
+	t.Parallel()
+
+	runtime := NewTestRuntime()
+
+	addressValue := cadence.BytesToAddress([]byte{0xCA, 0xDE})
+
+	contract := []byte(`
+      access(all) contract Test {
+          init(arg: {Int: Int}) {
+              check(arg)
+          }
+      }
+    `)
+
+	deploy := fmt.Sprintf(
+		`
+          transaction {
+              prepare(signer: auth(Contracts) &Account) {
+                  let arg: {Int: Int} = {}
+                  signer.contracts.add(name: "Test", code: "%s".decodeHex(), arg: arg)
+              }
+          }
+        `,
+		hex.EncodeToString(contract),
+	)
+
+	var accountCode []byte
+
+	runtimeInterface := &TestRuntimeInterface{
+		OnGetCode: func(_ Location) (bytes []byte, err error) {
+			return accountCode, nil
+		},
+		Storage: NewTestLedger(nil, nil),
+		OnGetSigningAccounts: func() ([]Address, error) {
+			return []Address{Address(addressValue)}, nil
+		},
+		OnGetAccountContractCode: func(_ common.AddressLocation) (code []byte, err error) {
+			return accountCode, nil
+		},
+		OnUpdateAccountContractCode: func(_ common.AddressLocation, code []byte) error {
+			accountCode = code
+			return nil
+		},
+		OnEmitEvent: func(event cadence.Event) error {
+			return nil
+		},
+	}
+
+	check := func(value interpreter.Value) {
+		dictionaryValue, ok := value.(*interpreter.DictionaryValue)
+		require.True(t, ok)
+
+		assert.Equal(t,
+			atree.ValueID{
+				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6,
+			},
+			dictionaryValue.ValueID(),
+		)
+	}
+
+	transactionEnvironment := newTransactionEnvironment()
+
+	functionType := sema.NewSimpleFunctionType(
+		sema.FunctionPurityView,
+		[]sema.Parameter{
+			{
+				Label:      sema.ArgumentLabelNotRequired,
+				Identifier: "arg",
+				TypeAnnotation: sema.NewTypeAnnotation(
+					sema.NewDictionaryType(nil, sema.IntType, sema.IntType),
+				),
+			},
+		},
+		sema.VoidTypeAnnotation,
+	)
+
+	var function interpreter.FunctionValue
+
+	const functionName = "check"
+	if *compile {
+		function = vm.NewNativeFunctionValue(
+			functionName,
+			functionType,
+			func(
+				_ interpreter.NativeFunctionContext,
+				_ interpreter.TypeArgumentsIterator,
+				_ interpreter.Value,
+				args []interpreter.Value,
+			) interpreter.Value {
+				check(args[0])
+				return interpreter.Void
+			},
+		)
+	} else {
+		function = interpreter.NewStaticHostFunctionValue(
+			nil,
+			functionType,
+			func(invocation interpreter.Invocation) interpreter.Value {
+				check(invocation.Arguments[0])
+				return interpreter.Void
+			},
+		)
+	}
+
+	transactionEnvironment.DeclareValue(
+		stdlib.StandardLibraryValue{
+			Name:  functionName,
+			Type:  functionType,
+			Kind:  common.DeclarationKindFunction,
+			Value: function,
+		},
+		nil,
+	)
+
+	nextTransactionLocation := NewTransactionLocationGenerator()
+
+	err := runtime.ExecuteTransaction(
+		Script{
+			Source: []byte(deploy),
+		},
+		Context{
+			Interface:   runtimeInterface,
+			Environment: transactionEnvironment,
+			Location:    nextTransactionLocation(),
+			UseVM:       *compile,
+		},
+	)
+	require.NoError(t, err)
+}

runtime/environment.go

@@ -372,13 +372,11 @@ func (e *InterpreterEnvironment) newContractValueHandler() interpreter.ContractV
 
 				constructor := constructorGenerator(invocation.Address)
 
-				value, err := interpreter.InvokeFunctionValue(
+				value, err := interpreter.InvokeExternally(
 					inter,
 					constructor,
+					constructor.FunctionType(inter),
 					invocation.ConstructorArguments,
-					invocation.ArgumentTypes,
-					invocation.ParameterTypes,
-					invocation.ContractType,
 				)
 				if err != nil {
 					panic(err)

stdlib/account.go

@@ -2311,8 +2311,6 @@ func updateAccountContractCode(
 type DeployedContractConstructorInvocation struct {
 	ContractType         *sema.CompositeType
 	ConstructorArguments []interpreter.Value
-	ArgumentTypes        []sema.Type
-	ParameterTypes       []sema.Type
 	Address              common.Address
 }
 
@@ -2348,22 +2346,20 @@ func instantiateContract(
 	constructorArguments []interpreter.Value,
 	argumentTypes []sema.Type,
 ) (*interpreter.CompositeValue, error) {
-	parameterTypes := make([]sema.Type, len(contractType.ConstructorParameters))
-
-	for i, constructorParameter := range contractType.ConstructorParameters {
-		parameterTypes[i] = constructorParameter.TypeAnnotation.Type
-	}
 
 	// Check argument count
 
+	constructorParameters := contractType.ConstructorParameters
+
 	argumentCount := len(argumentTypes)
-	parameterCount := len(parameterTypes)
+	parameterCount := len(constructorParameters)
 
 	if argumentCount < parameterCount {
+		parameter := constructorParameters[argumentCount]
 		return nil, errors.NewDefaultUserError(
 			"invalid argument count, too few arguments: expected %d, got %d, next missing argument: `%s`",
 			parameterCount, argumentCount,
-			parameterTypes[argumentCount],
+			parameter.TypeAnnotation.Type,
 		)
 	} else if argumentCount > parameterCount {
 		return nil, errors.NewDefaultUserError(
@@ -2379,12 +2375,14 @@ func instantiateContract(
 
 	for argumentIndex := 0; argumentIndex < argumentCount; argumentIndex++ {
 		argumentType := argumentTypes[argumentIndex]
-		parameterTye := parameterTypes[argumentIndex]
-		if !sema.IsSubType(argumentType, parameterTye) {
+		parameter := constructorParameters[argumentIndex]
+		parameterType := parameter.TypeAnnotation.Type
+
+		if !sema.IsSubType(argumentType, parameterType) {
 
 			return nil, &InvalidContractArgumentError{
 				Index:        argumentIndex,
-				ExpectedType: parameterTye,
+				ExpectedType: parameterType,
 				ActualType:   argumentType,
 			}
 		}
@@ -2406,8 +2404,6 @@ func instantiateContract(
 			Address:              location.Address,
 			ContractType:         contractType,
 			ConstructorArguments: constructorArguments,
-			ArgumentTypes:        argumentTypes,
-			ParameterTypes:       parameterTypes,
 		},
 	)
 }