¿Cómo implementar simplemente un contrato inteligente en Ethereum?

Los contratos inteligentes son bloques de código que residen en la string de bloques. Es como una cuenta de Ethereum, pero existe una diferencia fundamental entre una cuenta externa y un contrato inteligente. A diferencia de un contrato inteligente, una cuenta externa puede conectarse a múltiples redes Ethereum (Rinkebey, Kovan, principal, etc.), mientras que un contrato inteligente solo es específico para una red individual (la red en la que se implementa). Cuando se implementa un contrato inteligente, crea una instancia (cuenta de contrato) en la red. Se pueden crear varias instancias de un contrato inteligente en la red o en varias redes. La implementación de un contrato inteligente se realiza mediante el envío de una transacción a la red con un código de bytes.

Implementación en una red local

Se puede usar un emulador para implementar un contrato inteligente en una red local, por ejemplo. Ganache-cli. Se encarga de todo y el usuario no tiene que preocuparse por la seguridad y la cantidad de gas necesaria para las transacciones, ya que todo sucede en una red de prueba local. Todo lo que hay que hacer es pasar el proveedor de ganache como argumento a la instancia web3 (web3 facilita la conexión entre la red blockchain y la aplicación js). 

Implementación en la red real de Ethereum

Antes de implementar un contrato inteligente en una red Ethereum real, asegúrese de que la cuenta tenga algo de éter. La implementación de un contrato es como enviar una transacción y necesita cierta cantidad de gas para procesarse. A diferencia de la implementación en una red local, las transacciones tardarán un tiempo en completarse (entre 15 segundos y 5 minutos). Web3 se usa para interactuar con la red de la misma manera que se hace en la implementación local, excepto que se personaliza el proveedor que se pasará a la instancia de web3. En lugar de crear nuestro propio Node que se conecta a la red Ethereum, se puede usar Infura. Es una API pública que da acceso al Node Infura que ya está alojado en la red Ethereum. Simplemente regístrese en Infura y obtenga un punto final que se usará en el código para implementar el contrato inteligente.

ejemplo.sol- A continuación se muestra el código de solidez de muestra utilizado para las pruebas. Todo lo que hace es establecer una variable pública como la dirección del remitente.

// Solidity program to implement
// the above approach
pragma solidity ^0.8.4;
 
// Creating a contract named Example
contract Example
{
    // Public variable of type address
    address public manager;
 
    // Constructor function to set manager
    // as address of sender
     constructor()
     {
        manager = msg.sender;
     }
}

Paso 1: instale las dependencias requeridas ejecutando los siguientes comandos:

npm i solc@0.8.4 truffle-hdwallet-provider@1.0.17 web3@1.3.5

Asegúrese de instalar las mismas versiones para que los siguientes scripts se ejecuten correctamente.

Paso 2 : regístrese en Infura y cree un proyecto en una red Ethereum particular para obtener acceso al punto final. Se requerirá que el punto final implemente el contrato inteligente en el Node infura que ya está alojado en la red Ethereum. Para crear un proyecto en fura-

• Haga clic en crear un nuevo proyecto.
• Dale un nombre.
• Seleccione la red para implementar el contrato inteligente. 
• Se pueden crear un máximo de 3 proyectos en infura de forma gratuita.

Paso 3 : obtenga acceso a Bytecode y ABI (compile el contrato inteligente). El compilador Solidity proporciona una gran cantidad de código como salida, uno puede imprimir la salida en la consola si es necesario. Solo la parte relevante (relevante para la implementación), es decir, el código de bytes y la interfaz, se extraen de la salida en el siguiente script.

Compile.js- A continuación se muestra el archivo javascript.

// Javascript file to implement
// the above approach
const path = require("path");
const fs = require("fs");
const solc = require("solc");
 
// remember to change line 8 to your
// own file path. Make sure you have your
// own file name or contract name in line
// 13, 28 and 30 as well.
 
const examplePath = path.resolve(__dirname, "contracts", "example.sol");
const source = fs.readFileSync(examplePath, "utf-8");
 
var input = {
    language: 'Solidity',
    sources: {
        'example.sol': {
            content: source
        }
    },
    settings: {
        outputSelection: {
            '*': {
                '*': ['*']
            }
        }
    }
};
 
var output = JSON.parse(solc.compile(JSON.stringify(input)));
 
var interface = output.contracts["example.sol"]["example"].abi;
 
var bytecode = output.contracts['example.sol']["example"].evm.bytecode.object;
 
module.exports = { interface, bytecode };

Paso 4 : agregue la extensión Metamask a Google Chrome desde Chrome Web Store.

Paso 5 : una vez que tenga acceso al código de bytes y la interfaz, todo lo que se requiere es crear un proveedor con una frase mnemotécnica propia y un punto final de infura utilizando el proveedor truffle-hdwallet que se instaló anteriormente. Cree una instancia web3 y pase el proveedor como argumento. Finalmente, use el método de implementación con bytecode como argumento para implementar el contrato inteligente.

desplegar.js

const HDWalletProvider = require("truffle-hdwallet-provider");
 
// Web3 constructor function.
const Web3 = require("web3");
 
// Get bytecode and ABI after compiling
// solidity code.
const { interface, bytecode } = require("file-path");
 
const provider = new HDWalletProvider(
  "mnemonic phrase",
  // Remember to change this to your own phrase!
  "-"
  // Remember to change this to your own endpoint!
);
 
// Create an instance of Web3 and pass the
// provider as an argument.
const web3 = new Web3(provider);
 
const deploy = async () => {
  // Get access to all accounts linked to mnemonic
  // Make sure you have metamask installed.
  const accounts = await web3.eth.getAccounts();
 
  console.log("Attempting to deploy from account", accounts[0]);
 
  // Pass initial gas and account to use in the send function
  const result = await new web3.eth.Contract(interface)
    .deploy({ data: bytecode })
    .send({ gas: "1000000", from: accounts[0]});
 
  console.log("Contract deployed to", result.options.address);
};
 
deploy();
 
// The purpose of creating a function and
// calling it at the end -
// so that we can use async await instead
// of using promises

Producción: 

Contract is deployed to 0x8716443863c87ee791C1ee15289e61503Ad4443c

Ahora que el contrato está desplegado en la red, su funcionalidad se puede probar usando remix IDE o se puede crear una interfaz para interactuar con el contrato inteligente en la red.

Interactuar con el contrato inteligente implementado usando Remix IDE

Remix se puede usar para conectarse a redes Ethereum reales e interactuar con contratos inteligentes implementados. Es la forma más fácil de interactuar con un contrato inteligente implementado sin tener que crear una interfaz elegante. 

Paso 1: abra Remix IDE en el navegador Chrome y copie el código de solidez del contrato inteligente implementado y péguelo en el archivo Ballot.sol en el IDE. Cambie al compilador de solidez haciendo clic en el ícono «S» en la barra lateral y compílelo.

Paso 2 : navegue hasta Implementar y ejecutar transacciones desde la barra lateral y seleccione web3 inyectado en el menú desplegable del entorno. Es la instancia de web3 inyectada por metamask en su navegador. También tiene acceso a todas las cuentas.

Paso 3 : en lugar de implementar el contrato inteligente, copie la dirección del contrato inteligente ya implementado en el campo «En la dirección». Este botón está deshabilitado hasta que ingrese una dirección válida. Una vez que se hace clic en el botón, se puede ver la lista de funciones de sus contratos inteligentes. Uno puede interactuar con un contrato inteligente implementado usando estos botones de función. Dado que el “ejemplo.sol” solo tiene una variable, manager. Al hacer clic en este botón, se obtendrá la dirección de la cuenta desde la que se implementó como salida.