The requested contract was not found. Make sure the source code is available for compilation

Question

I'm using '@openzeppelin/truffle-upgrades' plugin to create an upgradeable contract. First time doing this and going base off the websites article that they have on it. https://docs.openzeppelin.com/learn/upgrading-smart-contracts

Everything compiles correct, but the 3_deploy_upgradeable_box.js is spitting out this error whenever I migrate "The requested contract was not found. Make sure the source code is available for compilation" or see this screenshot https://gyazo.com/f4b8d8afea69b67965670b520e48db13

Here is my code

// contracts/Box.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";

contract Box is Ownable {

    uint256 private value;

    // Emitted when the stored value changes
    event ValueChanged(uint256 _value);

    // Store a new value in the contract, only the owner can call this
    function store(uint256 _value) public onlyOwner {
        value = _value;
        emit ValueChanged(_value);
    }

    // Retrieve the last stored value
    function retrieve() public view returns(uint256) {
        return value;
    }

}

// migrations/2_deploy.js
const Box = artifacts.require('Box');

module.exports = async function (deployer) {
  await deployer.deploy(Box);
};

// migrations/3_deploy_upgradeable_box.js
const { deployProxy } = require('@openzeppelin/truffle-upgrades');

const Box = artifacts.require('Box');

module.exports = async function (deployer) {
    await deployProxy(Box, [42], { deployer, initializer: 'store' });
  };

Truffle Config File below

/**
 * 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:
 *
 * trufflesuite.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 accounts
 * 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 HDWalletProvider = require('@truffle/hdwallet-provider');
const { mnemonic } = require('./secrets.json');

module.exports = {
  /**
   * 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: 7545,            // Standard Ethereum port (default: none)
     network_id: "*",       // Any network (default: none)
    },
    // Another network with more advanced options...
    // advanced: {
    // port: 8777,             // Custom port
    // network_id: 1342,       // Custom network
    // gas: 8500000,           // Gas sent with each transaction (default: ~6700000)
    // gasPrice: 20000000000,  // 20 gwei (in wei) (default: 100 gwei)
    // from: <address>,        // Account to send txs from (default: accounts[0])
    // websocket: true        // Enable EventEmitter interface for web3 (default: false)
    // },
    // Useful for deploying to a public network.
    // NB: It's important to wrap the provider as a function.
    // rinkeby: {
    // provider: () => new HDWalletProvider(mnemonic, `https://rinkeby.infura.io/v3/fc9b1925f04c4be5b27288d3f016b054`),
    // network_id: 4,       // Ropsten's id
    // gas: 5500000,        // Ropsten has a lower block limit than mainnet
    // confirmations: 2,    // # of confs to wait between deployments. (default: 0)
    // timeoutBlocks: 200,  // # of blocks before a deployment times out  (minimum/default: 50)
    // skipDryRun: true     // Skip dry run before migrations? (default: false for public nets )
    // },
    // Useful for private networks
    // private: {
    // provider: () => new HDWalletProvider(mnemonic, `https://network.io`),
    // network_id: 2111,   // This network is yours, in the cloud.
    // production: true    // Treats this network as if it was a public net. (default: false)
    // }
  },

  // Set default mocha options here, use special reporters etc.
  mocha: {
    // timeout: 100000
  },

  // Configure your compilers
  compilers: {
    solc: {
      version: "0.8.4"    // Fetch exact version from solc-bin (default: truffle's version)
      // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
      // settings: {          // See the solidity docs for advice about optimization and evmVersion
      //  optimizer: {
      //    enabled: false,
      //    runs: 200
      //  },
      //  evmVersion: "byzantium"
      // }
    }
  },

  // Truffle DB is currently disabled by default; to enable it, change enabled: false to enabled: true
  //
  // Note: if you migrated your contracts prior to enabling this field in your Truffle project and want
  // those previously migrated contracts available in the .db directory, you will need to run the following:
  // $ truffle migrate --reset --compile-all

  db: {
    enabled: false
  }
};

Please guide me in the right direction, thank you.

Answer 1

I had this same problem in Ubuntu 18.04. The solution for me was based on OpenZeppelin Forum. I also deleted all previous compiled contracts from build/contracts and removed unneeded migration files, then executed:

truffle compile --all
truffle migrate --reset

Answer 2

Let's see the traceback and see what we can pop from it.

The error is originated on this file:

And it's triggered by the openzeppelin contract.

That redirects us to this line in your "3_deploy_upgradable_box.js"

...
const Box = artifacts.require('Box');

module.exports = async function (deployer) {
    await deployProxy(Box, [42], { deployer, initializer: 'store' }); // Error originated in this line
  };

So perhaps, truffle isn't grabbing your Box contract correctly? Try specifying the contracts directory in your truffle config:

...
contracts_directory: './contracts/',
...

Also try console logging Box and other variables, might bring some light into the issue.

Answer 3

This error seems to stem from a couple different items.

1. OpenZeppelin has issues on Windows with Solidity version 0.8.2 see this answer. I upgraded to Solidity version 0.8.3 and things went smoothly.
2. Only found the above issue because I changed the single parentheses in the 3rd migration contract (3_deploy_ugradeable_box.js) to a quotation mark.

This:

const Box = artifacts.require('Box');

To This:

const Box = artifacts.require("Box");

From there, it found the Box contract and threw another error about needing to ensure the contract was initialized once and only once, which then led me to the Initializable helper found in the contracts-upgradeable package.

At this point, I discarded the Ownable inheritance from my Box contract because it was causing issues with the Initializable inheritance. The Box contract was now verbatim what is shown in this page of the tutorials except with the Initializable piece.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.3;

//Import ownable from the OpenZeppelin Contracts library
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract Box is Initializable{
    uint256 private _value;

    function initialize() public initializer {
        _value = 0;
    }

    // Emitted when the stored value changes
    event ValueChanged(uint256 value);

    // Stores a new value in the contract
    function store(uint256 value) public {
        _value = value;
        emit ValueChanged(value);
    }

    // Reads the last stored value
    function retrieve() public view returns (uint256) {
        return _value;
    }
}

The BoxV2 contract should look similar except with the added increment function.

I doubt my initialize function is perfect but this should get you through the rest of the tutorial with no issues.