Create your own Cryptocurrency in Ethereum Blockchain
This article will illustrate the steps needed to create your own cryptocurrency in Ethereum blockchain. I created my own token called Kahawanu and it is available in Rinkby test network. Kahawanu is a medieval currency from Sri Lanka. https://en.wikipedia.org/wiki/Kahavanu
Check my currency : https://rinkeby.etherscan.io/address/0x8d0e76420ab138b8a28438ec4ca710f9459df15b
If you are new to Blockchain technology then please refer to my previous article on Ethereum blockchain and Solidity language.
What is a Token ?
Tokens in the Ethereum ecosystem can represent any fungible tradable good: coins, loyalty points, gold certificates, IOUs, in-game items, etc. Since all tokens implement some basic features in a standard way, this also means that your token will be instantly compatible with the Ethereum wallet and any other client or contract that uses the same standards.
https://www.ethereum.org/token
Understand Solidity code for a Token
A token can be created as a smart contract in Ethereum. The complete source code of the contract can be found in https://www.ethereum.org/token location. To create a new token we just need to change the name of the token in this code. The token name Kahawanu should be changed to your own contract name.
pragma solidity ^0.4.16;contract owned {
address public owner;constructor() public {
owner = msg.sender;
}modifier onlyOwner {
require(msg.sender == owner);
_;
}function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}/******************************************/
/* Change the name of the contract from Kahawanu to your own token name
*/
/******************************************/contract Kahawanu is owned, TokenERC20 {uint256 public sellPrice;
uint256 public buyPrice;mapping (address => bool) public frozenAccount;/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);/* Initializes contract with initial supply tokens to the creator of the contract */
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
address myAddress = this;
require(myAddress.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}
Test the Token in Remix browser
Copy and paste above smart contract code into remix web browser.
Make sure that no compilation errors are present. Now you can deploy the contract using Run menu item in remix. You need to specify the name of the token, how many tokens to be created and the symbol of the token before pressing the deploy button. Remix has an inbuilt Ethereum node running.
Press the transact button. Contract will be deployed to local Ethereum node.
You can expand the contract and then interact with the functions of the contract.
Once the token is tested in local Remix Ethereum node then we are in a position to test this in Rinkeby test network. Rinkeby is a test network to test your contracts before publishing to main network. Deployment of a smart contract is considered as a transaction in blockchain. Therefore we need to pay Ether for minors to deploy our contract. We can get test ether from Rinkeby network to our wallet. A wallet can be created using a wallet provider software such as MetaMask.
Wallet creation using MetaMask
MetaMask wallet manager software is a google chrome extension. You need to download and install it as below.
Once installed you care create a account (key pair) by specifying a password. Select Rinkeby test network in the drop down.
Get some test Ether
We can request test ether to our wallet using below web application. It is required to post a public post in Twitter, Facebook or Google plus as per below as the first step.
I am using google plus to publish the post. Copy your account address from MetaMask.
Copy and paste below text in your google plus posting box.
Requesting faucet funds into 0x***YOU_ADDRESS***************** on the #Rinkeby #Ethereum test network.Share the post publicly.
Open your post and copy the URL. This URL is needed in test ether request form.
References :
Navigate to below web page.
Paste your Google+ post URL into above text box and press “Give me Ether” button.
Your account will be funded with test Ether. You can check your account balance in MetaMask wallet.
Deploy Token in Rinkeby test network
Now change the Environment to “Injected Web3” in Remix browser. Specify contract name, initial supply and symbol for the Contract and press the transact button. You will be directed to MetaMask submit transaction page. Remember to select the Rinkeby test network in MetaMask. Specify some amount of Ether for the transaction and press the Send button. Our contract will be deployed.
Once deployed the contract will have its own address. This address can be used to track our token in wallet applications.
View Token in etherscan
It is possible to view your transaction in https://rinkeby.etherscan.io/ web application. Paste your account address in search box and press the GO button. All transactions initiated from your account will be shown as below.
Verify Token
Source code of our contract should be verified in order to listed in etherscan. The contract code should be submitted to etherscan for the verification. etherscan will compile the code and compare with the byte code deployed in network. We need to select the same compiler version that has been used to compile the code in Remix browser.
Add Token to Wallet
You can add your newly created token to MetaMask wallet application by clicking on add token button and specifying the contract address.
Hey hey, I am Rich now !!!
Deploy Token in Main network
Deploying the contract is same as deploying it in Rinkeby test network. The only differences are :
- We need real Ether in our wallet. The cost of deploying contract is around 2 to 3 dollars.
- Main network should be selected in MetaMask
- Verification should be done by sending an email to etherscan
Conclusion
Creating your own Cryptocurrency is not a complex activity. It is simple and fun. Why not try yourself ?
If you want some Kahawanu and become rich then let me know your account public key.
If you like the article Clap. I’ll will be sharing more articles on future so don’t forget to follow and if you think any of your friend could use these tips so share the article with them. Thanks for reading. 👏
Join Coinmonks Telegram Channel and Youtube Channel get daily Crypto News
Also, Read
- Crypto Telegram Signals | Crypto Trading Bot
- Copy Trading | Crypto Tax Software
- Grid Trading | Crypto Hardware Wallet
- Best Crypto Exchange | Best Crypto Exchange in India
- Best Crypto APIs for Developers
- Best Crypto Lending Platform
- An ultimate guide to Leveraged Token
- Best VPNs for Crypto Trading
- Best Crypto Analytics or On-Chain Data | Bexplus Review
- 10 Biggest NFT MarketPlaces to Mint a Collection
- AscendEx Staking | Bot Ocean Review | Best Bitcoin Wallets
- Bitget Review | Gemini vs BlockFi | OKEx Futures Trading
