title: Chainlink v0.8 Smart Contract Deployment Issue
body: <p>I am having issues verifying my smart contract on Rinkeby Testnet using @chainlink. My contract is deploying to Rinkeby fine but runs into issues when I have publish_source on. The contract verifies fine when using v0.6 and Solidity 0.6.6, I seem to only have issues with v0.8. Anyone know why this might be happening?</p>
  <pre><code>// SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  import &quot;@chainlink/contracts/src/v0.8/ChainlinkClient.sol&quot;;
  import &quot;@openzeppelin/contracts/token/ERC721/ERC721.sol&quot;;
  
  /**
   * @title MyContract is an example contract which requests data from
   * the Chainlink network
   * @dev This contract is designed to work on multiple networks, including
   * local test networks
   */
  contract MyContract is ChainlinkClient, ERC721 {
      using Chainlink for Chainlink.Request;
  
      address constant RINKEBY_ORACLE =
          0x3A56aE4a2831C3d3514b5D7Af5578E45eBDb7a40;
      bytes32 constant RINKEBY_JOB_ID =
          bytes32(&quot;187bb80e5ee74a139734cac7475f3c6e&quot;);
  
      uint256 constant FEE = 0.1 * 10**18;
  
      uint256 public tokenCounter;
  
      bytes32 public data;
      string public image_url;
  
      struct Clip {
          string name;
          string url;
      }
  
      Clip[] public clips;
  
      mapping(bytes32 =&gt; string) public requestIdToClipName;
      mapping(bytes32 =&gt; address) public requestIdToSender;
      mapping(bytes32 =&gt; string) public requestIdToTokenURI;
      event requestedCollectible(bytes32 indexed requestId);
  
      mapping(bytes32 =&gt; uint256) public requestToTokenId;
      mapping(uint256 =&gt; string) public tokenIdToName;
      mapping(uint256 =&gt; string) public tokenIdToImgUrl;
  
      constructor(address _link) public ERC721(&quot;Tests&quot;, &quot;TST&quot;) {
          if (_link == address(0)) {
              setPublicChainlinkToken();
          } else {
              setChainlinkToken(_link);
          }
          setChainlinkOracle(0x3A56aE4a2831C3d3514b5D7Af5578E45eBDb7a40);
          tokenCounter = 0;
      }
  
      function getChainlinkToken() public view returns (address) {
          return chainlinkTokenAddress();
      }
  
      function createRequestTo(
          string memory _url,
          string memory _path,
          string memory clipName
      ) public returns (bytes32 requestId) {
          Chainlink.Request memory req = buildChainlinkRequest(
              RINKEBY_JOB_ID,
              address(this),
              this.fulfill.selector
          );
          req.add(&quot;get&quot;, _url);
          req.add(&quot;path&quot;, _path);
  
          requestId = sendChainlinkRequestTo(RINKEBY_ORACLE, req, FEE);
          requestIdToClipName[requestId] = clipName;
          requestIdToSender[requestId] = msg.sender;
          emit requestedCollectible(requestId);
          return requestId;
      }
  
      function fulfill(bytes32 _requestId, bytes32 _data)
          public
          recordChainlinkFulfillment(_requestId)
      {
          address nftOwner = requestIdToSender[_requestId];
          string memory name = requestIdToClipName[_requestId];
          uint256 newItemId = clips.length;
  
          data = _data;
          image_url = bytes32ToString(data);
  
          clips.push(Clip(name, image_url));
  
          _safeMint(nftOwner, newItemId);
  
          tokenIdToName[newItemId] = name;
          tokenIdToImgUrl[newItemId] = image_url;
      }
  
      function getNumberOfClips() public view returns (uint256) {
          return clips.length;
      }
  
      /**
       * @notice Allows the owner to withdraw any LINK balance on the contract
       */
      function withdrawLink() public {
          LinkTokenInterface link = LinkTokenInterface(chainlinkTokenAddress());
          require(
              link.transfer(msg.sender, link.balanceOf(address(this))),
              &quot;Unable to transfer&quot;
          );
      }
  
      /**
       * @notice Call this method if no response is received within 5 minutes
       * @param _requestId The ID that was generated for the request to cancel
       * @param _payment The payment specified for the request to cancel
       * @param _callbackFunctionId The bytes4 callback function ID specified for
       * the request to cancel
       * @param _expiration The expiration generated for the request to cancel
       */
      function cancelRequest(
          bytes32 _requestId,
          uint256 _payment,
          bytes4 _callbackFunctionId,
          uint256 _expiration
      ) public {
          cancelChainlinkRequest(
              _requestId,
              _payment,
              _callbackFunctionId,
              _expiration
          );
      }
  }
  </code></pre>
  <p>Here is the script I am using to deploy:</p>
  <pre><code>from brownie import MyContract, accounts, network, config
  from scripts.helpful_scripts import fund_contract
  
  
  def main():
      dev = accounts.add(config['wallets']['from_key'])
      print(network.show_active())
  
      publish_source = True
  
      my_contract = MyContract.deploy(
          config['networks'][network.show_active()]['link_token'],
          {&quot;from&quot;: dev},
          publish_source=publish_source
      )
      fund_contract(my_contract)
      return my_contract
  
  </code></pre>
  <p>This is the error:</p>
  <pre><code>Transaction sent: 0x01ef409a5b0c2f6de60194f14f1d2e8ffac9a6ce6397aaa38392d949e2656909
    Gas price: 1.000000008 gwei   Gas limit: 2793499   Nonce: 359
    MyContract.constructor confirmed   Block: 9332417   Gas used: 2539545 (90.91%)
    MyContract deployed at: 0x42fBa06808C3cB11e5D7AcC6BB02B1A612e040d1
  
    File &quot;brownie/_cli/run.py&quot;, line 49, in main
      return_value, frame = run(
    File &quot;brownie/project/scripts.py&quot;, line 103, in run
      return_value = f_locals[method_name](*args, **kwargs)
    File &quot;./scripts/deploy_api.py&quot;, line 11, in main
      my_contract = MyContract.deploy(
    File &quot;brownie/network/contract.py&quot;, line 600, in __call__
      return tx[&quot;from&quot;].deploy(
    File &quot;brownie/network/account.py&quot;, line 555, in deploy
      contract.publish_source(deployed_contract, silent=silent)
    File &quot;brownie/network/contract.py&quot;, line 410, in publish_source
      contract_info = self.get_verification_info()
    File &quot;brownie/network/contract.py&quot;, line 292, in get_verification_info
      if symbol_alias[&quot;local&quot;] is not None:
  KeyError: 'local'
  </code></pre>