Topic: J'ai créé des token ethereum mais je ne sais pas où ils sont... (Read 434 times)

Token Factory spécifie être en alpha, c'est à dire que leur service est encore en développement. L'outil créée probablement des tokens qui sont reconnus comme compliant ERC20, c'est à dire que le token implémente les noms de fonctions attendus pour un token ERC20, mais cela ne veut pas dire que le contenu des fonctions/méthodes soient correct.

Si tu n'as pas écrit une ligne de code de ces smart-contracts, et que le code que j'ai inspecté plus tôt est intégralement généré par tokenfactory, alors ca veut dire que l'outil pour l'instant ne génére que des tokens inamovibles, sans aucune instruction de transaction dans les méthodes générées.

Pour faire plus clair : ton outil ne sert à rien pour l'instant si ce n'est faire mumuse et générer des tokens dans le vent. L'utilité viendra peut-être plus tard, mais il est clair que ce service en est encore à l'état de R&D.

Je crois que vous me surestimez...
L'aide que vous avez la gentillesse de me fournir est encore plus compliqué que ce qui m'arrive.

Donc si je comprends bien je ne peux rien faire avec tokenfactory qui m'a "fabriqué" les token.

https://tokenfactory.surge.sh/#/token/0x937A931b1291eA111FBaDF5Df172373843CD35Dc

C'est tokenfactory qui a tout fait...mes test d'avant je les oublie car avec mon ethereum wallet qui ne veut pas se sync' et qui plante en mode allègé,c'est la galère.

A quoi sert tockenfactory si on ne peut rien faire avec?

J'ai fait quelques test infructueux avec plus de GAZ ça m'a coûté encore plus et pareil...status = success mais token pas envoyés.
Comme on dit chez nous en Alsace:
Opération réussie mais le patient est mort.

https://etherscan.io/address/0x937a931b1291ea111fbadf5df172373843cd35dc#readContract

on fait quoi avec ça?

   function transfer(address _to, uint256 _value) returns (bool success) {}

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

 function transfer(address _to, uint256 _value) public returns (bool) {
    if (balances[msg.sender] >= _value) {
      balances[msg.sender] -= _value;
      balances[_to] += _value;
      Transfer(msg.sender, _to, _value);
      return true;
    }
    return false;
  }

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

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20

// Based on https://github.com/ConsenSys/Tokens/blob/master/Token_Contracts/contracts/Token.sol
pragma solidity 0.4.11;

contract ERC20TokenInterface {

    /// @return The total amount of tokens
    function totalSupply() constant returns (uint256 supply);

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant public returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) constant public returns (uint256 remaining);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 *  TRST Trustcoin contract, ERC20 compliant (see https://github.com/ethereum/EIPs/issues/20)
 *
 *  Code is based on multiple sources:
 *  https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC20.sol
 *  https://github.com/ConsenSys/Tokens/blob/master/Token_Contracts/contracts/StandardToken.sol
 *  https://github.com/ConsenSys/Tokens/blob/master/Token_Contracts/contracts/HumanStandardToken.sol
 */

pragma solidity 0.4.11;

import './ERC20TokenInterface.sol';

contract GRPToken is ERC20TokenInterface {

  //// Constants ////
  string public constant name = 'GRPToken';
  uint256 public constant decimals = 6;
  string public constant symbol = 'GRP';
  string public constant version = 'GRP1.0';

  // One hundred million coins, each divided to up to 10^decimals units.
  uint256 private constant totalTokens = 100000000 * (10 ** decimals);

  mapping (address => uint256) public balances; // (ERC20)
  // A mapping from an account owner to a map from approved spender to their allowances.
  // (see ERC20 for details about allowances).
  mapping (address => mapping (address => uint256)) public allowed; // (ERC20)

  //// Events ////
  event MigrationInfoSet(string newMigrationInfo);

  // This is to be used when migration to a new contract starts.
  // This string can be used for any authorative information re the migration
  // (e.g. address to use for migration, or URL to explain where to find more info)
  string public migrationInfo = "";

  // The only address that can set migrationContractAddress, a secure multisig.
  address public migrationInfoSetter;

  //// Modifiers ////
  modifier onlyFromMigrationInfoSetter {
    if (msg.sender != migrationInfoSetter) {
      throw;
    }
    _;
  }

  //// Public functions ////
  function GRPToken(address _migrationInfoSetter) {
    if (_migrationInfoSetter == 0) throw;
    migrationInfoSetter = _migrationInfoSetter;
    // Upon creation, all tokens belong to the deployer.
    balances[msg.sender] = totalTokens;
  }

  // See ERC20
  function totalSupply() constant returns (uint256) {
    return totalTokens;
  }

  // See ERC20
  // WARNING: If you call this with the address of a contract, the contract will receive the
  // funds, but will have no idea where they came from. Furthermore, if the contract is
  // not aware of TRST, the tokens will remain locked away in the contract forever.
  // It is always recommended to call instead compareAndApprove() (or approve()) and have the
  // receiving contract withdraw the money using transferFrom().
  function transfer(address _to, uint256 _value) public returns (bool) {
    if (balances[msg.sender] >= _value) {
      balances[msg.sender] -= _value;
      balances[_to] += _value;
      Transfer(msg.sender, _to, _value);
      return true;
    }
    return false;
  }

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

  // See ERC20
  function balanceOf(address _owner) constant public returns (uint256) {
    return balances[_owner];
  }

  // See ERC20
  // NOTE: this method is vulnerable and is placed here only to follow the ERC20 standard.
  // Before using, please take a look at the better compareAndApprove below.
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  // A vulernability of the approve method in the ERC20 standard was identified by
  // Mikhail Vladimirov and Dmitry Khovratovich here:
  // https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM
  // It's better to use this method which is not susceptible to over-withdrawing by the approvee.
  /// @param _spender The address to approve
  /// @param _currentValue The previous value approved, which can be retrieved with allowance(msg.sender, _spender)
  /// @param _newValue The new value to approve, this will replace the _currentValue
  /// @return bool Whether the approval was a success (see ERC20's `approve`)
  function compareAndApprove(address _spender, uint256 _currentValue, uint256 _newValue) public returns(bool) {
    if (allowed[msg.sender][_spender] != _currentValue) {
      return false;
    }
    return approve(_spender, _newValue);
  }

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

  // Allows setting a descriptive string, which will aid any users in migrating their token
  // to a newer version of the contract. This field provides a kind of 'double-layer' of
  // authentication for any migration announcement, as it can only be set by WeTrust.
  /// @param _migrationInfo The information string to be stored on the contract
  function setMigrationInfo(string _migrationInfo) onlyFromMigrationInfoSetter public {
    migrationInfo = _migrationInfo;
    MigrationInfoSet(_migrationInfo);
  }

  // To be used if the migrationInfoSetter wishes to transfer the migrationInfoSetter
  // permission to a new account, e.g. because of change in personnel, a concern that account
  // may have been compromised etc.
  /// @param _newMigrationInfoSetter The address of the new Migration Info Setter
  function changeMigrationInfoSetter(address _newMigrationInfoSetter) onlyFromMigrationInfoSetter public {
    migrationInfoSetter = _newMigrationInfoSetter;
  }
}

Hello !

Alors, je vais reprendre quelques points :

- Tes tokens ils sont créés dans ton contrat normalement. Si tu regardes la structure d'un smart-contract de token ERC20, tu verras qu'il y a normalement une variable de mapping nommé balances qui sert à savoir qui dispose de quels montants de tokens :



Si tu ne connais pas les mappings, je te conseille d'aller voir par là bas : http://solidity.readthedocs.io/en/develop/types.html#mappings

Pour expliquer un peu, imaginons que mon addresse de wallet soit 0x123456789, mon solde de ton token sera stocké dans balances[0x123456789]. Pour connaitre mon solde, il y a une fonction dans le smart-contract ERC20 :


Cette fonction, vu qu'elle renvoie une constante, et donc n'altère pas l'état du smart-contract ( pas de calcul et pas d'écriture, juste de la lecture dans l'EVM ), ne coûte rien. Il faut donc appeler la fonction balanceOf avec mon addresse pour récuperer mon solde de token :


Je te conseille de lire un peu de doc sur le fonctionnement et le principe des tokens ERC20 avant d'approfondir et de te lancer dans la distribution de tokens, ca te permettra de savoir ce que tu fais et être sur de pas semer chaos, désordre et malaria.

Voir ici : https://theethereum.wiki/w/index.php/ERC20_Token_Standard


Ensuite, en ce qui concerne la distribution, si tu as lu un peu les docs que je t'ai fourni ainsi que le code, tu verras qu'il y a des fonctions qui servent à gérer les aspects transactionnels du mapping de variables des balances. Du coup c'est simple, pour faire une distribution il suffit d'appeler ces fonctions.

Exemple, je créer un token avec 10000. Comme je suis un beau gosse je vais t'en filer 2000, toi  dont ton adresse est 0x987654321. Je vais donc appeler la méthode


du smart-contract.

L'EVM traitera la transaction, et mettra à jour la variable mappée : balances[0x987654321] . Vu qu'elle etait à 0 elle passera à 2000. Bim ! Je t'ai distribué des tokens de mon cru !


Après, tu peux automatiser en créant un smart-contract qui appelera le smart-contract ERC20 selon des règles que tu aura codé toi afin de distribuer régulièrement/équitablement/nimportecomment les tokens du contrat.


Enfin quelques pistes pour le développement :

- Pour ce qui est déploiement, compilation et création d'ABI pour tes smart-contracts tu peux regarder du côté de Truffle qui est très bien même si le compilateur est assez cryptique en ce qui concerne les bugs de compilation.  https://github.com/trufflesuite/truffle
- Une alternative est Embark, mais je n'en suis pas très fan personnellement, en dépit d'une console de suivi pas trop mal foutue. https://embark.readthedocs.io/en/2.5.2/

- Pour ce qui est du développement de smart-contracts je te conseille remix IDE qui te permettra de suivre toutes les recommandations, avoir les warnings et de bonnes indications sur les bugs de tes contracts.

Tu peux utiliser l'outil directement en ligne :  https://remix.ethereum.org
ou en installer une instance directement chez toi ou sur un serveur : https://github.com/ethereum/remix


Voilà de quoi démarrer. Courage et hésite pas à me solliciter ou à poser des questions sur http://ethereum.stackexchange.com si tu bloques sur certains points techniques. Dernière petite chose : patience ! L'apprentissage est long, demande pas mal de lecture, mais est clairement passionnant !

EDIT :

quelques outils complémentaires/nécéssaires :

TestRPC/Ganache-CLI pour simuler un réseau ethereum, très utile quand on développe et avant de déployer sur un testnet ou sur main net: https://github.com/trufflesuite/ganache-cli. Si tu veux tester tes smart-contracts sans que ca te coute un rond, à faire tourner absolument ! Les déploiements de contrats sur testnets et main net se font après que tes contrats soient bien développés et testés sur ce simulateur !

la doc Web3, qui sert à l'intéraction offchain-onchain : https://web3js.readthedocs.io/en/latest/

Attention, ces outils sont encore en développement pour la plupart, il faut donc régulièrement regarder les docs, fouiller les repos github. Avoir des connaissances solides en développement et notamment en P.O.O est loin d'être optionnel.

contract TokenContractFragment {
 2  
 3     // Balances for each account
 4     mapping(address => uint256) balances;
 5  
 6     // Owner of account approves the transfer of an amount to another account
 7     mapping(address => mapping (address => uint256)) allowed;
 8  
 9     // Get the token balance for account `tokenOwner`
10     function balanceOf(address tokenOwner) public constant returns (uint balance) {
11         return balances[tokenOwner];
12     }
13  
14     // Transfer the balance from owner's account to another account
15     function transfer(address to, uint tokens) public returns (bool success) {
16         balances[msg.sender] = balances[msg.sender].sub(tokens);
17         balances[to] = balances[to].add(tokens);
18         Transfer(msg.sender, to, tokens);
19         return true;
20     }
21  
22     // Send `tokens` amount of tokens from address `from` to address `to`
23     // The transferFrom method is used for a withdraw workflow, allowing contracts to send
24     // tokens on your behalf, for example to "deposit" to a contract address and/or to charge
25     // fees in sub-currencies; the command should fail unless the _from account has
26     // deliberately authorized the sender of the message via some mechanism; we propose
27     // these standardized APIs for approval:
28     function transferFrom(address from, address to, uint tokens) public returns (bool success) {
29         balances[from] = balances[from].sub(tokens);
30         allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
31         balances[to] = balances[to].add(tokens);
32         Transfer(from, to, tokens);
33         return true;
34     }
35  
36     // Allow `spender` to withdraw from your account, multiple times, up to the `tokens` amount.
37     // If this function is called again it overwrites the current allowance with _value.
38     function approve(address spender, uint tokens) public returns (bool success) {
39         allowed[msg.sender][spender] = tokens;
40         Approval(msg.sender, spender, tokens);
41         return true;
42     }
43 }

10     function balanceOf(address tokenOwner) public constant returns (uint balance) {
11         return balances[tokenOwner];
12     }

transfer(0x987654321,2000)

Je ne comprends pas pourquoi tu recherches un volontaire tu te crée un nouveau compte mew et tu fais tes tests.Sinon tu peut aussi te servir de Minereum pour créer des contrats sur la blockchain eth.Je ne connais plus le prix il n'y a pas longtemps c'était 50 mne.

Contract 0x937a931b1291ea111fbadf5df172373843cd35dc 
  ERC-20 Token Transfer Failed to complete, check with sender for more information.

Tout est relatif:
Sur EMS j'ai -0 +9
Comme quoi on est pas prophète en son pays (lol)

je cherche un volontaire:
Quelqu'un qui m'envoie une address Ethereum spécialement crée pour du WINSPIRAL (WSPRL)
Je lui offrirai des token pour faire mes tests.

C'est quoi l'objectif de ton token à part se faire du fric ?