This page is incomplete. If you’re an expert on the topic, please edit this page and sprinkle it with your wisdom.

Anatomy of smart contracts

Sam Richards
Last edit: @samajammin, December 2, 2020
Edit page

A smart contract is a program that runs at an address on Ethereum. They're made up of data and functions that can execute upon receiving a transaction. Here's an overview of what makes up a smart contract.

Prerequisites

Make sure you've read about smart contracts first. This document assumes you're already familiar with programming languages such as JavaScript or Python.

Data

Any contract data must be assigned to a location: either to storage or memory. It's costly to modify storage in a smart contract so you need to consider where your data should live.

Storage

Persistent data is referred to as storage and is represented by state variables. These values get stored permanently on the blockchain. You need to declare the type so that the contract can keep track of how much storage on the blockchain it needs when it compiles.

1// Solidity example
2contract SimpleStorage {
3 uint storedData; // State variable
4 // ...
5}
6
7
1# Vyper example
2storedData: int128
3
4

If you've already programmed object-oriented languages, you'll likely be familiar with most types. However address should be new to you if you're new to Ethereum development.

An address type can hold an Ethereum address which equates to 20 bytes or 160 bits. It returns in hexadecimal notation with a leading 0x.

Other types include:

  • boolean
  • integer
  • fixed point numbers
  • fixed-size byte arrays
  • dynamically-sized byte arrays
  • Rational and integer literals
  • String literals
  • Hexadecimal literals
  • Enums

For more explanation, take a look at the docs:

Memory

Values that are only stored for the lifetime of a contract function's execution are called memory variables. Since these are not stored permanently on the blockchain, they are much cheaper to use.

Learn more about how the EVM stores data (Storage, Memory, and the Stack) in the Solidity docs.

Environment variables

In addition to the variables you define on your contract, there are some special global variables. They are primarily used to provide information about the blockchain or current transaction.

Examples:

Prop

block.timestamp

State variable

uint256

Description

Current block epoch timestamp

Prop

msg.sender

State variable

address

Description

Sender of the message (current call)

Functions

In the most simplistic terms, functions can get information or set information in response to incoming transactions.

There are two types of function calls:

  • internal – these don't create an EVM call
    • Intenal functions and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it)
  • external – these do create an EVM call
    • External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works).

They can also be public or private

  • public functions can be called internally from within the contract or externally via messages
  • private functions are only visible for the contract they are defined in and not in derived contracts

Both functions and state variables can be made public or private

Here's a function for updating a state variable on a contract:

1// Solidity example
2function update_name(string value) public {
3 dapp_name = value;
4}
5
  • The parameter value of type string is passed into the function: update_name
  • It's declared public, meaning anyone can access it
  • It's not declared view, so it can modify the contract state

View functions

These functions promise not to modify the state of the contract's data. Command examples are "getter" functions – you might use this to receive a user's balance for example.

1// Solidity example
2function balanceOf(address _owner) public view returns (uint256 _balance) {
3 return ownerPizzaCount[_owner];
4}
5
1dappName: public(string)
2
3@view
4@public
5def readName() -> string:
6 return dappName
7

What is considered modifying state:

  1. Writing to state variables.
  2. Emitting events.
  3. Creating other contracts.
  4. Using selfdestruct.
  5. Sending ether via calls.
  6. Calling any function not marked view or pure.
  7. Using low-level calls.
  8. Using inline assembly that contains certain opcodes.

Constructor functions

constructor functions are only executed once when the contract is first deployed. Like constructor in many class-based programming languages, these functions often initialize state variables to their specified values.

1// Solidity example
2// Initializes the contract's data, setting the `owner`
3// to the address of the contract creator.
4constructor() public {
5 // All smart contracts rely on external transactions to trigger its functions.
6 // `msg` is a global variable that includes relevant data on the given transaction,
7 // such as the address of the sender and the ETH value included in the transaction.
8 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
9 owner = msg.sender;
10}
11
1# Vyper example
2
3@external
4def __init__(_beneficiary: address, _bidding_time: uint256):
5 self.beneficiary = _beneficiary
6 self.auctionStart = block.timestamp
7 self.auctionEnd = self.auctionStart + _bidding_time
8

Built-in functions

In addition to the variables and functions you define on your contract, there are some special built-in functions. The most obvious example is:

  • address.send() – Solidity
  • send(address) – Vyper

These allow contracts to send ETH to other accounts.

Writing functions

Your function needs:

  • parameter variable and type (if it accepts parameters)
  • declaration of internal/external
  • declaration of pure/view/payable
  • returns type (if it returns a value)
1pragma solidity >=0.4.0 <=0.6.0;
2
3contract ExampleDapp {
4 string dapp_name; //state variable
5
6 /*Called when the contract is deployed and initializes the value*/
7 constructor() public{
8 dapp_name = "My Example dapp";
9 }
10
11 // Get Function
12 function read_name() public view returns(string){
13 return dapp_name;
14 }
15
16 // Set Function
17 function update_name(string value) public {
18 dapp_name = value;
19 }
20}
21

A complete contract might look something like this. Here the constructor function provides an initial value for the dapp_name variable.

Events and logs

Events let you communicate with your smart contract from your frontend or other subscribing applications. When a transaction is mined, smart contracts can emit events and write logs to the blockchain that the frontend can then process.

Annotated examples

These are some examples written in Solidity. If you'd like to play with the code, you can interact with them in Remix.

Hello world

1// Specifies the version of Solidity, using semantic versioning.
2// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
3pragma solidity ^0.5.10;
4
5// Defines a contract named `HelloWorld`.
6// A contract is a collection of functions and data (its state).
7// Once deployed, a contract resides at a specific address on the Ethereum blockchain.
8// Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
9contract HelloWorld {
10
11 // Declares a state variable `message` of type `string`.
12 // State variables are variables whose values are permanently stored in contract storage.
13 // The keyword `public` makes variables accessible from outside a contract
14 // and creates a function that other contracts or clients can call to access the value.
15 string public message;
16
17 // Similar to many class-based object-oriented languages, a constructor is
18 // a special function that is only executed upon contract creation.
19 // Constructors are used to initialize the contract's data.
20 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
21 constructor(string memory initMessage) public {
22 // Accepts a string argument `initMessage` and sets the value
23 // into the contract's `message` storage variable).
24 message = initMessage;
25 }
26
27 // A public function that accepts a string argument
28 // and updates the `message` storage variable.
29 function update(string memory newMessage) public {
30 message = newMessage;
31 }
32}
33

Token

1pragma solidity ^0.5.10;
2
3contract Token {
4 // An `address` is comparable to an email address - it's used to identify an account on Ethereum.
5 // Addresses can represent a smart contract or an external (user) accounts.
6 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#address
7 address public owner;
8
9 // A `mapping` is essentially a hash table data structure.
10 // This `mapping` assigns an unsigned integer (the token balance) to an address (the token holder).
11 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#mapping-types
12 mapping (address => uint) public balances;
13
14 // Events allow for logging of activity on the blockchain.
15 // Ethereum clients can listen for events in order to react to contract state changes.
16 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#events
17 event Transfer(address from, address to, uint amount);
18
19 // Initializes the contract's data, setting the `owner`
20 // to the address of the contract creator.
21 constructor() public {
22 // All smart contracts rely on external transactions to trigger its functions.
23 // `msg` is a global variable that includes relevant data on the given transaction,
24 // such as the address of the sender and the ETH value included in the transaction.
25 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
26 owner = msg.sender;
27 }
28
29 // Creates an amount of new tokens and sends them to an address.
30 function mint(address receiver, uint amount) public {
31 // `require` is a control structure used to enforce certain conditions.
32 // If a `require` statement evaluates to `false`, an exception is triggered,
33 // which reverts all changes made to the state during the current call.
34 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
35
36 // Only the contract owner can call this function
37 require(msg.sender == owner, "You are not the owner.");
38
39 // Ensures a maximum amount of tokens
40 require(amount < 1e60, "Maximum issuance succeeded");
41
42 // Increases the balance of `receiver` by `amount`
43 balances[receiver] += amount;
44 }
45
46 // Sends an amount of existing tokens from any caller to an address.
47 function transfer(address receiver, uint amount) public {
48 // The sender must have enough tokens to send
49 require(amount <= balances[msg.sender], "Insufficient balance.");
50
51 // Adjusts token balances of the two addresses
52 balances[msg.sender] -= amount;
53 balances[receiver] += amount;
54
55 // Emits the event defined earlier
56 emit Transfer(msg.sender, receiver, amount);
57 }
58}
59

Unique digital asset

1pragma solidity ^0.5.10;
2
3// Imports symbols from other files into the current contract.
4// In this case, a series of helper contracts from OpenZeppelin.
5// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#importing-other-source-files
6
7import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721.sol";
8import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
9import "../node_modules/@openzeppelin/contracts/introspection/ERC165.sol";
10import "../node_modules/@openzeppelin/contracts/math/SafeMath.sol";
11
12// The `is` keyword is used to inherit functions and keywords from external contracts.
13// In this case, `CryptoPizza` inherits from the `IERC721` and `ERC165` contracts.
14// Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#inheritance
15contract CryptoPizza is IERC721, ERC165 {
16 // Uses OpenZeppelin's SafeMath library to perform arithmetic operations safely.
17 // Learn more: https://docs.openzeppelin.com/contracts/2.x/api/math#SafeMath
18 using SafeMath for uint256;
19
20 // Constant state variables in Solidity are similar to other languages
21 // but you must assign from an expression which is constant at compile time.
22 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constant-state-variables
23 uint256 constant dnaDigits = 10;
24 uint256 constant dnaModulus = 10 ** dnaDigits;
25 bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
26
27 // Struct types let you define your own type
28 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/types.html#structs
29 struct Pizza {
30 string name;
31 uint256 dna;
32 }
33
34 // Creates an empty array of Pizza structs
35 Pizza[] public pizzas;
36
37 // Mapping from owner's address to id of Pizza
38 mapping(uint256 => address) public pizzaToOwner;
39
40 // Mapping from owner's address to number of owned token
41 mapping(address => uint256) public ownerPizzaCount;
42
43 // Mapping from token ID to approved address
44 mapping(uint256 => address) pizzaApprovals;
45
46 // You can nest mappings, this example maps owner to operator approvals
47 mapping(address => mapping(address => bool)) private operatorApprovals;
48
49 // Internal function to create a random Pizza from string (name) and DNA
50 function _createPizza(string memory _name, uint256 _dna)
51 // The `internal` keyword means this function is only visible
52 // within this contract and contracts that derive this contract
53 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#visibility-and-getters
54 internal
55 // `isUnique` is a function modifier that checks if the pizza already exists
56 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html#function-modifiers
57 isUnique(_name, _dna)
58 {
59 // Adds Pizza to array of Pizzas and get id
60 uint256 id = SafeMath.sub(pizzas.push(Pizza(_name, _dna)), 1);
61
62 // Checks that Pizza owner is the same as current user
63 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
64 assert(pizzaToOwner[id] == address(0));
65
66 // Maps the Pizza to the owner
67 pizzaToOwner[id] = msg.sender;
68 ownerPizzaCount[msg.sender] = SafeMath.add(
69 ownerPizzaCount[msg.sender],
70 1
71 );
72 }
73
74 // Creates a random Pizza from string (name)
75 function createRandomPizza(string memory _name) public {
76 uint256 randDna = generateRandomDna(_name, msg.sender);
77 _createPizza(_name, randDna);
78 }
79
80 // Generates random DNA from string (name) and address of the owner (creator)
81 function generateRandomDna(string memory _str, address _owner)
82 public
83 // Functions marked as `pure` promise not to read from or modify the state
84 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#pure-functions
85 pure
86 returns (uint256)
87 {
88 // Generates random uint from string (name) + address (owner)
89 uint256 rand = uint256(keccak256(abi.encodePacked(_str))) +
90 uint256(_owner);
91 rand = rand % dnaModulus;
92 return rand;
93 }
94
95 // Returns array of Pizzas found by owner
96 function getPizzasByOwner(address _owner)
97 public
98 // Functions marked as `view` promise not to modify state
99 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#view-functions
100 view
101 returns (uint256[] memory)
102 {
103 // Uses the `memory` storage location to store values only for the
104 // lifecycle of this function call.
105 // Learn more: https://solidity.readthedocs.io/en/v0.5.10/introduction-to-smart-contracts.html#storage-memory-and-the-stack
106 uint256[] memory result = new uint256[](ownerPizzaCount[_owner]);
107 uint256 counter = 0;
108 for (uint256 i = 0; i < pizzas.length; i++) {
109 if (pizzaToOwner[i] == _owner) {
110 result[counter] = i;
111 counter++;
112 }
113 }
114 return result;
115 }
116
117 // Transfers Pizza and ownership to other address
118 function transferFrom(address _from, address _to, uint256 _pizzaId) public {
119 require(_from != address(0) && _to != address(0), "Invalid address.");
120 require(_exists(_pizzaId), "Pizza does not exist.");
121 require(_from != _to, "Cannot transfer to the same address.");
122 require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
123
124 ownerPizzaCount[_to] = SafeMath.add(ownerPizzaCount[_to], 1);
125 ownerPizzaCount[_from] = SafeMath.sub(ownerPizzaCount[_from], 1);
126 pizzaToOwner[_pizzaId] = _to;
127
128 // Emits event defined in the imported IERC721 contract
129 emit Transfer(_from, _to, _pizzaId);
130 _clearApproval(_to, _pizzaId);
131 }
132
133 /**
134 * Safely transfers the ownership of a given token ID to another address
135 * If the target address is a contract, it must implement `onERC721Received`,
136 * which is called upon a safe transfer, and return the magic value
137 * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
138 * otherwise, the transfer is reverted.
139 */
140 function safeTransferFrom(address from, address to, uint256 pizzaId)
141 public
142 {
143 // solium-disable-next-line arg-overflow
144 this.safeTransferFrom(from, to, pizzaId, "");
145 }
146
147 /**
148 * Safely transfers the ownership of a given token ID to another address
149 * If the target address is a contract, it must implement `onERC721Received`,
150 * which is called upon a safe transfer, and return the magic value
151 * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
152 * otherwise, the transfer is reverted.
153 */
154 function safeTransferFrom(
155 address from,
156 address to,
157 uint256 pizzaId,
158 bytes memory _data
159 ) public {
160 this.transferFrom(from, to, pizzaId);
161 require(_checkOnERC721Received(from, to, pizzaId, _data), "Must implmement onERC721Received.");
162 }
163
164 /**
165 * Internal function to invoke `onERC721Received` on a target address
166 * The call is not executed if the target address is not a contract
167 */
168 function _checkOnERC721Received(
169 address from,
170 address to,
171 uint256 pizzaId,
172 bytes memory _data
173 ) internal returns (bool) {
174 if (!isContract(to)) {
175 return true;
176 }
177
178 bytes4 retval = IERC721Receiver(to).onERC721Received(
179 msg.sender,
180 from,
181 pizzaId,
182 _data
183 );
184 return (retval == _ERC721_RECEIVED);
185 }
186
187 // Burns a Pizza - destroys Token completely
188 // The `external` function modifier means this function is
189 // part of the contract interface and other contracts can call it
190 function burn(uint256 _pizzaId) external {
191 require(msg.sender != address(0), "Invalid address.");
192 require(_exists(_pizzaId), "Pizza does not exist.");
193 require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
194
195 ownerPizzaCount[msg.sender] = SafeMath.sub(
196 ownerPizzaCount[msg.sender],
197 1
198 );
199 pizzaToOwner[_pizzaId] = address(0);
200 }
201
202 // Returns count of Pizzas by address
203 function balanceOf(address _owner) public view returns (uint256 _balance) {
204 return ownerPizzaCount[_owner];
205 }
206
207 // Returns owner of the Pizza found by id
208 function ownerOf(uint256 _pizzaId) public view returns (address _owner) {
209 address owner = pizzaToOwner[_pizzaId];
210 require(owner != address(0), "Invalid Pizza ID.");
211 return owner;
212 }
213
214 // Approves other address to transfer ownership of Pizza
215 function approve(address _to, uint256 _pizzaId) public {
216 require(msg.sender == pizzaToOwner[_pizzaId], "Must be the Pizza owner.");
217 pizzaApprovals[_pizzaId] = _to;
218 emit Approval(msg.sender, _to, _pizzaId);
219 }
220
221 // Returns approved address for specific Pizza
222 function getApproved(uint256 _pizzaId)
223 public
224 view
225 returns (address operator)
226 {
227 require(_exists(_pizzaId), "Pizza does not exist.");
228 return pizzaApprovals[_pizzaId];
229 }
230
231 /**
232 * Private function to clear current approval of a given token ID
233 * Reverts if the given address is not indeed the owner of the token
234 */
235 function _clearApproval(address owner, uint256 _pizzaId) private {
236 require(pizzaToOwner[_pizzaId] == owner, "Must be pizza owner.");
237 require(_exists(_pizzaId), "Pizza does not exist.");
238 if (pizzaApprovals[_pizzaId] != address(0)) {
239 pizzaApprovals[_pizzaId] = address(0);
240 }
241 }
242
243 /*
244 * Sets or unsets the approval of a given operator
245 * An operator is allowed to transfer all tokens of the sender on their behalf
246 */
247 function setApprovalForAll(address to, bool approved) public {
248 require(to != msg.sender, "Cannot approve own address");
249 operatorApprovals[msg.sender][to] = approved;
250 emit ApprovalForAll(msg.sender, to, approved);
251 }
252
253 // Tells whether an operator is approved by a given owner
254 function isApprovedForAll(address owner, address operator)
255 public
256 view
257 returns (bool)
258 {
259 return operatorApprovals[owner][operator];
260 }
261
262 // Takes ownership of Pizza - only for approved users
263 function takeOwnership(uint256 _pizzaId) public {
264 require(_isApprovedOrOwner(msg.sender, _pizzaId), "Address is not approved.");
265 address owner = this.ownerOf(_pizzaId);
266 this.transferFrom(owner, msg.sender, _pizzaId);
267 }
268
269 // Checks if Pizza exists
270 function _exists(uint256 pizzaId) internal view returns (bool) {
271 address owner = pizzaToOwner[pizzaId];
272 return owner != address(0);
273 }
274
275 // Checks if address is owner or is approved to transfer Pizza
276 function _isApprovedOrOwner(address spender, uint256 pizzaId)
277 internal
278 view
279 returns (bool)
280 {
281 address owner = pizzaToOwner[pizzaId];
282 // Disable solium check because of
283 // https://github.com/duaraghav8/Solium/issues/175
284 // solium-disable-next-line operator-whitespace
285 return (spender == owner ||
286 this.getApproved(pizzaId) == spender ||
287 this.isApprovedForAll(owner, spender));
288 }
289
290 // Check if Pizza is unique and doesn't exist yet
291 modifier isUnique(string memory _name, uint256 _dna) {
292 bool result = true;
293 for (uint256 i = 0; i < pizzas.length; i++) {
294 if (
295 keccak256(abi.encodePacked(pizzas[i].name)) ==
296 keccak256(abi.encodePacked(_name)) &&
297 pizzas[i].dna == _dna
298 ) {
299 result = false;
300 }
301 }
302 require(result, "Pizza with such name already exists.");
303 _;
304 }
305
306 // Returns whether the target address is a contract
307 function isContract(address account) internal view returns (bool) {
308 uint256 size;
309 // Currently there is no better way to check if there is a contract in an address
310 // than to check the size of the code at that address.
311 // See https://ethereum.stackexchange.com/a/14016/36603
312 // for more details about how this works.
313 // TODO Check this again before the Serenity release, because all addresses will be
314 // contracts then.
315 // solium-disable-next-line security/no-inline-assembly
316 assembly {
317 size := extcodesize(account)
318 }
319 return size > 0;
320 }
321}
322

Further reading

Check out Solidity and Vyper's documentation for a more complete overview of smart contracts: