Utilizando el SDK de zkSync 2.0

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:

bash $ 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:

```ts 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.

bash 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:

```solidity // 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:

```ts 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:

bash $ 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.