Che cos’è un token Ethereum e che cosa sono gli SMART CONTRACT ?

Quando qualcuno vuole svolgere un compito particolare in Ethereum, avvia un contratto intelligente con una o più persone.

Per un principiante, l’intero concetto di token Ethereum ed Ethereum potrebbe creare un po’ di confusione, perchè
Ethereum non ha solo la sua valuta (Ether) ma ha anche dei token che possono agire da soli come valuta, sfruttando la blockchain ethereum. Facciamo allora un po’ di chiarezza e cominciamo dalle basi.

MA COSA E’ ETHEREUM

L’intera rete Ethereum è un gigantesco groviglio di nodi (computer) collegati uno all’ altro, secondo una logica di sistemi distribuiti, dove l’intera rete può essere visualizzata come una singola entità chiamata ” Ethereum Virtual Machine ” o EVM.

Tutte le transazioni che si verificheranno in questa rete vengono automaticamente aggiornate e registrate in un registro aperto e distribuito, chiamato Blockchain e consultabile in qualsiasi momento.

CONTRATTI INTELLIGENTI

I contratti intelligenti sono scripting eseguiti sulla rete di Ethereum, che svolgono azioni in base a determinate condizioni, in questo senso possiamo dire che quando qualcuno vuole svolgere un compito particolare in Ethereum, avvia un contratto intelligente che coinvolge una o piu’ ” attori “.

Questi contratti sono una serie di istruzioni, scritte usando il linguaggio di programmazione proprietario, chiamato ” Solidity “, che funziona sfruttando la seguente logica: se la prima serie di istruzioni viene eseguita, esegui la funzione successiva e successivamente quella successiva e continua a ripetere fino a raggiungere la fine del contratto.

Chiaro che se la funziona venisse eseguita con un errore piu’ o meno volontario il danno sarebbe davvero importante ed .. irreversibile.

Per capire questo concetto immagina un distributore automatico. Ogni passo che fai agisce come un innesco per eseguire il prossimo passaggio e completare tutta la routine. È un po ‘come l’effetto domino.

Quindi, quali sono i passaggi intrapresi durante l’interazione con il distributore automatico:

.1: dai soldi al distributore.

.2: premi il pulsante corrispondente all’elemento che desideri.

.3: L’oggetto viene fuori e tu lo raccogli.

Che cosa è che è evidente ? semplice ! nessuno dei passaggi sarà funzionante ed operativo se il precedente non viene correttamente eseguito.

Inoltre come puoi facilmente osservare da questo esempio, non ci sono parti terze coinvolte. Ma ci sei solo tu e la macchina.

Come sarebbe stata questa transazione se fosse avvenuta nella rete Ethereum ?

Per capire meglio supponiamo che tu abbia acquistato qualcosa dal distributore e lo abbia fatto utilizzando la rete Ethereum, ecco quali sarebbero i passaggi:

.1: faccio una Tx ed invio denaro al distributore automatico. Questa procedura viene registrata da tutti i nodi della rete Ethereum e tale transazione viene aggiornata nel libro mastro.

.2: premi il pulsante corrispondente all’elemento desiderato e tale azione viene registrata nella rete e nel libro mastro di Ethereum.

.3: L’oggetto viene fuori e tu lo raccogli e questo viene registrato da tutti i nodi della rete e dal libro mastro ( Blockchain ).

Ogni transazione effettuata tramite i contratti intelligenti viene registrata e aggiornata nella rete. In questo modo tutte le persone ( i nodi ) sono coinvolte nella buona riuscita e registrazione del contratto.

Ogni azioni è VISIBILE dall’intera rete.

Ether

Ogni singolo passaggio, ed esecuzione di un un contratto intelligente, richiede il pagamento di un costo di una transazione che ha un valore misurato in “gas “.

In sostanza ogni volta che utilizziamo la EVM ci viene richiesto di pagare una piccola quantità di Ether, chiamata ” gas “. Quando le persone parlano di speculazione su ETH, in realtà ( dovrebbero sapere che … ) stanno parlando del valore dell’ Ether nella Blockchain proprietaria.

Ogni volta che viene eseguito uno scrypt di solidity, viene richiesto una certa quantità specifica di ” gas “, che ha comunque un limite finito e che va a garantire l’esecuzione di un pezzo di codice.

Perchè la rete stà in piedi … ? semplice perchè le persone ( nodi ) ricevono denaro per permetterci di eseguire i nostri script ed in questo senso sono incentivate a raccogliere Ether dall’esecuzione degli SC .

Ma Cosa succederebbe se l’offerta di Ether si esaurisse nel bel mezzo dell’esecuzione del contratto?

Tutte le transazioni che hanno già avuto luogo durante l’esecuzione del contratto torneranno allo stato originale ed il tuo portafoglio in Ether ritornerà alle condizioni di origine, poiché tutte le transazioni effettuate nella blockchain sono irreversibili.

CONTRATTO: ethereum-ico-contract/contracts/Sale.sol

pragma solidity ^0.4.21;
/*
BASIC ERC20 Sale Contract
Create this Sale contract first!
Sale(address ethwallet) // this will send the received ETH funds to this address
@author Hunter Long
@repo https://github.com/hunterlong/ethereum-ico-contract
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
function mintToken(address to, uint256 value) returns (uint256);
function changeTransfer(bool allowed);
}
contract Sale {
uint256 public maxMintable;
uint256 public totalMinted;
uint public endBlock;
uint public startBlock;
uint public exchangeRate;
bool public isFunding;
ERC20 public Token;
address public ETHWallet;
uint256 public heldTotal;
bool private configSet;
address public creator;
mapping (address => uint256) public heldTokens;
mapping (address => uint) public heldTimeline;
event Contribution(address from, uint256 amount);
event ReleaseTokens(address from, uint256 amount);
function Sale(address _wallet) {
startBlock = block.number;
maxMintable = 4000000000000000000000000; // 3 million max sellable (18 decimals)
ETHWallet = _wallet;
isFunding = true;
creator = msg.sender;
createHeldCoins();
exchangeRate = 600;
}
// setup function to be ran only 1 time
// setup token address
// setup end Block number
function setup(address token_address, uint end_block) {
require(!configSet);
Token = ERC20(token_address);
endBlock = end_block;
configSet = true;
}
function closeSale() external {
require(msg.sender==creator);
isFunding = false;
}
function () payable {
require(msg.value>0);
require(isFunding);
require(block.number <= endBlock);
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += total;
ETHWallet.transfer(msg.value);
Token.mintToken(msg.sender, amount);
Contribution(msg.sender, amount);
}
// CONTRIBUTE FUNCTION
// converts ETH to TOKEN and sends new TOKEN to the sender
function contribute() external payable {
require(msg.value>0);
require(isFunding);
require(block.number <= endBlock);
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += total;
ETHWallet.transfer(msg.value);
Token.mintToken(msg.sender, amount);
Contribution(msg.sender, amount);
}
// update the ETH/COIN rate
function updateRate(uint256 rate) external {
require(msg.sender==creator);
require(isFunding);
exchangeRate = rate;
}
// change creator address
function changeCreator(address _creator) external {
require(msg.sender==creator);
creator = _creator;
}
// change transfer status for ERC20 token
function changeTransferStats(bool _allowed) external {
require(msg.sender==creator);
Token.changeTransfer(_allowed);
}
// internal function that allocates a specific amount of TOKENS at a specific block number.
// only ran 1 time on initialization
function createHeldCoins() internal {
// TOTAL SUPPLY = 5,000,000
createHoldToken(msg.sender, 1000);
createHoldToken(0x4f70Dc5Da5aCf5e71905c3a8473a6D8a7E7Ba4c5, 100000000000000000000000);
createHoldToken(0x393c82c7Ae55B48775f4eCcd2523450d291f2418, 100000000000000000000000);
}
// public function to get the amount of tokens held for an address
function getHeldCoin(address _address) public constant returns (uint256) {
return heldTokens[_address];
}
// function to create held tokens for developer
function createHoldToken(address _to, uint256 amount) internal {
heldTokens[_to] = amount;
heldTimeline[_to] = block.number + 0;
heldTotal += amount;
totalMinted += heldTotal;
}
// function to release held tokens for developers
function releaseHeldCoins() external {
uint256 held = heldTokens[msg.sender];
uint heldBlock = heldTimeline[msg.sender];
require(!isFunding);
require(held >= 0);
require(block.number >= heldBlock);
heldTokens[msg.sender] = 0;
heldTimeline[msg.sender] = 0;
Token.mintToken(msg.sender, held);
ReleaseTokens(msg.sender, held);
}
}

RECENTEMENTE, abbiamo avuto modo di organizzare un WORKSHOP sull’argomento presso i nostri uffici di verona. Sono stati 3 intense giornate gratuite che abbiamo fatto con un consulente esperto dell’argomento.

Stay Tuned.

Condividi l'articolo con:

Andrea Belvedere

Ricercatore e consulente indipendente, crypto attivista.

Andrea Belvedere