Vamos a comenzar a programar en Solidity, que es el lenguaje para escribir los contratos de Ethereum. Para ello existe un juego para aprender que se llama CryptoZombies que esta muy bien y es bastante entretenido.

1.- Todo contrato comienza con:

El codigo en Solidity va encansulado en contratos. Un contrato es el bloque fundamental de las aplicaciones de Ehtereum y tienen una version.

Todo codigo en solidty tiene para comenzar una “version pragma” que es la declaracion de la version del compilador. Esto hace que a futuro no se roma el codigo.

pragma solidity ^0.4.19;
contract ZombieFactory {
    //start here
}

2.-  Variables de Estado y enteros.

Las variables de estado ( state variables) se almacenan en el contrato, esto significa que estan escritas en la cadena de bloques de Ethereum, podriamos pensar en ellas como escribiendo en base de datos.

• unit – es un tipo de datos entero sin signo, esto significa que no puede ser negativo, debe ser siempre positivo.  unit es actualmente un aligas uint256 , podemos declarar otros como unit8, unit16, unit32,…
• int – es un tipo de datos entero con signo.

Ejemplo:

pragma solidity ^0.4.19;
contract ZombieFactory {
    uint dnaDigits = 16;
}

3.- Operaciones matematicas en Solidity.

La operaciones mas comunes son sumas , restas , multiplicacion, division, resto, exponente.

• Suma: x + y
• Resta: x – y
• Multiplicacione x*y
• Division x/y
• Resto:  x % y . => 13 % 5  = 3
• Exponencial  x = y ** z  => 5 elevado a 2  = 25

4.- Estructuras

A veces nos hace falta trabajar con una estructura que tenga varias propiedades, para ello Solidity provee  ‘struct’ que nos va a permitir tener estructuras un poco mas complejas

struct Vehiculo {
  uint nRuedas;
  string color;
}

5.- Arrays

Para trabajar con colecciones podemos usar un array. Tenemos dos tipos de arrays fijos y dinamicos. Lo que se conoce como fixed arrays y dynamic arrays.

// Un Array con una longitud fija de 2 elementos:
uint[2] fixedArray;
// otro Array fijo, con longitud de 5 elementos:
string[5] stringArray;
// un Array dinámico, sin longitud fija que puede seguir creciendo:
uint[] dynamicArray;

Tambien podemos crear un array de structs. En el caso anterior

Person[] people; // Array dinámico, podemos seguir añadiéndole elementos

Las variables se almacenan permanentemente en la blockchain. El crearlas dinamicamente nos permite almacenarlas como en una base de datos.
Podemos crear arrays como publicos y Solidity nos creara automaticamente un metodo getter para el.

Esto va a permitir que otros contratos puedan leer ( pero no escribir) en este array.

6.- Funciones basicas en Solidity

Declarar una funcionen Solidity es igual que en otros lenguajes.

function crearVehiculos(string _color, uint _ruedas) {
}

Esta funcion llamada crearVehiculos se le pasa dos parametros . Por convencion se usa el escribir los parametros con underscore “_” para diferenciar de  constantes globales.

7.- Trabajando con estructuras y arrays

struct Person {
  uint age;
  string name;
}
Person[] public people;

// create a New Person:
Person satoshi = Person(172, "Satoshi");
// Add that person to the Array:
people.push(satoshi);

people.push(Person(16, "Vitalik"));

8 Funciones publicas y privadas

uint[] numbers;
function _addToArray(uint _number) private {
 numbers.push(_number);
}

string greeting = "Qué tal viejo!";
function sayHello() public returns (string) {
  return greeting;
}

Sino cambia el estado lo normal es que la marquemos como view , si lo modifica entonces usaremos pure. La funcion de arriba podria quedar como

function sayHello() public view returns (string) {

En el caso de tener una funcion en la que pasamos unos parametros y hacemos unos calculos y no leemos datos de la aplicacion se suele usar la funcion como pure

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

9 Eventos

Los eventos son la forma en la que nuestro contrato comunica que algo sucedió en la cadena de bloques a la interfaz de usuario, el cual puede estar ‘escuchando’ ciertos eventos y hacer algo cuando suceden.

Los eventos se declaran con la palabra event y el nombre del evento con los parametros

// declara el evento
event IntegersAdded(uint x, uint y, uint result);
function add(uint _x, uint _y) public {
  uint result = _x + _y;
  // lanza el evento para hacer saber a tu aplicación que la función ha sido llamada:
  IntegersAdded(_x, _y, result);
  return result;
}

Ejemplo completo del juego de CRYPTOZOMBIES

pragma solidity ^0.4.19;
contract ZombieFactory {
    event NewZombie(uint zombieId, string name, uint dna);
    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;
    struct Zombie {
        string name;
        uint dna;
    }
    Zombie[] public zombies;
    function _createZombie(string _name, uint _dna) private {
        uint id = zombies.push(Zombie(_name, _dna)) - 1;
        NewZombie(id, _name, _dna);
    }
    function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(_str));
        return rand % dnaModulus;
    }
    function createRandomZombie(string _name) public {
        uint randDna = _generateRandomDna(_name);
        _createZombie(_name, randDna);
    }
}

Una vez que ya tenemos nuestro contrato completo necesitamos escribir una aplicacion de usuario en javascript para interacturar con el.

La libreria que tiene Ethereum es Web3.js

En vez de continuar os invito a que os conecteis al juego gratuito y que vayais leccion por leccion aprendiendo. Este es solo un nivel de los que tiene.

https://cryptozombies.io

Aqui os dejo mi crytozombie

https://share.cryptozombies.io/es/lesson/1/share/Daniel_Casta%C3%B1era_Garrido?id=Z29vZ2xlLW9hdXRoMnwxMTIyODU1NDg1MzkyNjUxODk2NTI%3D