Published on

CryptoZombies Lesson 1 - The Basics of Contract Writing and Interaction


I started having a look at CryptoZombies to get more of a feel for what Ethereum and specifically Solidity are about. This post will give a high level summary of each of the chapters in CryptoZombies Lesson 1. I wrote this post as a cheatsheet/reference to refer back to. I also investigated some of the concepts a little further out of pure curiosity.


pragma solidity ^0.4.19;
contract YourAppName {



Used to specify the version of Solidity being used


  • State variables: permanently stored in contract storage (on the Ethereum blockchain)
  • var: You can use var to declare a variable where Solidity infers the type itself

Basic Types

  • uint: unsigned int: Example: uint count = 0;
    • uint is uint256 : a 256 unsigned integer
    • uint8, uint16 and uint32 are also available
  • int: signed int
  • Strings: string name = "John";


  • Feels like C structs
  • A way to define more complex objects
contract YourContract{
    struct Person{
        string name;
        uint age;

To create a new instance of the struct:

Person john = Person("John", 33);


  • Fixed: string[4] compassPoints or uint[3] size
  • Dynamic: uint[] names
    • YourStruct[] yourStructs: useful for storing structured data in your contract on the blockchain
  • Public Arrays: Specify an array that is accessible (read only) to other contracts. Solidity creates a getter if the public keyword is used
    • YourStruct[] public yourStructs;

To add something to an array:

  • .push adds items to the end of an array
    • uint id = someArray.push(someThingToAddToTheArray) -1;: this is the index of what was just added to the array

Typecasting / Type conversion

Implicit Conversion

According to the docs this can be done when no information is lost and not the other way around: uint128 to uint256 but not the other way around.

Explicit Conversion

To explicitly cast from for example uint to uint8:

uint8 a = 5;
uint b = 6;
// throws an error because a * b returns a uint, not uint8:
uint8 c = a * b;
// we have to typecast b as a uint8 to make it work:
uint8 c = a * uint8(b);


This is a way for a contract to communicate to the blockchain that something has happened.

The definition of an event looks like a struct but uses the event keyword.

event IntegersAdded(uint x, uint y, uint result);

You then invoke the event the way you would create a struct:

IntegersAdded(_x, _y, result);


  • Standard operators: +,-,/,* and %
  • Exponential operator: **

Access Modifiers

  • Variables are private by default (i.e. no access modifier)
    • public: Solidity creates a getter for this - readable (not writable) from other contracts
      • uint public age
      • Used to store data you want to be public
  • Functions are public by default, this means any contract can execute your functions
    • You can and should declare your functions private


function doSomething(uint _num1, uint _num2) {

  • It is convention in solidity to prefix function parameter variable names with _ to differentiate them from global variables
  • Functions are public by default
  • To declare a private function:
    • It is convention to prefix private functions with _
function _doSomething(uint _num1, uint _num2) private {

  • To return something from a function:
function sum(uint _num1, uint _num2) returns (uint) {
    return _num1 + _num2;

Function Modifiers

The Solidity compiler gives warnings that suggest modifiers for functions where it is appropriate

  • view: This means that a function does not change/mutate any values or write anything - it is viewing data in the contract and not modifying the data:

  • Lesson 1 Chapter 10

function sayHello() public view returns (string) {
  • pure: These are functions that are not accessing any data in the app - values are returned based only on the function parameters

  • Lesson 1 Chapter 10

function _multiply(uint a, uint b) private pure returns (uint) {
  return a * b;




  • web3.js git repo
  • This is the JavaScript API for Ethereum
  • This allows us to interact with contracts on the Ethereum blockchain
  • As per Crypto Zombies Lesson 1 Chapter 14 we need the following to access a contract:
var abi = /* this gets generated by the compiler */;
var YourContractsFactory = web3.eth.contract(abi);
var contractAddress = /*The Ethereum address of the contract after it has been deployed on the Ethereum blockchain*/;
var YourFactory =;
  • To create an instance of your contract:
  This is some method in your contract that creates an instance of what your contract manages
  in the Crypto Zombies case this is a method called createRandomZombie(name); which creates a new Zombie random traits and  the provided name
var event = YourFactory.SomeEventInContract(function (error, result) {
  if (error) return
    Where you have this JS function in this class that works with the result
    the result object will have the fields defined on the event in your contract
    e.g. event SomeEvent(string name, string surname); would have result with these exact 2 fields
  2. Contract using Solidity language
  3. Interacting with the Ethereum blockchain using the web3.js library