How to add "transaction fee" to ERC20 or BEP20 smart contracts?

Question

There's new tokens that "charge a transaction fee" aside the usual ETH gas fee. I'm talking about a transaction fee that subtracts from the token itself. Let's say 100 tokens are transferred. 1 token goes into a central account as "transaction fee". It's doable since coins like $GRUMPY have it but I can't find the function on the code that would allow me to do that.

Answer 1

intrested here too. I have something simple see _transfer function below. Problem is it will create 2 transactions and more Gas Fees to pay. Dont know if you splitt and send the fee to the contract itself if this reduce fees.

This is just an idea not testet. Intrested in other solutions from the community.

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");
    
    address FeeReceiverAdr = 0xE037D395bB24C69bD0347F4e1652199BF60a41d1;
    address payable FeeReceiver = payable(FeeReceiverAdr); // Correct since Solidity >= 0.6.0
    

    _beforeTokenTransfer(sender, recipient, amount);
    
    uint bpsfee = 1618;
    uint bps = 100000;
  
    uint256 senderBalance = _balances[sender];
    require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
    _balances[sender] = senderBalance - amount;
    _balances[recipient] += taxedValue;
 

    _balances[FeeReceiver] +=  fee;
    
    emit Transfer(sender, recipient, taxedValue);
    emit Transfer(sender, FeeReceiver, fee);
}

Answer 2

I found a solution that may help! In case anyone was still looking around for clarity. Here is a code snippet for enabling ERC20 % distribution. Code has not been audited, so please use it at your own risk, but this should be enough to start experimenting.

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

contract TransfertTokenAndPercentageToTargetAddress{

// pay 1% of all transactions to target address
//test address = testnet
address payable target = 0x326Da5Aa845675a1967e1F7E31A32a4412eD47DD;

// state variables for your token to track balances and to test
mapping (address => uint) public balanceOf;
uint public totalSupply;

// create a token and assign all the tokens to the creator to test
constructor(uint _totalSupply) public {
    totalSupply = _totalSupply;
    balanceOf[msg.sender] = totalSupply;
}

// the token transfer function with the addition of a 1% share that
// goes to the target address specified above
function transfer(address _to, uint amount) public {

    // calculate the share of tokens for your target address
    uint shareForX = amount/100;

    // save the previous balance of the sender for later assertion
    // verify that all works as intended
    uint senderBalance = balanceOf[msg.sender];
    
    // check the sender actually has enough tokens to transfer with function 
    // modifier
    require(senderBalance >= amount, 'Not enough balance');
    
    // reduce senders balance first to prevent the sender from sending more 
    // than he owns by submitting multiple transactions
    balanceOf[msg.sender] -= amount;
    
    // store the previous balance of the receiver for later assertion
    // verify that all works as intended
    uint receiverBalance = balanceOf[_to];

    // add the amount of tokens to the receiver but deduct the share for the
    // target address
    balanceOf[_to] += amount-shareForX;
    
    // add the share to the target address
    balanceOf[target] += shareForX;

    // check that everything works as intended, specifically checking that
    // the sum of tokens in all accounts is the same before and after
    // the transaction. 
    assert(balanceOf[msg.sender] + balanceOf[_to] + shareForX ==
        senderBalance + receiverBalance);
}

}