Quote from: Asone on January 05, 2018, 11:00:39 AM

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 :

Quote

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 }

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 :

Quote

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

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

Quote

transfer(0x987654321,2000)

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.

Très bien expliqué, il est clair qu'il doit avoir une bonne base de programmation sinon il pourra coder un contrat vulnérable.