Um caso de uso popular e prático para NFTs é gerar ingressos para eventos ao vivo. Blockchains como   podem   a propriedade, originador e autenticidade de um item digital, resolvendo efetivamente o problema de bilhetes falsificados. Enquanto os principais players, como a   lutam para mitigar os cambistas (tentando desesperadamente controlar quem pode revender os ingressos, onde e por quanto) e a fraude de ingressos -   já tem uma solução. A indústria de bilhética está pronta para a disrupção. Ethereum garantir Ticketmaster, a web3  Neste tutorial, veremos como criar uma solução de tíquete usando ConsenSys   ,   e a   Implantaremos um contrato inteligente que atua como um serviço de tíquetes e cria tíquetes como tokens não fungíveis (NFTs) ERC-20. Também examinaremos algumas arquiteturas de front-ends em potencial que podem interagir com o contrato e, juntos, funcionar como um sistema integrado de tíquetes web3 de pilha completa. Truffle Infura API Infura NFT.  Vamos construir!  Crie um sistema de emissão de bilhetes NFT no Ethereum  A arquitetura básica do nosso sistema visa criar um contrato inteligente que emita nossos tickets como tokens não fungíveis (NFTs). NFTs são   para o que queremos construir. Eles são tokens digitais comprovadamente exclusivos que nos permitem garantir que cada ingresso seja único e não possa ser copiado ou falsificado. Isso não apenas garante uma experiência segura de ingressos para os espectadores, mas também capacita os artistas (e organizadores de eventos) com maior controle sobre a distribuição, preços e revenda de ingressos. O uso de contratos inteligentes e NFTs permite até mesmo novos fluxos de receita, como pagamentos de royalties e compartilhamento de receita! perfeitos  (Se você precisar de informações básicas sobre qualquer um desses termos, tecnologia blockchain ou web3 em geral, confira este artigo em   ). Aprendendo a se tornar um desenvolvedor Web3 explorando a pilha Web3   Passo 1: Instale o MetaMask  A primeira coisa que vamos fazer é configurar uma carteira MetaMask e adicionar a rede de teste Sepolia a ela. A MetaMask é a carteira digital autocustodial mais popular, segura e fácil de usar do mundo.  Primeiro,   . Depois de instalar a extensão, o MetaMask configurará a carteira para você. No processo, você receberá uma frase secreta.  baixe a extensão MetaMask Mantenha isso seguro e, sob nenhuma circunstância, você deve torná-lo público.  Depois de configurar o MetaMask, clique na guia Rede no canto superior direito. Você verá uma opção para mostrar/ocultar redes de teste.  Depois de ativar as redes de teste, você poderá ver a rede de teste Sepolia no menu suspenso. Queremos usar a rede Sepolia para que possamos implantar e testar nosso sistema sem gastar dinheiro real.   Passo 2: Obtenha algum ETH de teste  Para implantar nosso contrato inteligente e interagir com ele, precisaremos de algum ETH de teste gratuito. Você pode obter Sepolia ETH grátis na   . torneira Sepolia  Depois de financiar sua carteira, você deve ver um saldo diferente de zero ao mudar para a rede de teste Sepolia no MetaMask.    Etapa 3: instalar o NPM e o nó  Como todos os dapps Ethereum, construiremos nosso projeto usando node e npm. Caso você não os tenha instalado em sua máquina local, poderá fazê-lo   . aqui  Para garantir que tudo esteja funcionando corretamente, execute o seguinte comando:   $ node -v  Se tudo correr bem, você deverá ver um número de versão para Node.   Passo 4: Inscreva-se para uma conta Infura  Para implantar nosso contrato na rede Sepolia, precisaremos de uma conta Infura. A Infura nos dá acesso a endpoints RPC que permitem acesso rápido, confiável e fácil ao blockchain de nossa escolha.    . Depois de criar sua conta, navegue até o   e selecione   .  Inscreva-se para uma conta gratuita painel Criar nova chave  Para rede, escolha   e nomeie-a   ou algo de sua escolha. Web3 API Ticketing System  Depois de clicar em   , o Infura gerará uma chave de API para você e fornecerá pontos de extremidade RPC para Ethereum, Goerli, Sepolia, L2s e não EVM L1s (e seus testnets correspondentes) automaticamente. Criar  Para este tutorial, estamos interessados apenas no endpoint Sepolia RPC. Este URL está no formato  https://sepolia.infura.io/v3/←API KEY→   Passo 5: Crie um projeto Node e instale os pacotes necessários  Vamos configurar um repositório de projeto vazio executando os seguintes comandos:   $ mkdir nft-ticketing && cd nft-ticketing $ npm init -y  Usaremos o Truffle, um ambiente de desenvolvimento de classe mundial e estrutura de teste para contratos inteligentes EVM, para criar e implantar nosso contrato inteligente de criptomoeda. Instale o Truffle executando:   $ npm install —save truffle  Agora podemos criar um projeto Trufa barebones executando o seguinte comando:   $ npx truffle init  Para verificar se tudo está funcionando corretamente, execute:   $ npx truffle test  Agora temos trufa configurada com sucesso. Em seguida, vamos instalar o pacote de contratos   . Este pacote nos dará acesso à implementação básica do ERC-721 (o padrão para tokens não fungíveis), bem como algumas funcionalidades adicionais úteis. do OpenZeppelin   $ npm install @openzeppelin/contracts  Para permitir que o Truffle use nossa carteira MetaMask, assine transações e pague gasolina em nosso nome, precisaremos de outro pacote chamado   . Instale-o usando o seguinte comando: hdwalletprovider   $ npm install @truffle/hdwallet-provider  Finalmente, para manter nossas informações confidenciais de carteira seguras, usaremos o pacote   . dotenv   $ npm install dotenv   Etapa 6: criar o contrato inteligente de tíquete para o NFT  Abra o repositório do projeto em um editor de código (por exemplo: VS Code). Na pasta   , crie um novo arquivo chamado   . contracts NftTicketing.sol  Nosso contrato de emissão de bilhetes herdará todas as funcionalidades oferecidas pela implementação   do OpenZeppelin. Isso inclui transferências, rastreamento de metadados, dados de propriedade, etc. ERC721Enumerable  Vamos implementar os seguintes recursos do zero:    : Nosso contrato dará ao seu proprietário o poder de vender ingressos a um determinado preço. O proprietário terá o poder de abrir e fechar vendas, atualizar os preços dos ingressos e retirar qualquer dinheiro enviado ao contrato para compra de ingressos. O público terá a oportunidade de cunhar bilhetes a preço de venda sempre que a venda estiver aberta e ainda houver bilhetes à venda. Venda pública primária    : O proprietário poderá enviar tickets para uma lista de endereços de carteira. Airdrop    : O proprietário também poderá reservar bilhetes para si mesmo sem ter que pagar o preço de venda ao público. Reserva  Adicione o código a seguir a   . NftTicketing.sol   //SPDX-License-Identifier: MIT pragma solidity ^0.8.19; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/utils/Counters.sol"; import "@openzeppelin/contracts/utils/Base64.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; contract NftTicketing is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable { using Counters for Counters.Counter; Counters.Counter private _tokenIds; // Total number of tickets available for the event uint public constant MAX_SUPPLY = 10000; // Number of tickets you can book at a time; prevents spamming uint public constant MAX_PER_MINT = 5; string public baseTokenURI; // Price of a single ticket uint public price = 0.05 ether; // Flag to turn sales on and off bool public saleIsActive = false; // Give collection a name and a ticker constructor() ERC721("My NFT Tickets", "MNT") {} // Generate NFT metadata function generateMetadata(uint tokenId) public pure returns (string memory) { string memory svg = string(abi.encodePacked( "<svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinyMin meet' viewBox='0 0 350 350'>", "<style>.base { fill: white; font-family: serif; font-size: 25px; }</style>", "<rect width='100%' height='100%' fill='red' />", "<text x='50%' y='40%' class='base' dominant-baseline='middle' text-anchor='middle'>", "<tspan y='50%' x='50%'>NFT Ticket #", Strings.toString(tokenId), "</tspan></text></svg>" )); string memory json = Base64.encode( bytes( string( abi.encodePacked( '{"name": "NFT Ticket #', Strings.toString(tokenId), '", "description": "A ticket that gives you access to a cool event!", "image": "data:image/svg+xml;base64,', Base64.encode(bytes(svg)), '", "attributes": [{"trait_type": "Type", "value": "Base Ticket"}]}' ) ) ) ); string memory metadata = string( abi.encodePacked("data:application/json;base64,", json) ); return metadata; } // Reserve tickets to creator wallet function reserveNfts(uint _count) public onlyOwner { uint nextId = _tokenIds.current(); require(nextId + _count < MAX_SUPPLY, "Not enough NFTs left to reserve"); for (uint i = 0; i < _count; i++) { string memory metadata = generateMetadata(nextId + i); _mintSingleNft(msg.sender, metadata); } } // Airdrop NFTs function airDropNfts(address[] calldata _wAddresses) public onlyOwner { uint nextId = _tokenIds.current(); uint count = _wAddresses.length; require(nextId + count < MAX_SUPPLY, "Not enough NFTs left to reserve"); for (uint i = 0; i < count; i++) { string memory metadata = generateMetadata(nextId + i); _mintSingleNft(_wAddresses[i], metadata); } } // Set Sale state function setSaleState(bool _activeState) public onlyOwner { saleIsActive = _activeState; } // Allow public to mint NFTs function mintNfts(uint _count) public payable { uint nextId = _tokenIds.current(); require(nextId + _count < MAX_SUPPLY, "Not enough NFT tickets left!"); require(_count > 0 && _count <= MAX_PER_MINT, "Cannot mint specified number of NFT tickets."); require(saleIsActive, "Sale is not currently active!"); require(msg.value >= price * _count, "Not enough ether to purchase NFTs."); for (uint i = 0; i < _count; i++) { string memory metadata = generateMetadata(nextId + i); _mintSingleNft(msg.sender, metadata); } } // Mint a single NFT ticket function _mintSingleNft(address _wAddress, string memory _tokenURI) private { // Sanity check for absolute worst case scenario require(totalSupply() == _tokenIds.current(), "Indexing has broken down!"); uint newTokenID = _tokenIds.current(); _safeMint(_wAddress, newTokenID); _setTokenURI(newTokenID, _tokenURI); _tokenIds.increment(); } // Update price function updatePrice(uint _newPrice) public onlyOwner { price = _newPrice; } // Withdraw ether function withdraw() public payable onlyOwner { uint balance = address(this).balance; require(balance > 0, "No ether left to withdraw"); (bool success, ) = (msg.sender).call{value: balance}(""); require(success, "Transfer failed."); } // Get tokens of an owner function tokensOfOwner(address _owner) external view returns (uint[] memory) { uint tokenCount = balanceOf(_owner); uint[] memory tokensId = new uint256[](tokenCount); for (uint i = 0; i < tokenCount; i++) { tokensId[i] = tokenOfOwnerByIndex(_owner, i); } return tokensId; } // The following functions are overrides required by Solidity. function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId, batchSize); } function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) { super._burn(tokenId); } function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) { return super.tokenURI(tokenId); } function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } }  Certifique-se de que o contrato está sendo compilado corretamente executando:   npx truffle compile  Nosso contrato já é bastante complexo, mas é possível adicionar alguns recursos extras conforme você achar melhor.   Por exemplo, você pode implementar um mecanismo anti-scalping em seu contrato. Os passos para isso seriam os seguintes:  Defina um mapeamento do Solidity que atue como uma lista de permissões para carteiras que podem conter mais de um tíquete.  Crie uma função que permita ao proprietário adicionar endereços a esta lista de permissões.  Introduza um check-in _   que permite cunhar ou transferir para uma carteira que já possua um ticket somente se estiver na lista de permissões. beforeTokenTransfer  Adicione o seguinte trecho abaixo do construtor do contrato:   mapping(address => bool) canMintMultiple; // Function that allowlists addresses to hold multiple NFTs. function addToAllowlist(address[] calldata _wAddresses) public onlyOwner { for (uint i = 0; i < _wAddresses.length; i++) { canMintMultiple[_wAddresses[i]] = true; } }  Por fim, modifique a função _   para o seguinte: beforeTokenTranfer   // The following functions are overrides required by Solidity. function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) { if (balanceOf(to) > 0) { require(to == owner() || canMintMultiple[to], "Not authorized to hold more than one ticket"); } super._beforeTokenTransfer(from, to, tokenId, batchSize); }  Compile o contrato mais uma vez usando o comando Truffle acima.   Etapa 7: atualize a configuração de trufas e crie um arquivo .env  Crie um novo arquivo no diretório raiz do projeto chamado   e adicione o seguinte conteúdo: .env   INFURA_API_KEY = "https://sepolia.infura.io/v3/<Your-API-Key>" MNEMONIC = "<Your-MetaMask-Secret-Recovery-Phrase>"  Em seguida, vamos adicionar informações sobre nossa carteira, o endpoint Infura RPC e a rede Sepolia ao nosso arquivo de configuração Truffle. Substitua o conteúdo de   pelo seguinte: truffle.config.js   require('dotenv').config(); const HDWalletProvider = require('@truffle/hdwallet-provider'); const { INFURA_API_KEY, MNEMONIC } = process.env; module.exports = { networks: { development: { host: "127.0.0.1", port: 8545, network_id: "*" }, sepolia: { provider: () => new HDWalletProvider(MNEMONIC, INFURA_API_KEY), network_id: '5', } } };   Etapa 8: implantar o contrato inteligente NFT  Vamos agora escrever um script para implantar nosso contrato na blockchain Sepolia.  Na pasta   , crie um novo arquivo chamado   e adicione o seguinte código: migrations 1_deploy_contract.js   // Get instance of the NFT contract const nftContract = artifacts.require("NftTicketing"); module.exports = async function (deployer) { // Deploy the contract await deployer.deploy(nftContract); const contract = await nftContract.deployed(); // Mint 5 tickets await contract.reserveNfts(5); console.log("5 NFT Tickets have been minted!") };  Estamos prontos! Implante o contrato executando o seguinte comando:   truffle migrate --network sepolia  Se tudo correr bem, você deverá ver a saída (contendo o endereço do contrato) mais ou menos assim:   Starting migrations... ====================== > Network name: 'sepolia' > Network id: 5 > Block gas limit: 30000000 (0x1c9c380) 1_deploy_contract.js ==================== Deploying 'NftTicketing' ----------------------- > transaction hash: … > Blocks: 2 Seconds: 23 … > Saving artifacts ------------------------------------- > Total cost: 0.1201 ETH Summary ======= > Total deployments: 1 > Final cost: 0.1201 ETH  Você pode procurar o endereço do seu contrato no Sepolia etherscan e vê-lo ao vivo.  Parabéns! Você implantou o contrato com sucesso na Sepolia.   Passo 9: Interface com o contrato inteligente  Temos nosso contrato inteligente! A próxima etapa é implantar front-ends que façam interface com o contrato e permitam que qualquer pessoa chame a função mint para fazer uma doação e cunhar um tíquete para si.  Para um serviço de emissão de bilhetes totalmente funcional, você normalmente precisa dos seguintes front-ends:  Um site (com uma ótima experiência do usuário) onde os usuários públicos podem pagar e cunhar seus ingressos.  Um portal de administração onde o proprietário pode reservar e enviar bilhetes, atualizar preços, transferir a função de administrador para outra carteira, retirar receita de vendas, abrir e fechar vendas, etc.  Uma ferramenta que verifica se uma pessoa possui um determinado ingresso online e IRL.  Construir esses sistemas do zero está fora do escopo deste tutorial, mas deixaremos alguns recursos e dicas para você.  Para o site de criação de front-end, confira o front-end que construí no tutorial   como ponto de partida. Thank You NFT  Se você verificar seu contrato no Etherscan, ele fornecerá automaticamente um portal de administração onde você poderá chamar qualquer função em seu contrato. Este é um bom primeiro passo antes de decidir criar uma solução personalizada.  Verificar se uma carteira possui um ticket de sua coleção é extremamente simples usando a função   . Se alguém puder provar que possui uma carteira contendo um de nossos ingressos, é basicamente uma prova de que possui um ingresso. Isso pode ser obtido usando assinaturas digitais. balanceOf   Verificação usando a API Infura NFT  Mais uma dica: depois de ter seu contrato inteligente e front-end (ou mesmo antes de seu front-end estar completo e você quiser provar que tudo funciona), você pode usar a   para verificar se seu novo NFT existe. A API Infura NFT é uma maneira rápida de substituir muitos códigos relacionados a NFT por uma única chamada de API. API Infura NFT  Por exemplo, as informações de que precisamos para mostrar a propriedade de nosso NFT estão facilmente disponíveis para nós por meio da API. Tudo o que precisamos fornecer é o endereço da carteira. O código ficaria mais ou menos assim:   const walletAddress = <your wallet address> const chainId = "1" const baseUrl = "https://nft.api.infura.io" const url = `${baseUrl}/networks/${chainId}/accounts/${walletAddress}/assets/nfts` // API request const config = { method: 'get', url: url, auth: { username: '<-- INFURA_API_KEY –>', password: '<-- INFURA_API_SECRET –>', } }; // API Request axios(config) .then(response => { console.log(response['data']) }) .catch(error => console.log('error', error));  Executá-lo …   $ node <filename>.js  E você deve ver algo assim:   { total: 1, pageNumber: 1, pageSize: 100, network: 'ETHEREUM', account: <account address>, cursor: null, assets: [ { contract: <NFT contract address>, tokenId: '0', supply: '1', type: 'ERC20', metadata: [Object] }, … ] }   Conclusão  Neste tutorial, implantamos um serviço de tíquete NFT totalmente funcional usando   ,   e Infura   . Truffle Infura NFT API  Obviamente, não é   que você precisa para interromper o Ticketmaster - mas é um começo sólido e uma ótima prova de conceito! Mesmo que você não pegue este código e inicie sua própria plataforma de tíquetes NFT, esperamos que você tenha aprendido um pouco sobre o web3 no processo. tudo o  A imagem principal deste artigo foi gerada pelo  do HackerNoon por meio do prompt "um show de rock em um grande estádio". AI Image Generator

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

The writer is smart, but don't just like, take their word for it. #DoYourOwnResearch before making any investment decisions or decisions regarding you health or security. (Do not regard any of this content as professional investment advice, or health advice)

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

I write about technology michael.bogan@gmail.com

2022 - HackerNoon Contributor of the Year - Api

2022 - HackerNoon Contributor of the Year - Devops

2022 - HackerNoon Contributor of the Year - Microservices

2022 - HackerNoon Contributor of the Year - Software

2022 - HackerNoon Contributor of the Year - Software Architecture

2022 - Software Developer of the Year

Nominated for 2022 - HackerNoon Contributor of the Year - Software Architecture

Nominated for 2022 - HackerNoon Contributor of the Year - Microservices

Nominated for 2022 - HackerNoon Contributor of the Year - Devops

Nominated for 2022 - HackerNoon Contributor of the Year - Api

Nominated for 2022 - Software Developer of the Year

Nominated for 2022 - HackerNoon Contributor of the Year - Software

Este áudio é produzido no idioma original da história!

Vamos interromper o Ticketmaster construindo um sistema de tíquetes Web3

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

Toque para ganhar: Telegram pode integrar os próximos 10 bilhões de usuários criptográficos antes de Solana

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

Toque para ganhar: Telegram pode integrar os próximos 10 bilhões de usuários criptográficos antes de Solana

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps