Criando, implantando, cunhando seu Token ERC1155 na Celo
Introdução
Criar, implantar e cunhar tokens ERC-1155 na Celo é um processo importante que é essencial para o sucesso de qualquer projeto baseado em tokens. Este artigo fornecerá um guia abrangente sobre como usar o padrão de tokens ERC-1155 usando Hardhat na Celo, uma plataforma de blockchain que suporta o desenvolvimento de contratos inteligentes e a tokenização de ativos.
Através deste guia, os usuários aprenderão como criar um token, implantá-lo na blockchain, e cunhá-lo para que possa ser usado para uma variedade de propósitos. Além disso, os usuários também se familiarizarão com as diversas ferramentas disponíveis na plataforma Celo.
Com uma melhor compreensão do processo e das ferramentas disponíveis, os usuários poderão criar seus tokens e aproveitar as características que o padrão de tokens ERC-1155 tem a oferecer.
A Celo é uma plataforma descentralizada que permite transações rápidas, seguras e de baixo custo usando stablecoins (criptomoedas estáveis). Ela fornece uma interface e ferramentas fáceis de usar para os desenvolvedores construírem e implantarem aplicações descentralizadas (Dapps). Neste artigo, discutiremos os passos necessários para criar, implantar e cunhar tokens ERC-1155 na Celo.
Pré-requisitos
Antes de mergulhar na criação, implantação e cunhagem de tokens ERC-1155 na Celo, é importante entender os pré-requisitos para o processo. Isto inclui ter uma compreensão básica do seguinte.
Hardhat: este é um ambiente de desenvolvimento Ethereum que permite aos desenvolvedores compilar, implantar e testar contratos inteligentes. Ele fornece um conjunto de ferramentas que tornam a construção de aplicações descentralizadas na blockchain mais fácil do que nunca.
Solidity: esta é uma linguagem de programação orientada a objetos utilizada para criar contratos inteligentes. Ela foi projetada para a Máquina Virtual Ethereum (EVM) e fornece uma ampla gama de recursos, incluindo herança, bibliotecas e tipos definidos pelo usuário.
OpenZeppelin: é uma estrutura de código aberto para desenvolver e implantar contratos inteligentes seguros na Ethereum e em outras blockchains. Ela fornece um conjunto de ferramentas e bibliotecas que facilitam a escrita de contratos inteligentes seguros e confiáveis.
Node Package Manager (Gerenciador de Pacotes de Nó): Além disso, é importante ter familiaridade com o Node Package Manager
(npm).npmé um gerenciador de pacotes para JavaScript e é usado para instalar, desinstalar e gerenciar as dependências de pacotes em um projeto.
Entendendo a Norma ERC1155 Token
Os tokens ERC-1155 são um novo tipo de token que permite aos usuários gerenciar facilmente vários tipos de tokens em um só lugar, tornando-os ideais para uso em vários projetos.
O ERC1155, ou Ethereum Request for Comments 1155, é um padrão de token baseado em Ethereum, projetado para ser versátil, permitindo aos usuários realizar uma variedade de ações diferentes com eles. As transações incluem cunhagem, queima e transferência de tokens entre usuários. Isto é diferente dos tradicionais tokens ERC20 e ERC721, que são limitados em funcionalidade.
A principal vantagem dos tokens ERC1155 é sua versatilidade. Por exemplo, um usuário poderia cunhar um token representando um ativo, e depois usá-lo para criar um mercado para a comercialização do ativo. Isto é algo que não seria possível com outros padrões de token. Além disso, o ERC1155 também é mais eficiente do que outros padrões de token, pois permite que várias transferências de tokens ocorram em uma única transação, reduzindo a quantidade de gas utilizado.
Além disso, os tokens ERC1155 também são mais seguros do que outros padrões de tokens. Isto porque a norma ERC1155 incorpora várias medidas de segurança, incluindo proteção de soma de controle e hashing. A norma ERC1155 também suporta transações com múltiplas assinaturas, que exigem que vários usuários assinem uma transação para garantir a sua validade.
Em resumo, a ERC1155 é um padrão token versátil, seguro e eficiente que oferece aos usuários uma gama de recursos e capacidades. Sua versatilidade o torna uma escolha perfeita para criar e negociar ativos, enquanto suas medidas de segurança protegem os usuários de atividades fraudulentas. É sem dúvida um dos padrões de token mais avançados do mercado e está rapidamente se tornando a escolha ideal para os desenvolvedores.
Usando o padrão de Token ERC1155
O ERC1155 é um padrão de token da Ethereum que permite a cunhagem, transferência e queima de múltiplos tipos de ativos digitais de forma segura e eficiente. Isto o torna uma escolha atraente para a criação de ativos digitais e tokens na Blockchain.
O principal uso do ERC1155 é criar tokens fungíveis e não fungíveis, tais como criptomoedas, que são intercambiáveis, o que significa que uma unidade é idêntica a outra. Os tokens não fungíveis, como os colecionáveis e os ativos de jogos, são únicos e, portanto, o valor de cada token é determinado por sua raridade e outras características.
Usando ERC1155, ambos os tipos de tokens podem ser criados dentro do mesmo contrato. Isto facilita a criação de ativos digitais e sua gestão mais eficiente.
Além disso, o ERC1155 também suporta a criação de swaps( trocas ) atômicas, que permitem a troca de múltiplos tipos de tokens sem a necessidade de um terceiro intermediário. Isto é útil para criar mercados descentralizados, permitindo que os usuários troquem tokens diretamente uns com os outros.
Os ERC1155 também são relativamente importantes nas seguintes áreas no espaço web3:
1 .Mercado de Tokens Não Fungíveis (NFT): O padrão de token ERC1155 permite a criação de um mercado para tokens não-fungíveis (NFTs). Isto permite aos usuários tokenizar ativos digitais tais como arte, música, vídeos e itens de jogos e comprá-los, vendê-los e negociá-los em um ambiente seguro e sem confiança. Isto pode ser feito diretamente ou através de contratos inteligentes.
2 .Organizações Autônomas Descentralizadas (DAOs): O padrão de token ERC1155 pode ser usado para criar organizações autônomas descentralizadas (DAOs) que podem ser usadas para governar o uso de um determinado token ou projeto. Isto permite que os portadores de tokens tenham uma palavra a dizer na direção do projeto, e votem em decisões importantes.
3 .Plataformas de jogos: O padrão de token ERC1155 pode ser usado para criar plataformas de jogos onde os usuários podem comprar, negociar e usar itens e ativos dentro do jogo. Isto permite que os usuários participem de experiências de jogos descentralizados e criem um ambiente seguro para a comercialização de itens de jogos.
4 .Tokenização de Ativos: O padrão de token ERC1155 pode ser usado para tokenizar bens do mundo real como arte, objetos de coleção, ouro e outros itens tangíveis. Isto permite aos usuários investir nesses ativos e negociá-los em um ambiente seguro e sem confiança.
Configurando o Hardhat
Antes de começar a cunhar seu contrato, você precisará criar um hardhat como seu Ambiente de Desenvolvimento Ethereum. Nas próximas etapas, você estará configurando um ambiente de trabalho Hardhat usando npm ou o gerenciador de pacotes de sua preferência.
1 .Crie um diretório de espaço de trabalho no seu editor de código preferido.
2 .Vá para o terminal do seu ambiente de trabalho e execute o comando npm init -y. Isso inicializará o gerenciador de pacotes e criará um arquivo package.json em preparação para a instalação do hardhat.
3 .Em seguida, execute o comando npm install hardhat @nomiclabs/hardhat-waffle @nomicfoundation/hardhat-toolbox @openzeppelin/contracts @nomiclabs/hardhat-waffle. Além disso, execute o comando npm i hardhat-deploy dotenv em seu terminal para instalar todas as dependências necessárias para este tutorial.
4 .Depois, execute o comando npx hardhat para iniciar seu ambiente de desenvolvimento do hardhat. Você será solicitado a escolher o idioma com o qual irá trabalhar.
5 .Clique em Enter três vezes para habilitar a opção Create a Javascript Project (Criar um projeto Javascript) e verificar a localização do projeto. Você notará uma nova estrutura de pasta no explorador de arquivos do seu editor de código.
6 .Renomeie o arquivo em sua pasta de contrato para MyToken.sol e exclua o código dentro do arquivo.
7 .Copie o código abaixo e substitua-o pelo código dentro do seu script hardhat.config.js no diretório principal com este;
require("@nomiclabs/hardhat-waffle");
require("dotenv").config({ path: ".env" });
require("hardhat-deploy");
// Você precisa exportar um objeto para configurar sua configuração
// Acesse https://hardhat.org/config/ para saber mais
// Imprime as contas da Celo associadas à mnemônica em .env
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
const accounts = await hre.ethers.getSigners();
for (const account of accounts) {
console.log(account.address);
}
});
/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
defaultNetwork: "alfajores",
networks: {
localhost: {
url: "http://127.0.0.1:7545",
},
alfajores: {
gasPrice: 1500000000,
gas: 4100000,
url: "https://alfajores-forno.celo-testnet.org",
accounts: {
mnemonic: process.env.MNEMONIC,
path: "m/44'/52752'/0'/0",
},
//chainId: 44787
},
celo: {
url: "https://forno.celo.org",
accounts: {
mnemonic: process.env.MNEMONIC,
path: "m/44'/52752'/0'/0",
},
chainId: 42220,
},
},
solidity: "0.8.10",
};
8 .Agora que você instalou e configurou com sucesso seu ambiente de desenvolvimento de hardhat, a seguir, você pode começar a criar seu contrato inteligente ERC1155.
Criando um Contrato Padrão de Token ERC1155
Criar um contrato inteligente na Celo é um processo simples. É o primeiro e mais importante passo para criar seu próprio Token Não-Fungível (NFT) ERC1155 na rede Celo.
Apesar de não ser necessário criar o contrato do zero ao importar o contrato remoto padrão do openzeppelin, o código para um token ERC1155 usando o contrato inteligente openzepppelin é como mostrado abaixo:
// Identificador da licença: MIT
// Contratos OpenZeppelin (última atualização v4.8.0) (token/ERC1155/ERC1155.sol
(token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapeamento do ID do token para os saldos da conta
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapeamento da conta para aprovações do operador
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Usado como URI para todos os tipos de token, dependendo do ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
) public view virtual override returns (uint256[] memory) {
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from, uint256 id, uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
Observação: Não copie o código acima para o arquivo do seu contrato, pois você pode importá-lo diretamente do openzeppelin.
O código abaixo é um contrato Solidity para um token ERC1155, que permite a propriedade fracionária de um ativo digital. O código define duas constantes,
PHENZIC000ePHENZIC001, cada uma representando um tipo de token. Ele também inclui umconstructor(construtor), que é chamado quando o contrato é implantado.Neste construtor, o remetente recebe
200tokensPHENZIC000e100tokensPHENZIC001.Finalmente, o código inclui uma função,
uri(), que retorna uma string URI para um determinado ID de token. Essa string URI pode ser usada para acessar o ativo digital associado ao token.
// Identificador da licença: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MyToken is ERC1155 {
uint256 constant PHENZIC000 = 0;
uint256 constant PHENZIC001 = 1;
constructor() public ERC1155("https://bafybeiaqqz4unoubpu2oz2rsgowh3irdqnpcqjoyspzwrepnrwql7rgvy4.ipfs.nftstorage.link/"){
_mint(msg.sender, PHENZIC000, 200, "");
_mint(msg.sender, PHENZIC001, 100, "");
}
function uri(uint256 _tokenId) override public pure returns (string memory) {
return string(abi.encodePacked("https://bafybeiaqqz4unoubpu2oz2rsgowh3irdqnpcqjoyspzwrepnrwql7rgvy4.ipfs.nftstorage.link/PHENZIC00",Strings.toString(_tokenId),".jpeg")
);
}
}
Copie e cole o código acima no arquivo do seu contrato MyToken.
Usando o contrato inteligente acima, o seu NFT terá todas as funcionalidades necessárias do padrão de token ERC1155. Em seguida, você aprenderá como implantar o token ERC1155 e como implantar e criar tokens na blockchain Celo.
Implantando e Criando o Contrato do Token
Nos próximos passos, você usará a CLI integrada do Hardhat para implantar seu contrato ERC115.
1 .Primeiro, crie um novo arquivo e nomeie o arquivo como .env e crie uma variável chamada MNEMONIC (MNEMÔNICA).
2 .Agora faça login em sua extensão de carteira preferida em seu navegador para obter sua 'MNEMÔNICA' da carteira e copie a frase completa.
Observação: sua MNEMÔNICA da carteira é a mesma que a frase chave dada a você quando você se inscreveu inicialmente para uma conta em sua carteira, geralmente variando de 12 a 18 palavras aleatórias para verificar sua propriedade como uma frase de senha.
3 .Cole a frase 'MNEMÔNICA' como o valor para a variável 'MNEMÔNICA' dentro do seu arquivo .env.
Observação: Sua 'MNEMÔNICA' deve ser mantida em segredo e segura (não pública) em todos os momentos. NUNCA REVELE esta frase em nenhum momento. Nenhuma citação deve ser adicionada.
4 .Em seguida, vá para o script deploy.js em sua pasta de scripts e copie o script de implantação abaixo para substituir o código existente no script de implantação.
onst hre = require("hardhat");
const main = async () => {
const MyToken = await hre.ethers.getContractFactory("MyToken");
const Token = await MyToken.deploy();
await Token.deployed();
console.log("The MyToken contract was deployed to: ", Token.address);
};
const runMain = async () => {
try {
await main();
process.exit(0);
} catch (error) {
console.error(error);
process.exit(1);
}
};
runMain();
5 .Agora execute o comando npx hardhat compile e seu contrato deve ser compilado sem nenhum erro, com o resultado como a imagem abaixo:
Observação: Se a sua declaração retornar a compilação de 3 arquivos Solidity com sucesso, você ainda está no caminho certo.
6 .Por fim, execute o comando npx hardhat deploy scripts/deploy.js e uma execução bem sucedida deve retornar um resultado semelhante à imagem abaixo.
Observação: Copie o endereço do contrato retornado e guarde-o, você precisará dele para interagir com seu contrato implantado posteriormente.
7 .Já que a função _mint é chamada dentro da sua função construtora com as entradas necessárias, o address (endereço) de recebimento, o symbol (símbolo) do token, a amount (quantidade) e a description (descrição). No momento da implantação, os dois contratos de *token* ERC1155PHENZIC000EPHENZIC001` são criados automaticamente.
Interagindo com o Token ERC1155 implantado
Para verificar se o seu token foi criado e está disponível na blockchain Celo, você pode chamar qualquer função, como transferir seu token ou verificar o saldo.
Nos próximos passos, você aprenderá como interagir com seu token ao vivo na blockchain Celo usando o console Hardhat:
Para começar a interagir com o contrato do seu token na blockchain Celo, execute o comando
npx hardhat console. Você deve notar uma seta semelhante a um prompt>para inserir qualquer declaração.Agora copie e cole a linha de código
const MyToken = await ethers.getContractFactory("MyToken"), e pressione enter para obter a fábrica do contrato e atribuí-la à variávelMyToken.Em seguida, copie e cole a linha
const token = await MyToken.attach("0x8B34A555B17dCeA818C4C69b19f4A4145413B2f3"), e pressione enter.
Depois de executar os códigos acima no console Hardhat, você deve ter uma resposta semelhante à imagem abaixo:
Observação: você deve usar o endereço do seu contrato implantado, o mesmo endereço que foi retornado quando você implantou o contrato.
a. Primeiro, para chamar a função uri, você precisará passar o índice de qualquer token e ele retornará a URL do token no IPSF. Execute a linha await token.uri(0) ou await token.uri(1) e pressione enter. O resultado deve ser semelhante à imagem abaixo.
b. Para verificar o saldo de qualquer um dos tokens, insira as linhas de código await token.balanceOf("0x9A11d5a704038BF7735dCE5Bbc71621da7052395", 0), para o primeiro token, ou await token.balanceOf("0x9A11d5a704038BF7735dCE5Bbc71621da7052395", 1), para o segundo token. E você deve ter um resultado semelhante à imagem abaixo.
Observação: você deve passar o endereço da conta que você usou para assinar e implantar o contrato, que também é o proprietário do contrato, e o endereço do *token, o endereço msg.sender.*
c. Para enviar seus tokens para qualquer endereço de carteira, você pode chamar a função safeTransferFrom e passar a seguinte entrada. Endereço de from (origem), endereço de to (destino), o ID do *token* que você deseja enviar, a amount (quantidade) que deseja enviar e para os dados, coloque o valor 0x00. Por exemplo, await token.safeTransferFrom("0x9A11d5a704038BF7735dCE5Bbc71621da7052395","0x8056c7C6B8a3a81bc4CbAf317973ce7f9Cbc747F",0,50,0x00). Ou await token.safeTransferFrom("0x9A11d5a704038BF7735dCE5Bbc71621da7052395","0x8056c7C6B8a3a81bc4CbAf317973ce7f9Cbc747F",1,50,"0x00")
d. Você pode verificar o saldo restante do token e notará a redução na quantidade de token. Execute o comando await token.balanceOf("0x9A11d5a704038BF7735dCE5Bbc71621da7052395", 0) ou await token.balanceOf("0x9A11d5a704038BF7735dCE5Bbc71621da7052395", 0.
Conclusão
Em resumo, criar, distribuir e cunhar tokens ERC-1155 na Celo usando Hardhat é um processo relativamente simples. Com apenas alguns passos, você pode criar rapidamente seus tokens exclusivos e usá-los para alimentar seus projetos. O processo é fácil de seguir e as estruturas de Hardhat facilitam seu uso.
Ao aproveitar o poder da blockchain Ethereum, você pode criar e distribuir seus tokens com o mínimo de esforço. E com a ajuda do Hardhat, você pode facilmente criar e implantar seus tokens na rede Celo. Isto pode abrir um mundo totalmente novo de oportunidades para você como desenvolvedor, para criar seus projetos e monetizar seus esforços.
Sobre o Autor
Mayowa Julius Ogungbola
é um engenheiro de software e escritor técnico sempre aberto a trabalhar em novas idéias. Eu gosto de trabalhar no GitHub e você também pode descobrir sobre o que eu twitto e se conectar comigo no LinkedIn.
Próximos Passos
Aqui estão alguns outros artigos tutoriais relacionados à NFT nos quais você pode se interessar:
- Como construir uma coleção de NFT na Celo
- Como implantar um ERC721 Contrato Inteligente usando a API Tatum
- Como cunhar seus tokens ERC1155 na Celo
- Como reimplantar seu Ethereum Dapp em Celo com hardhat
Referências
Aqui estão links para alguns tutoriais em vídeo que você poderá ter interesse em seguir junto com a leitura deste tutorial:
- Carregando seus NFTs para IPFS
- Publicando seus NFTs cunhados na Opensea
- Cópia de seu contrato ERC1155 no Remix
- Construir e implantar contratos inteligentes usando hardhat
- Como implantar um contrato ERC1155
Este artigo foi escrito por Mayowa Julius Ogungbola e traduzido para o português por Rafael Ojeda
Você pode encontrar o artigo original em inglês aqui
Top comments (0)