Move Crypto contract on-chain

.github/workflows/ci.yml

@@ -39,18 +39,12 @@ jobs:
           go-version: ${{ env.GO_VERSION }}
           cache: true
 
-      - name: Install Flow CLI
-        run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)"
-
       - name: Build
         run: make -j8 build
 
       - name: Test
         run: make ci
 
-      - name: Cadence Testing Framework
-        run: cd stdlib/contracts && flow test --cover --covercode="contracts" crypto_test.cdc
-
       - name: Upload coverage report
         uses: codecov/codecov-action@v2
         with:

cmd/cmd.go

@@ -97,13 +97,6 @@ func DefaultCheckerConfig(
 			importedLocation common.Location,
 			_ ast.Range,
 		) (sema.Import, error) {
-			if importedLocation == stdlib.CryptoCheckerLocation {
-				cryptoChecker := stdlib.CryptoChecker()
-				return sema.ElaborationImport{
-					Elaboration: cryptoChecker.Elaboration,
-				}, nil
-			}
-
 			stringLocation, ok := importedLocation.(common.StringLocation)
 			if !ok {
 				return nil, &sema.CheckerError{

runtime/environment.go

@@ -674,40 +674,29 @@ func (e *interpreterEnvironment) resolveImport(
 	importRange ast.Range,
 ) (sema.Import, error) {
 
-	var elaboration *sema.Elaboration
-	switch importedLocation {
-	case stdlib.CryptoCheckerLocation:
-		cryptoChecker := stdlib.CryptoChecker()
-		elaboration = cryptoChecker.Elaboration
-
-	default:
-
-		// Check for cyclic imports
-		if e.checkedImports[importedLocation] {
-			return nil, &sema.CyclicImportsError{
-				Location: importedLocation,
-				Range:    importRange,
-			}
-		} else {
-			e.checkedImports[importedLocation] = true
-			defer delete(e.checkedImports, importedLocation)
-		}
-
-		const getAndSetProgram = true
-		program, err := e.GetProgram(
-			importedLocation,
-			getAndSetProgram,
-			e.checkedImports,
-		)
-		if err != nil {
-			return nil, err
+	// Check for cyclic imports
+	if e.checkedImports[importedLocation] {
+		return nil, &sema.CyclicImportsError{
+			Location: importedLocation,
+			Range:    importRange,
 		}
+	} else {
+		e.checkedImports[importedLocation] = true
+		defer delete(e.checkedImports, importedLocation)
+	}
 
-		elaboration = program.Elaboration
+	const getAndSetProgram = true
+	program, err := e.GetProgram(
+		importedLocation,
+		getAndSetProgram,
+		e.checkedImports,
+	)
+	if err != nil {
+		return nil, err
 	}
 
 	return sema.ElaborationImport{
-		Elaboration: elaboration,
+		Elaboration: program.Elaboration,
 	}, nil
 }
 
@@ -1006,36 +995,30 @@ func (e *interpreterEnvironment) newInjectedCompositeFieldsHandler() interpreter
 		compositeKind common.CompositeKind,
 	) map[string]interpreter.Value {
 
-		switch location {
-		case stdlib.CryptoCheckerLocation:
-			return nil
+		switch compositeKind {
+		case common.CompositeKindContract:
+			var address Address
 
-		default:
-			switch compositeKind {
-			case common.CompositeKindContract:
-				var address Address
-
-				switch location := location.(type) {
-				case common.AddressLocation:
-					address = location.Address
-				default:
-					return nil
-				}
+			switch location := location.(type) {
+			case common.AddressLocation:
+				address = location.Address
+			default:
+				return nil
+			}
 
-				addressValue := interpreter.NewAddressValue(
-					inter,
-					address,
-				)
+			addressValue := interpreter.NewAddressValue(
+				inter,
+				address,
+			)
 
-				return map[string]interpreter.Value{
-					sema.ContractAccountFieldName: stdlib.NewAccountReferenceValue(
-						inter,
-						e,
-						addressValue,
-						interpreter.FullyEntitledAccountAccess,
-						interpreter.EmptyLocationRange,
-					),
-				}
+			return map[string]interpreter.Value{
+				sema.ContractAccountFieldName: stdlib.NewAccountReferenceValue(
+					inter,
+					e,
+					addressValue,
+					interpreter.FullyEntitledAccountAccess,
+					interpreter.EmptyLocationRange,
+				),
 			}
 		}
 
@@ -1046,36 +1029,22 @@ func (e *interpreterEnvironment) newInjectedCompositeFieldsHandler() interpreter
 func (e *interpreterEnvironment) newImportLocationHandler() interpreter.ImportLocationHandlerFunc {
 	return func(inter *interpreter.Interpreter, location common.Location) interpreter.Import {
 
-		switch location {
-		case stdlib.CryptoCheckerLocation:
-			cryptoChecker := stdlib.CryptoChecker()
-			program := interpreter.ProgramFromChecker(cryptoChecker)
-			subInterpreter, err := inter.NewSubInterpreter(program, location)
-			if err != nil {
-				panic(err)
-			}
-			return interpreter.InterpreterImport{
-				Interpreter: subInterpreter,
-			}
-
-		default:
-			const getAndSetProgram = true
-			program, err := e.GetProgram(
-				location,
-				getAndSetProgram,
-				importResolutionResults{},
-			)
-			if err != nil {
-				panic(err)
-			}
+		const getAndSetProgram = true
+		program, err := e.GetProgram(
+			location,
+			getAndSetProgram,
+			importResolutionResults{},
+		)
+		if err != nil {
+			panic(err)
+		}
 
-			subInterpreter, err := inter.NewSubInterpreter(program, location)
-			if err != nil {
-				panic(err)
-			}
-			return interpreter.InterpreterImport{
-				Interpreter: subInterpreter,
-			}
+		subInterpreter, err := inter.NewSubInterpreter(program, location)
+		if err != nil {
+			panic(err)
+		}
+		return interpreter.InterpreterImport{
+			Interpreter: subInterpreter,
 		}
 	}
 }
@@ -1123,45 +1092,32 @@ func (e *interpreterEnvironment) newCompositeValueFunctionsHandler() interpreter
 func (e *interpreterEnvironment) loadContract(
 	inter *interpreter.Interpreter,
 	compositeType *sema.CompositeType,
-	constructorGenerator func(common.Address) *interpreter.HostFunctionValue,
-	invocationRange ast.Range,
+	_ func(common.Address) *interpreter.HostFunctionValue,
+	_ ast.Range,
 ) *interpreter.CompositeValue {
 
-	switch compositeType.Location {
-	case stdlib.CryptoCheckerLocation:
-		contract, err := stdlib.NewCryptoContract(
-			inter,
-			constructorGenerator(common.ZeroAddress),
-			invocationRange,
-		)
-		if err != nil {
-			panic(err)
-		}
-		return contract
-
-	default:
-
-		var storedValue interpreter.Value
-
-		switch location := compositeType.Location.(type) {
+	var contractValue interpreter.Value
 
-		case common.AddressLocation:
-			storageMap := e.storage.GetStorageMap(
-				location.Address,
-				StorageDomainContract,
-				false,
+	location := compositeType.Location
+	if addressLocation, ok := location.(common.AddressLocation); ok {
+		storageMap := e.storage.GetStorageMap(
+			addressLocation.Address,
+			StorageDomainContract,
+			false,
+		)
+		if storageMap != nil {
+			contractValue = storageMap.ReadValue(
+				inter,
+				interpreter.StringStorageMapKey(addressLocation.Name),
 			)
-			if storageMap != nil {
-				storedValue = storageMap.ReadValue(inter, interpreter.StringStorageMapKey(location.Name))
-			}
-		}
-
-		if storedValue == nil {
-			panic(errors.NewDefaultUserError("failed to load contract: %s", compositeType.Location))
 		}
+	}
 
-		return storedValue.(*interpreter.CompositeValue)
+	if contractValue == nil {
+		panic(errors.NewDefaultUserError("failed to load contract: %s", location))
 	}
+
+	return contractValue.(*interpreter.CompositeValue)
 }
 
 func (e *interpreterEnvironment) newOnFunctionInvocationHandler() func(_ *interpreter.Interpreter) {