DEV Community

Nicholas
Nicholas

Posted on

Understanding the NikToken Smart Contract

Cryptocurrencies and blockchain technology have introduced a myriad of innovative solutions, including the creation of digital assets known as tokens. Smart contracts, powered by blockchain platforms like Ethereum, enable the creation and management of these tokens. In this article, we'll delve into the NikToken smart contract, dissecting its functionality and explaining each line of code to provide a comprehensive understanding of its operations.

Introduction to NikToken

The NikToken contract is a Solidity-based smart contract designed to represent a digital token on the Ethereum blockchain. Let's break down each component of the contract to understand its purpose and functionality.

What Did We Do

In the provided ERC20 token contract, we implemented a burn feature that deducts 10% of the sent amount from the total token supply. Let's delve into each line of code to understand how this works.

First line specifies the license under which the contract is distributed,
and the second line of code specifies the version of the Solidity compiler to be used.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
Enter fullscreen mode Exit fullscreen mode

Defines the start of the contract named and the contract state variables

contract NikToken {
   string public name;
   string public symbol;
   uint8 public decimals;
   uint256 public totalSupply;
Enter fullscreen mode Exit fullscreen mode

Create Mapping to store the balance of each address, and a nested mapping to store allowances granted by token owners to spenders.

mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
Enter fullscreen mode Exit fullscreen mode

Declares events to log token transfers,
approvals for token spending, and token burns.

   event Transfer(address indexed from, address indexed to, uint256 value);
   event Approval(address indexed owner, address indexed spender, uint256 value);
   event Burn(address indexed from, uint256 value);
Enter fullscreen mode Exit fullscreen mode

Constructor function to initialize token details and allocate initial supply to the contract deployer.

   constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) {
       name = _name;
       symbol = _symbol;
       decimals = _decimals;
       // Calculate total supply based on decimals
       totalSupply = _initialSupply * 10 ** uint256(_decimals);
       // Allocate total supply to contract deployer
       balanceOf[msg.sender] = totalSupply;
   }
Enter fullscreen mode Exit fullscreen mode

Function to transfer tokens to a specified recipient.

   function transfer(address _to, uint256 _value) public returns (bool success) {
       require(_to != address(0), "Invalid address");
       require(balanceOf[msg.sender] >= _value, "Insufficient balance");

       uint256 burnAmount = _value / 10; // 10% of the sent amount

       balanceOf[msg.sender] -= _value; // Deduct sent amount from sender's balance
       balanceOf[_to] += _value; // Add transferred tokens to recipient's balance
       totalSupply -= burnAmount; // Deduct burnt amount from total supply

       emit Transfer(msg.sender, _to, _value); // Emit Transfer event for the transferred tokens
       emit Burn(msg.sender, burnAmount); // Emit Burn event for the burnt tokens

       return true;
   }
Enter fullscreen mode Exit fullscreen mode

This function allows token holders to approve another address to spend tokens on their behalf.

   function approve(address _spender, uint256 _value) public returns (bool success) {
       allowance[msg.sender][_spender] = _value;
       emit Approval(msg.sender, _spender, _value);
       return true;
   }
Enter fullscreen mode Exit fullscreen mode

These functions facilitate the transfer of tokens between addresses, with transferFrom allowing approved addresses to transfer tokens on behalf of others.

   function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
       require(_to != address(0), "Invalid address");
       require(_value <= balanceOf[_from], "Insufficient balance");
       require(_value <= allowance[_from][msg.sender], "Allowance exceeded");

       uint256 burnAmount = _value / 10; // 10% of the sent amount

       balanceOf[_from] -= _value; // Deduct sent amount from sender's balance
       balanceOf[_to] += _value; // Add transferred tokens to recipient's balance
       totalSupply -= burnAmount; // Deduct burnt amount from total supply
       allowance[_from][msg.sender] -= _value; // Decrease spender's allowance

       emit Transfer(_from, _to, _value); // Emit Transfer event for the transferred tokens
       emit Burn(_from, burnAmount); // Emit Burn event for the burnt tokens

       return true;
   }
Enter fullscreen mode Exit fullscreen mode

Summary

The NikToken smart contract exemplifies a standard ERC-20 token implementation with additional features such as burning a percentage of tokens during transfers. By dissecting each line of code, we gain a deeper understanding of its functionality and the underlying principles of blockchain-based token management.
In conclusion, smart contracts like NikToken pave the way for the tokenization of assets, enabling secure and transparent transactions in the digital realm. Understanding the intricacies of such contracts empowers developers and users to harness the full potential of blockchain technology.

Top comments (0)