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

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( " ", " .base { fill: white; font-family: serif; font-size: 25px; } ", " ", " ", " NFT Ticket #", Strings.toString(tokenId), " " )); 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 0 && _count = 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 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/ " MNEMONIC = " " 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 = 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: ' ', password: ' ', } }; // API Request axios(config) .then(response => { console.log(response['data']) }) .catch(error => console.log('error', error)); Executá-lo … $ node .js E você deve ver algo assim: { total: 1, pageNumber: 1, pageSize: 100, network: 'ETHEREUM', account: , cursor: null, assets: [ { contract: , 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