No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Utilizando el SDK de zkSync 2.0

9/10
Recursos

zkSync es zkRollup donde encontrar√°s tanto una versi√≥n de uso espec√≠fico, como otra de uso general. Esta √ļltima te permitir√° lanzar cualquier tipo de contrato programado en Solidity, como si de Ethereum se tratase.

Despliegue de un contrato en un zkRollup de uso general

zkSync 2.0 es el nombre de este Rollups que nos permitir√° lanzar un smart contract escrito en Solidity, utilizando otras herramientas que tal vez ya conozcas como HardHat.

Paso 1: Preparación del entorno

Comienza asegur√°ndote de tener instalado Docker en tu computador. El mismo ser√° requerido por el script de HardHat para el despliegue del contrato.

Paso 2: Preparación del proyecto

Solicita algo de ETH en zkSync a través del bridge. Podrás enviarte fondos desde Ethereum o solicitarlos a través del faucet. Recuerda que utilizaremos la red de Goerli para utilizar fondos de prueba.

También deberás instalar yarn como manejador de dependencias de NodeJS, preparar el directorio de tu proyecto e instalar una serie de dependencias. Realiza todos estos pasos con los siguientes comandos:

$ npm install --global yarn
$ mkdir ejemploZkSync2
$ cd ejemploZkSync2
$ yarn init -y
$ yarn add -D typescript ts-node ethers zksync-web3 hardhat @matterlabs/hardhat-zksync-solc @matterlabs/hardhat-zksync-deploy dotenv @openzeppelin/contracts

Paso 3: Configuración de HardHat

Crea un archivo de configuración de HardHat llamado hardhat.config.ts con el siguiente contenido:

require("@matterlabs/hardhat-zksync-deploy");
require("@matterlabs/hardhat-zksync-solc");
import dotenv from "dotenv"

dotenv.config()

module.exports = {
  zksolc: {
    version: "1.1.5",
    compilerSource: "docker",
    settings: {
      optimizer: {
        enabled: true,
      },
      experimental: {
        dockerImage: "matterlabs/zksolc",
        tag: "v1.1.5"
      }
    },
  },
  zkSyncDeploy: {
    zkSyncNetwork: "https://zksync2-testnet.zksync.dev",
    ethNetwork: process.env.RPC_URL,
  },
  networks: {
    hardhat: {
      zksync: true,
    },
  },
  solidity: {
    version: "0.8.16",
  },
};

Nota: Presta atenci√≥n a la versi√≥n de Solidity de la configuraci√≥n y del contrato. No se trata de la √ļltima versi√≥n exactamente debido a peque√Īas incompatibilidades en el core. Se aconseja utilizar la versi√≥n recomendada en la documentaci√≥n de zkSync.

Adem√°s, deber√°s crear un archivo .env donde deber√°s colocar la llave privada de tu wallet, que puedes exportar desde Metamask, y el URL a un nodo de Ethereum que puedes obtener gratuitamente de servicios como Infura. Aseg√ļrate de que la llave privada de tu wallet sea la que disponga de los fondos conseguidos en el paso 2.

PRIVATE_KEY={LLAVE_PRIVADA_METAMASK}
RPC_URL=https://goerli.infura.io/v3/{LLAVE_PRIVADA_INFURA}

Paso 4: Creación del contrato inteligente

Podrás desplegar en zkSync cualquier tipo de contrato que desees. Incluso puedes utilizar las librerías de OpenZeppelin que ya conoces. Crearemos el contrato llamado contracts/SimpleToken.sol con el siguiente contenido:

// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract SimpleToken is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply * 1 ether);
    }
}

El contrato se trata de un simple token ERC20.

Paso 5: Script de despliegue del contrato

A continuación, es necesario crear el archivo deploy/deploy.ts para que HardHat pueda desplegar el contrato junto a la configuración anteriormente creada en el paso 3. Dicha configuración luce de la siguiente manera:

import { utils, Wallet } from "zksync-web3";
import * as ethers from "ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
import dotenv from "dotenv"
import * as zksync from "zksync-web3";

dotenv.config()

export default async function (hre: HardhatRuntimeEnvironment) {
  console.log("Imprimiendo en la pantalla tu balance en L2...")
  const ethProvider = ethers.getDefaultProvider("goerli");
  const syncProvider = new zksync.Provider("https://zksync2-testnet.zksync.dev");
  const syncWallet = new zksync.Wallet(process.env.PRIVATE_KEY, syncProvider, ethProvider);
  console.log("Tu balance en Layer 2: " + ethers.utils.formatEther(await syncWallet.getBalance(zksync.utils.ETH_ADDRESS)))

  console.log("Lanzando contrato en L2");
  const wallet = new Wallet(process.env.PRIVATE_KEY);
  const deployer = new Deployer(hre, wallet);
  const artifact = await deployer.loadArtifact("SimpleToken");
  const simpleTokenContract = await deployer.deploy(artifact, ["Mi Token", "MTKN", "1000000"]);

  console.log(`${artifact.contractName} ha sido lanzado en ${simpleTokenContract.address}`);
}

Este script desplegar√° el contrato en la testnet de zkSync y mintear√° 1000000 token hacia tu wallet.

Paso 6: Despliegue del contrato

Finalmente, despliega el contrato con el script anteriormente creado con los siguientes comandos:

$ yarn hardhat compile
$ yarn hardhat deploy-zksync

Primero debes compilar el contrato para luego desplegarlo.

Con la dirección del contrato, podrás verificar si se ha desplegado correctamente buscándolo en el explorer de zkSync.

Conclusión

zkSync 2.0 es uno de los principales protocolos de segunda capa de Ethereum para el despliegue de cualquier contrato y del tipo Zero Knowledge Rollups. Si de tecnologías de vanguardia se trata, sin duda nos encontramos trabajando con las tecnologías del futuro.


Contribución creada por: Kevin Fiorentino.

Aportes 2

Preguntas 0

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Primero en comentar ūüėú

Repo utilizado de zkSync 2.0. No se encuentra en los recursos de la clase.