Esta práctica es para el curso de Programación con Solidity de Coding Bootcamps: http://coding-bootcamps.com/es/ Para más información sobre este curso, visite el siguiente enlace: https://learn.coding-bootcamps.com/p/programacion-de-solidity-en-espanol
Para más información sobre cursos de Blockchain en Español, visite el siguiente enlace: https://learn.coding-bootcamps.com/p/coding-bootcamps-espanol
Voting DApp permitirá a los usuarios participar en una votación para seleccionar el candidato que quierán utilizando token. Los usuarios podrán comprar tokens con ether y usarlos para votar a su candidato seleccionado.
- Preparación del entorno de trabajo y creación del Smart Contract.
- Desplegamos el Smart Contract en Remix y Truffle e interactuamos con él.
- Testeando el Smart Contract.
- Front end e interfaz.
- Desplegando el Smart Contract en una testnet de Ethereum.
La organización (propietaria del smart contract) desplegará un smart contract con todos los candidatos disponibles. Los usuarios/votantes podrán comprar tokens usando ether. Podrán usar estos tokens para votar a su candidatos seleccionado. El propietario del smart contract podrá transferir los fondos de ether que almacena el smart contract a una dirección de Ethereum. La información de la votación se puede consultar en cualquier momento por cualquier usuario.
- Node.js instalado: https://nodejs.org/es/download/
- Ganache instalado: https://www.trufflesuite.com/ganache
- Truffle instalado: https://www.trufflesuite.com/docs/truffle/getting-started/installation
npm install -g truffle
- Extensión de Solidity de Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity
- Metamask instalado en navegador: https://metamask.io/
- Lite Server: https://www.npmjs.com/package/lite-server
- Crear carpeta directorio de nuestro proyecto: Voting_DApp
- Dentro de la carpeta de nuestro proyecto, ejecutamos:
truffle init
e indicamos Y (Yes). Se nos crea la estructura de carpetas: contracts, migrations, test y el archivo truffle-config.js - Ejecutamos
npm init
, se nos crea el archivo package.json. - Instalamos Lite Server:
npm install lite-server --save-dev
. En el archivo package.json, apartado scripts, añadimos:"dev": "lite_server"
- En nuestra carpeta del proyecto creamos el archivo: bs-config.json, introducimos el siguiente código, para configurar Lite Server:
{ "server": { "baseDir": ["./src", "./build/contracts"] } }
- Instalar Truffle Contract:
npm install @truffle/contract
- Web3.js instalado: https://github.com/ethereum/web3.js/
npm install web3
- Instalar Truffle hdwaller provider:
npm install truffle-hdwallet-provider
- Accedemos a la carpeta contracts y creamos el archivo Voting.sol. El código del Smart Contract se puede encontrar en: https://github.com/jordiguirao92/Voting_DApp/blob/master/contracts/Voting.sol
- Compilamos el smart contract. En la carpeta de nuestro proyecto ejecutamos el comando:
truffle compile
. Se nos creará la carpeta build.
- Abrimos Remix y creamos un nuevo archivo de Solidity.
- Copiamos el código de nuestro contrato.
- Compilamos el contrato.
- Desplegamos el contrato.
- Interactuamos desde Remix con el contrato.
- En la carpeta migrations, creamos el archivo: 2_Voting_migration.js. El código se encuentra en: https://github.com/jordiguirao92/Voting_DApp/blob/master/migrations/2_Voting_migration.js
- Modificamos el archivo truffle-config.js. Donde configuraremos nuestra red local de Ethereum para el despliegue del contrato. El código está: https://github.com/jordiguirao92/Voting_DApp/blob/master/truffle-config.js
- Iniciamos Ganache y comprobamos que los datos RPC SERVER sean los mismos que están en nuestro archivo truffle-config.js.
- En la carpeta raiz de nuestro proyecto ejecutamos el comando:
truffle migrate --network development
, se iniciará el despligue de nuestro smart contract.
- En la carpeta raiz de nuestro proyecto, ejecutamos
truffle console
, para acceder a la consola de truffle y poder interactuar con nuestro smart contract. Ejecutamos los siguientes comandos:
voter = await Voting.deployed()
voter.address
ownerAddress = await voter.get_owner()
ownerAddress
voterTotalTokens = await voter.totalTokens.call()
voterTotalTokens
voterTotalTokens.toString()
tokensBuy = await voter.buy({value:2000000000000000000})
tokensBuy
tokensBalance = await voter.balanceTokens.call()
tokensBalance
tokensBalance.toString()
En la carpeta test, cremos el archivo Voting_test.js, donde escribiremos los diferentes test de nuestra DApp. El código de los test está en: https://github.com/jordiguirao92/Voting_DApp/blob/master/test/Voting_test.js
Para comprobar nuestros test, ejecutamos: truffle test
Podremos ver en la terminal el resultado de nuestros test.
Creamos la carpeta src dentro de la carpeta de nuestro proyecto. Dentro de la carpeta src, creamos la carpeta js y el archivo index.html.
En este archivo crearemos la interfaz gráfica y visual de nuestra DApp. El código está: https://github.com/jordiguirao92/Voting_DApp/blob/master/src/index.html
Contiene los archivos:
- app.js: En este archivo crearemos el código necesario para poder conectar con nuestro smart contract. El código está: https://github.com/jordiguirao92/Voting_DApp/blob/master/src/js/app.js
- truffle-contract.js:El código está: https://github.com/jordiguirao92/Voting_DApp/blob/master/src/js/truffle-contract.js
- web3.min-js: El código está: https://github.com/jordiguirao92/Voting_DApp/blob/master/src/js/web3.min.js
- Acceder a https://infura.io/ y creamos un nuevo proyecto.
- Actualizamos el archivo truffle-config.js. Añadimos la configuración de la red RINKEBY, indicamos las características de nuestra conexión a Infura y indicamos las palabras clave mnemonic de nuestra wallet.
- Desplegamos el smart contract en la red de Rinkeby.
truffle migrate --network rinkeby
.
Si queremos resetear el contrato desplegado utilizar el comando: truffle migrate --network rinkeby --reset
- Tener nuestro Smart Contract desplegado.
truffle migrate
. Indicar que network queremos utilizartruffle migrate --network nombredelared
- Inicializar nuestra DApp, ejecutando el comando:
npm run dev
. - Conectar Metamask a la red donde está desplegado nuestro Smart Contract.
- Ya tenemos nuestra DApp preparada para interactuar con ella.