Aprenda como criar um Token dApp usando QuickNode.

echo ACCESS_KEY_ID:SECRET_ACCESS_KEY > ${HOME}/.passwd-s3fs
chmod 600 ${HOME}/.passwd-s3fs

s3fs mybucket /path/to/mountpoint -o passwd_file=${HOME}/.passwd-s3fs -o url=https://s3.filebase.com

npx create-react-app my-dapp

cd my-dapp

rm README.md

npm install --save-dev "hardhat@^2.9.3" "@nomiclabs/hardhat-waffle@^2.0.0" 
"ethereum-waffle@^3.0.0" "chai@^4.2.0" "@nomiclabs/hardhat-ethers@^2.0.0" 
"ethers@^5.0.0"

npx hardhat

//dApp.sol
//SPDX-License-Identifier: UNLICENSED
 pragma solidity ^ 0.7 . 0 ;
contract Token {
    string  public name = "dApp token" ;
    string  public symbol = "DAT" ;
    // A quantidade fixa de tokens armazenados em uma variável de tipo inteiro sem sinal.
    uint256 public totalSupply = 1000000 ;
    // Uma variável de tipo de endereço é usada para armazenar contas ethereum.
    address public owner;
    // Um ​​mapeamento é um mapa de chave/valor. Aqui armazenamos o saldo de cada conta.
    mapping(address => uint256) balances;
    /**
    * Inicialização do contrato.
    *
    * O `constructor` é executado apenas uma vez quando o contrato é criado.
    * O modificador `public` permite que uma função seja chamada de fora do contrato.
    */
    constructor () {
        // O totalSupply é atribuído ao remetente da transação, que é a conta
        // que está implementando o contrato.
        balances[msg.sender] = totalSupply;
        owner = msg.sender;
    }
    /**
    * Uma função para transferir tokens.
     *
    * O modificador `external` torna uma função *apenas* chamada de fora
    * do contrato.
    */ fnction transfer(address to, uint256 amount )external{
         // Verifica se o remetente da transação possui tokens suficientes.
        // Se o primeiro argumento de `require` for avaliado como `false`,então a
        // transação será revertida.
        require (balances[msg.sender] >= amount, "Not enough tokens" );
        // Transfira o valor.
        balances[msg.sender] -= amount;
        balances[a] += amount;
    }
     /**
    * Função somente leitura para recuperar o saldo do token de uma determinada conta.
    *
    * O modificador `view` indica que não modifica o
    * estado do contrato, o que nos permite chamá-lo sem executar uma transação.
    */
    function  balanceOf ( address account ) external view returns ( uint256 )  {
         return balances[account];
    }
}

npx hardhat node

require("@nomiclabs/hardhat-ethers");

module.exports = {
 defaultNetwork: "rinkeby",
 networks: {
   rinkeby: {
     url: "QUICKNODE_API_URL",
     accounts: "WALLET_PRIVATE_KEY"
   }
 },
 solidity: {
   version: "0.7.0",
   settings: {
     optimizer: {
       enabled: true,
       runs: 200
     }
   }
 },
 paths: {
   sources: "./contracts",
   tests: "./test",
   cache: "./cache",
   artifacts: "./artifacts"
 },
 mocha: {
   timeout: 20000
 }
}

//deploy.js
const hre = require("hardhat");
async function main() {
   // ethers está disponível no escopo global
   const [deployer] = await hre.ethers.getSigners();
   console.log(
     "Implantando os contratos com a conta:",
     await deployer.getAddress()
   );

   console.log("Account balance:", (await deployer.getBalance()).toString());

   const Token = await hre.ethers.getContractFactory("Token");
   const token = await Token.deploy();
   await token.deployed();

   console.log("Token address:", token.address);

 }

 main()
   .then(() => process.exit(0))
   .catch((error) => {
     console.error(error);
     process.exit(1);
   });

npx hardhat run –network rinkeby scripts/deploy.js

npx start

import './App.css';
import {ethers} from 'ethers'
import { useState } from 'react';
import TokenArtifact from "./artifacts/contracts/dApp.sol/Token.json"
const tokenAddress = "CONTRACT_ADDRESS"

function App() {
const [tokenData, setTokenData] = useState({})
const [amount, setAmount] = useState()
const [userAccountId, setUserAccountId] = useState()

async function requestAccount() {
 await window.ethereum.request({ método: 'eth_requestAccounts' });
}

const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
async function _intializeContract(init) {
// Primeiro inicializamos ethers criando um provedor usando window.ethereum
  // Quando, inicializamos o contrato usando esse provedor e o token
  // artefato. Você pode fazer a mesma coisa com seus contratos. 
 const contract = new ethers.Contract(
   tokenAddress,
   TokenArtifact.abi,
   init
 );

 return contract
}
async function _getTokenData() {
 const contract = await _intializeContract(signer)
 const name = await contract.name();
 const symbol = await contract.symbol();
 const tokenData = {name, symbol}
 setTokenData(tokenData);
}
async function senddAppToken() {
 if (typeof window.ethereum !== 'undefined') {
   await requestAccount()
   const contract = await _intializeContract(signer)
   const transaction = await contract.transfer(userAccountId, amount);
   await transaction.wait();
   console.log(`${amount} dAppToken has been sent to ${userAccountId}`);
 }
}
async function getBalance() {
 if (typeof window.ethereum !== 'undefined') {
   const contract = await _intializeContract(signer)
   const [account] = await window.ethereum.request({ method: 'eth_requestAccounts' })
   const balance = await contract.balanceOf(account);
   console.log("Account Balance: ", balance.toString());
 }
}
 return (
   <div className="App">
     <header className="App-header">
     <button onClick={_getTokenData}>get token data</button>
     <h1>{tokenData.name}</h1>
     <h1>{tokenData.symbol}</h1>
     <button onClick={getBalance}>Get Balance</button>
     <button onClick={senddAppToken}>Send dAppToken</button>
     <input onChange={e => setUserAccountId(e.target.value)} placeholder="Account ID" />
       <input onChange={e => setAmount(e.target.value)} placeholder="Amount" />
     </header>
   </div>
 );
}
export default App;