방법 : PIRL 네트워크에서 토큰 만들기

이 게시물 공유

서 공유
서 공유
서 공유
서 공유

동전

우리는 디지털 토큰을 만들 것입니다. Pirl 생태계의 토큰은 동전, 로열티 포인트, 금 증서, IOU, 게임 아이템 등 모든 거래 가능한 상품을 나타낼 수 있습니다. 모든 토큰은 표준 방식으로 일부 기본 기능을 구현하기 때문에 토큰이 즉시 제공됩니다. Pirl 지갑 및 동일한 표준을 사용하는 다른 클라이언트 또는 계약과 호환됩니다.

최소 생존 토큰

표준 토큰 계약은 상당히 복잡 할 수 있습니다. 그러나 본질적으로 매우 기본적인 토큰은 다음과 같이 요약됩니다.

contract MyToken {/ * 모든 잔액을 가진 배열을 만듭니다 * / mapping (address => uint256) public balanceOf; / * 계약 공급 업체에게 초기 공급 토큰을 사용하여 계약을 초기화합니다. * / function MyToken (uint256 initialSupply) {balanceOf [msg.sender] = initialSupply; // 생성자에게 모든 초기 토큰 제공} / * 동전 보내기 * / function transfer (address _to, uint256 _value) {require (balanceOf [msg.sender]> = _value); // 발신자에게 충분한 require (balanceOf [_to] + _value> = balanceOf [_to])가 있는지 확인하십시오. // 오버 플로우 확인 balanceOf [msg.sender]-= _value; // 발신자에서 빼기 balanceOf [_to] + = _value; // 수신자에게 동일하게 추가}}

코드

그러나 더 완벽한 코드를 복사하여 붙여 넣으려면 다음을 사용하십시오.

프라 그마 견고성 = 0.4.16;

interface tokenRecipient {함수 receiveApproval (주소 _from, uint256 _value, 주소 _token, 바이트 _extraData) public; }

계약 토큰 ERC20 {
   // 토큰의 공개 변수
   문자열 공개 이름;
   문자열 공개 기호;
   uint8 public decimals = 18;
   // 십진법으로 18 자리를 강력하게 권장합니다. 변경하지 마십시오.
   uint256 public totalSupply;

   // 모든 잔액으로 배열을 만듭니다.
   매핑 (주소 => uint256) public balanceOf;
   매핑 (주소 => 매핑 (주소 => uint256)) 공공 수당;

   // 블록 체인에 공개 이벤트를 생성하여 클라이언트에게 알립니다.
   이벤트 전송 (주소가 uint256 값으로 색인, 주소가 색인 됨);

   // 고객에게 불태운 양을 알려줍니다
   이벤트 번 (주소가 uint256 값으로 인덱싱 됨);

   /**
    * 생성자 함수
    *
    * 계약 공급 업체에게 초기 공급 토큰으로 계약을 초기화합니다.
    */
   기능 토큰 ERC20 (
       uint256 initialSupply,
       문자열 tokenName,
       문자열 토큰
   ) 공공의 {
       totalSupply = initialSupply * 10 ** uint256 (십진수); // 십진수로 총 공급량 업데이트
       balanceOf [msg.sender] = totalSupply; // 제작자에게 모든 초기 토큰 제공
       이름 = tokenName; // 표시 목적으로 이름을 설정합니다
       symbol = tokenSymbol; // 표시 목적으로 기호를 설정
   }

   /**
    * 내부 이체,이 계약으로 만 호출 가능
    */
   함수 _transfer (주소 _from, 주소 _to, uint _value) 내부 {
       // 0x0 주소로의 전송을 금지합니다. 대신 burn ()을 사용하십시오.
       요구 (_to! = 0x0);
       // 발신자가 충분한 지 확인
       require (balanceOf [_from]> = _value);
       // 오버 플로우 확인
       require (balanceOf [_to] + _value> balanceOf [_to]);
       // 미래에 명제를 위해 이것을 저장하십시오.
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // 발신자에서 빼기
       balanceOf [_from]-= _value;
       // 수신자에게 동일하게 추가
       balanceOf [_to] + = _value;
       전송 (_from, _to, _value);
       // Asserts는 정적 분석을 사용하여 코드에서 버그를 찾는 데 사용됩니다. 그들은 절대 실패해서는 안된다
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * 이체 토큰
    *
    * 귀하의 계정에서`_value` 토큰을`_to`로 보냅니다.
    *
    * @param _to 수신자 주소
    * @param _ 송금액
    */
   함수 전송 (주소 _to, uint256 _value) 공개 {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * 다른 주소에서 토큰을 이체
    *
    *`_from` 대신`_value` 토큰을`_to`로 보냅니다.
    *
    * @param _from 발신자의 주소
    * @param _to 수신자 주소
    * @param _ 송금액
    */
   함수 transferFrom (주소 _from, 주소 _to, uint256 _value) 공개 리턴 (bool success) {
       require (_value <= 수당 [_from] [msg.sender]); // 수당 확인
       수당 [_from] [msg.sender]-= _value;
       _transfer (_from, _to, _value);
       true를 반환;
   }

   /**
    * 다른 주소에 대한 수당 설정
    *
    *`_spender`가 귀하를 대신하여`_value` 토큰을 소비 할 수 없습니다
    *
    * @param _spender 지출 권한이있는 주소
    * @param _ 지출 할 수있는 최대 금액
    */
   함수 승인 (주소 _spender, uint256 _value) 공개
       반환 (불법 성공) {
       수당 [msg.sender] [_ spender] = _value;
       true를 반환;
   }

   /**
    * 다른 주소에 대한 허용을 설정하고 통지
    *
    *`_spender`가 귀하를 대신하여`_value` 토큰을 소비 한 다음 계약을 핑할 수 있습니다.
    *
    * @param _spender 지출 권한이있는 주소
    * @param _ 지출 할 수있는 최대 금액
    * @param _extraData 승인 된 계약서에 보낼 추가 정보
    */
   approveAndCall 함수 (주소 _spender, uint256 _value, 바이트 _extraData)
       공공의
       반환 (불법 성공) {
       tokenRecipient 지출 자 = tokenRecipient (_spender);
       if (approve (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           true를 반환;
       }
   }

   /**
    * 토큰을 파괴
    *
    * 시스템에서`_value` 토큰을 비가 역적으로 제거
    *
    * @param_ 연소 할 금액
    */
   함수 burn (uint256 _value) 공개 리턴 (bool success) {
       require (balanceOf [msg.sender]> = _value); // 발신자가 충분한 지 확인
       balanceOf [msg.sender]-= _value; // 발신자에서 빼기
       totalSupply-= _value; // totalSupply 업데이트
       번 (msg.sender, _value);
       true를 반환;
   }

   /**
    * 다른 계정에서 토큰을 파괴하십시오
    *
    `_from` 대신 시스템에서`_value` 토큰을 돌이킬 수 없게 제거하십시오.
    *
    * @param _ 발신인의 주소에서
    * @param_ 연소 할 금액
    */
   burnFrom 함수 (주소 _from, uint256 _value) public returns (bool success) {
       require (balanceOf [_from]> = _value); // 타겟 잔액이 충분한 지 확인
       require (_value <= 수당 [_from] [msg.sender]); // 수당 확인
       balanceOf [_from]-= _value; // 목표 저울에서 빼기
       수당 [_from] [msg.sender]-= _value; // 발신자의 수당에서 빼기
       totalSupply-= _value; // totalSupply 업데이트
       번 (_from, _value);
       true를 반환;
   }
}

코드 이해

이제 기본부터 시작하겠습니다. 월렛 앱을 열고 계약 탭으로 이동 한 다음 새 계약 배포 Solidity Contract Source 코드 텍스트 필드에 아래 코드를 입력하십시오.

계약 MyToken {
       / * 모든 잔액을 가진 배열을 만듭니다 * /
       매핑 (주소 => uint256) public balanceOf;
   }

매핑은 주소를 저울과 연결하는 연관 배열을 의미합니다. 주소는 기본 16 진수 Pirl 형식이며, 저울은 0에서 115까지의 정수입니다. quattuorvigintillion의 양을 모르는 경우 토큰을 사용하려는 것보다 많은 vigintillions입니다. 퍼블릭 키워드는 블록 체인의 모든 사용자가이 변수에 액세스 할 수 있음을 의미합니다. 즉, 모든 잔액은 공개되어 있습니다 (클라이언트가 표시 할 수 있도록 필요에 따라).

계약서를 바로 발행했다면, 그 계약은 효과가 있지만 그다지 유용하지는 않을 것입니다 : 어떤 주소에서든 동전의 잔액을 조회 할 수있는 계약일 것입니다. return 0. 그래서 우리는 시작할 때 몇 개의 토큰을 만들 것입니다. 이 코드를 마지막 닫는 괄호 앞에 mapping .. 행 바로 아래에 추가하십시오.

함수 MyToken () {
       balanceOf [msg.sender] = 21000000;
   }

MyToken 함수는 MyToken 계약과 이름이 같습니다. 이것은 매우 중요하며 하나의 이름을 바꾸는 경우 다른 하나의 이름도 바꾸어야합니다. 이것은 계약을 처음 네트워크에 업로드 할 때 한 번만 실행되는 특수한 시작 기능입니다. 이 기능은 계약을 배포 한 사용자 인 msg.sender의 잔액을 2,100 만 잔액으로 설정합니다.

2,100 만 개의 선택은 다소 임의적이며 코드에서 원하는 것으로 변경할 수 있지만 더 좋은 방법이 있습니다. 대신 다음과 같이 함수의 매개 변수로 제공하십시오.

MyToken 기능 (uint256 initialSupply) public {
       balanceOf [msg.sender] = 초기 공급;
   }

계약 옆의 오른쪽 열을 살펴보면 계약서 작성이라는 드롭 다운 목록이 표시됩니다. “MyToken”계약을 선택하면 생성자 매개 변수라는 섹션이 표시됩니다. 이들은 토큰에 대해 변경 가능한 매개 변수이므로 동일한 코드를 재사용하고 나중에 이러한 변수 만 변경할 수 있습니다.

현재 토큰 잔액을 생성하는 기능 계약이 있지만 토큰을 옮길 기능이 없으므로 동일한 계정으로 유지됩니다. 이제 우리는 그것을 구현할 것입니다. 마지막 대괄호 앞에 다음 코드를 작성하십시오.

/ * 동전 보내기 * /
   함수 전송 (주소 _to, uint256 _value) {
       / * 새 잔액 더하기 및 빼기 * /
       balanceOf [msg.sender]-= _value;
       balanceOf [_to] + = _value;
   }

이것은 매우 간단한 함수입니다. 수신자와 값을 매개 변수로 가지고 있으며 누군가 호출 할 때마다 _value를 밸런스에서 빼고 _to 저울에 추가합니다. 바로 명백한 문제가 있습니다. 사람이 소유 한 것보다 더 많은 것을 보내려면 어떻게됩니까? 우리는이 특정 계약에서 부채를 처리하고 싶지 않기 때문에 간단히 확인하고 발송인이 충분한 자금을 가지고 있지 않으면 계약 실행이 중단됩니다. 또한 오버플로를 확인하여 숫자가 너무 커서 다시 0이되지 않도록합니다.

실행 중 계약 실행을 중지하려면 반환하거나 던질 수 있습니다. 전자는 비용이 적게 들지만 지금까지 계약에 대한 변경 사항이 유지되므로 더 두통이 될 수 있습니다. 반면 'throw'는 모든 계약 실행을 취소하고 거래로 인한 변경 사항을 되돌리고 발신자는 가스로 보낸 모든 Pirl을 잃게됩니다. 그러나 월렛은 계약이 체결 될 것을 감지 할 수 있으므로 항상 경고를 표시하므로 Pirl을 전혀 사용하지 못합니다.

함수 전송 (주소 _to, uint256 _value) {
       / * 발신자에게 잔액이 있는지, 오버플로가 있는지 확인 * /
       require (balanceOf [msg.sender]> = _value && balanceOf [_to] + _value> = balanceOf [_to]);

       / * 새 잔액 더하기 및 빼기 * /
       balanceOf [msg.sender]-= _value;
       balanceOf [_to] + = _value;
   }

 

이제 누락 된 것은 계약에 대한 몇 가지 기본 정보입니다. 머지 않아 이것은 토큰 레지스트리에 의해 처리 될 수 있지만 지금은 계약에 직접 추가 할 것입니다 :

문자열 공개 이름;
문자열 공개 기호;
uint8 공개 소수점;

이제 생성자 함수를 업데이트하여 시작시 모든 변수를 설정할 수 있습니다.

/ * 계약 공급 업체에게 초기 공급 토큰으로 계약을 초기화합니다 * /
   MyToken 함수 (uint256 initialSupply, 문자열 tokenName, 문자열 tokenSymbol, uint8 decimalUnits) {
       balanceOf [msg.sender] = 초기 공급; // 제작자에게 모든 초기 토큰 제공
       이름 = tokenName; // 표시 목적으로 이름을 설정합니다
       symbol = tokenSymbol; // 표시 목적으로 기호를 설정
       십진수 = decimalUnits; // 표시 목적의 소수점 이하 자릿수
   }

마지막으로 Events라는 somPirling이 필요합니다. Pirl Wallet과 같은 고객이 계약에서 발생하는 활동을 추적 할 수 있도록 호출하는 특수한 빈 기능입니다. 이벤트는 대문자로 시작해야합니다. 계약 시작 부분에 다음 줄을 추가하여 이벤트를 선언하십시오.

이벤트 전송 (주소가 uint256 값으로 색인, 주소가 색인 됨);
 

그리고 나서 "transfer"함수 안에이 두 줄을 추가하면됩니다 :

      / *이 전송이 발생했음을 듣고있는 사람에게 * /
       이체 (msg.sender, _to, _value);

 

이제 토큰이 준비되었습니다!

댓글을 주목?

@notice 및 @param 의견은 무엇입니까? 그게 나 스펙 자연 언어 사양에 대한 새로운 표준으로, 지갑은 사용자에게 계약이 수행 될 작업에 대한 자연어 설명을 사용자에게 보여줄 수 있습니다. 현재 많은 지갑에서 지원하지는 않지만 앞으로 변경 될 것이므로 준비하는 것이 좋습니다.

배포하는 방법

아직없는 경우 Pirl Wallet을 열고 계약 탭으로 이동 한 다음 "새 계약 배포"를 클릭하십시오.

이제 위에서 토큰 소스를 가져 와서 "Solidity source 필드"에 붙여 넣습니다. 코드가 오류없이 컴파일되면 오른쪽에 "계약 선택"드롭 다운 목록이 표시됩니다. 그것을 얻고 "MyToken"계약을 선택하십시오. 오른쪽 열에는 자신의 토큰을 개인화하는 데 필요한 모든 매개 변수가 표시됩니다. 원하는대로 조정할 수 있습니다.

페이지 끝으로 스크롤하면 해당 계약의 계산 비용 추정치가 표시되며 Pirl 비용을 지불 할 수수료를 선택할 수 있습니다. 지출하지 않은 초과 Pirl은 귀하에게 반환되므로 원할 경우 기본 설정을 그대로 둘 수 있습니다. “배치”를 누르고 계정 비밀번호를 입력 한 후 거래가 완료 될 때까지 몇 초 동안 기다리십시오.

거래가 확인 대기중인 것을 확인할 수있는 첫 페이지로 리디렉션됩니다. 계정을 클릭하면 1 분 이내에 계정에 방금 생성 한 100%의 주식이 있음을 알 수 있습니다. 친구에게 몇 명을 보내려면 : "보내기"를 선택한 다음 보내려는 통화 (Pirl 또는 새로 만든 공유)를 선택하고 "받는 사람"필드에 친구의 주소를 붙여 넣고 "보내기"를 누르십시오.

친구에게 보내면 지갑에 아무것도 보이지 않습니다. 지갑이 알고있는 토큰 만 추적하기 때문에 수동으로 추가해야하기 때문입니다. 이제 "계약"탭으로 이동하면 새로 작성된 계약에 대한 링크가 표시됩니다. 클릭하면 해당 페이지로 이동합니다. 이 계약서는 매우 간단한 계약 페이지이므로 여기서 할 일은 많지 않습니다.“주소 복사”를 클릭하고 계약서 주소를 텍스트 편집기에 붙여 넣기 만하면됩니다.

볼 토큰을 추가하려면 계약 페이지로 이동 한 다음 "Watch Token"을 클릭하십시오. 팝업이 나타나고 계약 주소 만 붙여 넣기 만하면됩니다. 토큰 이름, 기호 및 10 진수는 자동으로 채워 져야하지만 그렇지 않은 경우 원하는 것을 넣을 수 있습니다 (지갑에 표시되는 방식에만 영향을 미칩니다). 이 작업을 수행하면 해당 토큰의 잔액이 자동으로 표시되며 다른 사람에게 보낼 수 있습니다.

그리고 지금 당신은 당신의 자신의 암호 토큰을 가지고 있습니다! 토큰 자체는 지역 사회에서의 가치 교환, 근로 시간 또는 기타 로열티 프로그램을 추적하는 방법으로 유용 할 수 있습니다. 그러나 우리는 통화를 유용하게하여 본질적인 가치를 가질 수 있습니까?

토큰 향상

한 줄의 코드를 건드리지 않고 전체 암호화 토큰을 배포 할 수 있지만 사용자 지정을 시작하면 진정한 마법이 발생합니다. 다음 섹션은 귀하의 요구에 더 적합하도록 토큰에 추가 할 수있는 기능에 대한 제안입니다.

더 기본 기능

승인, sendFrom 등과 같은 기본 토큰 계약에 더 많은 기능이 있음을 알 수 있습니다. 이러한 기능은 귀하의 토큰이 다른 계약과 상호 작용할 수 있도록하기위한 것입니다. 예를 들어, 분산 형 거래소에 토큰을 판매하려는 경우, 거래소가 새로운 토큰을 알지 못하거나 보낸 사람을 알 수 없으므로 주소로 보내는 것만으로는 충분하지 않습니다 계약은 기능 호출에만 이벤트를 구독 할 수 없기 때문입니다. 따라서 계약의 경우 먼저 계정에서 이동할 수있는 토큰의 양을 승인 한 다음 approveAndCall을 사용하여 자신이해야 할 일을 알리기 위해 핑 (ping)해야합니다.

이러한 기능 중 많은 기능이 토큰 전송을 다시 구현해야하므로 계약 자체에서만 호출 할 수있는 내부 기능으로 변경하는 것이 좋습니다.

/ * 내부 이체,이 계약으로 만 호출 가능 * /
   함수 _transfer (주소 _from, 주소 _to, uint _value) 내부 {
       필요 (_to! = 0x0); // 0x0 주소로의 전송을 금지합니다. 대신 burn ()을 사용하십시오.
       필요 (balanceOf [_from]> = _value); // 발신자가 충분한 지 확인
       필요 (balanceOf [_to] + _value> balanceOf [_to]); // 오버 플로우 확인
       require (! frozenAccount [_from]); // 발신자가 동결되었는지 확인
       require (! frozenAccount [_to]); // 수신자가 동결되었는지 확인
       balanceOf [_from]-= _value; // 발신자에서 빼기
       balanceOf [_to] + = _value; // 수신자에게 동일하게 추가
       전송 (_from, _to, _value);
   }

이제 동전을 이체하는 모든 기능은 자체 검사를 수행 한 다음 올바른 매개 변수로 이체를 호출 할 수 있습니다. 이 기능은 다른 사람의 허락없이 동전을 모든 계좌에서 다른 계좌로 옮길 수 있습니다. 그러므로 계약에 의해서만 호출되는 내부 함수입니다. 호출하는 함수를 추가하면, 발신자에게 이동 권한이 있어야합니다.

중앙 집중식 관리자

모든 dapps는 기본적으로 완전히 분산되어 있지만 원하는 경우 중앙 관리자를 가질 수 없음을 의미하지는 않습니다. 더 많은 동전을 넣을 수있는 기능을 원하거나, 일부 사람들이 통화를 사용하는 것을 금지하고 싶을 수도 있습니다. 이러한 기능 중 하나를 추가 할 수 있지만 시작 부분에서만 추가 할 수 있으므로 모든 토큰 보유자는 게임 규칙을 소유하기 전에 항상 게임 규칙을 정확히 알고 있어야합니다.

이를 위해서는 중앙 화폐 컨트롤러가 필요합니다. 이것은 간단한 계정 일 수도 있지만 계약일 수도 있습니다. 따라서 더 많은 토큰을 만들기위한 결정은 계약에 달려 있습니다. 투표 할 수있는 민주적 조직이거나 토큰 소유자의 힘.

이를 위해 계약의 매우 유용한 속성 인 상속을 배우게됩니다. 상속을 통해 계약은 모든 계약을 재정의하지 않고도 부모 계약의 속성을 획득 할 수 있습니다. 이것은 코드를 더 깨끗하고 재사용하기 쉽게 만듭니다. 계약 MyToken {전에 계약 코드의 첫 줄에이 코드를 추가하십시오.

계약 소유 {
       공공 소유자 주소;

       function owned () {
           owner = msg.sender;
       }

       수정 자만 소유자 {
           require (msg.sender == 소유자);
           _;
       }

       function transferOwnership (주소 newOwner) onlyOwner {
           소유자 = newOwner;
       }
   }

이것은 "소유"될 수있는 계약에 대한 일반적인 기능을 정의하는 것 외에는 아무 것도하지 않는 매우 기본적인 계약을 만듭니다. 이제 다음 단계는 계약서에 소유 한 텍스트를 추가하는 것입니다.

 계약 MyToken은 {
       / * 평소와 같이 계약의 나머지 * /

이는 MyToken 내부의 모든 함수가 변수 소유자 및 수정 자 onlyOwner에 액세스 할 수 있음을 의미합니다. 계약에는 소유권 이전 기능도 있습니다. 시작시 계약 소유자를 설정하는 것이 흥미로울 수 있으므로 생성자 함수에 추가 할 수도 있습니다.

함수 MyToken (
       uint256 initialSupply,
       문자열 tokenName,
       uint8 decimalUnits,
       문자열 tokenSymbol,
       centralMinter 주소
       ) {
       if (centralMinter! = 0) 소유자 = centralMinter;
   }

센트럴 민트

유통되는 동전의 양을 바꾸고 싶다고 가정 해보십시오. 이는 토큰이 실제로 블록 체인 자산 (골드 인증서 또는 정부 통화 등)을 나타내고 가상 인벤토리가 실제 자산을 반영하기를 원하는 경우입니다. 통화 보유자가 토큰 가격을 어느 정도 통제 할 것을 기대하고 유통에서 토큰을 발행하거나 제거하려는 경우에도 마찬가지입니다.

먼저 totalSupply를 저장하고 생성자 함수에 변수를 할당 할 변수를 추가해야합니다.

계약 MyToken {
       uint256 public totalSupply;

       함수 MyToken (…) {
           totalSupply = 초기 공급;
           …
       }
       …
   }

이제 소유자가 새로운 토큰을 생성 할 수 있도록 새로운 기능을 추가하겠습니다 :

함수 mintToken (주소 대상, uint256 mintedAmount) 만 소유자 {
       balanceOf [타겟] + = 민트 금액;
       totalSupply + = 발행량;
       양도 (0, owner, mintedAmount);
       양도 (소유자, 목표, 발행 금액);
   }

함수 이름 끝에 수정 자 onlyOwner를 주목하십시오. 이는이 함수가 컴파일시에 다시 작성되어 이전에 정의한 수정 자 onlyOwner의 코드를 상속 함을 의미합니다. 이 함수의 코드는 수정 자 함수에 밑줄이있는 곳에 삽입됩니다. 즉,이 특정 함수는 소유자로 설정된 계정으로 만 호출 할 수 있습니다. 소유자 수정자를 사용하여 계약에 추가하면 더 많은 코인을 만들 수 있습니다.

자산 동결

사용 사례에 따라 토큰을 사용할 수있는 사람과 사용할 수없는 사람에 대한 규제 장애물이 필요할 수 있습니다. 이를 위해 계약 소유자가 자산을 고정 또는 고정 해제 할 수있는 매개 변수를 추가 할 수 있습니다.

이 변수를 추가하고 계약서의 어느 곳에서나 기능하십시오. 원하는 위치에 배치 할 수 있지만 다른 방법으로 매핑하고 다른 이벤트와 함께 매핑하는 것이 좋습니다.

매핑 (주소 => bool) public frozenAccount;
   이벤트 FrozenFunds (주소 타겟, bool frozen);

   freezeAccount 함수 (주소 대상, bool freeze) onlyOwner {
       frozenAccount [target] = 동결;
       냉동 펀드 (목표, 동결);
   }

이 코드를 사용하면 기본적으로 모든 계정이 고정 해제되지만 소유자는 계정 고정을 호출하여 계정을 고정 상태로 설정할 수 있습니다. 불행히도, 전송 함수에 아무것도 추가하지 않았기 때문에 동결은 실질적인 효과가 없습니다. 우리는 지금 그것을 바꾸고 있습니다 :

함수 전송 (주소 _to, uint256 _value) {
       require (! frozenAccount [msg.sender]);

이제 동결 된 계정은 여전히 펀드를 유지하지만 옮길 수는 없습니다. 모든 계정은 기본적으로 동결 될 때까지 고정 해제되지만 모든 계정을 수동으로 승인해야하는 화이트리스트로 해당 동작을 쉽게 되돌릴 수 있습니다. frozenAccount의 이름을 certifiedAccount로 바꾸고 마지막 줄을 다음과 같이 변경하십시오.

require (approvedAccount [msg.sender]);

자동 판매 및 구매

지금까지 유틸리티에 의존하고 토큰을 소중하게 생각합니다. 그러나 원하는 경우 시장 가치로 자동 판매 및 구매하는 펀드를 만들어 Pirl (또는 다른 토큰)이 토큰의 가치를 뒷받침 할 수 있습니다.

먼저 구매 및 판매 가격을 설정해 보겠습니다.

uint256 공개 판매 가격;
   uint256 공개 구매 가격;

   함수 setPrices (uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

모든 새로운 가격 변경은 거래를 실행하고 약간의 Pirl을 소비해야하므로 자주 변경되지 않는 가격에 허용됩니다. 일정한 변동 가격을 원하면 표준 데이터 피드를 조사하는 것이 좋습니다.

다음 단계는 구매 및 판매 기능을 수행하는 것입니다.

함수 buy () 지불 가능 수익 (단품) {
       금액 = msg.value / 구매 가격; // 금액을 계산
       require (balanceOf [this]> = amount); // 팔기에 충분한 지 확인합니다
       balanceOf [msg.sender] + = 금액; // 구매자 잔액에 금액을 추가합니다
       balanceOf [this]-= 금액; // 판매자 잔액에서 금액을 뺍니다.
       송금 (this, msg.sender, amount); // 변경 사항을 반영한 이벤트를 실행
       반품 금액; // 함수를 종료하고 리턴
   }

   함수 매도 (소매 금액) 반환 (소매 수입) {
       require (balanceOf [msg.sender]> = amount); // 발신자가 팔 수있을만큼 충분한 지 확인
       balanceOf [this] + = 금액; // 소유자 잔액에 금액을 추가합니다
       balanceOf [msg.sender]-= 금액; // 판매자 잔액에서 금액을 뺍니다.
       수익 = 금액 * sellPrice;
       msg.sender.transfer (수익); // 판매자에게 Pirl을 보냅니다. 재귀 공격을 막기 위해 마지막으로이 작업을 수행하는 것이 중요합니다
       송금 (msg.sender, this, amount); // 변경 사항을 반영한 이벤트를 실행합니다.
       수익을 반환; // 함수를 종료하고 리턴
   }

이렇게하면 새 토큰이 생성되지 않지만 계약이 소유 한 잔액이 변경됩니다. 계약은 자체 토큰과 Pirl 및 계약 소유자를 모두 보유 할 수 있지만 가격을 설정하거나 경우에 따라 새 토큰을 생성 할 수 있습니다 (해당되는 경우) 은행의 토큰 또는 Pirl을 건드릴 수 없습니다. 이 계약으로 자금을 옮길 수있는 유일한 방법은 자금을 매매하는 것입니다.

참고 구매 및 판매“가격”은 Pirl에 설정되어 있지 않지만, 시스템의 최소 통화 (유로 및 달러 단위의 센트 또는 비트 코인의 Satoshi와 동일)입니다. 하나의 Pirl은 1000000000000000000 wei입니다. 따라서 Pirl에서 토큰 가격을 설정할 때 끝에 18을 추가하십시오.

계약을 만들 때 시장에있는 모든 토큰을 다시 구매할 수 있도록 충분한 Pirl을 보내십시오. 그렇지 않으면 계약이 해결되지 않아 사용자가 토큰을 판매 할 수 없습니다.

물론 앞의 예는 단일 중앙 구매자 및 판매자와의 계약을 설명합니다. 훨씬 흥미로운 계약은 누구나 다른 가격으로 입찰 할 수있는 시장을 허용하거나 외부 소스에서 직접 가격을로드 할 수 있습니다.

자동 리필

Pirl에서 거래를 할 때마다 스마트 계약의 결과를 계산하는 블록 채굴 자에게 수수료를 지불해야합니다. 미래에는 이것이 변경 될 수 있지만, 순간 수수료는 Pirl로만 지불 할 수 있으므로 모든 토큰 사용자에게 필요합니다. 수수료보다 적은 잔고를 가진 계정의 토큰은 소유자가 필요한 수수료를 지불 할 수있을 때까지 붙어 있습니다. 그러나 일부 유스 케이스에서는 사용자가 Pirl, 블록 체인 또는 Pirl을 얻는 방법에 대해 생각하지 않기를 원할 수 있으므로 한 가지 방법은 잔액이 위험하다는 것을 감지하자마자 동전이 자동으로 사용자 잔액을 보충하도록합니다.

그러기 위해서는 먼저 임계 값을 보유 할 변수와이를 변경하는 함수를 만들어야합니다.

uint minBalanceForAccounts;

   함수 setMinBalance (uint minimumBalanceInFinney) onlyOwner {
        minBalanceForAccounts = minimumBalanceInFinney * 1 핀니;
   }

 

그런 다음이 기능을 전송 기능에 추가하면 발신자가 환불됩니다.

  / * 동전 보내기 * /
   함수 전송 (주소 _to, uint256 _value) {
       …
       if (msg.sender.balance <minBalanceForAccounts)
           sell ((minBalanceForAccounts – msg.sender.balance) / sellPrice);
   }

 

대신 발신자가 수신자에게 수수료를 지불하도록 변경할 수도 있습니다.

  / * 동전 보내기 * /
   함수 전송 (주소 _to, uint256 _value) {
       …
       if (_to.balance            _to.send (sell ((minBalanceForAccounts – _to.balance) / sellPrice));
   }

이를 통해 토큰을받는 계정이 수수료를 지불하는 데 필요한 Pirl보다 적은 금액을 보유 할 수 없습니다.

작업 증명

동전 공급을 수학 공식에 묶는 방법이 있습니다. 가장 간단한 방법 중 하나는 Pirl을 사용하여 "병합 마이닝"으로 만드는 것입니다. 즉, Pirl에서 블록을 찾는 사람은 누구나 해당 블록에서 보상 기능을 호출 할 경우 코인으로부터 보상을받을 수 있습니다. 블록을 찾는 광부를 참조하는 특수 키워드 코인베이스를 사용하여 수행 할 수 있습니다.

giveBlockReward () 함수 {
       balanceOf [block.coinbase] + = 1;
   }

수학을 할 수있는 사람이라면 누구나 보상을받을 수 있도록 수학 공식을 추가 할 수도 있습니다. 이 다음 예에서는 현재 챌린지의 큐빅 근을 계산하여 다음 챌린지를 설정할 수있는 권한을 얻습니다.

uint currentChallenge = 1; //이 숫자의 세제곱근을 알아낼 수 있습니까?

   rewardMathGeniuses 함수 (uint answerToCurrentReward, uint nextChallenge) {
       require (answerToCurrentReward ** 3 == currentChallenge); // 답변이 잘못된 경우 계속하지 마십시오
       balanceOf [msg.sender] + = 1; // 플레이어에게 보상
       currentChallenge = nextChallenge; // 다음 도전을 설정
   }

물론 입방근을 계산하는 것은 누군가가 머리에서하기가 어려울 수 있지만 계산기를 사용하면 매우 쉬우므로이 게임은 컴퓨터에 의해 쉽게 깨질 수 있습니다. 또한 마지막 승자는 다음 도전을 선택할 수 있기 때문에 그들이 알고있는 somPirling을 선택할 수 있으므로 다른 플레이어에게는 매우 공정한 게임이 아닙니다. 사람에게는 쉽지만 컴퓨터에는 어려운 작업이 있지만 일반적으로 이와 같은 간단한 스크립트로 코딩하기는 매우 어렵습니다. 대신, 공정한 시스템은 컴퓨터가하기 어려운 시스템이어야하지만 컴퓨터를 검증하기는 어렵지 않습니다. 좋은 후보는 도전자가 주어진 난이도보다 낮은 것을 찾을 때까지 여러 숫자에서 해시를 생성해야하는 해시 챌린지를 만드는 것입니다.

이 프로세스는 1997 년 Adam Back에 의해 처음 제안되었습니다. 해시 캐쉬 그리고 2008 년 작업 증명으로 Satoshi Nakamoto에 의해 비트 코인에서 구현되었습니다.

동전을 무작위로 발행하는 형태로 해싱을 좋아하는 경우에도 작업 증명이있는 자체 Pirl 기반 통화를 만들 수 있습니다.

bytes32 public currentChallenge; // 동전은 도전으로 시작합니다
   uint 공개 timeOfLastProof; // 보상이 제공된 시점을 추적하는 변수
   uint 공공 난이도 = 10 ** 32; // 난이도가 낮게 시작됩니다

   함수 proofOfWork (uint nonce) {
       바이트 8 n = 바이트 8 (sha3 (nonce, currentChallenge)); // 입력을 기반으로 임의 해시 생성
       요구 (n> = 바이트 8 (난이도)); // 어려움이 있는지 확인

       uint timeSinceLastProof = (현재 – timeOfLastProof); // 마지막 보상 이후 시간 계산
       필요 (timeSinceLastProof> = 5 초); // 보상은 너무 빨리 주어질 수 없습니다
       balanceOf [msg.sender] + = timeSinceLastProof / 60 초; // 승자에 대한 보상은 분 단위로 증가합니다.

       난이도 = 난이도 * 10 분 / timeSinceLastProof + 1; // 난이도 조정

       timeOfLastProof = 지금; // 카운터를 재설정
       currentChallenge = sha3 (초급, currentChallenge, block.blockhash (block.number – 1)); // 다음 증명으로 사용될 해시를 저장합니다
   }

또한 생성자 함수 (계약과 동일한 이름을 가진 첫 번째 업로드에서 호출되는)를 변경하여이 줄을 추가하면 난이도 조정이 미치지 않습니다.

timeOfLastProof = 지금;

계약이 온라인 상태가되면 "작업 증명"기능을 선택하고 nonce 필드에 원하는 번호를 추가 한 후 실행하십시오. 확인 창에 "데이터를 실행할 수 없음"이라는 빨간색 경고가 표시되면 트랜잭션을 진행할 수있는 번호를 찾을 때까지 돌아가서 다른 번호를 선택하십시오.이 프로세스는 임의적입니다. 하나를 찾으면 마지막 보상이 주어진 이후 1 분마다 1 개의 토큰이 주어지며, 도전 난이도는 보상 당 평균 10 분을 목표로 조정됩니다.

보상을 줄 번호를 찾는이 과정은 광업입니다. 어려움이 증가하면 운이 좋은 번호를 찾기가 매우 어려울 수 있지만 항상 찾은 번호를 쉽게 확인할 수 있습니다.

개선 된 동전

전체 코인 코드
모든 고급 옵션을 추가하면 최종 코드는 다음과 같습니다.

프라 그마 견고성 = 0.4.16;

계약 소유 {
   공공 소유자 주소;

   function owned () public {
       owner = msg.sender;
   }

   수정 자만 소유자 {
       require (msg.sender == 소유자);
       _;
   }

   function transferOwnership (address newOwner) onlyOwner public {
       소유자 = newOwner;
   }
}


프라 그마 견고성 = 0.4.16;

계약 소유 {
   공공 소유자 주소;

   function owned () public {
       owner = msg.sender;
   }

   수정 자만 소유자 {
       require (msg.sender == 소유자);
       _;
   }

   function transferOwnership (address newOwner) onlyOwner public {
       소유자 = newOwner;
   }
}

interface tokenRecipient {함수 receiveApproval (주소 _from, uint256 _value, 주소 _token, 바이트 _extraData) public; }

계약 토큰 ERC20 {
   // 토큰의 공개 변수
   문자열 공개 이름;
   문자열 공개 기호;
   uint8 public decimals = 18;
   // 십진법으로 18 자리를 강력하게 권장합니다. 변경하지 마십시오.
   uint256 public totalSupply;

   // 모든 잔액으로 배열을 만듭니다.
   매핑 (주소 => uint256) public balanceOf;
   매핑 (주소 => 매핑 (주소 => uint256)) 공공 수당;

   // 블록 체인에 공개 이벤트를 생성하여 클라이언트에게 알립니다.
   이벤트 전송 (주소가 uint256 값으로 색인, 주소가 색인 됨);

   // 고객에게 불태운 양을 알려줍니다
   이벤트 번 (주소가 uint256 값으로 인덱싱 됨);

   /**
    * 건축 자 기능
    *
    * 계약 공급 업체에게 초기 공급 토큰으로 계약을 초기화합니다.
    */
   기능 토큰 ERC20 (
       uint256 initialSupply,
       문자열 tokenName,
       문자열 토큰
   ) 공공의 {
       totalSupply = initialSupply * 10 ** uint256 (십진수); // 십진수로 총 공급량 업데이트
       balanceOf [msg.sender] = totalSupply; // 제작자에게 모든 초기 토큰 제공
       이름 = tokenName; // 표시 목적으로 이름을 설정합니다
       symbol = tokenSymbol; // 표시 목적으로 기호를 설정
   }

   /**
    * 내부 이체,이 계약으로 만 호출 가능
    */
   함수 _transfer (주소 _from, 주소 _to, uint _value) 내부 {
       // 0x0 주소로의 전송을 금지합니다. 대신 burn ()을 사용하십시오.
       요구 (_to! = 0x0);
       // 발신자가 충분한 지 확인
       require (balanceOf [_from]> = _value);
       // 오버 플로우 확인
       require (balanceOf [_to] + _value> balanceOf [_to]);
       // 미래에 명제를 위해 이것을 저장하십시오.
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // 발신자에서 빼기
       balanceOf [_from]-= _value;
       // 수신자에게 동일하게 추가
       balanceOf [_to] + = _value;
       전송 (_from, _to, _value);
       // Asserts는 정적 분석을 사용하여 코드에서 버그를 찾는 데 사용됩니다. 그들은 절대 실패해서는 안된다
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * 이체 토큰
    *
    * 귀하의 계정에서`_value` 토큰을`_to`로 보냅니다.
    *
    * @param _to 수신자 주소
    * @param _ 송금액
    */
   함수 전송 (주소 _to, uint256 _value) 공개 {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * 다른 주소에서 토큰을 이체
    *
    *`_from` 대신`_value` 토큰을`_to`로 보냅니다.
    *
    * @param _from 발신자의 주소
    * @param _to 수신자 주소
    * @param _ 송금액
    */
   함수 transferFrom (주소 _from, 주소 _to, uint256 _value) 공개 리턴 (bool success) {
       require (_value <= 수당 [_from] [msg.sender]); // 수당 확인
       수당 [_from] [msg.sender]-= _value;
       _transfer (_from, _to, _value);
       true를 반환;
   }

   /**
    * 다른 주소에 대한 수당 설정
    *
    *`_spender`가 귀하를 대신하여`_value` 토큰을 넘지 않도록 허용
    *
    * @param _spender 지출 권한이있는 주소
    * @param _ 지출 할 수있는 최대 금액
    */
   함수 승인 (주소 _spender, uint256 _value) 공개
       반환 (불법 성공) {
       수당 [msg.sender] [_ spender] = _value;
       true를 반환;
   }

   /**
    * 다른 주소에 대한 허용을 설정하고 통지
    *
    *`_spender`가 귀하를 대신하여`_value` 토큰을 소비 한 다음 계약을 핑할 수 있습니다.
    *
    * @param _spender 지출 권한이있는 주소
    * @param _ 지출 할 수있는 최대 금액
    * @param _extraData 승인 된 계약서에 보낼 추가 정보
    */
   approveAndCall 함수 (주소 _spender, uint256 _value, 바이트 _extraData)
       공공의
       반환 (불법 성공) {
       tokenRecipient 지출 자 = tokenRecipient (_spender);
       if (approve (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           true를 반환;
       }
   }

   /**
    * 토큰을 파괴
    *
    * 시스템에서`_value` 토큰을 비가 역적으로 제거
    *
    * @param_ 연소 할 금액
    */
   함수 burn (uint256 _value) 공개 리턴 (bool success) {
       require (balanceOf [msg.sender]> = _value); // 발신자가 충분한 지 확인
       balanceOf [msg.sender]-= _value; // 발신자에서 빼기
       totalSupply-= _value; // totalSupply 업데이트
       번 (msg.sender, _value);
       true를 반환;
   }

   /**
    * 다른 계정에서 토큰을 파괴하십시오
    *
    `_from` 대신 시스템에서`_value` 토큰을 돌이킬 수 없게 제거하십시오.
    *
    * @param _ 발신인의 주소에서
    * @param_ 연소 할 금액
    */
   burnFrom 함수 (주소 _from, uint256 _value) public returns (bool success) {
       require (balanceOf [_from]> = _value); // 타겟 잔액이 충분한 지 확인
       require (_value <= 수당 [_from] [msg.sender]); // 수당 확인
       balanceOf [_from]-= _value; // 목표 저울에서 빼기
       수당 [_from] [msg.sender]-= _value; // 발신자의 수당에서 빼기
       totalSupply-= _value; // totalSupply 업데이트
       번 (_from, _value);
       true를 반환;
   }
}

/******************************************/
/ * 고급 토큰 시작 여기 * /
/******************************************/

계약 MyAdvancedToken 소유, TokenERC20 {

   uint256 공개 판매 가격;
   uint256 공개 구매 가격;

   매핑 (주소 => bool) public frozenAccount;

   / * 클라이언트에게 알리는 공개 이벤트를 블록 체인에 생성합니다 * /
   이벤트 FrozenFunds (주소 타겟, bool frozen);

   / * 계약 공급 업체에게 초기 공급 토큰으로 계약을 초기화합니다 * /
   MyAdvancedToken (
       uint256 initialSupply,
       문자열 tokenName,
       문자열 토큰
   ) TokenERC20 (initialSupply, tokenName, tokenSymbol) 공개 {}

   / * 내부 이체,이 계약으로 만 호출 가능 * /
   함수 _transfer (주소 _from, 주소 _to, uint _value) 내부 {
       필요 (_to! = 0x0); // 0x0 주소로의 전송을 금지합니다. 대신 burn ()을 사용하십시오.
       필요 (balanceOf [_from]> = _value); // 발신자가 충분한 지 확인
       필요 (balanceOf [_to] + _value> balanceOf [_to]); // 오버 플로우 확인
       require (! frozenAccount [_from]); // 발신자가 동결되었는지 확인
       require (! frozenAccount [_to]); // 수신자가 동결되었는지 확인
       balanceOf [_from]-= _value; // 발신자에서 빼기
       balanceOf [_to] + = _value; // 수신자에게 동일하게 추가
       전송 (_from, _to, _value);
   }

   /// @notice`mintedAmount` 토큰을 만들어`target`에 보냅니다
   /// @param target 토큰을받을 주소
   /// @param minted받을 토큰의 양
   함수 mintToken (주소 대상, uint256 mintedAmount) 만 소유자 public {
       balanceOf [타겟] + = 민트 금액;
       totalSupply + = 발행량;
       양도 (0, this, mintedAmount);
       양도 (this, target, mintedAmount);
   }

   /// @notice`freeze? 방지 | '대상'토큰 송수신 허용
   /// @param 대상 고정 주소
   /// @param 고정으로 고정 여부
   function freezeAccount (주소 대상, bool freeze) 만 소유자 public {
       frozenAccount [target] = 동결;
       냉동 펀드 (목표, 동결);
   }

   /// @notice 사용자가`newBuyPrice` Pirl에 대한 토큰을 구매하고`newSellPrice` Pirl에 대한 토큰을 판매하도록 허용
   /// @param newSellPrice Price 사용자가 계약에 판매 할 수 있습니다
   /// @param newBuyPrice 가격 사용자는 계약에서 구입할 수 있습니다
   함수 setPrices (uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

   /// @notice Pirl을 전송하여 계약에서 토큰을 구매하십시오.
   함수 buy () 지불 가능 공개 {
       uint 금액 = msg.value / 구매 가격; // 금액을 계산
       _transfer (this, msg.sender, amount); // 전송합니다
   }

   /// @notice 계약 할 '금액'토큰 판매
   /// @param 금액의 판매 할 토큰
   기능 판매 (uint256 금액) 공개 {
       require (this.balance> = amount * sellPrice); // 계약서에 구매할 Pirl이 충분한 지 확인
       _transfer (msg.sender, this, amount); // 전송합니다
       msg.sender.transfer (금액 * sellPrice); // Pirl을 판매자에게 보냅니다. 재귀 공격을 피하려면이 작업을 마지막에 수행하는 것이 중요합니다
   }
}

배포

아래로 스크롤하면 예상 배포 비용이 표시됩니다. 원하는 경우 슬라이더를 변경하여 더 적은 수수료를 설정할 수 있지만 가격이 평균 시장 가격보다 너무 낮은 경우 거래를받는 데 시간이 더 걸릴 수 있습니다. 배치를 클릭하고 비밀번호를 입력하십시오. 몇 초 후에 대시 보드로 리디렉션되고 최신 거래 아래에“계약 작성 중”이라는 줄이 나타납니다. 누군가가 거래를 선택할 때까지 몇 초 정도 기다린 다음 거래를 본 후 확인한 다른 노드 수를 나타내는 느린 파란색 사각형이 표시됩니다. 확인이 많을수록 코드가 배포되었다는 확신이 커집니다.

관리 페이지라는 링크를 클릭하면 세계에서 가장 간단한 중앙 은행 대시 보드로 이동하여 새로 만든 통화로 원하는 작업을 수행 할 수 있습니다.

계약서에서 읽기 아래 왼쪽에는 계약서에서 정보를 무료로 읽는 데 사용할 수있는 모든 옵션과 기능이 있습니다. 토큰에 소유자가있는 경우 여기에 주소가 표시됩니다. 해당 주소를 복사하여 잔액에 붙여 넣으면 계정 잔액이 표시됩니다 (잔액은 토큰이있는 계정 페이지에도 자동으로 표시됨).

오른쪽의 Write to Contract (계약에 쓰기) 아래에 블록 체인을 변경하거나 변경하는 데 사용할 수있는 모든 기능이 표시됩니다. 이들은 가스 비용이 든다. 새 코인을 발행 할 수있는 계약을 생성 한 경우 "민트 토큰"이라는 기능이 있어야합니다. 그것을 선택하십시오.

새 통화가 생성 될 주소를 선택한 다음 금액을 선택하십시오 (소수점을 2로 설정 한 경우 금액 뒤에 2를 0으로 추가하여 정확한 수량을 생성하십시오). 실행에서 소유자로 설정된 계정을 선택하고 Pirl 금액을 0으로 유지 한 다음 실행을 누릅니다.

몇 번의 확인 후에는 새로운 금액을 반영하여 수취인 잔액이 업데이트됩니다. 그러나 수신자 지갑은 자동으로 표시되지 않을 수 있습니다. 사용자 정의 토큰을 인식하려면 지갑이 수동으로 감시 목록에 추가해야합니다. 토큰 주소를 복사하고 (관리자 페이지에서 복사 주소를 누름)이를 수신자에게 보냅니다. 아직 계약 탭으로 이동하지 않은 경우 감시 토큰을 누른 다음 주소를 추가하십시오. 표시되는 이름, 기호 및 소수는 최종 사용자가, 특히 비슷한 (또는 동일한) 이름을 가진 다른 토큰이있는 경우 사용자 지정할 수 있습니다. 기본 아이콘은 변경할 수 없으며 사용자는 토큰을 보내고받을 때 일부 카피 캣 토큰이 아닌 실제 거래를 처리 할 수 있도록주의를 기울여야합니다.

동전 사용

토큰을 배포하면 관찰 된 토큰 목록에 토큰이 추가되고 총 잔액이 계정에 표시됩니다. 토큰을 보내려면 보내기 탭으로 이동하여 토큰이 포함 된 계정을 선택하십시오. 계정에있는 토큰은 Pirl 바로 아래에 표시됩니다. 토큰을 선택한 다음 보내려는 토큰의 양을 입력하십시오.

다른 사람의 토큰을 추가하려면 계약 탭으로 이동하여 토큰보기를 클릭하십시오. 예를 들어, Pirl Vortex 토큰을 관심 목록에 추가하려면 주소 0x0489A975393A1cD0330740040141D702C35180cb를 추가하십시오.

이제 뭐?

Pirl을 사용하여 원하는 것을 나타내는 토큰을 발행하는 방법을 배웠습니다. 그러나 토큰으로 무엇을 할 수 있습니까? 예를 들어 토큰을 사용하여 회사의 주식을 나타내거나 중앙위원회를 사용하여 인플레이션을 제어하기 위해 새 동전을 발행 할시기에 투표 할 수 있습니다. 또한 크라우드 세일을 통해 자금을 모아 사유로 돈을 모을 수도 있습니다. 다음에 무엇을 만들 것인가?

참고 자료 : ethereum.org


뉴스 레터 구독

업데이트를 받고 최고로부터 배우십시오

더 찾아보기

ko_KR한국어
en_USEnglish fr_FRFrançais nl_NLNederlands tr_TRTürkçe es_ESEspañol pt_PTPortuguês ru_RUРусский zh_CN简体中文 hi_INहिन्दी ko_KR한국어