이 더 리 움

원본 주소:https://www.jianshu.com/p/ce9417905b97
2017 년 에는 엄 청 난 디지털 화폐 가 나 왔 다.그러나 이런 화 폐 는 어떻게 생 겨 났 는 지 프로그래머 로 서.돈 을 보 내 는 것 에 대한 호기심 을 가지 고 직접 돈 을 보 내 는 절 차 를 한 번 걸 었 다.여기에 기록 하 시 오.여기 코 인 은 특별히 ERC 20 token 을 가리킨다.
Token 을 보 내기 전에 몇 시 를 먼저 확인 하 세 요.

Token 의 이름

Token 의 표지

Token 의 소수

Token 헤 어 스타일

나의 선택 은:

이름:MyFreeCoin

표지:MFC

소수:18

발행량:10000

소수점 은 18 자리 로 MFC 라 는 Token 이 최소 0.000000000000000000001 까지 가능 하 다 는 뜻 이다.
MFC 의 스마트 계약 작성:
Token 의 계약 코드 는 Token-Factory 의 코드 를 참고 합 니 다.

pragma solidity ^0.4.4;

contract Token {

    /// @return   token    
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner        token  
    /// @return The balance     
    function balanceOf(address _owner) constant returns (uint256 balance) {}

    /// @notice msg.sender（     ）   _value（    ）  token   _to（   ）  
    /// @param _to       
    /// @param _value   token   
    /// @return     
    function transfer(address _to, uint256 _value) returns (bool success) {}

    /// @notice        _value（    ）  token   _to（   ）  
    /// @param _from       
    /// @param _to       
    /// @param _value      
    /// @return     
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    /// @notice                   token
    /// @param _spender     token   
    /// @param _value   token   
    /// @return     
    function approve(address _spender, uint256 _value) returns (bool success) {}

    /// @param _owner   token   
    /// @param _spender     token   
    /// @return       token   
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}

    ///   Token  
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    ///     
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

/*
This implements ONLY the standard functions and NOTHING else.
For a token like you would want to deploy in something like Mist, see HumanStandardToken.sol.

If you deploy this, you won't have anything useful.

Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20

  ERC20  
.*/

pragma solidity ^0.4.4;

import "./Token.sol";

contract StandardToken is Token {

    function transfer(address _to, uint256 _value) returns (bool success) {
        //  token       (2^256 - 1)
        //         ，            token，           ，      if   
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        //        ，               
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }

    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}

/*
This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.

In other words. This is intended for deployment in something like a Token Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.

1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.

.*/
pragma solidity ^0.4.4;

import "./StandardToken.sol";

contract MyFreeCoin is StandardToken {

    function () {
        //if ether is sent to this address, send it back.
        throw;
    }

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //token  : MyFreeCoin 
    uint8 public decimals;                //   
    string public symbol;                 //  
    string public version = 'H0.1';       //   

    function MyFreeCoin(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) {
        balances[msg.sender] = _initialAmount;               //              
        totalSupply = _initialAmount;                        //    
        name = _tokenName;                                   // token  
        decimals = _decimalUnits;                            // token   
        symbol = _tokenSymbol;                               // token  
    }

    /*            */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);

        //           receiveApprovalcall    ，                   。
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //          ，      vanilla approve。
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}

자신의 token 을 발행 하려 면MyFreeCoin나타 난 곳 을 token 이름 으로 바 꿔 야 합 니 다.
주의해 야 할 것 은 발행 수량 이 token 소수점 에 비해 설정 되 어야 한 다 는 것 입 니 다.예 를 들 어 token 의 소수점 이 0 이 고 token 1000 개 를 발행 하려 면 발행 수량의 값 은 1000 입 니 다.그러나 token 의 소수점 이 18 자리 라면 1000 개의 token 을 발행 하려 면 발행 수량의 값 은 1000000000000000000000(1000 뒤에 18 개 0)입 니 다.balances[msg.sender] = _initialAmount;이 코드 는 계약 발표 자의 잔액 을 발행량 의 수량 으로 설정 합 니 다.
테스트 네트워크 에서 우리 의 token 을 발행 합 니 다:

MetaMask 지갑 을 설치 합 니 다.

MetaMask 를 설치 한 후 Metamask 에 로그 인하 고 왼쪽 상단 에 Ropsten 을 선택 하 십시오.다음 그림:
1.jpg

이 계 정 은 우리 의 스마트 계약 의 소유자 가 될 것 입 니 다.즉,token 의 발행 수량 은 모두 이 계 정 에 저 장 됩 니 다.

Solity Remix Compiler 를 켜 면 remix 는 온라인 컴 파일 러 로 스마트 계약 을 이 더 리 움 에 직접 발표 할 수 있 습 니 다.

위의 세 개의 파일 코드 를 remix 편집기 에 복사 합 니 다.remix 의 기본 ballot.sol 파일 을 먼저 삭제 할 수 있 습 니 다.새 Token.sol,StandardToken.sol,MyFreeCoin.sol 세 파일 에 해당 하 는 코드 를 파일 에 복사 할 수 있 습 니 다.다음 그림:
2.jpg

클릭start to compile코드 파일 을 컴 파일 합 니 다.

우리 의 테스트 계 정 에 eth 를 신청 하여 테스트 합 니 다.아래 그림 에서 buy 버튼 을 클릭 하고ropsten test faucet을 클릭 합 니 다.
3.jpg
4.jpg

faucet metamask 사 이 트 를 열 고 클릭request 1 eth from faucet합 니 다.성공 하면 거래 기록 이 생 성 됩 니 다.
5.jpg
6.jpg

저희 테스트 계좌 에 eth 가 있 음 을 확인 할 수 있 습 니 다.
7.jpg

remix 의 run 메뉴 를 선택 하고 드 롭 다운 상자 에서 MyFreeCoin 을 선택 하 십시오.create 단추 의 왼쪽 입력 상자 에 입력 하 십시오"10000000000000000000000","MyFreeCoin",18,"MFC".다음 그림 입 니 다.
8.jpg

create 단 추 를 누 르 면 발행량 이''에 포함 되 어야 한 다 는 것 을 주의해 야 한다.metamask 에서 확인 상자 가 팝 업 됩 니 다.다음 그림:
9.jpg

확정 후 걸 린 상태 로 들 어가 무단결근 포장 을 기다린다.

등 일정 기간 이 지나 면 거래 가 완료 되 고 마 이 프 리 코 인 계약 이 표 시 됩 니 다.
10.jpg

MyFreeCoin 의 복사 단 추 를 누 르 면 계약 주 소 를 복사 하여 ropsten etherscan 에서 조회 하면 우리 의 계약 상황 을 조회 할 수 있 습 니 다.다음 그림 과 같 습 니 다.
11.jpg

우리 가 발표 한 token 을 검증 합 니 다.metamask 의 token 에서 add token 단 추 를 누 르 십시오.다음 그림:
12.jpg

add token 의 주소 에 우리 가 방금 복사 한 계약 주 소 를 입력 합 니 다.다음 과 같 습 니 다.
13.jpg

token 에서 우리 가 새로 만 든 token 을 볼 수 있 습 니 다.다음 그림:
14.jpg

우리 의 계약 코드 를 인증 합 니 다.방금 ropsten ethscan 의 계약 주소 페이지 에서 Contract code 를 누 르 면 다음 과 같 습 니 다.
15.jpg

Verify and Publish 를 누 르 면 다음 페이지 에 들 어 갑 니 다.
16.jpg

Contract name:의 입력 상자 에 token 이름 MyFreeCoin 을 입력 하고 Compiler 는 remix 의 sttings 에서 Solity version 에 표 시 된 버 전 번 호 를 선택 합 니 다.Optimization 은 No 를 선택 합 니 다.그리고 Enter the Solid Contract Code below 아래 입력 상자 에 코드 를 입력 하 십시오.저희 코드 는 세 개의 파일 이 있 습 니 다.이 파일 을 하나의 파일 로 합 쳐 야 합 니 다.합 친 형식 은 다음 과 같 습 니 다.

pragma solidity ^0.4.4;
contract Token {
}
contract StandardToken is Token {
}
contract MyFreeCoin is StandardToken {
}

원래 코드 파일 의 import 문 구 를 제거 합 니 다.최종 제출.성공 하면 다음 페이지 가 인증 성공 을 표시 합 니 다.
17.jpg
마지막 으로 서로 다른 주소 사이 에 이 token 을 유통 합 니 다.우리 의 첫 번 째 계 좌 는 이미 1000 개의 MFC 가 있다.
먼저 새 계 정 을 만 듭 니 다.다음 그림:
18.jpg
저희 가 새로 만 든 계 정 을 볼 수 있 습 니 다.MFC 의 값 은 0 입 니 다.
19.jpg
우리 의 첫 번 째 계 정 을 자 르 고 transfer 에 두 번 째 계 정의 주소 와 전 입 된 수량("0xe4da4CBC 744708 A6656BD252f49DF5exxxxxxx C 97","10000000000000000")을 입력 합 니 다.다음 그림:
20.jpg
transfer 를 누 르 면 탄 상자 가 나타 납 니 다.sumbit 를 누 르 면 블록 포장 을 기다 리 고 있 습 니 다.두 번 째 계 정 으로 전환 하여 MFC 잔액 을 확인 합 니 다.이미 돌아 온 1MFC 를 볼 수 있다.
21.jpg
결국 우리 의 token 발송 절 차 는 이미 끝났다.그러나 이것 은 아직 첫 번 째 단계 에 불과 하 다.그 다음 에 우 리 는 token 의 충전,동전 인출 작업 을 절차 적 으로 실행 해 야 한다.토 큰 을 도입 하려 면 반드시 필요 한 기능 이기 도 합 니 다.나중에 저 는 계속 연구 해서 프로그램 으로 token 의 양 도 를 조작 할 것 입 니 다.
저자:RhainL
링크:https://www.jianshu.com/p/ce9417905b97
약서
저작권 은 작가 에 게 있다.상업 전 재 는 작가 에 게 연락 하여 권한 을 수 여 받 으 십시오.비 상업 전 재 는 출처 를 밝 혀 주 십시오.