Welcome to writing your first Cairo program. We will not be diving in to writing Starknet contracts until later modules, but will rather focus on Cairo fundamentals for now. 

The main function is the starting point of every Cairo program. Therefore, our first lesson is starting with the main() function. Let's do that now.

Every function signature must end with a 

Like Solidity, statements and expressions end in a 

Here is a sample of a function called triality with no parameters nor return values.

Modify the code to write a function named main that has no parameters nor return values.

https://www.cairo-lang.org/docs/hello_cairo/intro.html

Writing your Main Function

Next we will need to learn how to declare a variable. The primary primitive data type of Cairo is a field element (

, where P is a very large prime number. All math with field elements will be done Modulo P.

There are several ways to declare a variable, but in this lesson we will start with the 

 syntax. A valid variable declaration is:

 is the data type. If you do not denote a type, the variable will default to a felt so this syntax is equivalent to the above statement:

Assertions are operations that do one of two things.

Here is an example of an assert statement:

 memory cell to 3 if it has not already been set

 memory address has already been written to, this statement will verify that the two values are the same. The program will terminate with an error message if the two values are not equal

Memory is immutable (cannot be changed) in Cairo, so remember once you set a value to a memory address you cannot change it... but you can always write to a new memory address!

All the pyramids of Cairo Mummies are most optimally built using 4 sides, but using 3 sides is also acceptable. Modify the code by adding an assertion to ensure 

 does indeed equal 3 and instantiate a variable 

https://www.cairo-lang.org/docs/how_cairo_works/cairo_intro.html#field-elements

https://www.cairo-lang.org/docs/how_cairo_works/consts.html#assert-statement

Creating Assertions

 A function signature defines the parameters (and their types) and the return values (and their types) of the function. The main function written in section one is an example of a function signature with no parameters and no return values.

Here is a sample of a function called triality that has two parameters, 

func add(x : felt, y : felt) -> (z : felt) {

As seen in the first lesson, every function needs a 

 statement must return the types as specified in the function signature. You must set the output variable name = the result you are returning as seen in the line 

 is the name of the output variable from the function signature and 

Also, note that when declaring a variable that has been returned from a function you must 'unpack' it. So instead of saying:

This is because every function returns its result as a tuple. So by declaring 

, we are unpacking the tuple returned by the function and setting the 0th element of the returned tuple to the variable 

Mummies love for the area of the base of the pyramid to be 100 times more than the number of sides of the pyramid. Modify the code by adding a function 

 and return the ideal area of the pyramid's base which should be 100 times the number of sides. Return the ideal area in the variable 

https://www.cairo-lang.org/docs/how_cairo_works/functions.html

Function Parameters and Return Values

A conditional statement begins with the keyword 

 followed by parentheses. An expression is placed inside the parentheses, which is evaluated when the conditional statement is reached. The result of the evaluation is a boolean value. If that value is true, then the code inside the body of the conditional executes. If not, that code is skipped.

Let's have a look at a simple conditional comparing two numbers. We will return 1 if the two input parameters are equal and 0 if they are not. Notice we use 

 for checking for equality, every if statement ends with a 

 and the condition is contained between the if statement and a 

func is_equal(x : felt, y : felt) -> (z : felt) {

Mummies are very particular about the area of the base of their pyramids. They ask you to make sure you can verify that the base has the ideal area. Modify the code by adding a function 

 and will return 1 if the base area is ideal or 0 if it is not.

For official docs on writing a function with conditionals: 

Writing Function Logic and Conditionals

So you have decided to take on the challenge of skipping the step by step lessons and building the base of Cairo pyramids in one script! You can always go through the step by step lessons if you encounter any issues.

We will assume you have the Cairo fundamentals covered in this module down, so we will get right into the problem.

We have created a main function with several assertions and some calls to functions that do not exist yet. Your goal is to make the script compile and run successfully. Make sure to read the comments because certain code cannot be modified. The tasks:

Mummies love for the area of the base of the pyramid to be equal to 100 times the number of sides of the pyramid. Add a function 

Mummies are very particular about the area of the base of their pyramid being ideal. Add a function 

 and will return 1 if the base area is the ideal area or 0 if it is not.

Solve the Module Without Help

Overview: Welcome to Cairo Mummies! You will learn the Cairo programming language by learning the ins and outs of building pyramids, tombs and mummies.

        In module one we will be building our first simple Cairo script to help begin understanding pyramids. This will start with just the basics: we will create a main function, write some simple helper functions and deal with assertions. You will also become familiar with the concept of a field element (felt), the primitive type of Cairo.

        What you will implement: For this section you will write two simple functions, one that will calculate the optimal number of area units to build the base of a pyramid, and another that will check if the base of a pyramid is being built correctly.

        Topics covered: Inputs, Outputs, functions, felts, main function, conditionals.

        Note: You can either skips the step by step lessons and solve the whole module or go step by step starting at Lesson 1. See you on the other side of your first script.

Module 0 - Simple Cairo Scripting to build pyramids