If you did not log in your account fir sometime will your karma points deducted or you got neg karma for a reason?

Gusto mo bang gumawa ng token para sa iyong proyekto, gagawa ng komunidad sa mga tagasuporta sa pamamagitan ng pagbahagi ng tokens sa pamamagitan airdrop at marahil maglunsad ng ICO at sa ilang punto? Pagkatapos itong gabay ay para sayo!
Sa sunod-sunod na gabay na ito ipapakita ko sa inyo kung paano gagawa ng sariling ERC20 token at magsimulang ipamahagi ito sa pamamagitan ng einax.com token trading platform.

0. Kailangan may ETH ka
Upang makumpleto ang gabay na ito kailangan mo magkaroon ng halagang kahit $2 worth of Ethereum [ETH]. Sa gabay na ito gumamit ako ng Metamask Chrome Extenstion na kung saan pwede mo makuha dito: https://metamask.io/


1. Paggawa ng ERC20 Ethereum based token
Una, gusto naming mag-deploy ng smart contract na ERC20 ayon sa pamantayan.
Buksan mo ang Remix (kung saan may isang kahanga-hangang browser-based IDE para sa pag-unlad ng smart contract) sa pamamagitan ng pagsunod sa link na ito : https://remix.ethereum.org/. Sa pamamagitan ng default makikita mo ang ballot.sol smart contract. Maari mo nang e-close ang ballot.sol tab gumawa ng bago sa pagpindot ng binilugan na  "+" sign
Ngayon sa sandaling mayroon ka ng isang bagong walang laman na tab kopyahin ang code sa ibaba at i-paste mo ito sa Remix:

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function div(uint a, uint b) internal pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}


// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}


// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ----------------------------------------------------------------------------
contract FixedSupplyToken is ERC20Interface, Owned {
    using SafeMath for uint;

    string public symbol;
    string public  name;
    uint8 public decimals;
    uint _totalSupply;

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;


    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    constructor() public {
        symbol = "FIXED";
        name = "Example Fixed Supply Token";
        decimals = 18;
        _totalSupply = 1000000 * 10**uint(decimals);
        balances[owner] = _totalSupply;
        emit Transfer(address(0), owner, _totalSupply);
    }


    // ------------------------------------------------------------------------
    // Total supply
    // ------------------------------------------------------------------------
    function totalSupply() public view returns (uint) {
        return _totalSupply.sub(balances[address(0)]);
    }


    // ------------------------------------------------------------------------
    // Get the token balance for account `tokenOwner`
    // ------------------------------------------------------------------------
    function balanceOf(address tokenOwner) public view returns (uint balance) {
        return balances[tokenOwner];
    }


    // ------------------------------------------------------------------------
    // Transfer the balance from token owner's account to `to` account
    // - Owner's account must have sufficient balance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = balances[msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
    // from the token owner's account
    //
    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
    // recommends that there are no checks for the approval double-spend attack
    // as this should be implemented in user interfaces
    // ------------------------------------------------------------------------
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Transfer `tokens` from the `from` account to the `to` account
    //
    // The calling account must already have sufficient tokens approve(...)-d
    // for spending from the `from` account and
    // - From account must have sufficient balance to transfer
    // - Spender must have sufficient allowance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = balances[from].sub(tokens);
        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(from, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Returns the amount of tokens approved by the owner that can be
    // transferred to the spender's account
    // ------------------------------------------------------------------------
    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
    // from the token owner's account. The `spender` contract function
    // `receiveApproval(...)` is then executed
    // ------------------------------------------------------------------------
    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
        return true;
    }


    // ------------------------------------------------------------------------
    // Don't accept ETH
    // ------------------------------------------------------------------------
    function () public payable {
        revert();
    }


    // ------------------------------------------------------------------------
    // Owner can transfer out any accidentally sent ERC20 tokens
    // ------------------------------------------------------------------------
    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
        return ERC20Interface(tokenAddress).transfer(owner, tokens);
    }
}Dito ako kumopya ng Code this wiki page
Ngayon Pindutin ang "Simula magtipon o Start to compile" at siguraduhin mong na walang compilation errors (Pulang mga mensahe)

Ngayon mag-log in sa iyong MetaMask browser extension at siguraduhin Remix ay konektado nito. Dapat ito ang lumabas katulad nito:

Baguhin ang token name na iyong gusto, simbolo at kabuuang supply:

Ngayon ay simple lang gawin ilipat ang contract sa FixedSupplyToken at pindutin ang Deploy button. Ayan!

Pagkatapos mong napindot yung Deploy button ang Remix ay magtatanong sayo ng kumpirmasyon

Kung ok lang sayo ang gas price na nagpapahiwatig sa iyo na magbayad at maari mo nang e-click "Confirm" baba ng sumolpot na window or Tab.
Dadalhin nito ang window ng Metamask na mukhang ganito:
Kung saan maaari nating makita ang ating pag-deploy ng kontrata ay nagkakahalaga sa ito ng $ 1.12
Ngayon pindutin ang  "Confirm" button at ang iyong kontrata ay dapat na deployed na ito sa Ethereum mainnet
0x0e0a6c613Ea16aE347CB98732e152530Ae9Bc7F2 gagamitin ko ito bilang isang example
Pagkatapos ng ilang minuto dapat itong makumpirma at makikita mo ang link sa iyong sariwang deploy na smart na kontrata sa listahan ng mga transaksyong Metamask. Narito ang transaksyon sa pag-deploy ng aking token:
https://etherscan.io/tx/0x6a39c40cc35eb03874808358eb0ab2ea9967c0c27f40fe3bf65c345fa2080da2
Token's smart contract address is: 0x0e0a6c613ea16ae347cb98732e152530ae9bc7f2
Ayos! Sa puntong ito ang aming token ay ganap na umaandar.

2. Kumpirmahin ang kontrata sa etherscan.io
Ito ay isang magandang ideya upang kumpirmahin ang iyong smart code ng kontrata sa etherscan.io kaya lahat ng tao ay magagawang tingnan ito nang madali. Dahil ang address ng kontrata ng aking token ay 0x0e0a6c613Ea16aE347CB98732e152530Ae9Bc7F2 Gagamitin ko ito bilang isang halimbawa

Pumunta sa pahina ng kontrata ng token sa etherscan.io:
https://etherscan.io/address/0x0e0a6c613ea16ae347cb98732e152530ae9bc7f2

Pindutin ang Code tab at pindutin ang Verify And Publish

Sa "I-verify ang Kontrata ng Code" dapat mong punan ang lahat ng kinakailangang mga patlang nang tama upang ma-verify ng etherscan ang code ng smart code ng iyong token:
I-click ang pindutan ng Verify at I-publish at kung ang lahat ng bagay ay mabuti dapat mong makita ang mga sumusunod:

Ngayon na ang code ng token ay na-verify kahit sino ay maaaring suriin ito at siguraduhin na ito ay eksakto kung ano ang iyong inaangkin na ginagawa nito. Bukod dito ang token na ito ay maaaring e lista sa exchange site kung may naiipon kanang budget sa project mo.

To those who plan on creating a project I can share a guide on how to create ERC20 Tokens with easy steps!
This is the link to the guide on how to create erc20 tokens -
https://www.altcoinstalks.com/index.php?topic=47936.0

Hello everyone I would like to share this "GUIDE" in here.

Ever wanted to create a token for your project, build up a community of supporters by destributing tokens through an airdrop and maybe launch an ICO at some point? Then this guide is for you!
In this step-by-step guide I will show you how you can create your own ERC20 token.

0. Have some ETH
In order to finish this guide you will need to have at least $2 worth of Ethereum [ETH]. In this guide I'm using Metamask Chrome Extenstion which you can get here: https://metamask.io/


1. Creating an ERC20 Ethereum based token
First we want to deploy a smart contract that is ERC20 standard compliant.
Open up Remix (which is an awesome browser-based IDE for smart contract development) by following this link: https://remix.ethereum.org/. By default you will see some ballot.sol smart contract. You may close this ballot.sol tab and create a new one by clicking on a circled "+" sign
Now once you've got a new empty tab copy the code below and paste it into Remix:

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function div(uint a, uint b) internal pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}


// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}


// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ----------------------------------------------------------------------------
contract FixedSupplyToken is ERC20Interface, Owned {
    using SafeMath for uint;

    string public symbol;
    string public  name;
    uint8 public decimals;
    uint _totalSupply;

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;


    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    constructor() public {
        symbol = "FIXED";
        name = "Example Fixed Supply Token";
        decimals = 18;
        _totalSupply = 1000000 * 10**uint(decimals);
        balances[owner] = _totalSupply;
        emit Transfer(address(0), owner, _totalSupply);
    }


    // ------------------------------------------------------------------------
    // Total supply
    // ------------------------------------------------------------------------
    function totalSupply() public view returns (uint) {
        return _totalSupply.sub(balances[address(0)]);
    }


    // ------------------------------------------------------------------------
    // Get the token balance for account `tokenOwner`
    // ------------------------------------------------------------------------
    function balanceOf(address tokenOwner) public view returns (uint balance) {
        return balances[tokenOwner];
    }


    // ------------------------------------------------------------------------
    // Transfer the balance from token owner's account to `to` account
    // - Owner's account must have sufficient balance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = balances[msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
    // from the token owner's account
    //
    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
    // recommends that there are no checks for the approval double-spend attack
    // as this should be implemented in user interfaces
    // ------------------------------------------------------------------------
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Transfer `tokens` from the `from` account to the `to` account
    //
    // The calling account must already have sufficient tokens approve(...)-d
    // for spending from the `from` account and
    // - From account must have sufficient balance to transfer
    // - Spender must have sufficient allowance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = balances[from].sub(tokens);
        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(from, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Returns the amount of tokens approved by the owner that can be
    // transferred to the spender's account
    // ------------------------------------------------------------------------
    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
    // from the token owner's account. The `spender` contract function
    // `receiveApproval(...)` is then executed
    // ------------------------------------------------------------------------
    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
        return true;
    }


    // ------------------------------------------------------------------------
    // Don't accept ETH
    // ------------------------------------------------------------------------
    function () public payable {
        revert();
    }


    // ------------------------------------------------------------------------
    // Owner can transfer out any accidentally sent ERC20 tokens
    // ------------------------------------------------------------------------
    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
        return ERC20Interface(tokenAddress).transfer(owner, tokens);
    }
}I copied this code from this wiki page
Now click "Start to comile" and make sure there are no compilation errors (red messages)

Now log in to your MetaMask browswer extension and make sure Remix is connected to it. It should appear like so:

Change your token name, symbol and total supply:

Now simply switch contract to FixedSupplyToken and hit Deploy button. That's it!

After you hit Deploy button Remix will ask you for a confirmation

If you're fine with the gas price it suggests you to pay you may click "Confirm" at the bottom of this pop up window.
This will bring up Metamask window that looks something like this:
Where we can see that our contract depoloyment will cost us $1.12
Now click "Confirm" button and your contract should be deployed to Ethereum mainnet

After a couple of minutes it should get confirmed and you will see the link to your freshly deployed smart contract in Metamask transactions list. Here's my token's deployment transaction:
https://etherscan.io/tx/0x6a39c40cc35eb03874808358eb0ab2ea9967c0c27f40fe3bf65c345fa2080da2
Token's smart contract address is: 0x0e0a6c613ea16ae347cb98732e152530ae9bc7f2
Great! At this point our token is fully functional.

2. Confirm contract on etherscan.io
It's always a good idea to confirm your smart contracts code on etherscan.io so everybody will be able to view it easily. Since my token's contract address is 0x0e0a6c613Ea16aE347CB98732e152530Ae9Bc7F2 I will use it as an example

Go to token's contract page on etherscan.io:
https://etherscan.io/address/0x0e0a6c613ea16ae347cb98732e152530ae9bc7f2

Click on Code tab and hit Verify And Publish

On the "Verify Contract Code" you should fill all the required fields correctly so etherscan could verify your token's smart contract code:
Click Verify and Publish button and if everything is well you should see the following:

Now that token's code is verified anybody can easily review it and make sure it does exactly what you are claiming it does. Furthermore this token is now eligible to be listed on exchange sites where you want to be listed after ICO is finished.

Hi everyone, This is the table I create about Rank Requirements. I created this thread is to let you know that I am not responsible for your account getting penalties. Post at your own risk. This table is to track your progress If your going to "RANK" or "NOT".

---

Table of Contents
Rank Requirements

---

---

Rank	Required Post Count	Required Karma
Newbie	0	0
Baby Steps	10	0
Jr. Member	20	0
Full Member	60	0
Sr. Member	120	0
Hero Member	500	0
Legendary	1000+	0

---

If there's an update just let me know and I'll also update this one. Just let me know if there's a mistake I might have made.

Woah! What a nice achievement in the forum which means there will be lots of users in here that can share their own expertise in cryptocurrency oe blockchain and it's advantage to beginners!
Let's start sharing now on what you learn in cryptoindustry by replying your knowledge below to motivate clueless users in here. I know some of us are experts already by now but don't forget where you started.

I'll start.

There are two most popular algorithms used in cryptocurrency:
First, is Sha-256 which is used in bitcoin
Second, is scrypt which is used in altcoins such as litecoin.

More infornation will be found in here especially for miners this information will be useful.
https://www.coinpursuit.com/pages/bitcoin-altcoin-SHA-256-scrypt-mining-algorithms/

Share your infornation below.

SCRYPT MINER

---

Crypto mining advances to greater heights. More and more users begin to discover its perks. As more altcoins are introduced, it becomes a more viable way of earning profits. Today, manufacturers produce equipment that makes the whole mining process faster and easier, called scrypt miner. These tools reduce power and improve mining efficiency. It is one of the many innovations that makes the process more attractive and rewarding.

One of the biggest differences between a scrypt miner and the SHA-256 is that scrypt relies on computing resources other than the processing unit itself. On the other hand, the latter does not. This makes it hard for scrypt-based systems to scale up and consume computing power because they would have to employ a relative amount of memory, which is costly.

---

The role of a SCRYPT MINER

---

The scrypt miner was first introduced with the emergence of Litecoin. Some of the benefits that draw the attention of a miner includes lower block times and ASIC resistance. It was implemented to prevent litecoins from being mined using GPU’s. However, it failed to prevent GPU miners from entering the network. Scrypt was initially made to serve as a backup service. It prevents attacks from happening.

---

BENEFITS OF A SCRYPT MINER

---

Meanwhile, miners commend it because it is GPU-friendly. A large portion of scrypt miners involves GPU miners as well. While it takes up more memory than its counterparts, the fact that it uses less energy makes it more attractive. With less electricity consumption, miners can get the most out of their earnings.

A scrypt miner also lessens the advantage of ASIC Bitcoin miners. It keeps the field level. It means that more miners have the chance to join the network. Anyone can contribute and make the most of their efforts.