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.
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.
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.
Confirmar a transação de ponte.
Finalize a transação mudando para zkEVM e depois confirmando a transação.
Se a transação foi bem sucedida, você deverá ver uma tela de confirmação e o resultado no Explorador de Bloco.
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.
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.
Quando estiver pronto, clique no botão deploy e confirme a transação em sua carteira.
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.
Abra sua MetaMask, clique em Assets (Ativos) e clique em Import tokens (Importar tokens).
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).
Agora você poderá seguir as instruções e depois ver o novo token ZK20 em sua carteira com a quantidade inicial correta.
🎉 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.
Latest comments (0)