A sample ABI of CCBusERC20 contract
· 7 min read
For the ABI of CCBusERC20, you should include all public and external methods that you want to be accessible from outside the contract. This includes:
- All methods from IERC20 interface (required for ERC20 compliance)
- Any additional public methods specific to your contract
- Events that you want to be queryable
- Constructor (only needed for deployment)
Here's what should be included based on your contract:
Required Methods (from IERC20):
"function decimals() view returns (uint256)",
"function symbol() view returns (string)",
"function name() view returns (string)",
"function totalSupply() view returns (uint256)",
"function balanceOf(address) view returns (uint256)",
"function transfer(address, uint256) returns (bool)",
"function allowance(address, address) view returns (uint256)",
"function approve(address, uint256)",
"function transferFrom(address, address, uint256)"
Additional Public Methods (from CCBusERC20):
"function deadAddress() view returns (address)",
"function decreaseAllowance(address, uint256) returns (bool)",
"function getCirculatingSupply() view returns (uint256)",
"function increaseAllowance(address, uint256) returns (bool)",
"function owner() view returns (address)"
Events:
"event Approval(address indexed owner, address indexed spender, uint256 value)",
"event Transfer(address indexed from, address indexed to, uint256 value)"
Constructor:
"constructor(string[] stringParams, address[] addressParams, uint256[] numberParams, bool[] boolParams)"
Your current ABI is correct and complete:
const abiCCBusERC20 = [
"constructor(string[] stringParams, address[] addressParams, uint256[] numberParams, bool[] boolParams)",
"event Approval(address indexed owner, address indexed spender, uint256 value)",
"event Transfer(address indexed from, address indexed to, uint256 value)",
"function allowance(address owner, address spender) view returns (uint256)",
"function approve(address spender, uint256 amount)",
"function balanceOf(address account) view returns (uint256)",
"function deadAddress() view returns (address)",
"function decimals() view returns (uint256)",
"function decreaseAllowance(address spender, uint256 subtractedValue) returns (bool)",
"function getCirculatingSupply() view returns (uint256)",
"function increaseAllowance(address spender, uint256 addedValue) returns (bool)",
"function name() view returns (string)",
"function owner() view returns (address)",
"function symbol() view returns (string)",
"function totalSupply() view returns (uint256)",
"function transfer(address recipient, uint256 amount) returns (bool)",
"function transferFrom(address sender, address recipient, uint256 amount)"
] as const;
What to exclude:
- Internal/private methods (
_approve,_transfer,_basicTransfer,_msgSender,_msgData) - Library functions (SafeMath, Address)
- The
receive()function (special fallback function doesn't need ABI entry)
CCBusERC20.sol
// Created By: CC-Bus
// Website: https://ccbus.cc
// Telegram: https://t.me/CCBus
// The Best Tool for Token Management
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
contract Context {
function _msgSender() internal view returns (address) {
return payable(msg.sender);
}
function _msgData() internal view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
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;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
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;
}
}
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"
);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{value: amount}("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(
target,
data,
value,
"Address: low-level call with value failed"
);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(
address(this).balance >= value,
"Address: insufficient balance for call"
);
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: weiValue}(
data
);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address _spender, uint _value) external;
function transferFrom(address _from, address _to, uint _value) external ;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract CCBusToken is Context, IERC20{
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint256 private _decimals;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address public immutable deadAddress =
0x000000000000000000000000000000000000dEaD;
uint256 private _totalSupply;
constructor(
string[] memory stringParams,
address[] memory addressParams,
uint256[] memory numberParams,
bool[] memory boolParams
) {
require(addressParams.length==0);
require(boolParams.length==0);
address receiveAddr = tx.origin;
_name = stringParams[0];
_symbol = stringParams[1];
_decimals = numberParams[0];
_totalSupply = numberParams[1];
_balances[receiveAddr] = _totalSupply;
emit Transfer(address(0), receiveAddr, _totalSupply);
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function decimals() public view override returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function owner() public view returns (address) {
return deadAddress;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner1, address spender)
public
view
override
returns (uint256)
{
return _allowances[owner1][spender];
}
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 approve(address spender, uint256 amount)
public
override
{
_approve(_msgSender(), spender, amount);
}
function _approve(
address owner1,
address spender,
uint256 amount
) private {
require(owner1 != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner1][spender] = amount;
emit Approval(owner1, spender, amount);
}
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(deadAddress));
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(
amount,
"ERC20: transfer amount exceeds allowance"
)
);
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
return _basicTransfer(sender, recipient, amount);
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
_balances[sender] = _balances[sender].sub(
amount,
"Insufficient Balance"
);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
}