2

Unable to verify my contract on etherscan. This is the link - https://ropsten.etherscan.io/address/0xc68c67a1864060631817be1eebdb91e8661fae7a . Please help. Its urgent.

Here is my code:

pragma solidity ^0.4.11;

contract Ownable {
    address public owner;

    function Ownable() {
        owner = msg.sender;
    }

    modifier onlyOwner {
        if (msg.sender != owner) throw;
        _;
    }

    function transferOwnership(address newOwner) onlyOwner {
        if (newOwner != address(0)) {
            owner = newOwner;
        }
    }
}
contract Pausable is Ownable {
  bool public stopped;

  modifier stopInEmergency {
    if (stopped) {
      throw;
    }
    _;
  }

  modifier onlyInEmergency {
    if (!stopped) {
      throw;
    }
    _;
  }

  // called by the owner on emergency, triggers stopped state
  function emergencyStop() external onlyOwner {
    stopped = true;
  }

  // called by the owner on end of emergency, returns to normal state
  function release() external onlyOwner onlyInEmergency {
    stopped = false;
  }

}
contract Migrations {
  address public owner;
  uint public last_completed_migration;

  modifier restricted() {
    if (msg.sender == owner) _;
  }

  function Migrations() {
    owner = msg.sender;
  }

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

  function upgrade(address new_address) restricted {
    Migrations upgraded = Migrations(new_address);
    upgraded.setCompleted(last_completed_migration);
  }
}

library SafeMath {
  function mul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function div(uint a, uint b) internal returns (uint) {
    assert(b > 0);
    uint c = a / b;
    assert(a == b * c + a % b);
    return c;
  }
  function sub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function add(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c >= a);
    return c;
  }
  function max64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a >= b ? a : b;
  }
  function min64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a < b ? a : b;
  }
  function max256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a >= b ? a : b;
  }
  function min256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a < b ? a : b;
  }
  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}

contract ERC20Basic {
  uint public totalSupply;
  function balanceOf(address who) constant returns (uint);
  function transfer(address to, uint value);
  event Transfer(address indexed from, address indexed to, uint value);
}

contract BasicToken is ERC20Basic {

  using SafeMath for uint;

  mapping(address => uint) balances;

  /*
   * Fix for the ERC20 short address attack
  */
  modifier onlyPayloadSize(uint size) {
     if(msg.data.length < size + 4) {
       throw;
     }
     _;
  }

  function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
  }

  function balanceOf(address _owner) constant returns (uint balance) {
    return balances[_owner];
  }
}
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) constant returns (uint);
  function transferFrom(address from, address to, uint value);
  function approve(address spender, uint value);
  event Approval(address indexed owner, address indexed spender, uint value);
}

contract StandardToken is BasicToken, ERC20 {
  mapping (address => mapping (address => uint)) allowed;

  function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
    var _allowance = allowed[_from][msg.sender];
    // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
    // if (_value > _allowance) throw;
    balances[_to] = balances[_to].add(_value);
    balances[_from] = balances[_from].sub(_value);
    allowed[_from][msg.sender] = _allowance.sub(_value);
    Transfer(_from, _to, _value);
  }

  function approve(address _spender, uint _value) {
    // To change the approve amount you first have to reduce the addresses`
    //  allowance to zero by calling `approve(_spender, 0)` if it is not
    //  already 0 to mitigate the race condition described here:
    //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
  }

  function allowance(address _owner, address _spender) constant returns (uint remaining) {
    return allowed[_owner][_spender];
  }
}

contract Manus is StandardToken, Ownable {
  string public constant name = "Manus";
  string public constant symbol = "MANUS";
  uint public constant decimals = 18;


  // Constructor
  function Manus() {
      totalSupply = 40000000000000000000000000;
      balances[msg.sender] = totalSupply; // Send all tokens to owner
  }

  /**
   *  Burn away the specified amount of Manus tokens
   */
  function burn(uint _value) onlyOwner returns (bool) {
    balances[msg.sender] = balances[msg.sender].sub(_value);
    totalSupply = totalSupply.sub(_value);
    Transfer(msg.sender, 0x0, _value);
    return true;
  }

}

contract PullPayment {

  using SafeMath for uint;

  mapping(address => uint) public payments;

  event LogRefundETH(address to, uint value);


  /**
  *  Store sent amount as credit to be pulled, called by payer
  **/
  function asyncSend(address dest, uint amount) internal {
    payments[dest] = payments[dest].add(amount);
  }

  // withdraw accumulated balance, called by payee
  function withdrawPayments() {
    address payee = msg.sender;
    uint payment = payments[payee];

    if (payment == 0) {
      throw;
    }

    if (this.balance < payment) {
      throw;
    }

    payments[payee] = 0;

    if (!payee.send(payment)) {
      throw;
    }
    LogRefundETH(payee,payment);
  }
}

contract Crowdsale is Pausable, PullPayment {

    using SafeMath for uint;

    struct Backer {
        uint weiReceived; // Amount of Ether given
        uint manusSent;
    }

    /*
    * Constants
    */
    /* Minimum number of manus to sell */
    uint public constant MIN_CAP = 2000000000000000000000000;
    /* Maximum number of manus to sell */
    uint public constant MAX_CAP =4000000000000000000000000 ;


    /*
    * Variables
    */
    /* Manus contract reference */
    Manus public manus;
    /* Multisig contract that will receive the Ether */
    address public multisigEther;
    /* Number of Ether received */
    uint public etherReceived;
    /* Number of manus sent to Ether contributors */
    uint public manusSentToEther;

    /* Backers Ether indexed by their Ethereum address */
    mapping(address => Backer) public backers;


    /*
    * Modifiers
    */
    modifier minCapNotReached() {
        if (manusSentToEther >= MIN_CAP ) throw;
        _;
    }

    /*
     * Event
    */
    event LogReceivedETH(address addr, uint value);
    event LogManusEmited(address indexed from, uint amount);

    /*
     * Constructor
    */
    function Crowdsale(address _manusAddress, address _to) {
        manus = Manus(_manusAddress);
        multisigEther = _to;
    }

    /*


    /*
     *  Receives a donation in Ether
    */
    function receiveETH(address beneficiary) internal {

            uint manusToSend = bonus(msg.value.div(1 ether));
        Backer backer = backers[beneficiary];
        manus.transfer(beneficiary, manusToSend); // Transfer ManusToken right now

        backer.manusSent = backer.manusSent.add(manusToSend);
        backer.weiReceived = backer.weiReceived.add(msg.value); // Update the total wei collected during the crowdfunding for this backer

        etherReceived = etherReceived.add(msg.value); // Update the total wei collected during the crowdfunding
        manusSentToEther = manusSentToEther.add(manusToSend);

        // Send events
        LogManusEmited(msg.sender ,manusToSend);
        LogReceivedETH(beneficiary, etherReceived);
    }


    /*
     *Compute the manus bonus according to the investment period
     */
    function bonus(uint amount) internal constant returns (uint) {
            return amount.add(amount.div(5));   // bonus 20%
        return amount;
    }

    /*
     * Finalize the crowdsale, should be called after the refund period
    */

    /*
    * Failsafe drain
    */
    function drain() onlyOwner {
        if (!owner.send(this.balance)) throw;
    }

    /**
     * Allow to change the team multisig address in the case of emergency.
     */
    function setMultisig(address addr) onlyOwner public {
        if (addr == address(0)) throw;
        multisigEther = addr;
    }

    /**
     * Manually back manus owner address.
     */
    function backManusOwner() onlyOwner public {
        manus.transferOwnership(owner);
    }

    /*
     * When MIN_CAP is not reach:
     * 1) backer call the "approve" function of the manus token contract with the amount of all manus they got in order to be refund
     * 2) backer call the "refund" function of the Crowdsale contract with the same amount of manus
     * 3) backer call the "withdrawPayments" function of the Crowdsale contract to get a refund in ETH
     */
    function refund(uint _value) minCapNotReached public {

        if (_value != backers[msg.sender].manusSent) throw; // compare value from backer balance

        manus.transferFrom(msg.sender, address(this), _value); // get the token back to the crowdsale contract

        if (!manus.burn(_value)) throw ; // token sent for refund are burnt

        uint ETHToSend = backers[msg.sender].weiReceived;
        backers[msg.sender].weiReceived=0;

        if (ETHToSend > 0) {
            asyncSend(msg.sender, ETHToSend); // pull payment to get refund in ETH
        }
    }

}

contract Airdropper is Ownable
{
function multisend(address _tokenAddr, address[] dests, uint256[] values)
    onlyOwner
    returns (uint256) {
        uint256 i = 0;
        while (i < dests.length) {
           ERC20(_tokenAddr).transfer(dests[i], values[i]);
           i += 1;
        }
        return(i);
    }

}
2
  • Well we need more information that that... Tell the mecanic "my car does not work", he will be pleased... Tried that? ropsten.etherscan.io/… – Florian Castelain Aug 18 '18 at 6:57
  • shall i share you my code??? – Himanshi Aug 18 '18 at 7:02
0

By scan do you mean explore? As in, see all the data related to the contract? If yes, then it works for me. Etherscan has been doing some maintenance to the indexer and it might've been that it just wasn't showing your contract because of that.

If this is not it, could you elaborate on what scan means?

1
  • i mean i am not able to verify my contract – Himanshi Aug 18 '18 at 11:49
0

Currently etherscan verify smart contracts is not that friendly, If you are using truffle and smart contract is complicated involving many imports of library etc, or compilers settings are different like optimize enabled and runs set to not default value. Try https://www.npmjs.com/package/truffle-flattener Flattener concats solidity files from Truffle and Buidler projects with all of their dependencies If you still get some compilation warning like in my case I am using pragma experimental ABIEncoderV2. I just removed it from other files except for the main file which I was deploying in the flattened version, and it worked well and deployed my contract

For more information on how to use truffle-flattener check out "https://medium.com/coinmonks/how-to-verify-and-publish-on-etherscan-52cf25312945#"

0

Just because you specified in your contract to use the solidity version 0.4.11 doesn't mean you compiled them with that version.

I had this problem too recently. Here's how I solved it:

I specified which version of solidity I wanted to use in my contract like this: pragma solidity ^0.4.11; then I went to remix and deployed the contracts with another version, solidity 0.4.12 or similar. The deployment didn't fail because I was still using the version 0.4 but the bytecode generated was different.

So to solve your problem, to go remix or truffle and check which solidity compiler you've used when you deployed your contract. Then use that version in the etherscan verifier. It may not be the same as the one specified in the contract.

Make sure to indicate wether you're using the optimizer or not in the verifier. You may have enabled it in the past.

Also if your contract has some constructor arguments be sure to pass the right values.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.