# Hola - Contrato (Trufa + Nodo Remoto) ### ¡Hola mundo ! Agregar un contrato con el comando ``` truffle create contract HelloWorld ``` No entraremos en detalles sobre cómo escribir Solidity en este ejercicio, pero puede obtener más información en la [página de documentación de Solidity](https://solidity.readthedocs.io/en/latest/) . El contrato sólo almacenará un nombre por ahora: contratos/HelloWorld.sol ``` pragma solidity >=0.5.0 <0.8.0; contract HelloWorld { string name = 'Celo'; function getName() public view returns (string memory) { return name; } function setName(string calldata newName) external { name = newName; } } ``` ### Preparar la implementación #### compilar el [contrato](https://docs.celo.org/developer/walkthrough/hello-contract-remote-node#compile-the-contract) Antes de implementar el contrato, debe compilar el código de Solidity en el código de bytes de Ethereum. El siguiente comando trufa buscará en el `./contracts`directorio y compilará cualquier contrato de Solidity () nuevo o actualizado `.sol`. ``` truffle compile ``` Después de compilar el contrato, debe crear una migración para implementar el contrato. Para eso, cree un archivo en la `./migrations/`carpeta llamada `2_deploy_helloworld.js`: INFORMACIÓN [Obtenga más información sobre las migraciones de trufas aquí.](https://www.trufflesuite.com/docs/truffle/getting-started/running-migrations) migraciones/2\_deploy\_helloworld.js ``` var HelloWorld = artifacts.require("HelloWorld"); module.exports = function (deployer) { deployer.deploy(HelloWorld); }; ``` INFORMACIÓN Puede [obtener más información sobre las opciones de configuración de Truffle aquí.](https://www.trufflesuite.com/docs/truffle/reference/configuration) ### Implementar en Alfajores (Remotamente [)](https://docs.celo.org/developer/walkthrough/hello-contract-remote-node#deploy-to-alfajores-remotely) Cuando implementa contratos en la red Celo con un nodo remoto, debe firmar la transacción de implementación del contrato localmente antes de enviarla al nodo remoto para que se transmita a la red. Esto presenta algunos desafíos únicos al usar herramientas de desarrollo de Ethereum (como Truffle) porque los objetos de transacción de Celo son ligeramente diferentes a los objetos de transacción de Ethereum. Cuando esté listo para implementar su contrato en Alfajores, necesitará un cliente Celo conectado a la red de prueba. En este ejercicio, se conectará a un nodo remoto para leer y escribir en la red de prueba pública (Alfajores), pero también podría ejecutar un nodo de red de prueba localmente para realizar las mismas acciones. Estos son los pasos a seguir para implementar el contrato en la red de prueba de Alfajores. 1. Conéctese a Forno (un proveedor de servicios de nodo Celo remoto) 2. Obtener información de la cuenta personal (generar una clave privada si es necesario, almacenada en `./.env`) 3. Obtenga la dirección de su cuenta personal y financíela a través del [faucet](https://faucet.celo.org/) 4. Obtenga el código de bytes del contrato compilado 5. Crear y firmar la transacción de implementación del contrato. 6. Enviar transacción a la red. Asegúrese de que las dependencias estén instaladas con: ``` yarn install ``` Ejecute el script createAccount.js con: ``` node createAccount.js ``` crearCuenta.js ``` const Web3 = require("web3"); const web3 = new Web3("http://localhost:8545"); console.log(web3.eth.accounts.create()); ``` El código proporcionado imprimirá un par de clave privada/cuenta en la terminal. Copie y pegue lo impreso `priavteKey`en una `PRIVATE_KEY`variable en un archivo llamado `.env`, similar a lo que se muestra en el `.envexample`archivo. La `address`que está impresa con la clave privada es la cuenta a la que financiaremos con el faucet. Si vas a la [página de Faucet de Alfajores](https://faucet.celo.org/) , puedes acceder a tu cuenta con CELO y ver cómo aumenta tu saldo. #### Implementar el contrato **Implementación de trufa** Antes de poder utilizar trufa para la migración, debe establecer la configuración adecuada en `./truffle-config.js`. En la parte superior de `./truffle-config.js`, configure `kit`conectándose a la red de prueba y agregando la cuenta que acaba de financiar. trufa.config.js ``` const ContractKit = require("@celo/contractkit"); const Web3 = require("web3"); require("dotenv").config(); const web3 = new Web3("https://alfajores-forno.celo-testnet.org"); const kit = ContractKit.newKitFromWeb3(web3); kit.connection.addAccount(process.env.PRIVATE_KEY); ``` Luego, en el `networks`objeto, puede agregar el `kit`proveedor inicializado a una `alfajores`propiedad. trufa.config.js ``` networks: { test: { host: "127.0.0.1", port: 7545, network_id: "*" }, alfajores: { provider: kit.connection.web3.currentProvider, // CeloProvider network_id: 44787, // Alfajores network id gas: 4000000, // You need to include the gas limit } } ``` INFORMACIÓN Truffle no estima el gas correctamente, por lo que debes especificar un límite de gas en `truffle.config.js`. Ahora, despliega los contratos a Alfajores con este comando: ``` truffle migrate --network alfajores ``` [**Implementación**](https://docs.celo.org/developer/walkthrough/hello-contract-remote-node#custom-nodejs-deployment) **personalizada de Node.js** En esta sección, implementará un contrato utilizando un script Node.js simple para mostrar cómo puede hacerlo sin usar Truffle. Debe compilar el `HelloWorld.sol`contrato usando (si aún no lo está): ``` truffle compile ``` Este comando generará un `HelloWorld.json`archivo en el `./build/contracts/`directorio. `HelloWorld.json`Contiene una gran cantidad de datos sobre el contrato, el compilador y detalles de bajo nivel. Importe este archivo al script de implementación `celo_deploy.js`con: ``` const HelloWorld = require("./build/contracts/HelloWorld.json"); ``` Finalmente está listo para implementar el contrato. Utilice `kit`para crear una transacción personalizada que incluya el código de bytes del contrato. celo\_deploy.js ``` let tx = await kit.connection.sendTransaction({ from: address, data: HelloWorld.bytecode, // from ./build/contracts/HelloWorld.json }); ``` INFORMACIÓN Para implementar un contrato en Celo, use la `kit.connection.sendTransaction()`función sin `to:`campo y el código de bytes del contrato en el `data`campo. La cuenta desde la que envía la transacción debe tener suficiente CELO para pagar la tarifa de transacción, a menos que especifique otra moneda como `feeCurrency`, entonces necesitará suficiente cantidad de esa moneda para pagar la tarifa de transacción. El script de implementación completo tiene aproximadamente 20 líneas de código. celo\_deploy.js ``` const Web3 = require("web3"); const ContractKit = require("@celo/contractkit"); const web3 = new Web3("https://alfajores-forno.celo-testnet.org"); const privateKeyToAddress = require("@celo/utils/lib/address").privateKeyToAddress; const kit = ContractKit.newKitFromWeb3(web3); require("dotenv").config(); const HelloWorld = require("./build/contracts/HelloWorld.json"); async function awaitWrapper() { kit.connection.addAccount(process.env.PRIVATE_KEY); // this account must have a CELO balance to pay transaction fees // This account must have a CELO balance to pay tx fees // get some testnet funds at https://faucet.celo.org const address = privateKeyToAddress(process.env.PRIVATE_KEY); console.log(address); let tx = await kit.connection.sendTransaction({ from: address, data: HelloWorld.bytecode, }); const receipt = await tx.waitReceipt(); console.log(receipt); } awaitWrapper(); ``` ¡Felicidades! ¡Has implementado tu primer contrato en Celo! Puede verificar la implementación de su contrato en [Blockscout](https://alfajores-blockscout.celo-testnet.org/) . Puede obtener el hash de la transacción del recibo y buscarlo en el explorador de bloques. #### Interactuar con [contratos](https://docs.celo.org/developer/walkthrough/hello-contract-remote-node#interacting-with-custom-contracts) Ahora HelloWorld.sol está implementado en la testnet de Alfajores. ¿Cómo se puede interactuar con el contrato implementado utilizando ContractKit? `helloWorld.js`Incluye un código de ejemplo que muestra cómo puedes hacer esto. Hay 3 funciones definidas `helloWorld.js`que logran esto. La primera función `initContract()`, lee la información del contrato implementado del artefacto Truffle en `HelloWorld.json`. Con esta información, puede crear una nueva instancia de contrato web3.js: holaMundo.js ``` async function initContract() { // Check the Celo network ID const networkId = await web3.eth.net.getId(); // Get the contract associated with the current network const deployedNetwork = HelloWorld.networks[networkId]; // Create a new contract instance with the HelloWorld contract info let instance = new kit.web3.eth.Contract( HelloWorld.abi, deployedNetwork && deployedNetwork.address ); getName(instance); setName(instance, "hello world!"); } ``` Después de crear la instancia del contrato, la `initContract()`función llama `getName()`y `setName()`. La `getName()`función llamará, devolverá e imprimirá la `getName()`función de la instancia proporcionada del contrato HelloWorld. holaMundo.js ``` async function getName(instance) { let name = await instance.methods.getName().call(); console.log(name); } ``` La `setName()`función es un poco más complicada. Primero, obtiene la clave de la cuenta del `./secret`archivo proporcionado, como en `celo_deploy.js`. Luego crea una `txObject`que codifica una llamada de transacción de contrato inteligente `setName()`con la `newName`instancia proporcionada del contrato HelloWorld. Luego, la función envía el objeto de transacción codificado a la red, espera un recibo y lo imprime en la consola. holaMundo.js ``` async function setName(instance, newName) { // Add your account to ContractKit to sign transactions // This account must have a CELO balance to pay tx fees, get some https://faucet.celo.org kit.connection.addAccount(process.env.PRIVATE_KEY); const address = privateKeyToAddress(process.env.PRIVATE_KEY); // Encode the transaction to HelloWorld.sol according to the ABI let txObject = await instance.methods.setName(newName); // Send the transaction let tx = await kit.sendTransactionObject(txObject, { from: address }); let receipt = await tx.waitReceipt(); console.log(receipt); } ``` El método anterior muestra más detalles sobre cómo crear secuencias de comandos y transacciones de implementación personalizadas que el método anterior. Como puede ver, todas las ventajas de Ethereum se aplican a Celo, por lo que prácticamente todos los tutoriales y otro contenido deberían poder traducirse fácilmente a Celo. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://andino.gitbook.io/andino-recursos/celo/construir-en-celo/herramientas-para-desarrolladores/contract-kit/hola-contrato-trufa-+-nodo-remoto.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.