Unable to verify contract on Etherscan created with Solidity 0.4, OpenZeppelin and deployed with Mist

Hi All -

A dev no longer associated with our project deployed the below contract in October of 2017.

I’m trying to get it verified and published on Etherscan now, but am running into problems.

What would make this work?

The contract was created using Zeppelin base contracts, and was deployed using Truffle (to my knowledge, at least).

Here’s the contract:

pragma solidity ^0.4.11;
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }
  function sub(uint256 a, uint256 b) internal constant returns (uint256) {
    assert(b <= a);
    return a - b;
  }
  function add(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}
/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic {
  using SafeMath for uint256;
  mapping(address => uint256) balances;
  /**
  * @dev transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    // SafeMath.sub will throw if there is not enough balance.
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }
  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public constant returns (uint256 balance) {
    return balances[_owner];
  }
}
/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken {
  mapping (address => mapping (address => uint256)) allowed;
  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amount of tokens to be transferred
   */
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    uint256 _allowance = allowed[_from][msg.sender];
    // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
    // require (_value <= _allowance);
    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = _allowance.sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }
  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   *
   * Beware that changing an allowance with this method brings the risk that someone may use both the old
   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }
  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }
  /**
   * approve should be called when allowed[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   */
  function increaseApproval (address _spender, uint _addedValue)
    returns (bool success) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }
  function decreaseApproval (address _spender, uint _subtractedValue)
    returns (bool success) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }
}
/**
* @title Seeds token. Implements Standard ERC20 token
*/
contract SeedsToken is StandardToken {
  string public name = 'SeedsToken';
  string public symbol = 'SEEDS';
  uint public decimals = 10;
  uint public INITIAL_SUPPLY = 10000000000000000000;
  function SeedsToken() {
    totalSupply = INITIAL_SUPPLY;
    balances[msg.sender] = INITIAL_SUPPLY;
  }
}
1 Like

Hi @seedsgives,

Welcome to the community :wave:

Are you able to publicly share, a GitHub repository, the mainnet address and the license (I assume MIT as that is what OpenZeppelin uses).

Thanks! Glad to have found it!

Yes, it’s an MIT license, and the mainnet address is 0x61404d2d3f2100b124d6827d3f2ddf6233cd71c0.

The repo is https://github.com/therealseeds/seeds-token.

The link to the token creation contract specifically is:

1 Like

Hi @seedsgives,

Given that the contract is flattened and the truffle.js doesn’t have any public networks I assume that the contract may have been deployed using Remix rather than Truffle.

https://etherscan.io/address/0x61404d2d3f2100b124d6827d3f2ddf6233cd71c0

The contract was deployed Oct-08-2017: https://etherscan.io/tx/0xd52edbc43e5e45fcab7df5d8948a131e9894ee150914b5ddfc00ba23f9d866a2

I tried to get the source from Swarm:
bzzr://6d9406ca992a7939efb4f453a9241f5e92f3450337f2542417665b1552045706

https://github.com/ethereum/solidity/releases/tag/v0.4.18 was released on Oct 19, 2017 so the Solidity version must be earlier than v0.4.18 (unless it was a nightly build)

So we are looking for a compiler version between v0.4.11 and v0.4.17.
Though they could have used a nightly build.

Assuming Remix then I don’t recall it having optimization as the default. (If I recall correctly Truffle used to have optimization as the default).

I tried v0.4.11 to v0.4.17 with no optimization but wasn’t able to get it to verify.

Thanks for checking this out, Andrew!

I did a little more digging and discovered that the contract was deployed via the Mist UI.

I just did a quick search and wasn’t able to determine whether Mist had an optimization default setting and/or if the Mist UI was used to interact with the Remix IDE back in late 2017/ever.

Do you happen to know if the Mist UI had a default optimization setting?

1 Like

Hi @seedsgives,

I never used Mist, so don’t know what settings they had for deploying contracts or whether they also showed the nightly solidity compiler builds.

You could try optimization with 200 runs and try to verify for each compiler version.

Otherwise you could try asking someone from the old Mist team (perhaps https://twitter.com/avsa). Failing that you could ask the Solidity team or Etherscan for suggestions.