Support new import syntax (#307)

* Enable new import syntax

* Enable new import syntax

Author: DylanTinianov

blockchain/contracts/contracts.go

@@ -22,6 +22,7 @@ import (
 	"embed"
 	"fmt"
 	"github.com/onflow/flow-cli/flowkit/config"
+	"github.com/onflow/flow-go-sdk"
 )
 
 // Embed all contracts in this folder
@@ -31,46 +32,44 @@ var contracts embed.FS
 
 // Core defines core contract to be embedded, along with their locations in the emulator
 var Core = []config.Contract{
-	/*
-		{
-			Name: "NonFungibleToken",
-			Aliases: config.Aliases{
-				config.Alias{
-					Network: "emulator",
-					Address: flow.HexToAddress("0xf8d6e0586b0a20c7"),
-				},
+	{
+		Name: "FungibleToken",
+		Aliases: config.Aliases{
+			config.Alias{
+				Network: "emulator",
+				Address: flow.HexToAddress("0xee82856bf20e2aa6"),
 			},
 		},
-		{
-			Name: "FungibleToken",
-			Aliases: config.Aliases{
-				config.Alias{
-					Network: "emulator",
-					Address: flow.HexToAddress("0xee82856bf20e2aa6"),
-				},
+	},
+	{
+		Name: "NonFungibleToken",
+		Aliases: config.Aliases{
+			config.Alias{
+				Network: "emulator",
+				Address: flow.HexToAddress("0xf8d6e0586b0a20c7"),
 			},
 		},
-		// TODO: Need to support new import schema in order to resolve core contracts
-
-			{
-				Name: "FlowToken",
-				Aliases: config.Aliases{
-					config.Alias{
-						Network: "emulator",
-						Address: flow.HexToAddress("0x0ae53cb6e3f42a79"),
-					},
-				},
-			},
-			{
-				Name: "MetadataViews",
-				Aliases: config.Aliases{
-					config.Alias{
-						Network: "emulator",
-						Address: flow.HexToAddress("0xf8d6e0586b0a20c7"),
-					},
-				},
+	},
+	/* TODO: Remove init args from FlowToken
+	{
+		Name: "FlowToken",
+		Aliases: config.Aliases{
+			config.Alias{
+				Network: "emulator",
+				Address: flow.HexToAddress("0x0ae53cb6e3f42a79"),
 			},
+		},
+	},
 	*/
+	{
+		Name: "MetadataViews",
+		Aliases: config.Aliases{
+			config.Alias{
+				Network: "emulator",
+				Address: flow.HexToAddress("0xf8d6e0586b0a20c7"),
+			},
+		},
+	},
 }
 
 func Included() []string {

blockchain/flowkit.go

@@ -291,6 +291,12 @@ func (fk *flowKit) createServiceAccount() error {
 		Address: flow.HexToAddress("0x01"),
 		Key:     serviceAccount.Key,
 	})
+
+	state.Deployments().AddOrUpdate(config.Deployment{ // init empty deployment
+		Network: config.EmulatorNetwork.Name,
+		Account: "Service Account",
+	})
+
 	return nil
 }
 
@@ -327,12 +333,19 @@ func (fk *flowKit) createAccount() (*flow.Account, error) {
 		return nil, err
 	}
 
+	name := fmt.Sprintf("Account 0x0%d", len(state.Accounts().Names())-1)
+
 	state.Accounts().AddOrUpdate(&accounts.Account{
-		Name:    fmt.Sprintf("Account 0x0%d", len(state.Accounts().Names())-1),
+		Name:    name,
 		Address: account.Address,
 		Key:     serviceAccount.Key,
 	})
 
+	state.Deployments().AddOrUpdate(config.Deployment{ // init empty deployment
+		Network: config.EmulatorNetwork.Name,
+		Account: name,
+	})
+
 	return account, nil
 }
 

blockchain/flowkit_test.go

@@ -20,7 +20,6 @@ package blockchain
 
 import (
 	"context"
-	"fmt"
 	"github.com/onflow/flow-cli/flowkit/accounts"
 	"github.com/onflow/flow-go-sdk"
 	"github.com/stretchr/testify/assert"
@@ -81,20 +80,12 @@ func Test_FlowJsonExport(t *testing.T) {
 	flowJson, err := fk.getFlowJson()
 	assert.NoError(t, err)
 
-	const CoreContracts = `"contracts": {
-		"FungibleToken": {
+	const FungibleToken = `"FungibleToken": {
 			"source": "",
 			"aliases": {
 				"emulator": "ee82856bf20e2aa6"
 			}
-		},
-		"NonFungibleToken": {
-			"source": "",
-			"aliases": {
-				"emulator": "f8d6e0586b0a20c7"
-			}
-		}
-	}`
+		}`
 
 	const Networks = `"networks": {
 		"emulator": "127.0.0.1:3569",
@@ -103,8 +94,7 @@ func Test_FlowJsonExport(t *testing.T) {
 		"testnet": "access.devnet.nodes.onflow.org:9000"
 	}`
 
-	fmt.Println(flowJson)
-	assert.Contains(t, flowJson, CoreContracts)
+	assert.Contains(t, flowJson, FungibleToken)
 	assert.Contains(t, flowJson, Networks)
 
 	// Accounts

blockchain/projects_test.go

@@ -510,6 +510,44 @@ func Test_DeployContract(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, args, deployment.Arguments)
 	})
+
+	t.Run("deploy contract with new import syntax", func(t *testing.T) {
+		projects, _, proj, _ := newWithSeededProject()
+
+		const contract = `
+		pub contract HelloWorld {
+			pub var A: Int
+			pub init() { self.A = 5 }
+		}`
+
+		const importContract = `
+		import "HelloWorld"
+
+		pub contract Test {
+			pub var B: Int
+			pub init() { self.B = HelloWorld.A }
+		}`
+
+		_, err := projects.DeployContract(proj.ID, model.NewAddressFromIndex(0), contract, nil)
+		require.NoError(t, err)
+
+		_, err = projects.DeployContract(proj.ID, model.NewAddressFromIndex(0), importContract, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("import core contracts", func(t *testing.T) {
+		projects, _, proj, _ := newWithSeededProject()
+
+		const contract = `
+		import "FungibleToken"
+		import "MetadataViews"
+		import "NonFungibleToken"
+		
+		pub contract Test {}`
+
+		_, err := projects.DeployContract(proj.ID, model.NewAddressFromIndex(0), contract, nil)
+		require.NoError(t, err)
+	})
 }
 
 func Test_ScriptExecution(t *testing.T) {

e2eTest/contract_deployments_test.go

@@ -116,6 +116,113 @@ func TestContractTitleParsing(t *testing.T) {
 	require.Equal(t, "HelloWorld", respA.CreateContractDeployment.Title)
 }
 
+func TestImportSyntax(t *testing.T) {
+	t.Run("new import syntax", func(t *testing.T) {
+		c := newClient()
+		project := createProject(t, c)
+
+		const contractA = `
+		pub contract HelloWorld {
+			pub var A: Int
+			pub init(a: Int) { self.A = a }
+		}`
+
+		args := []string{
+			`{"type":"Int","value":"42"}`,
+		}
+
+		const contractB = `
+		import "HelloWorld"
+		pub contract Test {
+			pub var B: Int
+			pub init() { self.B = HelloWorld.A }
+		}`
+
+		var resp CreateContractDeploymentResponse
+		err := c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractA),
+			client.Var("address", addr1),
+			client.Var("arguments", args),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+
+		err = c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractB),
+			client.Var("address", addr1),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+	})
+
+	t.Run("multiple deployments with same name", func(t *testing.T) {
+		c := newClient()
+		project := createProject(t, c)
+
+		const contractA = `
+		pub contract HelloWorld {
+			pub var A: Int
+			pub init() { self.A = 5 }
+		}`
+
+		const contractB = `
+		import "HelloWorld"
+		pub contract Test {
+			pub var B: Int
+			pub init() { self.B = HelloWorld.A }
+		}`
+
+		var resp CreateContractDeploymentResponse
+		err := c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractA),
+			client.Var("address", addr1),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+
+		err = c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractA),
+			client.Var("address", addr2),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+
+		// TODO: What if we deploy a different contract with the same name?!?
+
+		err = c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractA),
+			client.Var("address", addr3),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+
+		err = c.Post(
+			MutationCreateContractDeployment,
+			&resp,
+			client.Var("projectId", project.ID),
+			client.Var("script", contractB),
+			client.Var("address", addr1),
+			client.AddCookie(c.SessionCookie()),
+		)
+		assert.NoError(t, err)
+	})
+}
+
 func TestContractRedeployment(t *testing.T) {
 	t.Run("same contract name with different arguments", func(t *testing.T) {
 		c := newClient()

e2eTest/project_test.go

@@ -19,7 +19,6 @@
 package e2eTest
 
 import (
-	"fmt"
 	"github.com/dapperlabs/flow-playground-api/e2eTest/client"
 	"github.com/dapperlabs/flow-playground-api/model"
 	"github.com/google/uuid"
@@ -567,6 +566,12 @@ func TestExportFlowJson(t *testing.T) {
 				"emulator": "ee82856bf20e2aa6"
 			}
 		},
+		"MetadataViews": {
+			"source": "",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7"
+			}
+		},
 		"NonFungibleToken": {
 			"source": "",
 			"aliases": {
@@ -586,7 +591,6 @@ func TestExportFlowJson(t *testing.T) {
 		"testnet": "access.devnet.nodes.onflow.org:9000"
 	}`
 
-	fmt.Println(flowJsonResp.FlowJson)
 	require.Contains(t, flowJsonResp.FlowJson, CoreContracts)
 	require.Contains(t, flowJsonResp.FlowJson, Networks)
 	require.Contains(t, flowJsonResp.FlowJson, "Person")

resolver.go

@@ -20,7 +20,6 @@ package playground
 
 import (
 	"context"
-	"fmt"
 	"github.com/Masterminds/semver"
 	"github.com/dapperlabs/flow-playground-api/adapter"
 	"github.com/dapperlabs/flow-playground-api/auth"
@@ -209,7 +208,6 @@ func (r *mutationResolver) CreateTransactionExecution(
 	ctx context.Context,
 	input model.NewTransactionExecution,
 ) (*model.TransactionExecution, error) {
-	fmt.Println("CreateTransactionExecution()")
 	err := r.authorize(ctx, input.ProjectID)
 	if err != nil {
 		return nil, err
@@ -220,8 +218,6 @@ func (r *mutationResolver) CreateTransactionExecution(
 		return nil, err
 	}
 
-	fmt.Println("TX: ", exe.Logs)
-
 	return adapter.TransactionToAPI(exe), nil
 }