EthFiddle - Solidity IDE in the Browser. Powered By Loom Network

//To modify a KIP-20 token contract for the Klaytn blockchain to include fee handling and update the ownership address, you can use the following implementation:

### KIP-20 Token Contract with Fee Handling

1. **Update Ownership Address**: Replace the current ownership address with your new address.
2. **Add Fee Handling Mechanism**: Implement a function to deduct a fee from each token transaction.

Here’s an example of a KIP-20 token contract with these modifications:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;

interface IKIP20 {
      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 UpdatedKIP20Token is IKIP20 {
      string public name = "Updated KIP20 Token";
          string public symbol = "UKIP20";
              uint8 public decimals = 18;
                  uint256 private _totalSupply;
                  
                      address public owner;
                          address public feeReceiver;
                              uint256 public transactionFeePercent; // Fee percentage in basis points (100 basis points = 1%)
                              
                                  mapping(address => uint256) private _balances;
                                      mapping(address => mapping(address => uint256)) private _allowances;
                                      
                                          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
                                          
                                              modifier onlyOwner() {
                                                        require(msg.sender == owner, "Caller is not the owner");
                                                                _;
                                              }
                                              
                                                  constructor(address _feeReceiver, uint256 _transactionFeePercent, uint256 initialSupply) {
                                                            owner = msg.sender;
                                                                    feeReceiver = _feeReceiver;
                                                                            transactionFeePercent = _transactionFeePercent;
                                                                                    _totalSupply = initialSupply * 10 ** uint256(decimals);
                                                                                            _balances[owner] = _totalSupply;
                                                                                                    emit Transfer(address(0), owner, _totalSupply);
                                                  }
                                                  
                                                      function totalSupply() external view override returns (uint256) {
                                                                return _totalSupply;
                                                      }
                                                      
                                                          function balanceOf(address account) external view override returns (uint256) {
                                                                    return _balances[account];
                                                          }
                                                          
                                                              function transfer(address recipient, uint256 amount) external override returns (bool) {
                                                                        _transfer(msg.sender, 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(msg.sender, spender, amount);
                                                                                        return true;
                                                                      }
                                                                      
                                                                          function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
                                                                                    _transfer(sender, recipient, amount);
                                                                                            _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
                                                                                                    return true;
                                                                          }
                                                                          
                                                                              function _transfer(address sender, address recipient, uint256 amount) internal {
                                                                                        require(sender != address(0), "Transfer from the zero address");
                                                                                                require(recipient != address(0), "Transfer to the zero address");
                                                                                                
                                                                                                        uint256 fee = (amount * transactionFeePercent) / 10000;
                                                                                                                uint256 amountAfterFee = amount - fee;
                                                                                                                
                                                                                                                        _balances[sender] -= amount;
                                                                                                                                _balances[recipient] += amountAfterFee;
                                                                                                                                        _balances[feeReceiver] += fee;
                                                                                                                                                emit Transfer(sender, recipient, amountAfterFee);
                                                                                                                                                        emit Transfer(sender, feeReceiver, fee);
                                                                              }
                                                                              
                                                                                  function _approve(address owner, address spender, uint256 amount) internal {
                                                                                            require(owner != address(0), "Approve from the zero address");
                                                                                                    require(spender != address(0), "Approve to the zero address");
                                                                                                    
                                                                                                            _allowances[owner][spender] = amount;
                                                                                                                    emit Approval(owner, spender, amount);
                                                                                  }
                                                                                  
                                                                                      function transferOwnership(address newOwner) public onlyOwner {
                                                                                                require(newOwner != address(0), "New owner is the zero address");
                                                                                                        emit OwnershipTransferred(owner, newOwner);
                                                                                                                owner = newOwner;
                                                                                      }
                                                                                      
                                                                                          function setFeeReceiver(address _feeReceiver) public onlyOwner {
                                                                                                    feeReceiver = _feeReceiver;
                                                                                          }
                                                                                          
                                                                                              function setTransactionFeePercent(uint256 _transactionFeePercent) public onlyOwner {
                                                                                                        transactionFeePercent = _transactionFeePercent;
                                                                                              }
                                                                                              
                                                                                                  function renounceOwnership() public onlyOwner {
                                                                                                            emit OwnershipTransferred(owner, address(0));
                                                                                                                    owner = address(0);
                                                                                                  }
}
```

### Key Changes and Additions:

1. **Ownership and Fee Receiver**:
   - `feeReceiver`: Address to receive the deducted fees.
      - `transactionFeePercent`: Fee percentage to be deducted from each transaction (in basis points, where 100 basis points = 1%).
      
      2. **Constructor**:
         - Initializes `feeReceiver`, `transactionFeePercent`, and `initialSupply`.
         
         3. **Fee Handling in Transfer Function**:
            - Calculates the fee as a percentage of the transferred amount.
               - Deducts the fee from the transfer amount.
                  - Sends the fee to `feeReceiver`.
                  
                  4. **Ownership Functions**:
                     - `setFeeReceiver`: Allows the owner to set the fee receiver address.
                        - `setTransactionFeePercent`: Allows the owner to set the transaction fee percentage.
                           - `transferOwnership`: Allows the owner to transfer ownership to a new address.
                              - `renounceOwnership`: Allows the owner to renounce ownership.
                              
                              ### Deployment and Testing:
                              
                              1. **Deploy the Contract**: Deploy the contract using a Klaytn-compatible wallet and network.
                              2. **Test the Contract**: Test the contract functions, especially the transfer function to ensure the fee deduction works as expected.
                              
                              Make sure to thoroughly test the contract and review the fee percentages and fee receiver address before deploying to the main network.Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.7.1;
contract SimpleStore {
  function set(uint _value) public {
    value = _value;
  }

function get() public constant returns (uint) {
    return value;
  }

uint value;
}