Remove legacy contract update

Author: SupunS

interpreter/config.go

@@ -70,8 +70,6 @@ type Config struct {
 	CapabilityCheckHandler CapabilityCheckHandlerFunc
 	// CapabilityBorrowHandler is used to borrow ID capabilities
 	CapabilityBorrowHandler CapabilityBorrowHandlerFunc
-	// LegacyContractUpgradeEnabled specifies whether to fall back to the old parser when attempting a contract upgrade
-	LegacyContractUpgradeEnabled bool
 	// ValidateAccountCapabilitiesGetHandler is used to handle when a capability of an account is got.
 	ValidateAccountCapabilitiesGetHandler ValidateAccountCapabilitiesGetHandlerFunc
 	// ValidateAccountCapabilitiesPublishHandler is used to handle when a capability of an account is got.

runtime/config.go

@@ -35,8 +35,6 @@ type Config struct {
 	ResourceOwnerChangeHandlerEnabled bool
 	// CoverageReport enables and collects coverage reporting metrics
 	CoverageReport *CoverageReport
-	// LegacyContractUpgradeEnabled enabled specifies whether to use the old parser when parsing an old contract
-	LegacyContractUpgradeEnabled bool
 	// StorageFormatV2Enabled specifies whether storage format V2 is enabled
 	StorageFormatV2Enabled bool
 }

runtime/contract_update_test.go

@@ -682,123 +682,6 @@ func TestRuntimeContractRedeploymentInSeparateTransactions(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestRuntimeLegacyContractUpdate(t *testing.T) {
-	t.Parallel()
-
-	t.SkipNow()
-
-	runtime := NewTestInterpreterRuntimeWithConfig(Config{
-		AtreeValidationEnabled:       true,
-		LegacyContractUpgradeEnabled: true,
-	})
-
-	accountCodes := map[common.Location][]byte{}
-	signerAccount := common.MustBytesToAddress([]byte{0x1})
-	fooLocation := common.AddressLocation{
-		Address: signerAccount,
-		Name:    "Foo",
-	}
-	var checkGetAndSetProgram, getProgramCalled bool
-
-	programs := map[Location]*interpreter.Program{}
-	clearPrograms := func() {
-		for l := range programs {
-			delete(programs, l)
-		}
-	}
-
-	runtimeInterface := &TestRuntimeInterface{
-		OnGetCode: func(location Location) (bytes []byte, err error) {
-			return accountCodes[location], nil
-		},
-		Storage: NewTestLedger(nil, nil),
-		OnGetSigningAccounts: func() ([]Address, error) {
-			return []Address{signerAccount}, nil
-		},
-		OnResolveLocation: NewSingleIdentifierLocationResolver(t),
-		OnGetAccountContractCode: func(location common.AddressLocation) (code []byte, err error) {
-			return accountCodes[location], nil
-		},
-		OnGetAccountContractNames: func(_ Address) ([]string, error) {
-			return []string{"Foo"}, nil
-		},
-		OnUpdateAccountContractCode: func(location common.AddressLocation, code []byte) error {
-			accountCodes[location] = code
-			return nil
-		},
-		OnEmitEvent: func(event cadence.Event) error {
-			return nil
-		},
-		OnDecodeArgument: func(b []byte, t cadence.Type) (value cadence.Value, err error) {
-			return json.Decode(nil, b)
-		},
-		OnGetAndSetProgram: func(
-			location Location,
-			load func() (*interpreter.Program, error),
-		) (
-			program *interpreter.Program,
-			err error,
-		) {
-			_, isTransactionLocation := location.(common.TransactionLocation)
-			if checkGetAndSetProgram && !isTransactionLocation {
-				require.Equal(t, location, fooLocation)
-				require.False(t, getProgramCalled)
-			}
-
-			var ok bool
-			program, ok = programs[location]
-			if ok {
-				return
-			}
-
-			program, err = load()
-
-			// NOTE: important: still set empty program,
-			// even if error occurred
-
-			programs[location] = program
-
-			return
-		},
-	}
-
-	nextTransactionLocation := NewTransactionLocationGenerator()
-
-	const fooContractV1 = `
-		pub contract Foo {
-            init() {}
-            pub fun hello() {}
-        }
-    `
-
-	const fooContractV2 = `
-        access(all) contract Foo {
-            init() {}
-            access(all) fun hello() {}
-        }
-    `
-
-	// Mock the deployment of the old 'Foo' contract
-	accountCodes[fooLocation] = []byte(fooContractV1)
-
-	// Programs are only valid during the transaction
-	clearPrograms()
-
-	// Update 'Foo' contract to Cadence 1.0 version
-
-	signerAccount = common.MustBytesToAddress([]byte{0x1})
-	err := runtime.ExecuteTransaction(
-		Script{
-			Source: UpdateTransaction("Foo", []byte(fooContractV2)),
-		},
-		Context{
-			Interface: runtimeInterface,
-			Location:  nextTransactionLocation(),
-		},
-	)
-	require.NoError(t, err)
-}
-
 func TestRuntimeContractUpdateWithOldProgramError(t *testing.T) {
 	t.Parallel()
 

runtime/contract_update_validation_test.go

@@ -168,42 +168,23 @@ func testDeployAndRemove(t *testing.T, name string, code string, config Config)
 }
 
 func testWithValidators(t *testing.T, name string, testFunc func(t *testing.T, config Config)) {
-	for _, withC1Upgrade := range []bool{true, false} {
-		withC1Upgrade := withC1Upgrade
-		name := name
-
-		if withC1Upgrade {
-			name = fmt.Sprintf("%s (with C1 validator)", name)
-		}
-
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			config := DefaultTestInterpreterConfig
-			config.LegacyContractUpgradeEnabled = withC1Upgrade
-			testFunc(t, config)
-		})
-	}
+	t.Run(name, func(t *testing.T) {
+		t.Parallel()
+		config := DefaultTestInterpreterConfig
+		testFunc(t, config)
+	})
 }
 
 func testWithValidatorsAndTypeRemovalEnabled(
 	t *testing.T,
 	name string,
 	testFunc func(t *testing.T, config Config),
 ) {
-	for _, withC1Upgrade := range []bool{true, false} {
-		withC1Upgrade := withC1Upgrade
-		name := name
-
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			config := DefaultTestInterpreterConfig
-			config.LegacyContractUpgradeEnabled = withC1Upgrade
-
-			testFunc(t, config)
-		})
-	}
+	t.Run(name, func(t *testing.T) {
+		t.Parallel()
+		config := DefaultTestInterpreterConfig
+		testFunc(t, config)
+	})
 }
 
 func TestRuntimeContractUpdateValidation(t *testing.T) {
@@ -2063,7 +2044,6 @@ func TestRuntimeContractUpdateValidation(t *testing.T) {
         `
 
 		config := DefaultTestInterpreterConfig
-		config.LegacyContractUpgradeEnabled = true
 		err := testDeployAndUpdate(t, "Test", oldCode, newCode, config)
 		require.NoError(t, err)
 	})

runtime/environment.go

@@ -195,7 +195,6 @@ func (e *interpreterEnvironment) NewInterpreterConfig() *interpreter.Config {
 		OnInvokedFunctionReturn:                   e.newOnInvokedFunctionReturnHandler(),
 		CapabilityBorrowHandler:                   e.newCapabilityBorrowHandler(),
 		CapabilityCheckHandler:                    e.newCapabilityCheckHandler(),
-		LegacyContractUpgradeEnabled:              e.config.LegacyContractUpgradeEnabled,
 		ValidateAccountCapabilitiesGetHandler:     e.newValidateAccountCapabilitiesGetHandler(),
 		ValidateAccountCapabilitiesPublishHandler: e.newValidateAccountCapabilitiesPublishHandler(),
 	}

stdlib/account.go

@@ -1673,28 +1673,13 @@ func changeAccountContracts(
 		handleContractUpdateError(err, newCode)
 
 		memoryGauge := invocation.InvocationContext
-		//legacyUpgradeEnabled := invocation.InvocationContext.SharedState.Config.LegacyContractUpgradeEnabled
-
-		//var oldProgram *ast.Program
-
-		// It is not always possible to determine whether the old code is pre-1.0 or not,
-		// only based on the parser errors. Therefore, always rely on the flag only.
-		// If the legacy contract upgrades are enabled, then use the old parser.
-		//if legacyUpgradeEnabled {
-		//	oldProgram, err = old_parser.ParseProgram(
-		//		memoryGauge,
-		//		oldCode,
-		//		old_parser.Config{},
-		//	)
-		//} else {
 		oldProgram, err := parser.ParseProgram(
 			memoryGauge,
 			oldCode,
 			parser.Config{
 				IgnoreLeadingIdentifierEnabled: true,
 			},
 		)
-		//}
 
 		if err != nil && !ignoreUpdatedProgramParserError(err) {
 			// NOTE: Errors are usually in the new program / new code,
@@ -1706,25 +1691,13 @@ func changeAccountContracts(
 			handleContractUpdateError(err, oldCode)
 		}
 
-		//var validator UpdateValidator
-		//if legacyUpgradeEnabled {
-		//	validator = NewCadenceV042ToV1ContractUpdateValidator(
-		//		location,
-		//		contractName,
-		//		handler,
-		//		oldProgram,
-		//		program,
-		//		inter.AllElaborations(),
-		//	)
-		//} else {
 		validator := NewContractUpdateValidator(
 			location,
 			contractName,
 			handler,
 			oldProgram,
 			program.Program,
 		)
-		//}
 
 		err = validator.Validate()
 		handleContractUpdateError(err, newCode)