Truffle: "Hola Mundo!" en un Blockchain de Prueba
Published: 2021-05-29 20:42:13

---
title: Truffle: "Hola Mundo!" en un Blockchain de Prueba
published: true
description: 
tags: 
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jd23pnq93vw1fz9rlfks.png
---

Truffle es una herramienta que nos ayuda a compilar y _deployar_ smart contracts en el blockchain. En este blog escribiremos un "Hola mundo!" en Solidity para introducirnos al desarrollo de aplicaciones decentralizadas.

{% youtube w6vQ0o7e0Cg %}

Antes de iniciar asegurate de instalar node (te recomiendo que lo instales [via nvm](https://heynode.com/tutorial/install-nodejs-locally-nvm)) y creamos nuestra carpeta de proyecto e instalamos las dependencias.

```bash
mkdir MyTruffleProject
cd MyTruffleProject
npm install --save-dev truffle ganache-cli @truffle/hdwallet-provider
```

## 1. Compilar un contrato

Primero inicializamos Truffle.

```bash
npx truffle init
```

Ahora podemos escribir nuestro contrato en la carpeta `contracts/`

`contracts/MyContract.sol`
```solidity
// SPDX-License-Identifier: MIT

pragma solidity 0.8.4;

contract MyContract {
    string public hello;

    constructor()
    {
        hello = "Hola mundo!";
    }
    
    function setHello(string memory _hello) public {
        hello = _hello;
    }
}
```

Antes de compilar, necesitamos indicarle a Truffle que vamos a usar la versión `0.8.4` de solidity.

`truffle-config.js`
```js
[...]
  // Configure your compilers
  compilers: {
    solc: {
       version: "0.8.4",    // <- Coloca aquí la versión de Solidity
      // docker: true,        
      // settings: {          
      //  optimizer: {
      //    enabled: false,
      //    runs: 200
      //  },
      //  evmVersion: "byzantium"
      // }
    }
  },
[...]
```

Ahora podemos compilar nuestro contrato.

```bash
npx truffle compile
```

## 2. Deploy local

Truffle nos pide que creemos un archivo de migración para poder _deployar_ nuestro smart contract. Estos archivos tienen que seguir la numeración `1_*.js`, `2_*.js`, `3_*.js` etc... El primero ya está creado así que creamos el segundo.

`migrations/2_my_deploy.js`
```js
const MyContract = artifacts.require("MyContract");

module.exports = async function (deployer) {
  await deployer.deploy(MyContract);
};
```

Abrimos una nueva terminal en la misma carpeta y levantamos un servidor de Ganache, nuestro blockchain de prueba local.

```bash
npx ganache-cli --deterministic
```

Para comunicarnos con Ganache debemos descomentar la sección `development` dentro de `networks`.

```js
[...]
  networks: {
     development: {
      host: "127.0.0.1",     // Localhost (default: none)
      port: 8545,            // Standard Ethereum port (default: none)
      network_id: "*",       // Any network (default: none)
     },
[...]
```

Ahora sí podemos _deployar_ nuestro contrato en el blockchain local de Ganache.

```bash
npx truffle migrate --network development
```

Interactuamos con el contracto mediante la consola de Truffle.

```bash
npx truffle console --network development
```

Una vez dentro de la consola de truffle podemos leer variables y ejecutar funciones.

```bash
my_contract = await MyContract.deployed()
await my_contract.hello()
await my_contract.setHello("Probando...")
await my_contract.hello()
```

## 3. Deploy en un testnet

Asegúrate de tener lo siguiente:

1. Una wallet instalada, mi recomendación es [metamask](https://metamask.io/)
2. Fondos de Kovan testnet que puedes conseguir gratis en el [faucet](https://faucet.kovan.network/)
3. Una llave para Kovan en [Infura](https://infura.io/)

En nuestro archivo de configuración de Truffle agregamos la opción `kovan` dentro de `networks` como se indica a continuación. Recuerda inicializar la variable `infuraApiKey` con tu Project Id de infura.

`truffle-config.js`
```js
const HDWalletProvider = require('@truffle/hdwallet-provider');
const infuraKey = "a3e70735b4.....";

const fs = require('fs');
const mnemonic = fs.readFileSync(".secret").toString().trim();

module.exports = {
  networks: {
    development: {
      host: "127.0.0.1",
      port: 8545,
      network_id: "*",
    },
    kovan: {
      provider: function () {
        return new HDWalletProvider(mnemonic, "wss://kovan.infura.io/ws/v3/" + infuraKey);
      },
      network_id: 42,
      gas: 4000000
    }
  },
  mocha: {
  },
  compilers: {
    solc: {
      version: "0.8.4",
    }
  },
  db: {
    enabled: false
  }
};
```

⚠️⚠️⚠️ Ahora copia tu `mnemonic` o `seed pharase` desde Metamask (Settings > Security & Privacy > Reveal Seed Phrase). Pero ten mucho cuidado y nunca mostrar esto a nadie porque esta es la llave privada de tus fondos.⚠️⚠️⚠️

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7ttky8gtjso0ivi1tgmt.png)

⚠️⚠️⚠️Copia tu `seed pharase` en un archivo vacío y llámalo `.secret`. Y agregalo a tu `.gitignore`. ¡No olvides agregarlo a tu .gitignore! También agrega la llave de Infura que puedes conseguir gratis creando un proyecto desde tu sitio web. Asegurate que la llave sea para Kovan.⚠️⚠️⚠️

De nuevo, recuerda agregar este archivo a tu .gitignore.

`.gitignore`

```
.secret
```
Ahora _deployamos_ en Kovan e ingresamos en la consola, muy similar a como lo hicimos antes.

```bash
npx truffle migrate --network kovan
```

```bash
npx truffle console --network kovan
```

Podemos interactuar con el contrato de la misma manera que lo hicimos anteriormente.

```bash
my_contract = await MyContract.deployed()
await my_contract.hello()
await my_contract.setHello("Probando...")
await my_contract.hello()
```

El siguiente paso será conectar esto con un frontend web pero será en otro post para no seguir alargando.

**Gracias por ver este tutorial!**

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