So begrenzen Sie das Gesamtangebot für einen ICO-Vertrag

Ich versuche, einen Test-ICO-Vertrag zu erstellen (einfach um etwas über Blockchain usw. zu lernen). Ich habe ein Tutorial befolgt und den folgenden Vertrag erstellt. Die Gesamtzahl der an den Absender gelieferten Token scheint jedoch unbegrenzt zu sein. Wie stelle ich es ein, dass gelieferte Token vom Gesamtvorrat abgezogen werden?

pragma solidity ^0.4.11;

import './IERC20.sol';
import './SafeMath.sol';

contract testy2 is IERC20 {

using SafeMath for uint256;

uint public _totalSupply = 1000000000000000000000000;

string public constant symbol = "TSTY2";
string public constant name = "testy2";
uint8 public constant decimals = 18;

// 1 ether = 250000 TSTY2
uint256 public constant RATE = 250000000000000000000000;

address public owner;

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

function() payable {
    createTokens();
}

function testy2() {
    owner = msg.sender;
    balances[msg.sender] = 500000000000000000000000;
}

function createTokens() payable {
    require(msg.value > 0);

    uint256 tokens = msg.value.mul(RATE);
    balances[msg.sender] = balances[msg.sender].add(tokens);
   _totalSupply = _totalSupply.add(tokens);

    owner.transfer(msg.value);
}

function totalSupply() constant returns (uint256 totalSupply) {
    return _totalSupply;
}

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

function transfer(address _to, uint256 _value) returns (bool success) {
    require(
        balances[msg.sender] >= _value
        && _value > 0
    );
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
}

function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
    require(
        allowed[_from][msg.sender] >= _value
        && balances[_from] >= _value
        && _value > 0
    );
    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
}

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];
}

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

Antworten (1)

Erstellen Sie zunächst einen Token mit einer Erstausstattung. Ordnen Sie dann die Erstversorgung der Gesamtversorgung zu.

pragma solidity ^0.4.18;


import "./StandardToken.sol";


/**
* @title SimpleToken
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/
contract SamyToken is StandardToken {

    string public constant name = "SAMY";
    string public constant symbol = "SMY";
    uint8 public constant decimals = 18;
    uint256 public constant initialSupply = 100000000 * (10 ** uint256(decimals));
    uint256 totalSupply_;

  /**
  * @dev Constructor that gives msg.sender all of existing tokens.
  */
  function SamyToken() public {
      totalSupply_ = initialSupply;
      balances[msg.sender] = initialSupply;
      Transfer(0x0, msg.sender, initialSupply);
  }
  /**
  * @dev total number of tokens in existence
  */
  function totalSupply() public view returns (uint256) {
      return totalSupply_;
  }
}

Das Gesamtangebot wird sich nie ändern oder sollte sich nicht ändern, es sei denn, Sie erstellen einen Mintable-Token, in diesem Fall kann ich Ihnen nicht helfen. Aber wenn Sie zeplin solidity googeln, wird ihr Github Sie auf den richtigen Weg bringen.

BEARBEITEN:

Fügen Sie dies Ihrem bestehenden Vertrag hinzu.

uint256 _currentSupply = 0;

Fügen Sie dann in Ihrer "mint" -Funktion hinzu:

require(_currentSupply.add(tokens) < _totalSupply);
_currentSupply = _currentSupply.add(tokens);
Danke Dorian - ich werde mich durch die Zeppelin-Verträge wühlen. Gibt es in der Zwischenzeit einen einfachen Code, den ich meinem obigen Vertrag hinzufügen kann, um die Anzahl der Token zu begrenzen, die erstellt werden können?
Ich habe eine Antwort hinzugefügt. Sie müssen eine aktuelle Versorgung verwenden, anstatt zur Gesamtversorgung hinzuzufügen. Das Gesamtangebot könnte der Gesamtbetrag sein, der jemals ausgegeben werden durfte, während das aktuelle Angebot die aktuelle Menge der ausgegebenen Token wäre. ich hoffe das hilft
@SDH Achten Sie darauf, totalSupply auf eine Konstante einzustellen!
So begrenzen Sie das Gesamtangebot für einen ICO-Vertrag
AntwortenHierDatenschutz-Bestimmungen1y, 0v