Hi, I’m trying to verify a Contract on BscScan but I’m unable to get ABI in encoded form. I have it in a JSON format from compiling it on Remix.
Environment
openzeppelin@4.0.0
remix
Details
I have Googled dozens of queries but cannot find any relevant information on encoding ABI from JSON. I did came across a website called https://abi.hashex.org/ but it doesn’t seems to be working for me.
Code to reproduce
ServiceReceiver.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title ServiceReceiver
* @dev Implementation of the ServiceReceiver
*/
contract ServiceReceiver is Ownable {
mapping (bytes32 => uint256) private _prices;
event Created(string serviceName, address indexed serviceAddress);
function pay(string memory serviceName) public payable {
require(msg.value == _prices[_toBytes32(serviceName)], "ServiceReceiver: incorrect price");
emit Created(serviceName, _msgSender());
}
function getPrice(string memory serviceName) public view returns (uint256) {
return _prices[_toBytes32(serviceName)];
}
function setPrice(string memory serviceName, uint256 amount) public onlyOwner {
_prices[_toBytes32(serviceName)] = amount;
}
function withdraw(uint256 amount) public onlyOwner {
payable(owner()).transfer(amount);
}
function _toBytes32(string memory serviceName) private pure returns (bytes32) {
return keccak256(abi.encode(serviceName));
}
}
Ownable.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
