Ist es auf Ethereum möglich, auf diese Weise einen Token zu erstellen?

a) Ich sollte in der Lage sein, den Token bequem ohne viel Programmieraufwand zu erstellen

Sie können versuchen, den Quellcode aus dem MiniMe-Token-Vertrag , meinem TestERC20Token oder einem der wichtigsten Token mit einem Issue Supported-ERC20-Tokens zu verwenden, der von der dezentralen Börse https://cryptoderivatives.market/ unterstützt wird.

Führen Sie für die einfachste Bereitstellung Ethereum Wallet aus, wählen Sie die Registerkarte Contracts aus, klicken Sie auf Deploy New Contract , fügen Sie Ihren Quellcode in das Feld Solidity Contract Source Code ein, klicken Sie auf Deploy und bestätigen Sie die Transaktion mit Ihrem Passwort.

Suchen Sie dann im Idealfall den neu bereitgestellten Vertrag mithilfe von https://etherscan.io/ und überprüfen Sie den bereitgestellten Bytecode im Quellcode – siehe Problem beim Überprüfen des Quellcodes auf Etherscan für die Schritte dazu.

Hier ist ein einfaches Token mit den + 10 Adressen des Eigentümers, die vorab zugewiesen wurden:

pragma solidity ^0.4.8;

// ----------------------------------------------------------------------------------------------
// Basic ERC20 Token Contract. Don't use for any high value contracts without a lot more
// security testing
//
// Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
// ----------------------------------------------------------------------------------------------

// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {

    // Get the total token supply
    function totalSupply() constant returns (uint256 totalSupply);

    // Get the account balance of another account with address _owner
    function balanceOf(address _owner) constant returns (uint256 balance);

    // Send _value amount of tokens to address _to
    function transfer(address _to, uint256 _value) returns (bool success);

    // Send _value amount of tokens from address _from to address _to
    // The transferFrom method is used for a withdraw workflow, allowing contracts to send
    // tokens on your behalf, for example to "deposit" to a contract address and/or to charge
    // fees in sub-currencies; the command should fail unless the _from account has
    // deliberately authorized the sender of the message via some mechanism; we propose
    // these standardized APIs for approval:
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);

    // Allow _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) returns (bool success);

    // Returns the amount which _spender is still allowed to withdraw from _owner
    function allowance(address _owner, address _spender) constant returns (uint256 remaining);

    // Triggered when tokens are transferred.
    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    // Triggered whenever approve(address _spender, uint256 _value) is called.
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract BokkyPooBahTestToken is ERC20Interface {

    string public name;
    string public symbol;
    uint8 public decimals;

    // Owner of this contract
    address public owner;

    // Balances for each account
    mapping(address => uint256) balances;

    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;

    // Total supply
    uint256 _totalSupply;

    // Functions with this modifier can only be executed by the owner
    modifier onlyOwner() {
        if (msg.sender != owner) {
            throw;
        }
        _;
    }

    // Constructor
    function BokkyPooBahTestToken() {
        owner = msg.sender;
        name = "BokkyPooBahTest";
        symbol = "BPBT☺";
        decimals = 18;
        // 1 million with 18 decimal places
        _totalSupply = 1000000000000000000000000;
        balances[owner] = _totalSupply * 50 / 100;
        balances[0x00001009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00011009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00021009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00031009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00041009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00051009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00061009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00071009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00081009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
        balances[0x00091009bd8f0b1301cc5edc28ed1222a3ce671e] = _totalSupply * 5 / 100;
    }

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

    // What is the balance of a particular account?
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    // Transfer the balance from owner's account to another account
    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount && _amount > 0) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
           return false;
        }
    }

    // Send _value amount of tokens from address _from to address _to
    // The transferFrom method is used for a withdraw workflow, allowing contracts to send
    // tokens on your behalf, for example to "deposit" to a contract address and/or to charge
    // fees in sub-currencies; the command should fail unless the _from account has
    // deliberately authorized the sender of the message via some mechanism; we propose
    // these standardized APIs for approval:
    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) returns (bool success) {

        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0) {

            balances[_to] += _amount;
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    // Allow _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 _amount) returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

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

    // Don't want any ethers leaking into this contract
    function () {
        throw;
    }
}

b) Ich sollte in der Lage sein, den Token an einer dezentralen Börse zu listen

Sie können jeden ERC20-konformen Token auf https://cryptoderivatives.market/ auflisten . Lesen Sie die Handbücher (ich bin dabei, es zu schreiben), wie das geht.

c) Ich sollte in der Lage sein, den Token auf einmal an eine Liste von 100 Ethereum-Adressen zu verteilen, ohne mehr als etwa 0,01 USD an Transaktionsgebühren zu zahlen

Wenn Sie Ihren Token-Vertrag bereitstellen, können Sie den totalSupplyauf Ihren Gesamtvorrat setzen und ihn Ihrem Eigentümerkonto zuweisen – ein Beispiel finden Sie unter 0x2c875e5ea4706b1978a41b59edf2d3af31d60e70

// Constructor
function IncentCoffeeToken() {
    _totalSupply = 824;
    owner = msg.sender;
    balances[owner] = _totalSupply;
}

Es kostet ungefähr 0,01 USD, Token an jede Ethereum-Adresse zu verteilen, zum Beispiel Tx 0x404f03c9... kostet 0,00112580763312 Ether (0,01 USD).

Es gibt Möglichkeiten, die anfängliche Token-Verteilung in großen Mengen hochzuladen, aber es wird kompliziert. Ein Beispiel finden Sie unter The DAO ExtraBalance-Rückerstattungsvertrag von @ledgerwatch – suchen Sie nach ExtraBalToken-Vertrag in Wie bekomme ich eine Rückerstattung für den Betrag, den ich über 1 Ether bis 100 The DAO-Tokens bezahlt habe, wo er die fill(...)und seal(...)Funktionen hinzugefügt hat:

bool public sealed;
// The 160 LSB is the address of the balance
// The 96 MSB is the balance of that address.
function fill(uint[] data) {
    if ((msg.sender != owner)||(sealed))
        throw;

    for (uint i=0; i<data.length; i++) {
        address a = address( data[i] & (D160-1) );
        uint amount = data[i] / D160;
        if (balanceOf[a] == 0) {   // In case it's filled two times, it only increments once
            balanceOf[a] = amount;
            totalSupply += amount;
        }
    }
}

function seal() {
    if ((msg.sender != owner)||(sealed))
        throw;    
    sealed= true;
}  

Die Idee dabei ist, dass Sie den Vertrag bereitstellen und dann fill(...)mit einem Array von uint256Daten aufrufen, wobei die 160 niederwertigsten Bits die Adresse des Saldos und die 96 höchstwertigen Bits der Saldo dieser Adresse sind.