개요

요즘 스팀엔진이 뒤숭숭 하여 나름 대안으로 트론의 토큰생성을 해보려 합니다.

참조 : 개발 : 트론 계정 생성하기 by @wonsama

빠르게 만들어 보자

누구나 비용 없이 만들어 보고 테스트 할 수 있도록 테스트넷에서 진행 해보도록 하겠습니다.

TL;DR

• 개발 : 트론 계정 생성하기 글 참조
• 테스트용 토큰(TRX) 받기
• 테스트 NODE로 변경하기
• 소스복사 ( 약간의 설정만 변경 )
• 토큰 생성 코드 컴파일 / 배포
• 토큰 생성 등록
• 토큰 확인하기

테스트용 토큰(TRX) 받기

https://www.trongrid.io/faucet 으로 접속 후 Test wallet address 에 토큰을 받을 트론 지갑 주소를 입력 합니다. 이후 submit 버튼을 누르면 아래와 같은 메시지를 볼 수 있습니다. ( 지갑에 1만 TRX 가 들어옴, 테스트서버로 ... ㅋ )

Your request was successfully submitted, please check your wallet.

[그림] 자신의 트론 주소를 입력 후 submit 버튼을 누른다

테스트 NODE로 변경하기

Set up - Node manage - Shasta Testnet 을 선택한다. 1만 트론이 들어온 것을 확인할 수 있다.

[그림] 우측 상단의 set up 버튼을 누른다

[그림] Node manage 버튼을 눌러 노드를 변경한다

[그림] shasta testnet 을 선택한다

[그림] 테스트 노드로 변경 되었으며, 10000만 트론이 들어 온 것을 확인

소스복사 ( 약간의 설정만 변경 )

맨아래 설정 정보만 약간 변경한다. 더 이상의 자세한 설명은 생략한다.

• constructor() CommonToken("WONSAMA TOKEN", "WONSAMA", 3, 1000000000) public {}
• 토큰명, 토큰심볼, 소숫점자리수, 발행량 이 4가지만 바꿔준다.
• 메모장에 token.sol 이라고 저장한다. ( 확장자만 .sol 로 하면 됨 )

pragma solidity ^0.5.0;

// ---------------------------------------------------------------------
// ERC-20 Token Standard Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ---------------------------------------------------------------------
contract ERC20Interface {
  /**
  Returns the name of the token - e.g. "MyToken"
   */
  string public name;
  /**
  Returns the symbol of the token. E.g. "HIX".
   */
  string public symbol;
  /**
  Returns the number of decimals the token uses - e. g. 8
   */
  uint8 public decimals;
  /**
  Returns the total token supply.
   */
  uint256 public totalSupply;
  /**
  Returns the account balance of another account with address _owner.
   */
  function balanceOf(address _owner) public view returns (uint256 balance);
  /**
  Transfers _value amount of tokens to address _to, and MUST fire the Transfer event. 
  The function SHOULD throw if the _from account balance does not have enough tokens to spend.
   */
  function transfer(address _to, uint256 _value) public returns (bool success);
  /**
  Transfers _value amount of tokens from address _from to address _to, and MUST fire the Transfer event.
   */
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
  /**
  Allows _spender to withdraw from your account multiple times, up to the _value amount. 
  If this function is called again it overwrites the current allowance with _value.
   */
  function approve(address _spender, uint256 _value) public returns (bool success);
  /**
  Returns the amount which _spender is still allowed to withdraw from _owner.
   */
  function allowance(address _owner, address _spender) public view returns (uint256 remaining);
  /**
  MUST trigger when tokens are transferred, including zero value transfers.
   */
  event Transfer(address indexed _from, address indexed _to, uint256 _value);
  /**
  MUST trigger on any successful call to approve(address _spender, uint256 _value).
    */
  event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

/**
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);
  }
}

/**
Function to receive approval and execute function in one call.
 */
contract TokenRecipient { 
  function receiveApproval(address _from, uint256 _value, address _token, bytes memory _extraData) public; 
}

/**
Token implement
 */
contract Token is ERC20Interface, Owned {

  mapping (address => uint256) _balances;
  mapping (address => mapping (address => uint256)) _allowed;
  
  // This notifies clients about the amount burnt
  event Burn(address indexed from, uint256 value);
  
  function balanceOf(address _owner) public view returns (uint256 balance) {
    return _balances[_owner];
  }

  function transfer(address _to, uint256 _value) public returns (bool success) {
    _transfer(msg.sender, _to, _value);
    return true;
  }

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_value <= _allowed[_from][msg.sender]); 
    _allowed[_from][msg.sender] -= _value;
    _transfer(_from, _to, _value);
    return true;
  }

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

  function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
    return _allowed[_owner][_spender];
  }

  /**
  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);
  }

  /**
  Approves and then calls the receiving contract
   */
  function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
    TokenRecipient spender = TokenRecipient(_spender);
    approve(_spender, _value);
    spender.receiveApproval(msg.sender, _value, address(this), _extraData);
    return true;
  }

  /**
  Destroy tokens.
  Remove `_value` tokens from the system irreversibly
    */
  function burn(uint256 _value) public returns (bool success) {
    require(_balances[msg.sender] >= _value);
    _balances[msg.sender] -= _value;
    totalSupply -= _value;
    emit 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(_balances[_from] >= _value);
    require(_value <= _allowed[_from][msg.sender]);
    _balances[_from] -= _value;
    _allowed[_from][msg.sender] -= _value;
    totalSupply -= _value;
    emit Burn(_from, _value);
    return true;
  }

  /**
  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 != address(0x0));
    // Check if the sender has enough
    require(_balances[_from] >= _value);
    // Check for overflows
    require(_balances[_to] + _value > _balances[_to]);
    // Save this for an assertion in the future
    uint previousBalances = _balances[_from] + _balances[_to];
    // Subtract from the sender
    _balances[_from] -= _value;
    // Add the same to the recipient
    _balances[_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(_balances[_from] + _balances[_to] == previousBalances);
  }

}

contract CommonToken is Token {

  constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) public {
    name = _name;
    symbol = _symbol;
    decimals = _decimals;
    totalSupply = _initialSupply * 10 ** uint256(decimals);
    _balances[msg.sender] = totalSupply;
  }

  /**
  If ether is sent to this address, send it back.
   */
  function () external payable {
    revert();
  }

}

contract NCToken is CommonToken {

// wonsama's token publish 
// name : wonsama Token
// symbol : WSM 
// decimals : 3
// init supply : 1000000000
  constructor() CommonToken("WONSAMA TOKEN", "WONSAMA", 3, 1000000000) public {}

}

토큰 생성 코드 컴파일 / 배포

https://shasta.tronscan.org/#/contracts/contract-Compiler 주소로 접속 하여 파일을 업로드 이후 컴파일 및 배포를 진행합니다.

[그림] 컨트렉트 파일 업로드 버튼을 누른다.

[그림] 컴파일 버튼을 누른 후, 팝업에서 solidity 버전을 tron-0.5.8 ...로 변경 후 확인 버튼을 눌러준다.

[그림] 컴파일이 정상적으로 되면 위와 같이 보여진다.

[그림] NCToken 으로 변경 해준 다음 확인 버튼을 누른다.

[그림] Accept 버튼을 눌러 해당 컨트렉트를 전송한다

[그림] 정상적으로 배포가 완료되면, 트렉젝션 주소(27... ) 및 컨트렉트 주소 ( TDBB... ) 를 확인할 수 있다. ( 주소 정보는 꼭 기억 해주도록 한다. )

토큰 생성 등록

새탭을 열어서 https://shasta.tronscan.org/#/tokens/create/Type 주소를 들어간다

[그림] TRC20 을 선택

• 위에서 소스코드 맨 하단에 입력한 것과 동일한 정보를 입력 해준다.
  constructor() CommonToken("WONSAMA TOKEN", "WONSAMA", 3, 1000000000) public {}

[그림] 위에서 입력한 것과 동일한 정보를 채워 넣어준다. 토큰이름, 토큰 약자, 정밀도, 발행량 ( 다르면 진행 안됨 )

[그림] 나머지 정보도 입력해준다, 컨트렉트 주소는 이전 소스 배포할때 나온 값인 (TDBB... ) 을 넣어주도록 한다. ( Contract address 옆에 있는 T 로 시작하는 정보임 )

[그림] 제출 버튼을 눌러 토큰 발행을 최종적으로 확인한다.

[그림] 지갑을 통해 Accept 를 눌러 서명을 완료하면

[그림] 토큰 생성이 된 것을 확인할 수 있다.

토큰 확인하기

[그림] 지갑을 들어가도 아직은 안보인다. 토큰 주소를 추가해야 보이기 때문이다.

[그림] 우측 햄버거 버튼 누르고 Asset management 버튼을 눌러준다

[그림] 아까 생성한 계약 주소를 넣어준다. TDBBKzSMMR7uPQXrQxynKZ5SSBuuGEj34c 를 넣으면 원사마 토큰을 볼 수 있다.

[그림] 자 이제 초기 화면에서도 원사마 토큰을 볼 수 있다. 물론 테스트넷 기준으로 타인에게도 송금 또한 가능하다 :)

맺음말

스샷 때문에 내용이 길어 보이겠지만 실제는 금방 만든다. 복붙이니 뭐 한번 해보면 어렵지도 않다. 참고로 토큰명은 중복이 가능하다. 그러기 때문에 반드시 토큰의 컨트랙트 주소를 확인해야 된다.

누군가 가짜 원사마 토큰을 만들고 전송했다고 우길 수도 있는지라 ... 하지만 contract address 를 확인하면 된다 이럴경우엔 :)