truffle-config.js

/**
 * Use this file to configure your truffle project. It's seeded with some
 * common settings for different networks and features like migrations,
 * compilation and testing. Uncomment the ones you need or modify
 * them to suit your project as necessary.
 *
 * More information about configuration can be found at:
 *
 * truffleframework.com/docs/advanced/configuration
 *
 * To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
 * to sign your transactions before they're sent to a remote public node. Infura API
 * keys are available for free at: infura.io/register
 *
 * You'll also need a mnemonic - the twelve word phrase the wallet uses to generate
 * public/private key pairs. If you're publishing your code to GitHub make sure you load this
 * phrase from a file you've .gitignored so it doesn't accidentally become public.
 *
 */

// const fs = require('fs');
const HDWalletProvider = require('@truffle/hdwallet-provider');
const Web3 = require('web3');
const web3 = new Web3();
require('ts-node/register');

const infuraKey = 'fj4jll3k.....';
const mnemonicPhrase = process.env.MNEMONIC; // fs.readFileSync('.secret').toString().trim();

module.exports = {
    test_file_extension_regexp: /.*\.ts$/,
    /**
     * Networks define how you connect to your ethereum client and let you set the
     * defaults web3 uses to send transactions. If you don't specify one truffle
     * will spin up a development blockchain for you on port 9545 when you
     * run `develop` or `test`. You can ask a truffle command to use a specific
     * network from the command line, e.g
     *
     * $ truffle test --network <network-name>
     */

    networks: {
        // Useful for testing. The `development` name is special - truffle uses it by default
        // if it's defined here and no other network is specified at the command line.
        // You should run a client (like ganache-cli, geth or parity) in a separate terminal
        // tab if you use this network and you must also set the `host`, `port` and `network_id`
        // options below to some value.
        //
        development: {
            host: '127.0.0.1', // Localhost (default: none)
            port: 8545, // Standard Ethereum port (default: none)
            network_id: '*', // Any network (default: none)
        },

        // this is necessary for coverage
        coverage: {
            host: 'localhost',
            network_id: '*',
            port: 8555,
            gas: 0xfffffffffff,
            gasPrice: 0x01,
        },

        homestead: {
            provider: () =>
              new HDWalletProvider({
                mnemonic: {
                  phrase: mnemonicPhrase
                },
                providerOrUrl: `https://mainnet.infura.io/v3/${infuraKey}`,
      //          numberOfAddresses: 1,
      //          shareNonce: true,
      //          derivationPath: "m/44'/1'/0'/0/"
                derivationPath: "m/44'/60'/0'/0/"
              }),
            gas: 3111752,
            confirmations: 2,    // # of confs to wait between deployments. (default: 0)
            timeoutBlocks: 50000,  // # of blocks before a deployment times out  (minimum/default: 50)
            gasPrice: web3.utils.toWei('58', 'gwei'),
            network_id: 1,
        },

        kovan: {
            provider: () =>
              new HDWalletProvider({
                mnemonic: {
                  phrase: mnemonicPhrase
                },
                providerOrUrl: `https://kovan.infura.io/v3/${infuraKey}`,
              }),
              gas: 10000000,
              gasPrice: web3.utils.toWei('46', 'gwei'),
              network_id: 42,
        },

        sokol: {
            provider: () =>
              new HDWalletProvider({
                mnemonic: {
                  phrase: mnemonicPhrase
                },
                providerOrUrl: "https://sokol.poa.network",
              }),
              gas: 10000000,
              gasPrice: 5000000000,
              network_id: 77,
        },

        xdai: {
            provider: () =>
              new HDWalletProvider({
                mnemonic: {
                  phrase: mnemonicPhrase
                },
                providerOrUrl: "https://dai.poa.network",
              }),
            gas: 12087782,
            gasPrice: 1000000000,
            network_id: 100,
        },
          
        // Useful for deploying to a public network.
        // NB: It's important to wrap the provider as a function.
        goerli: {
            provider: () => new HDWalletProvider(mnemonicPhrase, `https://goerli.infura.io/v3/${infuraKey}`),
            network_id: 5, // Ropsten's id
            confirmations: 2, // # of confs to wait between deployments. (default: 0)
            timeoutBlocks: 200, // # of blocks before a deployment times out  (minimum/default: 50)
        },
    },

    // Set default mocha options here, use special reporters etc.
    mocha: {
        timeout: 100000,
        reporter: 'eth-gas-reporter',
    },

    plugins: ['solidity-coverage', 'truffle-plugin-verify'],

    api_keys: {
      etherscan: '<add key here>'
    },

    // Configure your compilers
    compilers: {
        solc: {
            version: '0.8.0', // Fetch exact version from solc-bin (default: truffle's version)
            settings: { // See the solidity docs for advice about optimization and evmVersion
                optimizer: {
                    enabled: true,
                    runs: 200,
                },
            },
        },
    },

    ens: {
        enabled: true
    },
};