Create your own Cryptocurrency in Ethereum Blockchain

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 nominal called Kahawanu and it is available in Rinkby test network. Kahawanu is a medieval currency from Sri Lanka. hypertext transfer protocol : //en.wikipedia.org/wiki/Kahavanu Check my currentness : hypertext transfer protocol : //rinkeby.etherscan.io/address/0x8d0e76420ab138b8a28438ec4ca710f9459df15b If you are new to Blockchain engineering then please denote to my previous article on Ethereum blockchain and Solidity lyric.

What is a Token ?

Tokens in the Ethereum ecosystem can represent any fungible tradable good : coins, commitment points, gold certificates, IOUs, in-game items, etc. Since all tokens implement some basic features in a standard way, this besides means that your token will be immediately compatible with the Ethereum wallet and any early customer or compress that uses the same standards. hypertext transfer protocol : //www.ethereum.org/token Understand Solidity code for a Token A keepsake can be created as a smart contract in Ethereum. The complete source code of the abridge can be found in hypertext transfer protocol : //www.ethereum.org/token location. To create a new token we equitable need to change the name of the token in this code. The token name Kahawanu should be changed to your own sign diagnose .

 pragma solidity ^0.4.16 ; sign owned { 
address public owner ; builder ( ) populace {
owner = msg.sender ;
} modifier onlyOwner {
necessitate ( msg.sender == owner ) ;
_ ;
} serve transferOwnership ( address newOwner ) onlyOwner populace {
owner = newOwner ;
}
} interface tokenRecipient { function receiveApproval ( address _from, uint256 _value, address _token, bytes _extraData ) external ; } narrow TokenERC20 {
// Public variables of the token
string public name ;
string populace symbol ;
uint8 public decimals = 18 ;
// 18 decimals is the strongly suggested nonpayment, avoid changing it
uint256 public totalSupply ; // This creates an array with all balances
mapping ( address = > uint256 ) populace balanceOf ;
function ( address = > mapping ( address = > uint256 ) ) public allowance ; // This generates a populace consequence on the blockchain that will notify clients
event Transfer ( address index from, address index to, uint256 value ) ;

// This generates a public event on the blockchain that will notify clients
event Approval ( address index _owner, address index _spender, uint256 _value ) ; // This notifies clients about the sum burned
event Burn ( address index from, uint256 value ) ; / * *
* Constrctor affair
*
* Initializes contract with initial provision tokens to the godhead of the contract
* /
builder (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 * * uint256 ( decimals ) ; // Update total provision with the decimal fraction sum
balanceOf [ msg.sender ] = totalSupply ; // Give the creator all initial tokens
name = tokenName ; // Set the name for expose purposes
symbol = tokenSymbol ; // Set the symbol for display purposes
} / * *
* Internal transfer, alone can be called by this narrow
* /
affair _transfer ( address _from, address _to, uint _value ) inner {
// Prevent transfer to 0x0 address. Use burn ( ) alternatively
ask ( _to ! = 0x0 ) ;
// Check if the transmitter has adequate
want ( balanceOf [ _from ] > = _value ) ;
// Check for overflows
want ( balanceOf [ _to ] + _value > balanceOf [ _to ] ) ;
// Save this for an affirmation in the future
uint previousBalances = balanceOf [ _from ] + balanceOf [ _to ] ;
// Subtract from the transmitter
balanceOf [ _from ] -= _value ;
// Add the lapp to the recipient
balanceOf [ _to ] += _value ;
utter Transfer ( _from, _to, _value ) ;
// Asserts are used to use electrostatic 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
*
*
*
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
} / * * * Transfer tokens * Send ` _value ` tokens to ` _to ` from your explanation @ param _to The address of the recipient role @ param _value the amount to send * /function transfer ( address _to, uint256 _value ) public returns ( bool success ) { _transfer ( msg.sender, _to, _value ) ; return on-key ;

* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
*
*
*
*/
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;
} / * * * Transfer tokens from early cover * Send ` _value ` tokens to ` _to ` in behalf of ` _from ` @ param _from The savoir-faire of the transmitter @ param _to The address of the recipient @ param _value the sum to send * /function transferFrom ( address _from, address _to, uint256 _value ) public returns ( bool success ) { want ( _value < = allowance [ _from ] [ msg.sender ] ) ; // Check allowanceallowance [ _from ] [ msg.sender ] -= _value ; _transfer ( _from, _to, _value ) ; return truthful ;

* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
*
*
*/
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 * Allows ` _spender ` to spend no more than ` _value ` tokens in your behalf @ param _spender The address authorized to spend @ param _value the soap sum they can spend * /function approve ( address _spender, uint256 _value ) publicreturns ( 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
*
*
*
*
*/
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;
}
} / * * * Set allowance for other address and advise * 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 soap measure they can spend @ param _extraData some extra information to send to the approved contract * /function approveAndCall ( address _spender, uint256 _value, bytes _extraData ) publicreturns ( bool success ) { tokenRecipient spender = tokenRecipient ( _spender ) ; if ( approve ( _spender, _value ) ) { spender.receiveApproval ( msg.sender, _value, this, _extraData ) ; return on-key ;

* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
*
*/
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 * Remove ` _value ` tokens from the system irreversibly @ param _value the sum of money to burn * /function burn ( uint256 _value ) public returns ( bool success ) { necessitate ( balanceOf [ msg.sender ] > = _value ) ; // Check if the sender has enoughbalanceOf [ msg.sender ] -= _value ; // Subtract from the sendertotalSupply -= _value ; // Updates totalSupplyemit Burn ( msg.sender, _value ) ; return true ;

* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
*
*
*/
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;
}
} / * * * Destroy tokens from other report * Remove ` _value ` tokens from the system irreversibly on behalf of ` _from `. @ param _from the address of the sender @ param _value the total of money to burn * /function burnFrom ( address _from, uint256 _value ) public returns ( bool success ) { want ( balanceOf [ _from ] > = _value ) ; // Check if the target counterweight is enoughrequire ( _value < = allowance [ _from ] [ msg.sender ] ) ; // Check allowancebalanceOf [ _from ] -= _value ; // Subtract from the target balanceallowance [ _from ] [ msg.sender ] -= _value ; // Subtract from the sender 's allowancetotalSupply -= _value ; // Update totalSupplyemit Burn ( _from, _value ) ; return genuine ;
/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /
/ * Change the list of the sign from Kahawanu to your own token appoint
* /
/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / shrink Kahawanu is owned, TokenERC20 { uint256 public sellPrice ;
uint256 public buyPrice ; map ( address = > bool ) public frozenAccount ; / * This generates a populace event on the blockchain that will notify clients * /
event FrozenFunds ( address target, bool freeze ) ; / * Initializes contract with initial provide tokens to the godhead of the contract * /
builder (
uint256 initialSupply,
bowed stringed instrument tokenName,
string tokenSymbol
) TokenERC20 ( initialSupply, tokenName, tokenSymbol ) public { } / * Internal transfer, merely can be called by this contract * /
function _transfer ( address _from, address _to, uint _value ) home {
want ( _to ! = 0x0 ) ; // Prevent transfer to 0x0 address. Use cut ( ) alternatively
ask ( balanceOf [ _from ] > = _value ) ; // Check if the transmitter has adequate
ask ( balanceOf [ _to ] + _value > = balanceOf [ _to ] ) ; // Check for overflows
command ( ! frozenAccount [ _from ] ) ; // Check if sender is freeze
necessitate ( ! frozenAccount [ _to ] ) ; // Check if recipient is frozen
balanceOf [ _from ] -= _value ; // Subtract from the sender
balanceOf [ _to ] += _value ; // Add the like to the recipient role
utter Transfer ( _from, _to, _value ) ;
}
///
///
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
} /// @ notification Create ` mintedAmount ` tokens and send it to ` target ` /// @ param target Address to receive the tokens/// @ param mintedAmount the amount of tokens it will receivefunction mintToken ( address target, uint256 mintedAmount ) onlyOwner public { balanceOf [ target ] += mintedAmount ; totalSupply += mintedAmount ; emit Transfer ( 0, this, mintedAmount ) ; emit Transfer ( this, target, mintedAmount ) ;

///
///
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} /// @ detect ` freeze ? Prevent | Allow ` ` target ` from sending & receiving tokens/// @ param target Address to be frozen/// @ param freeze either to freeze it or notfunction freezeAccount ( address target, bool freeze ) onlyOwner public { frozenAccount [ target ] = freeze ; emit FrozenFunds ( aim, freeze ) ;

///
///
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
} /// @ 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 contractfunction setPrices ( uint256 newSellPrice, uint256 newBuyPrice ) onlyOwner public { sellPrice = newSellPrice ; buyPrice = newBuyPrice ;

function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
} /// @ notice Buy tokens from contract by sending etherfunction buy ( ) collectible populace { uint measure = msg.value / buyPrice ; // calculates the amount_transfer ( this, msg.sender, total ) ; // makes the transfers

///
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
}
} /// @ notice Sell ` come ` tokens to contract/// @ param measure amount of tokens to be soldfunction betray ( uint256 come ) public { address myAddress = this ; ask ( myAddress.balance > = measure * sellPrice ) ; // checks if the contract has enough ether to buy_transfer ( msg.sender, this, measure ) ; // makes the transfersmsg.sender.transfer ( come * sellPrice ) ; // sends ether to the seller. It 's crucial to do this concluding to avoid recursion attacks

Test the Token in Remix browser copy and paste above smart contract code into remix vane browser.

remix compiler 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 list of the token, how many tokens to be created and the symbol of the nominal before pressing the deploy release. Remix has an built-in Ethereum lymph node running . Press the transact button. Contract will be deployed to local Ethereum lymph node .Deploy contract You can expand the contract and then interact with the functions of the compress .Invoke methods in the Contract once the nominal is tested in local Remix Ethereum node then we are in a put to test this in Rinkeby screen network. Rinkeby is a test network to test your contracts before publishing to main network. deployment of a ache compress is considered as a transaction in blockchain. Therefore we need to pay Ether for minors to deploy our condense. We can get test ether from Rinkeby net to our wallet. A wallet can be created using a wallet supplier software such as MetaMask. Wallet creation using MetaMask MetaMask wallet coach software is a google chrome extension. You need to download and install it as below .Install MetaMask google chrome extension once installed you care create a report ( key pair ) by specifying a password. Select Rinkeby test network in the drop down .Wallet Get some test Ether We can request test quintessence to our wallet using below world wide web application. It is required to post a populace station in Twitter, Facebook or Google plus as per below as the first gradation. hypertext transfer protocol : //ethereum.stackexchange.com/questions/34718/how-do-i-buy-tokens-on-the-rinkeby-test-environmentPublishing a public post to Request Ether I am using google plus to publish the post. Copy your bill address from MetaMask .Copy account address copy and spread below text in your google plus posting box .

 Requesting faucet funds into 0x * * * YOU_ADDRESS * * * * * * * * * * * * * * * * * on the # Rinkeby # Ethereum screen network .

plowshare the post publicly .Google+ Open your mail and copy the URL. This URL is needed in test ether request shape .Copy URL of the Google+ post References : hypertext transfer protocol : //ethereum.stackexchange.com/questions/34718/how-do-i-buy-tokens-on-the-rinkeby-test-environment navigate to below web page. hypertext transfer protocol : //faucet.rinkeby.io/Request test Ether to your wallet Paste your Google+ mail URL into above text box and iron “ Give me Ether ” button. Your account will be funded with test quintessence. You can check your report libra in MetaMask wallet. Deploy Token in Rinkeby test network now change the environment to “ Injected Web3 ” in Remix browser. Specify abridge name, initial supply and symbol for the Contract and press the transact button. You will be directed to MetaMask take transaction page. Remember to select the Rinkeby test net in MetaMask. Specify some come of Ether for the transaction and crush the Send push button. Our sign will be deployed .Deploy Token in Rinkeby once deployed the compress 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 hypertext transfer protocol : //rinkeby.etherscan.io/ network application. Paste your account address in research corner and press the GO button. All transactions initiated from your account will be shown as below .View transactions in https://rinkeby.etherscan.io/ Verify Token source code of our contract should be verified in order to listed in etherscan. The abridge code should be submitted to etherscan for the confirmation. etherscan will compile the code and compare with the byte code deployed in network. We need to select the same compiler interpretation that has been used to compile the code in Remix browser .Remix compiler version Add Token to Wallet You can add your newly created token to MetaMask wallet lotion by clicking on add token clitoris and specifying the contract address .Track my Token Hey hey, I am rich nowadays ! ! ! Deploy Token in Main network Deploying the contract is lapp as deploying it in Rinkeby test net. 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

hypertext transfer protocol : //ethereum.stackexchange.com/questions/31902/how-to-verify-token-after-etherscan-and-submit-icon Conclusion

Creating your own Cryptocurrency is not a building complex bodily process. It is childlike and playfulness. Why not try yourself ? If you want some Kahawanu and become rich then let me know your account populace key. If you like the article Clap. I ’ ll will be sharing more articles on future so don ’ triiodothyronine forget to follow and if you think any of your acquaintance could use these tips so share the article with them. Thanks for reading. 👏

Also, Read

source : https://ontopwiki.com
Category : Finance

Post navigation

Leave a Comment

Trả lời

Email của bạn sẽ không được hiển thị công khai.