Solidity basics for programmers

11 Aug 2022

Hello after long break! 😅 Today I want to present you everything I learned about Solidity from "web2" developer perspective. My knowledge is based pretty much on CryptoZombies online course/game. In this post I use many js analogies and in a few places I also use c++ ones. You have been warned.

Solidity version in contract:

pragma solidity >=0.5.0 <0.6.0;
// declare version range
pragma solidity ^0.8.4;
// or without specifying upper bound

contract HelloWorld {} - it's pretty much like class HelloWorld {}
struct is similar to struct in c++. In js I'd say it's like a fn with constructor:

// in solidity:
struct Person {
  uint age;
  string name;
}
Person person = Person(25, 'Jakub');

// in js:
function Person(age, name) {
  this.age = age;
  this.name = name;
}
const person = new Person(25, 'Jakub');

Function structure: name, parameters, visibility, modifier, return:

function functionName(uint param) private|public|internal|external  pure|view|-  returns|- {
  // body
}

internal - protected
external - can be called only outside contract (e.g. from frontend web app)
view - only to read data, no gas being used
pure - like static function, cannot access outer data

// complete function example
function _multiply(uint a, uint b) private pure returns(uint) {
  return a * b;
}

Reference types:
- array
- struct
- mapping
- string
memory keyword needs to be used if we want to pass reference type to function or return it
calldata is equivalent to memory for external functions:

function createZombie(string memory _name) private {
  // create zombie
}

function takeTwo(uint[] calldata values) external pure returns (uint[2] memory) {
  return [values[0], values[1]];
}

string[5] stringArray; - it is possible to declare the array size like in other languages
msg.sender - address of contract caller, e.g.
0x0cE446255506E92DF41614C46F1d6df9Cc969183
Semi-random number generator in solidity:

uint rand = uint(keccak256(abi.encodePacked('key_to_hash')));
// generating number is based on hashing a string.
// 1 char replacement can return totally different value.

String comparison in solidity 🙈:

keccak256(abi.encodePacked('kitty')) == keccak256(abi.encodePacked('kitty'))

Emitting events is quite straightforward:

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

function _add(uint _x, uint _y) private {
  uint result = _x + _y;
  emit IntegersAdded(_x, _y, result);
}

mapping is actually a key-value dictionary:

mapping(address => uint) ownerNFTCount;
mapping(address => uint) public addressToBalance;

function storeValues() public {
  ownerNFTCount[0x0cE446255506E92DF41614C46F1d6df9Cc969183] = 2;
  addressToBalance[0x0cE446255506E92DF41614C46F1d6df9Cc969183] = 10;
}

function retrieveValues(address _address) public view returns (uint, uint) {
  return (ownerNFTCount[_address], addressToBalance[_address]);
  // returns (0, 0) if not defined
}

mapping equivalent in TypeScript:

const ownerNFTCount: { [address: number]: number } = {};
const addressToBalance: { [address: number]: number } = {};

const storeValues = () => {
  ownerNFTCount[0x0ce446255506e92df41614c46f1d6df9cc969183] = 2;
  addressToBalance[0x0ce446255506e92df41614c46f1d6df9cc969183] = 10;
};

const retrieveValues = (address: number) => ({
  0: ownerNFTCount[address] ?? 0,
  1: addressToBalance[address] ?? 0,
});

require() function:

function fn(uint a) private {
  require(a == 0, 'value should be 0');
}

// equivalent in js:
function fn(a) {
  if (a !== 0) return 'value should be 0';
  // notice != in js and == in solidity
}

Contract inheritance:

contract ZombieFeeding is ZombieFactory {}

Mutating state using storage:

Sandwich storage mySandwich = sandwiches[_index];
// changing mySandwich mutates sandwiches
Sandwich memory anotherSandwich = sandwiches[_index];
// no mutation

Interfaces in solidity are kind of contract skeletons. We only declare functions we want to use:

interface KittyInterface {
  function getKitty(uint kittyId) external view returns (
    string calldata kittyName,
    uint kittyDna
  );
}

contract KittyContract {
  string kittyName;
  uint kittyDna;
  // initializing contract with address points to this external contract
  KittyInterface kittyContract = KittyInterface(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d);
  function getKittyData() public {
    (kittyName, kittyDna) = kittyContract.getKitty(1);
  }
}

modifier in solidity is a mini function which can modify other functions. Usually it just checks some condition. A bit like TypeScript's type predicates:

bool mintPaused = true;

function isOwner() public view returns(bool) {
  return msg.sender == _owner;
}

modifier onlyOwner() {
  require(isOwner());
  _; // _; tells contract to return to fn body
}

function startMint() external onlyOwner {
  mintPaused = false;
}

renounceOwnership() - interesting function from OpenZeppelin's Ownable.sol contract. It sets contract owner to address 0, which makes it impossible to call onlyOwner functions after that anymore
Saving gas with unint:
- Declaring uint less than 256, e.g. uint8 or uint16 doesn't save gas, because solidity reserves 256 bits of storage anyway
- However, it makes sense inside struct. Using smaller uints can save you gas. It's important to put them next to each other
- Note that uint is default for uint256

struct DoesntSaveGas { // ❌
  uint32 a;
  uint b;
  uint32 c;
}

struct SavesGas { // ✅
  uint32 a;
  uint32 c;
  uint b;
}

external views are free when they are called externally. If they are called internally by other non view functions, it costs additional gas
Fun fact: writing to storage is one of the most expensive operations in Solidity
Functions with memory stored array can be used as gas usage optimisation.
Creating function, which iterates over an array every time may sound like a bad practice, but gas-wise this is better option. Creating separate array in storage and manipulating on it would be more expensive:

function getZombiesByOwner(address _owner) external view returns (uint[] memory) {
  uint[] memory result = new uint[](ownerZombieCount[_owner]);
  uint counter = 0;
  for (uint i = 0; i < zombies.length; i++) {
    if (zombieToOwner[i] == _owner) {
      result[counter] = i;
      counter++;
    }
  }
  return result;
}

payable - function modificator for operations with transferring ethers
transferring ethers from txn to contract:

owner.transfer(address(this).balance);

address(this).balance - contract’s balance
Generating random numbers in contract is not so safe, can be potentially abused, more info here
using SafeMath for uint256; - if you're familiar with c++, using keyword shouldn't be new to you. The difference is that in Solidity we declare it for specific data type.
SafeMath is a lib which helps with preventing number overflows
require() function will refund gas if condition don’t pass, assert() will not
In frontend side communication with smart contracts:
- call - is used for view and pure functions
- send - will create a transaction and change data on the blockchain
indexed event parameter:

event Transfer(address indexed _from) {}
// indexed is necessary to filter events

// on frontend:
cryptoZombies.events.Transfer({ filter: { _to: userAccount } })

Using events can be used in some cases as a cheaper form of storage.

And that's it! Thanks for reading :)

Jakub Kuś - Fullstack Dev

React + Node

Abstract Factory - coffee→