Unable to deploy NFT in terminal

Question

I already deployed my smart contract to my wallet and connected it to my Alchemy account.

Here are my codings (Note that my contract address, PUBLIC_KEY, PRIVATE_KEY, API_URL and alchemy address are edited for security purposes).

mint-nft.js

  require('dotenv').config();
const API_URL = process.env.API_URL;
const PUBLIC_KEY = process.env.PUBLIC_KEY;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
const web3 = createAlchemyWeb3(API_URL);

const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
const contractAddress = "My_Contract_Adress";
const nftContract = new web3.eth.Contract(contract.abi, contractAddress);

async function mintNFT(tokenURI) {
  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce

  //the transaction
  const tx = {
    'from': PUBLIC_KEY,
    'to': contractAddress,
    'nonce': nonce,
    'gas': 500000,
    'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
  };

  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY);
  signPromise.then((signedTx) => {

    web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(err, hash) {
      if (!err) {
        console.log("The hash of your transaction is: ", hash, "\nCheck Alchemy's Mempool to view the status of your transaction!"); 
      } else {
        console.log("Something went wrong when submitting your transaction:", err)
      }
    });
  }).catch((err) => {
    console.log(" Promise failed:", err);
  });
}

mintNFT("https://gateway.pinata.cloud/ipfs/My_NFT_Picture_Hash");

alchemyContext.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeAlchemyContext = void 0;
var tslib_1 = require("tslib");
var sturdy_websocket_1 = tslib_1.__importDefault(require("sturdy-websocket"));
var websocket_1 = require("websocket");
var jsonRpc_1 = require("../util/jsonRpc");
var version_1 = require("../version");
var alchemySendHttp_1 = require("./alchemySendHttp");
var alchemySendWebSocket_1 = require("./alchemySendWebSocket");
var httpProvider_1 = require("./httpProvider");
var sendPayload_1 = require("./sendPayload");
var webSocketProvider_1 = require("./webSocketProvider");
var NODE_MAX_WS_FRAME_SIZE = 100 * 1024 * 1024; // 100 MB
function makeAlchemyContext(url, config) {
    var makePayload = jsonRpc_1.makePayloadFactory();
    if (/^https?:\/\//.test(url)) {
        var alchemySend = alchemySendHttp_1.makeHttpSender(url);
        var _a = sendPayload_1.makePayloadSender(alchemySend, config), sendPayload = _a.sendPayload, setWriteProvider = _a.setWriteProvider;
        var senders = jsonRpc_1.makeSenders(sendPayload, makePayload);
        var provider = httpProvider_1.makeAlchemyHttpProvider(sendPayload);
        return { provider: provider, senders: senders, setWriteProvider: setWriteProvider };
    }
    else if (/^wss?:\/\//.test(url)) {
        var protocol = isAlchemyUrl(url) ? "alchemy-web3-" + version_1.VERSION : undefined;
        var ws = new sturdy_websocket_1.default(url, protocol, {
            wsConstructor: getWebSocketConstructor(),
        });
        var alchemySend = alchemySendWebSocket_1.makeWebSocketSender(ws);
        var _b = sendPayload_1.makePayloadSender(alchemySend, config), sendPayload = _b.sendPayload, setWriteProvider = _b.setWriteProvider;
        var senders = jsonRpc_1.makeSenders(sendPayload, makePayload);
        var provider = new webSocketProvider_1.AlchemyWebSocketProvider(ws, sendPayload, senders);
        return { provider: provider, senders: senders, setWriteProvider: setWriteProvider };
    }
    else {
        throw new Error("Alchemy URL protocol must be one of http, https, ws, or wss. Recieved: " + url);
    }
}
exports.makeAlchemyContext = makeAlchemyContext;
function getWebSocketConstructor() {
    return isNodeEnvironment()
        ? function (url, protocols) {
            return new websocket_1.w3cwebsocket(url, protocols, undefined, undefined, undefined, {
                maxReceivedMessageSize: NODE_MAX_WS_FRAME_SIZE,
                maxReceivedFrameSize: NODE_MAX_WS_FRAME_SIZE,
            });
        }
        : WebSocket;
}
function isNodeEnvironment() {
    return (typeof process !== "undefined" &&
        process != null &&
        process.versions != null &&
        process.versions.node != null);
}
function isAlchemyUrl(url) {
    return url.indexOf("alchemyapi.io") >= 0;
}

.env

API_URL = "https://eth-rinkeby.alchemyapi.io/v2/KEY"
PRIVATE_KEY = "MY_PRIVATE_KEY"
PUBLIC_KEY = "MY_PUBLIC_KEY"

But then I was trying to deploy my NFT with metadata and nft-mint.js, I got these error.

Can anyone please tell me what was the error about?

Answer 1

Your issue may be with dotenv not reading in the values in your .env. If you add console.log(API_URL), is it correct or is it undefined? If it is undefined, I was able to resolve the issue by adding the path to my .env like so:

require('dotenv').config({path:"../.env"});

(In my case my mint-nft.js was in scripts/mint-nft.js and .env is in the root directory.)