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 .

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

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 ./contractsdirectorio 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í.

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í.

Implementar en Alfajores (Remotamente )

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

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 priavteKeyen una PRIVATE_KEYvariable en un archivo llamado .env, similar a lo que se muestra en el .envexamplearchivo. La addressque 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 , 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 kitconectá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 networksobjeto, puede agregar el kitproveedor inicializado a una alfajorespropiedad.

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 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.solcontrato usando (si aún no lo está):

truffle compile

Este comando generará un HelloWorld.jsonarchivo en el ./build/contracts/directorio. HelloWorld.jsonContiene 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.jscon:

const HelloWorld = require("./build/contracts/HelloWorld.json");

Finalmente está listo para implementar el contrato. Utilice kitpara 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 datacampo. 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 . Puede obtener el hash de la transacción del recibo y buscarlo en el explorador de bloques.

Interactuar con contratos

Ahora HelloWorld.sol está implementado en la testnet de Alfajores. ¿Cómo se puede interactuar con el contrato implementado utilizando ContractKit? helloWorld.jsIncluye un código de ejemplo que muestra cómo puedes hacer esto.

Hay 3 funciones definidas helloWorld.jsque 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 ./secretarchivo proporcionado, como en celo_deploy.js. Luego crea una txObjectque codifica una llamada de transacción de contrato inteligente setName()con la newNameinstancia 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.