Aprenda a implantar contratos para a Testnet zkEVM da Polygon
O que é zkEVM?
Você deve estar se perguntando “O que é zkEVM?”
A zkEVM da Polygon é o primeiro zk-Rollup com código fonte disponível, que fornece uma equivalência completa do opcode >EVM para uma experiência de usuário sem atritos e segurança >da Ethereum.
- https://polygon.technology/solutions/polygon-zkevm
É uma rede diferente da Matic POS da Polygon?
Sim, é uma rede completamente diferente com suas próprias configurações de tokens e carteiras.
Isso significa que usa seus próprios tokens?
Sim, ele usa seus próprios tokens nativos e não os tokens Matic ou Testnet Mumbai.
Ok, mas o que significa Equivalência de EVM?
Equivalência se refere ao Tipo 2 ZK-EVM que é um pouco melhor definido no blog do Vitalik sobre ZK-EVMs.
Tipo 2 ZK-EVMs esforçar-se para ser exatamente equivalente à EVM, mas não exatamente equivalente à Ethereum. Ou seja, eles >se parecem exatamente com a Ethereum "de dentro", mas têm >algumas diferenças no exterior, particularmente em estruturas >de dados como a estrutura de blocos e árvore de estado. - https://vitalik.eth.limo/general/2022/08/04/zkevm.html
Para Desenvolvedores
O que isso significa para os desenvolvedores é que você pode implantar seu código Solidity existente sem precisar de nenhuma etapa extra para compilar seu código para que ele funcione nesta rede. Comparado com outras soluções ZK-EVM por aí, o Tipo 2 oferece uma maneira mais fácil de trabalhar com essa solução ZK-EVM em comparação com as soluções Tipo 3 e Tipo 4.
O objetivo é ser totalmente compatível com os aplicativos existentes, mas fazer algumas pequenas modificações na >Ethereum para facilitar o desenvolvimento e tornar a geração de >provas mais rápida.
TL;DR
Vá para a seção Código Completo para o repositório GitHub.
Configuração da Carteira
Deve-se notar que muitas destas informações já existem na Wiki da Polygon Para zkEVM oficial e que essas configurações podem mudar quando a Mainnet zkEVM estiver disponível.
A configuração da carteira do zkEVM está no Chainlist.org?
Infelizmente ainda não, porque as configurações da rede e o número da porta podem mudar.
Nossas configurações para a Testnet zkEVM são as seguintes:
- Nome da Rede: Testnet zkEVM da Polygon
- URL RPC: https://rpc.public.zkevm-test.net
- ID da CHAIN: 1402
- Símbolo da Moeda: ETH
- URL do Explorador de Bloco: https://explorer.public.zkevm-test.net
Você pode adicionar isto à sua carteira MetaMask atual, indo a suas redes e adicionando uma rede manualmente.
MetaMask Acrescenta uma Rede Manualmente
MetaMask Configurada com a Testnet zkEVM Polygon
Vamos dar uma olhada em nossa carteira no Explorador de Blocos zkEVM.
[https://explorer.public.zkevm-test.net/address/0xB3f03B93F0bd65B960EE950d9aFC6867D461C33f]
Obtendo tokens de Testnet de uma Faucet
É um pouco diferente obter tokens de Testnet para zkEVM em comparação com outras redes Testnet. Para conseguir os tokens, você precisa obtê-los da Testnet Goerli e depois fazer a ponte entre eles e o zkEVM.
Estaremos usando a Faucet Goerli QuickNode, mas você também pode usar qualquer uma das seguintes opções (por favor, me avise se eu me esqueci de alguma):
NOTA: Se uma faucet não estiver funcionando no momento, consulte os respectivos fornecedores de RPC para problemas de rede.
Faucet de Testnet Goerli do QuickNode
Assim que tivermos os Tokens de Testnet da Goerli, precisamos fazer a ponte entre eles e a Testnet zkEVM, usando https://public.zkevm-test.net/.
Conecte sua carteira preferida, certifique-se de que a rede está definida para Google da Ethereum, digite a quantidade desejada para fazer a ponte, e clique em Continue.
Confirmando a transação da ponte para zkEVM
Finalize a transação mudando para zkEVM e depois confirmando a transação.
Finalização da transação de ponte zkEVM
Se a transação foi bem sucedida, você deverá ver uma tela de confirmação e o resultado no Explorador de Bloco.
Ponte bem sucedida da Testnet Goerli para a Testnet zkEVM
Implantando um contrato ERC20 para a Testnet zkEVM
Nesta próxima parte vamos instalar e implantar o contrato ERC20 para a zkEVM com o Hardhat.
Requisitos
Certifique-se de ter instalado o seguinte em seu computador previamente.
- nvm ou node
v18.12.1 - pnpm
v7.15.0
Configurando o Hardhat
A primeira coisa que vamos fazer é criar uma nova pasta de projeto, iniciar o pnpm, instalar o Hardhat e configurá-lo.
mkdir zkevm-erc20;
cd zkevm-erc20;
git init;
pnpx hardhat;
# Prompts Esperados
# 888 888 888 888 888
# 888 888 888 888 888
# 888 888 888 888 888
# 8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
# 888 888 "88b 888P" d88" 888 888 "88b "88b 888
# 888 888 .d888888 888 888 888 888 888 .d888888 888
# 888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
# 888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
#
# 👷 Benvindo ao Hardhat v2.12.3 👷
#
# ? O que você deseja fazer? …
# Criar um projeto Javascript
# ❯ Criar um projeto TypeScript
# Criar um hardhat.config.js vazio
# Sair
# ? Raiz do projeto Hardhat: › /path/to/zkevm-erc20
# ? Você deseja adicionar um .gitignore? (Y/n) › y
# ? Você quer instalar as dependências deste projeto de amostra com npm (@nomicfoundation/hardhat-toolbox)? (Y/n) › y
pnpm install;
Vamos verificar duas vezes se nossa configuração do Hardhat está funcionando como esperado, executando um nó, implantando o contrato padrão, e depois testando esse contrato.
Terminal 1
# FROM: ./zkevm-erc20
./node_modules/.bin/hardhat node;
# Output esperado:
# Servidor HTTP e WebSocket JSON-RPC inicializado em http://127.0.0.1:8545/
#
# Contas
# ========
#
# Aviso: Essas contas e suas chaves privadas são publicamente conhecidas.
# Quaisquer fundos enviados para eles na Mainnet ou em qualquer outra rede ao vivo SERÃO PERDIDOS.
# ...
Terminal 2
Implante o contrato Lock.sol para o nó local que estamos executando.
# FROM: ./zkevm-erc20
./node_modules/.bin/hardhat run scripts/deploy.ts
# Output esperado:
# Compilado 1 arquivo Solidity com sucesso
# Bloquear com 1 ETH e desbloquear o timestamp 1701595951 implantado para 0x5FbDB2315678afecb367f032d93F642f64180aa3
Executar os testes que foram gerados com o projeto original.
# FROM: ./zkevm-erc20
./node_modules/.bin/hardhat test;
# Output Esperado:
# Bloquear
# Implantação
# ✔ Deve definir o unlockTime correto (894ms)
# ✔ Deve definir o proprietário certo
# ✔ Deve receber e armazenar os fundos para bloquear
# ✔ Deve falhar se o UnlockTime não existir no futuro
# Retiradas
# Validações
# ✔ Deve reverter com o erro exato se for chamado muito cedo
# ✔ Deve reverter com o erro exato se for chamado de outra conta
# ✔ Não deve falhar se o unlockTime tiver chegado e o proprietário o chamar
# Eventos
# ✔ Deve emitir um evento no momento da retirada
# Transferências
# ✔ Deve transferir os fundos para o proprietário
#
# 9 passando (1s)
Criando um contrato ERC20
Vamos basear nosso contrato no contrato ERC20 Solidity do OpenZeppelin, que criará tokens com 10.000 tokens iniciais e permitirá ao proprietário cunhar mais tokens.
Acrescente Dependências
# FROM: ./zkevm-erc20
pnpm add -D @openzeppelin/contracts;
Configure o ERC20
Use o OpenZepplin Wizard para configurar um token ERC20.
Faça um Novo Contrato
Vamos renomear o nosso Lock.sol existente para zkerc20.sol e substituí-lo pelo código que geramos a partir do assistente OpenZeppeling.
# FROM: ./zkevm-erc20
mv ./contracts/Lock.sol ./contracts/zkERC20.sol;
File: ./contracts/zkERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ZkERC20 is ERC20, Ownable {
constructor() ERC20("zkERC20", "ZK20") {
_mint(msg.sender, 10000 * 10 ** decimals());
}
function mint(address to, uint256 amount) public onlyOwner {
_mint(to, amount);
}
}
Testando Nosso Contrato ERC20
Primeiro vamos fazer um único teste para nosso contrato ERC20 e depois verificar se ele está funcionando corretamente.
Implante o Script
Primeiro precisamos modificar nosso script de implantação da conta para o novo nome do contrato.
File: ./scripts/deploy.ts
// Importa
// ========================================================
import { ethers } from "hardhat";
// Script de Implantação Principal
// ========================================================
async function main() {
// Certificar-se na fábrica do contrato que ele corresponda ao nome do contrato no arquivo da Solidity
// Ex: contrato ZkERC20
const zkERC20Contract = await ethers.getContractFactory("ZkERC20");
const contract = await zkERC20Contract.deploy();
await contract.deployed();
console.log(`ZkERC20 deployed to ${contract.address}`);
};
// Init
// ========================================================
// Recomendamos este padrão para poder usar async/await em qualquer lugar
// e lidar apropriadamente com os erros.
main().catch((error) => {
console.error(error);
process.exitCode = 1;
});
Criando Nosso Teste
Em seguida, vamos renomear nosso arquivo de teste Lock.ts para zkERC20.test.ts e adicionar um teste que confirme o saldo total do token ERC20 cunhado.
# FROM: ./zkevm-erc20
mv ./test/Lock.ts ./test/zkERC20.test.ts;
File: ./test/zkERC20.test.ts
// Importa
// ========================================================
import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
import { expect } from "chai";
import { ethers } from "hardhat";
// Testa
// ========================================================
describe("zkERC20", function () {
// Definimos um mecanismo para reutilizar a mesma configuração em cada teste.
// Usamos loadFixture para executar esta configuração uma vez, fazer um snapshot desse estado,
// e redefinir a rede Hardhat para esse snapshot em cada teste.
async function deployZkERC20() {
// Os contratos são implantados usando o primeiro signatário/conta por padrão
const [owner, otherAccount] = await ethers.getSigners();
// Certificar-se na fábrica do contrato que ele corresponda ao nome do contrato no arquivo Solidity
// Ex: contrato ZkERC20
const zkERC20Contract = await ethers.getContractFactory("ZkERC20");
const zkERC20 = await zkERC20Contract.deploy();
return { zkERC20, owner, otherAccount };
};
/**
*
*/
describe("Deployment", function () {
/**
*
*/
it("Deve implantar com suprimento inicial de 10,000", async function () {
// Configura
const { zkERC20 } = await loadFixture(deployZkERC20);
// Init + Test
expect(await zkERC20.totalSupply()).to.equal(ethers.utils.parseEther(`10000`).toString());
});
});
/**
*
*/
describe("Minting", function () {
/**
*
*/
it("Deve cunhar e aumentar o suprimento de 137", async function () {
// Configura
const { zkERC20, owner } = await loadFixture(deployZkERC20);
// Init
await zkERC20.connect(owner).mint(owner.address, ethers.utils.parseUnits('137', 18));
// Init + Test
expect(await zkERC20.totalSupply()).to.equal(ethers.utils.parseEther(`10137`).toString());
});
});
});
Vamos executar o nó do Hardhat e testar este contrato.
Terminal 1
Executando um nó local.
# FROM: ./zkevm-erc20
./node_modules/.bin/hardhat node;
# Saída esperada:
# Servidor HTTP e WebSocket JSON-RPC inicializado em http://127.0.0.1:8545/
#
# Contas
# ========
#
# Aviso: Essas contas e suas chaves privadas são de conhecimento público.
# Quaisquer fundos enviados para eles na Mainnet ou em qualquer outra rede ao vivo SERÃO PERDIDOS.
# ...
Terminal 2
Executando Nossos Testes.
# FROM: ./zkevm-erc20
./node_modules/.bin/hardhat test;
# Saída esperada:
# zkERC20
# Implantação
# ✔ Deve implantar com um suprimento inicial de 10,000 (803ms)
# Cunhando
# ✔ Deve cunhar e aumentar o suprimento de 137
#
# 2 passando (819ms)
Implantando um Contrato ERC20
Deve-se notar que atualmente as implantações zkEVM não são suportadas em Hardhat. Para implantar seus contratos, você precisará usar a configuração do Provedor Injetado com Ethereum Remix.
Certifique-se de criar um arquivo zkERC20.sol em remix com o código de contrato que criamos acima.
Remix zkERC20.sol
Mude para a seção de compilação e clique no botão de compilação grande para obter o sinal de verificação verde indicando que tudo foi compilado corretamente.
Contrato de Compilação Remix
Passe para a seção de implantação na barra de navegação à esquerda, defina o Ambiente para Injected Provider — Metamask. e certifique-se de que sua carteira está configurada para a rede zkEVM.
zkEVM no Ambiente Remix
Quando estiver pronto, clique no botão deploy e confirme a transação em sua carteira.
Contrato de Implantação Remix
Visualizando Nossos Tokens na MetaMask
Abra sua carteira MetaMask, clique na transação, e visualize-a no explorador de blocos. No explorador de blocos, clique no endereço do contrato para abrir o contrato. Com o contrato carregado no explorador de blocos, copie o endereço do contrato.
Contrato zkEVM Implantado
Abra sua MetaMask, clique em Assets (Ativos) e clique em Import tokens (Importar tokens).
Importar tokens da MetaMask
Cole o endereço do contrato e preencha os outros campos conforme necessário. Eles podem ser preenchidos automaticamente. Em seguida, clique em Add custom token (Adicionar token personalizado).
Adicionar token personalizado da Metamask
Agora você poderá seguir as instruções e depois ver o novo token ZK20 em sua carteira com a quantidade inicial correta.
MetaMask com o novo token ZK20 ERC20
🎉 Aí está, você implantou totalmente um contrato ERC20 para a Testnet zkEVM Hermes da Polygon.
Código Completo
Aqui está o código completo para o token zkEVM ERC20. Basta lembrar que as implantações do Hardhat ainda não são suportadas.
GitHub - codingwithmanny/zkevm-erc20
Este código é para um token ERC20 e como configurá-lo para zkEVM. NOTA: No momento não é possível implantar para a Testnet zkEVM t…
O que vem a seguir
Por favor, fique atento ao tutorial do ERC721 que virá em breve.
Se você obteve algum valor com isso, por favor, dê-lhe um pouco de amor, e por favor, siga-me também no twitter (onde eu sou bastante ativo) @codingwithmanny e no Instagram em @codingwithmanny.
Esse artigo foi escrito por Manny e traduzido por Fátima Lima. O original pode ser lido aqui.