L7 - Ethereum Smart Contracts

Question 1

Is the source code of a contract stored on the blockchain?

Answer 1

No only the byte code.

Question 2

Which state does a contract on the blockchain have?

Answer 2

A contract has its own, persistent state which is defined by state variables.

Question 3

Steps from a Solidity Code to a Deployed Smart Contract

Answer 3

1. Contract development
2. Compilation
3. Transaction creation
4. Transaction mined

Question 4

Which steps take place on chain?

Answer 4

3. Transaction creation

4. Transaction mined

Question 5

1. Contract development

Answer 5

Smart contract code is written in Solidity

Question 6

2. Compilation

Answer 6

Compiler takes the Solidity code and produces EVM bytecode

Question 7

3. Transaction creation

Answer 7

The hex encoded bytecode is sent as transaction to the network.

Question 8

4. Transaction mined

Answer 8

The bytecode is put into a block and mined. The contract can now be used.

Question 9

struct Tutor {
string firstName; string lastName;
}
mapping (address => Tutor) tutors; address professor;

-> What is this?

Answer 9

State variables

Question 10

What is there to know about state variables?

Answer 10

• permanently stored in the contract’s storage
• changing the state requires a transaction and therefore costs ether
• reading the state of a contract is free and does not require a transaction

Question 11

What is there to know about function modifiers?

Answer 11

• convenient way to reuse pieces of code
• changes the behavior of a function
• can execute code before or/and after the actual function
• low dash_ indicates where the actual function code is injected.
• often used for authentication

Question 12

What is there to know about the constructor?

Answer 12

• exectued once when the contract is created
• cannot be called after the creation of the contract
• execution costs gas and more complex contructors lead to higher deployment costs

Question 13

What is there to know about functions?

Answer 13

• can be used to read the state of the contract
• can be used to change the state of a contract
• consist of a name, signature, visibility, a type, list of modifiers, return type.

Question 14

pure in a function

Answer 14

has no side effects so does not modify the blockchain

Can be seen as a subset of view functions which don’t modify the state but also don’t read from the state.

function add(uint a, uint b) public pure returns (uint sum) { return a +b }

Question 15

constant in a function

Answer 15

function cannot be overwritten

Question 16

view in a function

Answer 16

read-only access to the data. They do not modify any state variable nor alter the state of the blockchain. However, it can read from the state variables.

uint state = 5;

function add(uint a, uint b) public view returns (uint sum) { return a + b + state}

Question 17

payable in a function

Answer 17

By default, it is not possible to send ether to a function because the function will by default revert the transaction. This prevents that Ether is accidentally lost.

Therefore, Solidity implements payable functions.

Question 18

mapping

Answer 18

generates key-value pair

Question 19

Build-in first level object block

Answer 19

allows you to access the current block that is mined.

Question 20

Build-in first level object msg

Answer 20

message object

Question 21

Build-in first level object tx

Answer 21

transaction

Question 22

external

Answer 22

External methods can be called by other contracts via transactions issued by a certain wallet. Methods declared as external are always publicly visible and can’t be called directly by the contract itself.

Question 23

public

Answer 23

Can be called internally but also externally by other contracts and via transactions. State variables which are defined as public will by default have getter method created.

Question 24

Internal

Answer 24

Internal methods can only be accessed by the contract itself or by any contract derived from it.

Question 25

Private

Answer 25

can only be called internally by the contract who owns the method. Derived contracts cannot access a private method of their parent contract.

Question 26

What is the stack?

Answer 26

because the EVM is a stack machine rather than a register machine, all computations are done on a data region called the stack.

Question 27

Difference between storage and memory

Answer 27

• storage is comparable to a hard drive. Reading the storage is expensive and initializing and modifying storage is even more expensive.
• memory is temporary. –> memory has a lower gas consumption. It is better to do intermediary calculations here and store the result in storage.

Question 28

Where are state variables and local variables stored?

Answer 28

in storage by default

Question 29

Where can memory be used?

Answer 29

Inside a function

Question 30

Were are function arguments saved?

Answer 30

In memory by default .

Question 31

What happens if we use the keyword “storage” when declaring an array called “myArray”?

Answer 31

Then we create a pointer to the numbers array’s storage location. If the storage keyword was not used, Solidity would still have created myArray as a pointer to the numbers array’s storage location.

Question 32

What happens if we use the keyword “memory”?

Answer 32

int[] memory myArray = numbers;

// has no influence:
myArray[0] = 0;

Then the array “myArray” only exists locally. So we create a copy of the array numbers and if we change something in myArray then the numbers array is not altered.

Question 33

Where is the payable keyword required?

Answer 33

For declaring constructors and addresses that can receive/send Ether.

(e.g., constructor payable { /* … / }, function withdraw (address payable _to) public { / … */ }).

While implicit conversions are allowed from address payable to address, a casting function called
payable (<address>) must be used for conversions from address to address payable.

address public customer;

function transfer (uint amount) 
public {
payable(customer).transfer(amount); 
}
</address>

Question 34

What is a Fallback function?

Answer 34

The fallback function is called when no other function matches the function call. (e.g. when Ether is sent to a contract without a receive function). It can’t have any parameters and doesn’t return anything.

Question 35

What is function overloading?

Answer 35

When you define the same function twice with a different signature. This can be helpful if a method needs to be adapted to certain situations.

Example
function sendEther(uint amount) {
require(this.balance >= amount);
payable(msg.sender).transfer(amount); }
function sendEther(uint amount, address payable  to) {
require(this.balance >= amount);
to.transfer(amount);
}

If sendEther() is called without the address argument, the Ether will be sent to the caller. Otherwise, it will be sent to the address passed as parameter to the function.

Question 36

What are named function calls?

Answer 36

Usually, function parameters are passed by their defined signature order. Solidity supports the concept of named calls. The named calls principle allows to pass function parameters explicitly via a dictionary.

return myAddFunction({
b: 2, a:4
});

Question 37

What happens when the parent contract contains a function that is also present in the sub contract?

Answer 37

Then the functions are overloaded. In case both functions have the same signature, the sub contract’s function will overload the parent’s function. However, the parent function can still be explicitly accessed using the super keyword.

Question 38

What keyword is used for inheritance in Solidity?

Answer 38

“is”

Question 39

What is there to know about the FRO?

Answer 39

The function resolution order is not intuitive. When you draw the contracts in a tree like diagram then you start at the bottom go up and then horizontal before you go up further.

Question 40

When is a contract abstract in Solidity?

Answer 40

A function is abstract if it does not have a body. A contract is abstract if one or more functions are abstract.

Question 41

Can an abstract contract be compiled to bytecode?

Answer 41

No. A contract that inherits from an abstract contract must implement and override all methods from the base contract to be compliable.

Question 42

What is an interface?

Answer 42

Similar to an abstract class but more restrictive. Does not allow to define constructor, variables, structs and enums. It cannot inherit from a contract or implement another interface.

Example
interface CarInsurance {
function payMonthlyFee() returns (boolean result); }

One contract can implement multiple interfaces at once.