Rarible EP11 Cannot read property 'imports' of undefined

So my code was working fine until I tried to change a contract filename, at least I think that’s what likely is the cause…

When I run the command

truffle migrate --reset

I hit the following error:

TypeError: Cannot read property 'imports' of undefined
    at Object.<anonymous> (/usr/local/lib/node_modules/truffle/build/webpack:/packages/compile-common/dist/src/profiler/requiredSources.js:98:1)
    at Generator.next (<anonymous>)
    at fulfilled (/usr/local/lib/node_modules/truffle/build/webpack:/packages/compile-common/dist/src/profiler/requiredSources.js:5:42)
Truffle v5.1.66 (core: 5.1.66)
Node v15.8.0

Looking online it says that this error is likely due to a mismatch between my compiler version and the solidity contract versions. I don’t think this is the case but I could be wrong.

I have 3 contracts

These contracts compiled cleanly and then I wanted to change the name of MorPolyRari.sol to MorPolyRariToken.sol. Once I made that change, everything broke and I haven’t been able to figure out why. I’ve been troubleshooting so I’m worried I may have made things worse. Where should I start looking for this error based on the message given?

Below are my contracts in case that’s helpful:


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721.sol";

contract MorPolyRariMarketContract {
  struct AuctionItem{
    uint256 id;
    address tokenAddress;
    uint256 tokenId;
    address payable seller;
    uint256 askingPrice;
    bool isSold;

  AuctionItem[] public itemsForSale;
  mapping (address => mapping(uint256 => bool)) activeItems;

  event itemAdded(uint256 id, uint256 tokenId, address tokenAddress, uint256 askingPrice);
  event itemSold(uint256 id, address buyer, uint256 askingPrice);

  modifier OnlyItemOwner(address tokenAddress, uint256 tokenId){
    IERC721 tokenContract = IERC721(tokenAddress);
    require(tokenContract.ownerOf(tokenId) == msg.sender);

  modifier HasTransferApproval(address tokenAddress, uint256 tokenId){
    IERC721 tokenContract = IERC721(tokenAddress);
    require(tokenContract.getApproved(tokenId) == address(this));

  modifier ItemExists(uint256 id){
    require(id < itemsForSale.length && itemsForSale[id].id == id, "Could not find item");

  modifier IsForSale(uint256 id){
    require(itemsForSale[id].isSold == false, "Item has already sold");
  function addItemToMarket(uint256 tokenId, address tokenAddress, uint256 askingPrice) OnlyItemOwner(tokenAddress, tokenId) HasTransferApproval(tokenAddress, tokenId) external returns (uint256){
    require(activeItems[tokenAddress][tokenId] == false, "Item is already up for sale!");
    uint256 newItemId = itemsForSale.length;
    itemsForSale.push(AuctionItem(newItemId, tokenAddress, tokenId, payable(msg.sender),askingPrice, false));
    activeItems[tokenAddress][tokenId] = true;

    assert(itemsForSale[newItemId].id == newItemId);
    emit itemAdded(newItemId, tokenId, tokenAddress, askingPrice);
    return newItemId;

  function buyItem(uint256 id) payable external ItemExists(id) IsForSale(id) HasTransferApproval(itemsForSale[id].tokenAddress, itemsForSale[id].tokenId){
    require(msg.value >= itemsForSale[id].askingPrice, "Not enough funds sent");
    require(msg.sender != itemsForSale[id].seller);
    itemsForSale[id].isSold = true;
    activeItems[itemsForSale[id].tokenAddress][itemsForSale[id].tokenId] = false;
    IERC721(itemsForSale[id].tokenAddress).safeTransferFrom(itemsForSale[id].seller,msg.sender, itemsForSale[id].tokenId);

    emit itemSold(id, msg.sender, itemsForSale[id].askingPrice);



// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

contract Migrations {
  address public owner = msg.sender;
  uint public last_completed_migration;

  modifier restricted() {
      msg.sender == owner,
      "This function is restricted to the contract's owner"

  function setCompleted(uint completed) public restricted {
    last_completed_migration = completed;


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "../node_modules/@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../node_modules/@openzeppelin/contracts/utils/Counters.sol";

contract MorPolyRari is ERC721 {
  using Counters for Counters.Counter;
  Counters.Counter private _tokenIds;

  constructor () ERC721("MorPolyRari", "MPR") {}

  struct Item {
    uint256 id;
    address creator;
    string uri;

  mapping (uint256 => Item) public Items;

  function createItem(string memory uri) public returns (uint256){
    uint256 newItemId = _tokenIds.current();
    _safeMint(msg.sender, newItemId);

    Items[newItemId] = Item(newItemId, msg.sender, uri);

    return newItemId;

  function tokenURI(uint256 tokenId) public view override returns (string memory) {
    require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

    return Items[tokenId].uri;

For good measure here are the migration javascript files as well:


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

module.exports = function (deployer) {


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

module.exports = function (deployer) {


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

module.exports = function (deployer) {

And again just in case…

 * 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 infuraKey = "fj4jll3k.....";
// const fs = require('fs');
// const mnemonic = fs.readFileSync(".secret").toString().trim();

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: "",     // Localhost (default: none)
    //  port: 8545,            // 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.
    // ropsten: {
    // provider: () => new HDWalletProvider(mnemonic, `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
    // network_id: 3,       // 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.0",    // 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"
      // }