Error! Invalid constructor arguments provided. Please verify that they are in ABI-encoded format

Hi @abcoathup. I had the same issue this morning and I did it using your solution. Thanks!

1 Like

Hello, I have the same issue. But removing constructor arguments field gives me the same error. Could you please explain how can I verify a simple contract?

pragma solidity ^0.6.2;

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

contract Context {
    constructor () internal { }

    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this;
        return msg.data;
    }
}


library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;

        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}


contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

contract TestToken is ERC20 {
    constructor() public ERC20("TEST TOKEN", "TEST") {
        _mint(msg.sender, 400000000 * (10 ** uint(decimals())));
    }
}
1 Like

A post was split to a new topic: Error verifying contract with constructor arguments on Etherscan

A post was split to a new topic: Cannot verify contract

Hi @abcoathup. I had the same issue, please can you help me to solve it ?

1 Like

Hi @mufasa,

I recommend the following method to verify: Verify smart contract inheriting from OpenZeppelin Contracts

If you are using a flattened contract then you can encode your constructor parameters using: https://abi.hashex.org/

If you continue to run into issues, please create a new topic with your Solidity code, contract address, network, Solidity version, constructor parameters and whether optimization was used.

3 Likes

Many thanks! It worked.

Same error is coming in my contract while verification, the developer is blaming me that I ruin the code by verifying 3-4 times with wrong information, is it possibile ,smart contract ruin if it goes 3-4 times verify with wrong info? Plzz help me

Hi, welcome! :wave:

I do not think so, at least to the best of my knowledge.

1 Like

Can u help me to verify the contract ?

Please have a check these tutorial:

I use the flattern solidity source code for verification but the same error I found … 🥲

Emmmm, so please share your source contract code, compiler version and contract address

1 Like

Address 0x6c744d699876fb86bbf869e040652b74e4ebe18c
Compiler version 0.6.8

Source code

// SPDX-License-Identifier: WRC
pragma solidity 0.6.8;

library SafeMath {

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
  }


  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
  }


  function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }


  function mul(uint256 a, uint256 b) internal pure returns (uint256) {

    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
  }

  function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b > 0, errorMessage);
    uint256 c = a / b;
    return c;
  }

  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, "SafeMath: modulo by zero");
  }

  function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

contract Context {
  constructor () internal { }

  function _msgSender() internal view returns (address payable) {
    return msg.sender;
  }

  function _msgData() internal view returns (bytes memory) {
    this; 
    return msg.data;
  }
}

contract Ownable is Context {
  address private _owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  constructor () internal {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
  }

  function owner() public view returns (address) {
    return _owner;
  }

  modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");
    _;
  }

  
  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
  }


  function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
  }


  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}

interface iBEP20 {

  function totalSupply() external view returns (uint256);

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getOwner() external view returns (address);

  function balanceOf(address account) external view returns (uint256);

  function transfer(address recipient, uint256 amount) external returns (bool);

  function allowance(address _owner, address spender) external view returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);


  event Transfer(address indexed from, address indexed to, uint256 value);
  
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract WRC20 is Context, iBEP20, Ownable {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;
  


  mapping (address => mapping (address => uint256)) private _allowances;

  uint256 private _totalSupply;
  uint8 public _decimals;
  string public _symbol;
  string public _name;
  address public walletaddress=0xf740ca19afAEb60E9AA5A67bf344E19696012637; //sample wallet address 
  uint public _maxfee;

  constructor() public {
    _name = 'White Rock Crypto(WRC) Casino Token';
    _symbol = 'WRC';
    _decimals = 18;
    _totalSupply = 12 *1e8*1e18; // one billion  two hundred thousand million
    _balances[msg.sender] = _totalSupply;
    _maxfee=9*1e5*1e18; //1000 tokens 90 can be burned
   emit Transfer(address(0), msg.sender, _totalSupply);
  }
  
  uint public _totalfee;
  
  

  function getOwner() external view virtual override returns (address) {
    return owner();
  }


  function decimals() external view virtual override returns (uint8) {
    return _decimals;
  }


  function symbol() external view virtual override returns (string memory) {
    return _symbol;
  }


  function name() external view virtual override returns (string memory) {
    return _name;
  }

  function totalSupply() external view virtual override returns (uint256) {
    return _totalSupply;
  }

  function balanceOf(address account) external view virtual override returns (uint256) {
    return _balances[account];
  }

  function transfer(address recipient, uint256 amount) external override returns (bool) {
    _transfer(_msgSender(), recipient, amount);
    return true;
  }


  function allowance(address owner, address spender) external view override returns (uint256) {
    return _allowances[owner][spender];
  }

  function approve(address spender, uint256 amount) external override returns (bool) {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
    return true;
  }


  function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
    return true;
  }


  function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
    return true;
  }


  function burn(uint256 amount) public virtual {
      _burn(_msgSender(), amount);
  }

  function burnFrom(address account, uint256 amount) public virtual {
      uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
      _approve(account, _msgSender(), decreasedAllowance);
      _burn(account, amount);
  }


  
  function _transfer(address sender, address recipient, uint256 amount) internal returns(bool) {
      require(amount>=1e18,"minimum 1 token");
     
    require(sender != address(0), "BEP20: transfer from the zero address");
    require(recipient != address(0), "BEP20: transfer to the zero address");
    
     uint fee = (amount.mul(250)).div(10000);
     uint _finalfee=_totalfee+fee;
     //checks wheather total fee exceeds maximum fee
     if(_finalfee<_maxfee) {
           _balances[sender] = _balances[sender].sub(fee, "BEP20: transfer amount exceeds balance");
           _balances[walletaddress] = _balances[walletaddress].add(fee);
           _totalfee=_totalfee.add(fee);
           _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
           _balances[recipient] = _balances[recipient].add(amount);
          
   emit Transfer(sender, recipient, amount);
   emit Transfer(sender, walletaddress, fee);
   return true;
     }
     else  if(_finalfee>=_maxfee) {
           _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
           _balances[recipient] = _balances[recipient].add(amount);
   emit Transfer(sender, recipient, amount);
   return true;
     }
  

  }



  function _burn(address account, uint256 amount) internal {
    require(account != address(0), "BEP20:account cant be zero address");
   _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
   _totalSupply = _totalSupply.sub(amount);
    emit Transfer(account, address(0), amount);
  }

  function _approve(address owner, address spender, uint256 amount) internal {
    require(owner != address(0), "BEP20: Owner cant be zero");
    require(spender != address(0), "BEP20: Spender cant be zero");
   _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
  }
}

Tried, but failed, maybe this is not your original source code.

Soo it’s developer fault ? Bcz he is saying I do this by doing wrong info

Emmmm, no matter who wants to verify a contract, he should provide the source code. I tried some times, but they all failed, so I think the code you provided above is not the source code.
And I do not think failed to verify contracts can do damage to the contract.

Okkk ,can u tell me bro after verification on mainnet can I deploy again the same smart contract with another bnb address where the bnb deducts as gas fees ?but verification is still same?

Emmmm, yeah, if you have the source code, you can deploy it on the BSC, but maybe you should have a look at the contract license, if it allows, you can use it free.
And after you deploying contracts on the BSC, you need to verify by yourself.

Ohkk thanks ,he makes a new smart contract and verified it , will u tell the difference between both ?

/**
 *Submitted for verification at BscScan.com on 2021-06-25
*/

// SPDX-License-Identifier: WRC20
pragma solidity 0.6.8;

library SafeMath {

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
  }


  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
  }


  function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }


  function mul(uint256 a, uint256 b) internal pure returns (uint256) {

    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
  }

  function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b > 0, errorMessage);
    uint256 c = a / b;
    return c;
  }

  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, "SafeMath: modulo by zero");
  }

  function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

contract Context {
  constructor () internal { }

  function _msgSender() internal view returns (address payable) {
    return msg.sender;
  }

  function _msgData() internal view returns (bytes memory) {
    this; 
    return msg.data;
  }
}

contract Ownable is Context {
  address private _owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  constructor () internal {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
  }

  function owner() public view returns (address) {
    return _owner;
  }

  modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");
    _;
  }

  
  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
  }


  function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
  }


  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}

interface iBEP20 {

  function totalSupply() external view returns (uint256);

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getOwner() external view returns (address);

  function balanceOf(address account) external view returns (uint256);

  function transfer(address recipient, uint256 amount) external returns (bool);

  function allowance(address _owner, address spender) external view returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);


  event Transfer(address indexed from, address indexed to, uint256 value);
  
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract WRC20 is Context, iBEP20, Ownable {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;
  


  mapping (address => mapping (address => uint256)) private _allowances;

  uint256 private _totalSupply;
  uint8 public _decimals;
  string public _symbol;
  string public _name;
  address public walletaddress=0x88A393f2aFF8D8E0dd7bB4Add82cd8EBAc439b9e; //admin wallet address 
  uint public _maxfee;

  constructor(string memory cname,string memory csymbol,uint8 cdecimals,uint ctotalsupply,uint cmaxfee) public {
    _name = cname;
    _symbol = csymbol;
    _decimals = cdecimals;
    _totalSupply = ctotalsupply; // one billion  two hundred thousand million
    _balances[msg.sender] = ctotalsupply;
    _maxfee=cmaxfee; //1000 tokens 90 can be burned
   emit Transfer(address(0), msg.sender, _totalSupply);
  }
  
  uint public _totalfee;
  
  

  function getOwner() external view virtual override returns (address) {
    return owner();
  }


  function decimals() external view virtual override returns (uint8) {
    return _decimals;
  }


  function symbol() external view virtual override returns (string memory) {
    return _symbol;
  }


  function name() external view virtual override returns (string memory) {
    return _name;
  }

  function totalSupply() external view virtual override returns (uint256) {
    return _totalSupply;
  }

  function balanceOf(address account) external view virtual override returns (uint256) {
    return _balances[account];
  }

  function transfer(address recipient, uint256 amount) external override returns (bool) {
    _transfer(_msgSender(), recipient, amount);
    return true;
  }


  function allowance(address owner, address spender) external view override returns (uint256) {
    return _allowances[owner][spender];
  }

  function approve(address spender, uint256 amount) external override returns (bool) {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
    return true;
  }


  function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
    return true;
  }


  function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
    return true;
  }


  function burn(uint256 amount) public virtual {
      _burn(_msgSender(), amount);
  }

  function burnFrom(address account, uint256 amount) public virtual {
      uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
      _approve(account, _msgSender(), decreasedAllowance);
      _burn(account, amount);
  }


  
  function _transfer(address sender, address recipient, uint256 amount) internal returns(bool) {
      require(amount>=1e18,"minimum 1 token");
     
    require(sender != address(0), "BEP20: transfer from the zero address");
    require(recipient != address(0), "BEP20: transfer to the zero address");
    
     uint fee = (amount.mul(250)).div(10000);
     uint _finalfee=_totalfee+fee;
     //checks wheather total fee exceeds maximum fee
     if(_finalfee<_maxfee) {
           _balances[sender] = _balances[sender].sub(fee, "BEP20: transfer amount exceeds balance");
           _balances[walletaddress] = _balances[walletaddress].add(fee);
           _totalfee=_totalfee.add(fee);
           _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
           _balances[recipient] = _balances[recipient].add(amount);
          
   emit Transfer(sender, recipient, amount);
   emit Transfer(sender, walletaddress, fee);
   return true;
     }
     else  if(_finalfee>=_maxfee) {
           _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
           _balances[recipient] = _balances[recipient].add(amount);
   emit Transfer(sender, recipient, amount);
   return true;
     }
  

  }



  function _burn(address account, uint256 amount) internal {
    require(account != address(0), "BEP20:account cant be zero address");
   _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
   _totalSupply = _totalSupply.sub(amount);
    emit Transfer(account, address(0), amount);
  }

  function _approve(address owner, address spender, uint256 amount) internal {
    require(owner != address(0), "BEP20: Owner cant be zero");
    require(spender != address(0), "BEP20: Spender cant be zero");
   _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
  }
}