Restrictions

Once enabled, trading can not be turned back off.

Enabling trading

The sERC20 contract takes full control of your tokens trading status. Under the hood the library exposes the following functions for your convenience. Unlike other methods provided by sERC20 however, the enable method is marked as virtual, thus allowing your to override it for more fine grained control. For example you may wish to capture the launch block.

Enabling trading

function sercSetTradingEnabled() public virtual onlyOwner

Overriding the enable trading method

As mentioned above, this method is marked as virtual. This means that you are free to override this method within your contract for finer control.

function sercSetTradingEnabled() public virtual override onlyOwner {
    
    // Parent call - IMPORTANT
    super.sercSetTradingEnabled();
    
    // Additional functionality...
    launchedBlock = block.number;
    ...
}

Checking if trading is enabled

The sERC20 contract exposes functions for reading trading status of your token. You should NEVER handle these yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

Retrieve the trading status

// External usage
function sercTradingEnabled() public view returns (bool)

// Internal usage
function _sercTradingEnabled() internal view returns (bool)

Restrictions

The router address must be passed to the SERC20 constructor method upon initialisation. This will create a pair for you using the relevant factory.

Accessing the router object

The router object can be accessed at any point using the following method. You should NEVER handle this yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

function _sercRouter() internal view return (IUniswapV2Router02)

// Usage
_sercRouter();

Reading the pair address

The sERC20 library exposes a getPair method for accessing the pair address. You should NEVER handle these yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

function _sercPair() internal view return (address)

// Usage
_sercPair();

Restrictions

The router address can not be blacklisted.

The pair address can not be blacklisted.

The contract address can not be blacklisted.

Blacklisting is only available for 10 minutes post trading enabled.

Blacklisting an address

The sERC20 contract takes full control of changes to your blacklist. Under the hood the library exposes the following functions for your convenience.

Setting the blacklisted status of an address

// External usage
function sercSetBlacklisted(address[] memory _addrList, bool _isBlacklisted)
        external
        onlyOwner

// Internal usage        
function _sercSetBlacklisted(address[] memory _addrList, bool _isBlacklisted)
        internal

Checking if an account is blacklisted

The sERC20 contract exposes functions for reading the blacklisted status on an address. You should NEVER handle these yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

Retrieve the blacklisted status for an address

// External usage
function sercIsBlacklisted(address _addr) public view returns (bool)

// Internal usage
function _sercIsBlacklisted(address _addr) internal returns (bool)

Restrictions

The maximum single transaction amount must be less than or equal to the maximum wallet amount.

The maximum wallet amount must be equal to or higher than the maximum single transaction amount.

The maximum single transaction amount can never be lowered, it is important that you set a sensible default during initialisation.

Like the maximum single transaction amount, the maximum wallet amount also can never be lowered. Again it is important that you set a sensible default during initialisation.

Setting up transaction limits

sERC20 will automatically initialise with 0 max single transaction limit and 0 max wallet limit. These must be manually set before you can open trading.

function sercSetMaxTx(uint256 _maxTx) external onlyOwner
function sercSetMaxWallet(uint256 _maxWallet) external onlyOwner

Changing transaction limits

Unlike taxes, the sERC20 contract takes full control of changes to your transaction limits. Under the hood the library exposes the following functions for your convenience.

Setting the maximum single transaction amount

function sercSetMaxTx(uint256 _maxTx) external onlyOwner

Setting the maximum wallet amount

function sercSetMaxWallet(uint256 _maxWallet) external onlyOwner

Reading transaction limits

The sERC20 contract exposes functions for reading the current transaction limits. You should NEVER handle these yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

Retrieve the maximum single transaction amount

// External usage
function sercMaxTx() public view returns (uint256)

// Internal usage
function _sercMaxTx() internal view returns (uint256)

Retrieve the maximum wallet amount

// External usage
function sercMaxWallet() public view returns (uint256)

// Internal usage
function _sercMaxWallet() internal view returns (uint256)

Installation

npm install @serc-20/serc

Usage

// contracts/MyToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import "@serc20/contracts/SERC20.sol";

contract MyToken is SERC20 {

    constructor()
        SERC20(
            "SERC20MOCK", // Name
            "SERC20MOCK", // Symbol
            0xFABB0ac9d68B0B445fB7357272Ff202C5651694a, // Router address
            15, // Buy tax threshold
            15 // Sell tax threshold
        )
    {
        uint256[] memory buyTaxes = new uint256[](2);
        // Dev Tax
        buyTaxes[0] = 8;

        // Liq Tax
        buyTaxes[1] = 2;

        uint256[] memory sellTaxes = new uint256[](2);
        // Dev Tax
        sellTaxes[0] = 8;

        // Liq Tax
        sellTaxes[1] = 2;

        _sercSetTaxes(buyTaxes, true); // initilise buy taxes
        _sercSetTaxes(sellTaxes, false); // initilise buy taxes

        /*
            _mint is an internal function in ERC20.sol that is only called here,
            and CANNOT be called ever again
        */
        _mint(msg.sender, 1_000_000_000 * 1e18);
    }
}

Security

Please report any security issues you find directly to contact@serc20.com

sERC20 quick audit checklist

• Verify that the SERC20 abstract contract has not been modified. You can find the source code for both of these on our Github repository HERE.

• Verify that tax, transaction limits, blacklists, trading status and the router/pair are all being managed and controlled by the sERC20 helper methods. A more in-depth overview on this can be found HERE.

• As with any any contract regardless of sERC20 integration, review all methods and their functionality before investing.

Here lies a curated list of templates that will server as a starting point for your sERC20 implementation should you require.

Check our Github for a full range of templates HERE.

Restrictions

The buy tax threshold can be set as high as 35%, however the combination of the buy and sell tax thresholds can not exceed 35%.

The sell tax threshold can be set as high as 35%, however the combination of the buy and sell tax thresholds can not exceed 35%.

Round trip tax rates can not exceed 35%

Setting up taxes

constructor()
    SERC20(
        ...
        15,
        15
    )
{
    ...
    
    uint256[] memory buyTaxes = new uint256[](2);
    // Dev Tax
    buyTaxes[0] = 8;

    // Liq Tax
    buyTaxes[1] = 2;

    uint256[] memory sellTaxes = new uint256[](2);
    // Dev Tax
    sellTaxes[0] = 8;

    // Liq Tax
    sellTaxes[1] = 2;

    _sercSetTaxes(buyTaxes, true);
    _sercSetTaxes(sellTaxes, false);
    
    ...
}

Changing tax rates

The sERC20 contract does not implement any functionality to externally change your tax rates. This is because there are a wide variety of options available for taxing. To avoid restricting this customisability you are free to implement these methods yourself.

Examples

constructor()
    SERC20(
        ...
        15,
        15
    )
{
    ...
    
    uint256[] memory buyTaxes = new uint256[](1);
    // Dev Tax
    buyTaxes[0] = 8;

    uint256[] memory sellTaxes = new uint256[](1);
    // Dev Tax
    sellTaxes[0] = 8;

    _sercSetTaxes(buyTaxes, true);
    _sercSetTaxes(sellTaxes, false);
    
    ...
}

function setBuyTax(uint256 buyDevTax)
    external
    onlyOwner
{
    uint256[] memory buyTaxes = new uint256[](1);
    buyTaxes[0] = buyDevTax;

    // uint256[] taxes, bool isBuy
    _sercSetTaxes(buyTaxes, true);
}

function setSellTax(uint256 sellDevTax)
    external
    onlyOwner
{
    uint256[] memory sellTaxes = new uint256[](1);
    sellTaxes[0] = sellDevTax;
    
    // uint256[] taxes, bool isBuy
    _sercSetTaxes(buyTaxes, false);
}

constructor()
    SERC20(
        ...
        15,
        15
    )
{
    ...
    
    uint256[] memory buyTaxes = new uint256[](3);
    // Dev Tax
    buyTaxes[0] = 4;
    
    // Marketing Tax
    buyTaxes[1] = 4;

    // Liq Tax
    buyTaxes[2] = 2;

    uint256[] memory sellTaxes = new uint256[](3);
    // Dev Tax
    sellTaxes[0] = 8;
    
    // Marketing Tax
    sellTaxes[1] = 4;

    // Liq Tax
    sellTaxes[2] = 2;
    
    _sercSetTaxes(sellTaxes, false);
    
    ...
}

function setBuyTax(uint256 buyDevTax, uint256 buyMarketingTax, uint256 buyLiqTax)
    external
    onlyOwner
{
    uint256[] memory buyTaxes = new uint256[](3);
    buyTaxes[0] = buyDevTax;
    buyTaxes[1] = buyMarketingTax;
    buyTaxes[2] = buyLiqTax;
    
    // uint256[] taxes, bool isBuy
    _sercSetTaxes(buyTaxes, true);
}

function setSellTax(uint256 sellDevTax, uint256 sellMarketingTax, uint256 sellLiqTax)
    external
    onlyOwner
{
    uint256[] memory sellTaxes = new uint256[](3);
    sellTaxes[0] = sellDevTax;
    sellTaxes[1] = sellMarketingTax;
    sellTaxes[2] = sellLiqTax;

    // uint256[] taxes, bool isBuy
    _sercSetTaxes(sellTaxes, false);
}

Reading tax rates

The sERC20 contract exposes functions for reading the current tax rates. You should NEVER handle these yourself, always refer to our built in methods to maintain your sERC20 implementation integrity.

// External usage
function sercBuyTax() public view returns (uint256[] memory)

// Internal usage
function _sercBuyTax() internal view returns (uint256[] memory)

// External usage
function sercBuyTotalTax() public view returns (uint256)

// Internal usage
function _sercBuyTotalTax() internal view returns (uint256)

// External usage
function sercSellTax() public view returns (uint256[] memory)

// Internal usage
function _sercSellTax() internal view returns (uint256[] memory)

// External usage
function sercSellTotalTax() public view returns (uint256)

// Internal usage
function _sercSellTotalTax() internal view returns (uint256)