> For the complete documentation index, see [llms.txt](https://andino.gitbook.io/andino-recursos/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://andino.gitbook.io/andino-recursos/celo/construir-en-celo/herramientas-para-desarrolladores/contract-kit/hola-contrato-trufa-+-nodo-remoto.md).

# Hola - Contrato (Trufa + Nodo Remoto)

### ¡Hola mundo ! <a href="#hello-world" id="hello-world"></a>

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 <a href="#prepare-deployment" id="prepare-deployment"></a>

#### compilar el [contrato](https://docs.celo.org/developer/walkthrough/hello-contract-remote-node#compile-the-contract) <a href="#compile-the-contract" id="compile-the-contract"></a>

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) <a href="#deploy-to-alfajores-remotely" id="deploy-to-alfajores-remotely"></a>

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 <a href="#deploy-the-contract" id="deploy-the-contract"></a>

**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) <a href="#interacting-with-custom-contracts" id="interacting-with-custom-contracts"></a>

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.