Lesson 14: uploadToPinata.js returned Error: Request failed with status code 400

[ybnx]

Problem Description

When I ran the deploy command line:

hh deploy --tags randomipfs,mocks

I got this error:

D:\HardhatProject\hardhatNft\images\randomNft\st-bernard.png
Error: Request failed with status code 400
    at createError (D:\HardhatProject\hardhatNft\node_modules\@pinata\sdk\lib\webpack:\pinata-sdk\node_modules\axios\lib\core\createE
rror.js:16:1)
    at settle (D:\HardhatProject\hardhatNft\node_modules\@pinata\sdk\lib\webpack:\pinata-sdk\node_modules\axios\lib\core\settle.js:17
:1)
    at IncomingMessage.handleStreamEnd (D:\HardhatProject\hardhatNft\node_modules\@pinata\sdk\lib\webpack:\pinata-sdk\node_modules\ax
ios\lib\adapters\http.js:260:1)
    at IncomingMessage.emit (node:events:525:35)
    at endReadableNT (node:internal/streams/readable:1358:12)
    at processTicksAndRejections (node:internal/process/task_queues:83:21) {
  config: {
    url: 'https://api.pinata.cloud/pinning/pinFileToIPFS',
    method: 'post',
    data: FormData {
      _overheadLength: 155,
      _valueLength: 0,
      _valuesToMeasure: [Array],
      writable: false,
      readable: true,
      dataSize: 0,
      maxDataSize: 2097152,
      pauseStreams: true,
      _released: true,
      _streams: [],
      _currentStream: null,
      _insideLoop: false,
      _pendingNext: false,
      _boundary: '--------------------------554784490731602051203934',
      _events: [Object: null prototype],
      _eventsCount: 1
    },
    headers: {
      Accept: 'application/json, text/plain, */*',
      'Content-Type': 'multipart/form-data; boundary= --------------------------554784490731602051203934',
      pinata_api_key: '286e4dea1f14e4c517d7',
      pinata_secret_api_key: 'a164132c7b4dc2b5b71fab1a10a1563cffac4671ac346699a3d5dd804883fb16',
      'User-Agent': 'axios/0.21.1',
      host: 'api.pinata.cloud'
    },
    transformRequest: [ [Function: transformRequest] ],
    transformResponse: [ [Function: transformResponse] ],
    timeout: 0,
    withCredentials: true,
    adapter: [Function: httpAdapter],
    xsrfCookieName: 'XSRF-TOKEN',
    xsrfHeaderName: 'X-XSRF-TOKEN',
    maxContentLength: Infinity,
    maxBodyLength: Infinity,
    validateStatus: [Function: validateStatus]
  },
  request: <ref *1> ClientRequest {
    _events: [Object: null prototype] {
      abort: [Function (anonymous)],
      aborted: [Function (anonymous)],
      connect: [Function (anonymous)],
      error: [Function (anonymous)],
      socket: [Function (anonymous)],
      timeout: [Function (anonymous)],
      prefinish: [Function: requestOnPrefinish]
    },
    _eventsCount: 7,
    _maxListeners: undefined,
    outputData: [],
    outputSize: 0,
    writable: true,
    destroyed: false,
    _last: true,
    chunkedEncoding: true,
    shouldKeepAlive: false,
    maxRequestsOnConnectionReached: false,
    _defaultKeepAlive: true,
    useChunkedEncodingByDefault: true,
    sendDate: false,
    _removedConnection: false,
    _removedContLen: false,
    _removedTE: false,
    _contentLength: null,
    _hasBody: true,
    _trailer: '',
    finished: true,
    _headerSent: true,
    _closed: false,
    socket: Socket {
      connecting: false,
      _hadError: false,
      _parent: null,
      _host: null,
      _readableState: [ReadableState],
      _events: [Object: null prototype],
      _eventsCount: 7,
      _maxListeners: undefined,
      _writableState: [WritableState],
      allowHalfOpen: false,
      _sockname: null,
      _pendingData: null,
      _pendingEncoding: '',
      server: null,
      _server: null,
      parser: null,
      _httpMessage: [Circular *1],
      [Symbol(async_id_symbol)]: 1079,
      [Symbol(kHandle)]: [TCP],
      [Symbol(lastWriteQueueSize)]: 0,
      [Symbol(timeout)]: null,
      [Symbol(kBuffer)]: null,
      [Symbol(kBufferCb)]: null,
      [Symbol(kBufferGen)]: null,
      [Symbol(kCapture)]: false,
      [Symbol(kSetNoDelay)]: false,
      [Symbol(kSetKeepAlive)]: false,
      [Symbol(kSetKeepAliveInitialDelay)]: 0,
      [Symbol(kBytesRead)]: 0,
      [Symbol(kBytesWritten)]: 0,
      [Symbol(RequestTimeout)]: undefined
    },
    _header: 'POST https://api.pinata.cloud/pinning/pinFileToIPFS HTTP/1.1\r\n' +
      'Accept: application/json, text/plain, */*\r\n' +
      'Content-Type: multipart/form-data; boundary= --------------------------554784490731602051203934\r\n' +
      'pinata_api_key: 286e4dea1f14e4c517d7\r\n' +
      'pinata_secret_api_key: a164132c7b4dc2b5b71fab1a10a1563cffac4671ac346699a3d5dd804883fb16\r\n' +
      'User-Agent: axios/0.21.1\r\n' +
      'host: api.pinata.cloud\r\n' +
      'Connection: close\r\n' +
      'Transfer-Encoding: chunked\r\n' +
      '\r\n',
    _keepAliveTimeout: 0,
    _onPendingData: [Function: nop],
    agent: Agent {
      _events: [Object: null prototype],
      _eventsCount: 2,
      _maxListeners: undefined,
      defaultPort: 80,
      protocol: 'http:',
      options: [Object: null prototype],
      requests: [Object: null prototype] {},
      sockets: [Object: null prototype],
      freeSockets: [Object: null prototype] {},
      keepAliveMsecs: 1000,
      keepAlive: false,
      maxSockets: Infinity,
      maxFreeSockets: 256,
      scheduling: 'lifo',
      maxTotalSockets: Infinity,
      totalSocketCount: 1,
      [Symbol(kCapture)]: false
    },
    socketPath: undefined,
    method: 'POST',
    maxHeaderSize: undefined,
    insecureHTTPParser: undefined,
    path: 'https://api.pinata.cloud/pinning/pinFileToIPFS',
    _ended: true,
    res: IncomingMessage {
      _readableState: [ReadableState],
      _events: [Object: null prototype],
      _eventsCount: 3,
      _maxListeners: undefined,
      socket: [Socket],
      httpVersionMajor: 1,
      httpVersionMinor: 1,
      httpVersion: '1.1',
      complete: true,
      rawHeaders: [Array],
      rawTrailers: [],
      aborted: false,
      upgrade: false,
      url: '',
      method: null,
      statusCode: 400,
      statusMessage: 'Bad Request',
      client: [Socket],
      _consuming: true,
      _dumped: false,
      req: [Circular *1],
      responseUrl: 'http://127.0.0.1:10809/https://api.pinata.cloud/pinning/pinFileToIPFS',
      redirects: [],
      [Symbol(kCapture)]: false,
      [Symbol(kHeaders)]: [Object],
      [Symbol(kHeadersCount)]: 12,
      [Symbol(kTrailers)]: null,
      [Symbol(kTrailersCount)]: 0,
      [Symbol(RequestTimeout)]: undefined
    },
    aborted: false,
    timeoutCb: null,
    upgradeOrConnect: false,
    parser: null,
    maxHeadersCount: null,
    reusedSocket: false,
    host: '127.0.0.1',
    protocol: 'http:',
    _redirectable: Writable {
      _writableState: [WritableState],
      _events: [Object: null prototype],
      _eventsCount: 2,
      _maxListeners: undefined,
      _options: [Object],
      _ended: true,
      _ending: true,
      _redirectCount: 0,
      _redirects: [],
      _requestBodyLength: 10557,
      _requestBodyBuffers: [],
      _onNativeResponse: [Function (anonymous)],
      _currentRequest: [Circular *1],
      _currentUrl: 'http://127.0.0.1:10809/https://api.pinata.cloud/pinning/pinFileToIPFS',
      [Symbol(kCapture)]: false
    },
    [Symbol(kCapture)]: false,
    [Symbol(kNeedDrain)]: false,
    [Symbol(corked)]: 0,
    [Symbol(kOutHeaders)]: [Object: null prototype] {
      accept: [Array],
      'content-type': [Array],
      pinata_api_key: [Array],
      pinata_secret_api_key: [Array],
      'user-agent': [Array],
      host: [Array]
    },
    [Symbol(kUniqueHeaders)]: null
  },
  response: {
    status: 400,
    statusText: 'Bad Request',
    headers: {
      'content-length': '248',
      connection: 'keep-alive',
      'content-type': 'text/html',
      date: 'Wed, 26 Oct 2022 05:21:59 GMT',
      'keep-alive': 'timeout=4',
      'proxy-connection': 'keep-alive'
    },
    config: {
      url: 'https://api.pinata.cloud/pinning/pinFileToIPFS',
      method: 'post',
      data: [FormData],
      headers: [Object],
      transformRequest: [Array],
      transformResponse: [Array],
      timeout: 0,
      withCredentials: true,
      adapter: [Function: httpAdapter],
      xsrfCookieName: 'XSRF-TOKEN',
      xsrfHeaderName: 'X-XSRF-TOKEN',
      maxContentLength: Infinity,
      maxBodyLength: Infinity,
      validateStatus: [Function: validateStatus]
    },
    request: <ref *1> ClientRequest {
      _events: [Object: null prototype],
      _eventsCount: 7,
      _maxListeners: undefined,
      outputData: [],
      outputSize: 0,
      writable: true,
      destroyed: false,
      _last: true,
      chunkedEncoding: true,
      shouldKeepAlive: false,
      maxRequestsOnConnectionReached: false,
      _defaultKeepAlive: true,
      useChunkedEncodingByDefault: true,
      sendDate: false,
      _removedConnection: false,
      _removedContLen: false,
      _removedTE: false,
      _contentLength: null,
      _hasBody: true,
      _trailer: '',
      finished: true,
      _headerSent: true,
      _closed: false,
      socket: [Socket],
      _header: 'POST https://api.pinata.cloud/pinning/pinFileToIPFS HTTP/1.1\r\n' +
        'Accept: application/json, text/plain, */*\r\n' +
        'Content-Type: multipart/form-data; boundary= --------------------------554784490731602051203934\r\n' +
        'pinata_api_key: 286e4dea1f14e4c517d7\r\n' +
        'pinata_secret_api_key: a164132c7b4dc2b5b71fab1a10a1563cffac4671ac346699a3d5dd804883fb16\r\n' +
        'User-Agent: axios/0.21.1\r\n' +
        'host: api.pinata.cloud\r\n' +
        'Connection: close\r\n' +
        'Transfer-Encoding: chunked\r\n' +
        '\r\n',
      _keepAliveTimeout: 0,
      _onPendingData: [Function: nop],
      agent: [Agent],
      socketPath: undefined,
      method: 'POST',
      maxHeaderSize: undefined,
      insecureHTTPParser: undefined,
      path: 'https://api.pinata.cloud/pinning/pinFileToIPFS',
      _ended: true,
      res: [IncomingMessage],
      aborted: false,
      timeoutCb: null,
      upgradeOrConnect: false,
      parser: null,
      maxHeadersCount: null,
      reusedSocket: false,
      host: '127.0.0.1',
      protocol: 'http:',
      _redirectable: [Writable],
      [Symbol(kCapture)]: false,
      [Symbol(kNeedDrain)]: false,
      [Symbol(corked)]: 0,
      [Symbol(kOutHeaders)]: [Object: null prototype],
      [Symbol(kUniqueHeaders)]: null
    },
    data: '<html>\r\n' +
      '<head><title>400 The plain HTTP request was sent to HTTPS port</title></head>\r\n' +
      '<body>\r\n' +
      '<center><h1>400 Bad Request</h1></center>\r\n' +
      '<center>The plain HTTP request was sent to HTTPS port</center>\r\n' +
      '<hr><center>nginx</center>\r\n' +
      '</body>\r\n' +
      '</html>\r\n'
  },
  isAxiosError: true,
  toJSON: [Function: toJSON]
}

Here is my code for uploadToPinata.js

const pinataSDK = require("@pinata/sdk");
const path = require("path");
const fs = require("fs");
require("dotenv").config();

const pinataApiKey = process.env.PINATA_API_KEY;
const pinataApiSecret = process.env.PINATA_API_SECRET;
const pinata = pinataSDK(pinataApiKey, pinataApiSecret);
const url = "http://api.pinata.cloud/pinning/pinFileToIPFS"

async function storeImages(imagesFilePath) {
    const fullImagesPath = path.resolve(imagesFilePath);

    console.log(fullImagesPath);

    const files = fs.readdirSync(fullImagesPath);
    let responses = [];
    console.log("Uploading to Pinata");
    for (fileIndex in files) {
        console.log(`Working on ${fileIndex}`);

        console.log(`${fullImagesPath}\\${files[fileIndex]}`);

        const readableStreamForFile = fs.createReadStream(`${fullImagesPath}\\${files[fileIndex]}`);
        try {
            const response = await pinata.pinFileToIPFS(readableStreamForFile);
            responses.push(response);
        } catch (error) {
            console.error(error);
        }
    }
    return {responses, files};
}

module.exports = {storeImages};

I tried to ping api.pinata.cloud

ping api.pinata.cloud

and got 100% package loss.

I'm in China, so I guess that's because China Great Firewall (GFW) polluted my DNS.I tried to manually map the connection between the domin and ip in the host file

167.172.153.16 api.pinata.cloud
162.243.171.76 api.pinata.cloud
137.184.21.130 api.pinata.cloud

But it doesn't work

I use v2rayn and I think I set up the system proxy correctly

Additional Information

hardhat.config.js

require("@nomicfoundation/hardhat-toolbox");
require("@nomiclabs/hardhat-waffle");
require("dotenv").config();
require("@nomiclabs/hardhat-etherscan");
require("hardhat-gas-reporter");
require("solidity-coverage");
require("hardhat-deploy");
require("hardhat-contract-sizer");

const GOERLI_RPC_URL = process.env.GOERLI_RPC_URL || "http";
const PRIVATE_KEY = process.env.PRIVATE_KEY || "0x00";
const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY || "key";
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY || "key";

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    goerli: {
      chainId: 5,
      blockConfirmations: 6,
      url: GOERLI_RPC_URL,
      accounts: [PRIVATE_KEY]
    },
    localhost: {
      chainId: 31337,
      blockConfirmations: 1
    }
  },
  solidity: "0.8.8",
  gasReporter: {
    enabled: false,
    outputFile: "gas-report.txt",
    noColors: true,
    currency: "USD",
    coinmarketcap: COINMARKETCAP_API_KEY,
    token: "MATIC"
  },
  namedAccounts: {
    deployer: {
      default: 0
    },
    player: {
      default: 1
    }
  },
  mocha: {
    timeout: 500000
  },
  etherscan: {
    apiKey: {
      goerli: ETHERSCAN_API_KEY
    },
    customChains: [
      {
        network: "goerli",
        chainId: 5,
        urls: {
          apiURL: "http://api-goerli.etherscan.io/api", // https => http
          browserURL: "https://goerli.etherscan.io"
        }
      }
    ]
  }
};

[ybnx]

I forgot to hide the api key pinata_api_key and pinata_secret_api_key, I've removed this api key

[JamesMckenna]

@ybnx

The only thing in your code that jumps out to me is the double backslash in
const readableStreamForFile = fs.createReadStream(${fullImagesPath}\\${files[fileIndex]});

[ybnx]

i use webstorm as my IDE, if i don't add double backslash, webstorm will think "$" is escaped

[ybnx]

and the absolute path of file will become "D:\HardhatProject\hardhatNft\images\randomNft${files[fileIndex]}"

[JamesMckenna]

@ybnx
Try changing from backslash (\), to forward slash (/)
In vs code, I only need 1 forward slash. But if I used 1 backslash, it was showing as an escaping the '$'

[alymurtazamemon]

@ybnx Push it to GitHub and leave a link here I will test it.

[ybnx]

thanks a lot
https://github.com/ybnx/hardhatNft