Este es el futuro de Ethereum
Tags: solidity, cairo, blockchain, starknet
Published: 2022-01-03 16:33:07

---
title: Este es el futuro de Ethereum
published: true
description: Starknet ZK-Rollup Ethereum Layer 2
tags: solidity, cairo, blockchain, starknet
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s5jyii5o15hg1gf3nwka.png
--- 

Es muy importante estar actualizados con el blockchain, por eso en este video exploramos los ZK-Rollups. Lanzaremos e interactuaremos con un smart contract en Starknet, una solución de ethereum L2 que provee escalabilidad a nivel de protocolo. Starknet cuenta con su propio lenguaje basado en Cairo, conserva muchas similitudes con Solidity que veremos a continuación.

{% youtube _Y9DuZdS7Ow %}

## Dependencias

Antes de comenzar debemos instalar las dependencias.

```bash
apt install -y python3.8-venv libgmp3-dev
sudo apt install python3.8-venv
python3.8 -m venv ~/cairo_venv
source ~/cairo_venv/bin/activate
pip3 install cairo-lang
```

## Lanzar smart contract

Creamos un archivo y escribimos el contrato usando el lenguaje StarkNet.

`contract.cairo`
```solidity
# Declare this file as a StarkNet contract and set the required
# builtins.
%lang starknet
%builtins pedersen range_check

from starkware.cairo.common.cairo_builtins import HashBuiltin

# Define a storage variable.
@storage_var
func balance() -> (res : felt):
end

# Increases the balance by the given amount.
@external
func increase_balance{
        syscall_ptr : felt*, pedersen_ptr : HashBuiltin*,
        range_check_ptr}(amount : felt):
    let (res) = balance.read()
    balance.write(res + amount)
    return ()
end

# Returns the current balance.
@view
func get_balance{
        syscall_ptr : felt*, pedersen_ptr : HashBuiltin*,
        range_check_ptr}() -> (res : felt):
    let (res) = balance.read()
    return (res)
end
```

Compilamos el contrato.

```bash
starknet-compile contract.cairo --output contract_compiled.json --abi contract_abi.json
```

Establecemos que estaremos deployando nuestro contrato en el testnet.

```bash
export STARKNET_NETWORK=alpha-goerli
```

Lo lanzamos.

```bash
starknet deploy --contract contract_compiled.json
```

## Probarlo

Ejecutamos la función `increase_balance`, asegúrate de cambiar el address por el que devolvió el comando anterior.

```bash
starknet invoke \
    --address 0x0000000000000000000000000000000000000000000000000000000000000000 \
    --abi contract_abi.json \
    --function increase_balance \
    --inputs 1234
```

Observamos el estado de la transacción. Asegúrate de cambar el tx hash por el que devolvió el comando anterior.

```bash
starknet tx_status --hash 0x0000000000000000000000000000000000000000000000000000000000000000
```

Una vez que el estado de la transacción sea `ACCEPTED_ON_L2` ejecutamos obtenemos el comando de la siguiente manera.

```bash
starknet call \
    --address 0x0000000000000000000000000000000000000000000000000000000000000000 \
    --abi contract_abi.json \
    --function get_balance
```

## Bono: Cairo vs Solidity

¿Te preguntás cómo se miraría este contrato si lo escribimos en Soldity? Aquí te lo dejo.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

contract MyContract {
  uint balance;

  function increase_balance(uint amount) public
  {
    balance += amount;
  }

  function get_balance() returns(uint) public view
  {
    return balance;
  }
}
```

[Documentación Oficial](https://www.cairo-lang.org/docs/hello_starknet/intro.html#your-first-contract)

**¡Gracias por ver este tutorial!**

Sígueme en dev.to y en [Youtube](https://www.youtube.com/c/FilosofiaCodigo) para todo lo relacionado al desarrollo en Blockchain en Español.