Privatenet issue: ERROR: Contract Migrations has not been deployed on the network. about tronbox HOT 11 CLOSED

pragma solidity >= 0.5.0 < 0.7.0;
pragma experimental ABIEncoderV2;

import "./IERC20.sol";

contract Exchange {
  address owner;

  enum SwapType {
    Buy,
    Sell
  }

  struct SwapEntry {
    address maker;

    bool fulfilled;
    bool canceled;

    SwapType swapType;
    IERC20 erc20Token;

    uint inputAmount;
    uint outputAmount;
    address restrictToAddress;
  }

  event SwapEntryCreated(uint swapEntryId);
  event SwapEntryFulfilled(uint swapEntryId);
  event SwapEntryCanceled(uint swapEntryId);


  SwapEntry[] public swapEntries;

  constructor() public {
    owner = msg.sender;
  }

  function swapEntriesLength() external view returns (uint) {
    return swapEntries.length;
  }

  function swapEntriesArray() external view returns (SwapEntry[] memory) {
    return swapEntries;
  }

  function isFulFillable(uint swapEntryId) public view returns (bool) {
    SwapEntry storage swapEntry = swapEntries[swapEntryId];
    return !swapEntry.fulfilled && !swapEntry.canceled;
  }

  function isAuthorizedToFulfill(address addr, uint swapEntryId) internal view returns (bool) {
    SwapEntry storage swapEntry = swapEntries[swapEntryId];
    // not restricted
    if (swapEntry.restrictToAddress == address(0)) {
      return true;
    }
    return addr == swapEntry.restrictToAddress;
  }

  function _createSwapEntry(SwapType swapType, IERC20 erc20Token, uint inputAmount, uint outputAmount, address restrictToAddress) internal returns (uint) {
    address maker = msg.sender;
    SwapEntry memory swapEntry = SwapEntry({
      maker: maker,
      fulfilled: false,
      canceled: false,
      swapType: swapType,
      erc20Token: erc20Token,
      inputAmount: inputAmount,
      outputAmount: outputAmount,
      restrictToAddress: restrictToAddress
    });
    // push and return index of entry
    swapEntries.push(swapEntry);
    uint swapEntryId = swapEntries.length - 1;
    emit SwapEntryCreated(swapEntryId);
    return swapEntryId;
  }

  function createBuySwapEntry(IERC20 erc20Token, uint outputAmount,
                              address restrictToAddress) external payable returns (uint) {
    uint inputAmount = msg.value;
    return _createSwapEntry(SwapType.Buy, erc20Token, inputAmount, outputAmount, restrictToAddress);
  }

  function createSellSwapEntry(IERC20 erc20Token, uint inputAmount, uint outputAmount, address restrictToAddress) external returns (uint) {
    address sender = msg.sender;
    address recipient = address(this);
    // transfer the tokens to smart contract to ensure the swap is guaranteed to succeed if fulfilled
    erc20Token.transferFrom(sender, recipient, inputAmount);
    return _createSwapEntry(SwapType.Sell, erc20Token, inputAmount, outputAmount, restrictToAddress);
  }

  function cancelSwapEntry(uint swapEntryId) external returns (uint) {
    require(isFulFillable(swapEntryId), "only fulfillable swap entry can be canceled");
    SwapEntry storage swapEntry = swapEntries[swapEntryId];
    address payable maker = address(uint160(swapEntry.maker));
    require(msg.sender == maker || msg.sender == owner, "only owner creator of swap entry can cancel it");
    swapEntry.canceled = true;
    if (swapEntry.swapType == SwapType.Buy) {
      maker.transfer(swapEntry.inputAmount);
    } else if (swapEntry.swapType == SwapType.Sell) {
      swapEntry.erc20Token.transfer(maker, swapEntry.inputAmount);
    } else {
      assert(false);
    }
    emit SwapEntryCanceled(swapEntryId);
  }

  function fulfillBuySwap(uint swapEntryId) external returns (uint) {
    require(isFulFillable(swapEntryId), "swap entry is not fulfillable");
    require(isAuthorizedToFulfill(msg.sender, swapEntryId), "swap entry is restricted to another address");
    SwapEntry storage swapEntry = swapEntries[swapEntryId];
    require(swapEntry.swapType == SwapType.Buy, "swap entry is not of type Buy");
    swapEntry.fulfilled = true;

    address maker = swapEntry.maker;
    address payable taker = address(uint160(msg.sender));

    swapEntry.erc20Token.transferFrom(taker, maker, swapEntry.outputAmount);

    taker.transfer(swapEntry.inputAmount);
    emit SwapEntryFulfilled(swapEntryId);
  }

  function fulfillSellSwap(uint swapEntryId) external payable returns (uint) {
    require(isFulFillable(swapEntryId), "swap entry is not fulfillable");
    require(isAuthorizedToFulfill(msg.sender, swapEntryId), "swap entry is restricted to another address");
    SwapEntry storage swapEntry = swapEntries[swapEntryId];
    require(swapEntry.swapType == SwapType.Sell, "swap entry is not of type Sell");
    require(msg.value == swapEntry.outputAmount, "value is not exactly equal to swapEntry outputAmount");
    swapEntry.fulfilled = true;

    address payable maker = address(uint160(swapEntry.maker));
    address taker = msg.sender;

    swapEntry.erc20Token.transfer(taker, swapEntry.inputAmount);

    maker.transfer(swapEntry.outputAmount);
    emit SwapEntryFulfilled(swapEntryId);
  }
}