Vai al contenuto principale
Change page

Standard dei Token ERC-20

Ultimo aggiornamento della pagina: 26 febbraio 2026

ilradoi (opens in a new tab)
Herbie_23H (opens in a new tab)
pete-vielhaberp (opens in a new tab)
+21

Introduzione

Cos'è un Token?

I token possono rappresentare virtualmente qualsiasi cosa in Ethereum:

  • punti reputazione in una piattaforma online
  • abilità di un personaggio in un gioco
  • attività finanziarie come un'azione in una società
  • una valuta fiat come l'USD
  • un'oncia d'oro
  • e molto altro...

Una funzionalità così potente di Ethereum deve essere gestita da uno standard robusto, giusto? È esattamente qui che l'ERC-20 entra in gioco! Questo standard consente agli sviluppatori di creare applicazioni di token interoperabili con altri prodotti e servizi. Lo standard ERC-20 è utilizzato anche per fornire funzionalità aggiuntive all'.

Cos'è l'ERC-20?

L'ERC-20 introduce uno standard per i Token Fungibili, in altre parole, hanno una proprietà che rende ogni Token esattamente uguale (per tipo e valore) a un altro Token. Ad esempio, un Token ERC-20 agisce proprio come l'ETH, il che significa che 1 Token è e sarà sempre uguale a tutti gli altri Token.

Prerequisiti

Corpo

L'ERC-20 (Ethereum Request for Comments 20), proposto da Fabian Vogelsteller nel novembre 2015, è uno Standard dei Token che implementa un'API per i token all'interno dei contratti intelligenti.

Esempi di funzionalità fornite dall'ERC-20:

  • trasferire token da un account a un altro
  • ottenere il saldo attuale dei token di un account
  • ottenere l'offerta totale del token disponibile sulla rete
  • approvare se una quantità di token di un account può essere spesa da un account di terze parti

Se un contratto intelligente implementa i seguenti metodi ed eventi, può essere definito un Contratto di Token ERC-20 e, una volta distribuito, sarà responsabile di tenere traccia dei token creati su Ethereum.

Da EIP-20 (opens in a new tab):

Metodi

1function name() public view returns (string)
2function symbol() public view returns (string)
3function decimals() public view returns (uint8)
4function totalSupply() public view returns (uint256)
5function balanceOf(address _owner) public view returns (uint256 balance)
6function transfer(address _to, uint256 _value) public returns (bool success)
7function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
8function approve(address _spender, uint256 _value) public returns (bool success)
9function allowance(address _owner, address _spender) public view returns (uint256 remaining)
Mostra tutto

Eventi

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

Esempi

Vediamo come uno Standard sia così importante per semplificarci l'ispezione di qualsiasi Contratto di Token ERC-20 su Ethereum. Abbiamo solo bisogno dell'Application Binary Interface (ABI) del contratto per creare un'interfaccia per qualsiasi Token ERC-20. Come puoi vedere di seguito, utilizzeremo un'ABI semplificata, per renderlo un esempio a basso attrito.

Esempio con Web3.py

Innanzitutto, assicurati di aver installato la libreria Python Web3.py (opens in a new tab):

1pip install web3
1from web3 import Web3
2
3
4w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
5
6dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" # DAI
7weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" # Wrapped ether (WETH)
8
9acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11" # Uniswap V2: DAI 2
10
11# Questa è una Contract Application Binary Interface (ABI) semplificata di un contratto token ERC-20.
12# Esporrà solo i metodi: balanceOf(address), decimals(), symbol() e totalSupply()
13simplified_abi = [
14    {
15        'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}],
16        'name': 'balanceOf',
17        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
18        'stateMutability': 'view', 'type': 'function', 'constant': True
19    },
20    {
21        'inputs': [],
22        'name': 'decimals',
23        'outputs': [{'internalType': 'uint8', 'name': '', 'type': 'uint8'}],
24        'stateMutability': 'view', 'type': 'function', 'constant': True
25    },
26    {
27        'inputs': [],
28        'name': 'symbol',
29        'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
30        'stateMutability': 'view', 'type': 'function', 'constant': True
31    },
32    {
33        'inputs': [],
34        'name': 'totalSupply',
35        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
36        'stateMutability': 'view', 'type': 'function', 'constant': True
37    }
38]
39
40dai_contract = w3.eth.contract(address=w3.to_checksum_address(dai_token_addr), abi=simplified_abi)
41symbol = dai_contract.functions.symbol().call()
42decimals = dai_contract.functions.decimals().call()
43totalSupply = dai_contract.functions.totalSupply().call() / 10**decimals
44addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decimals
45
46# DAI
47print("===== %s =====" % symbol)
48print("Total Supply:", totalSupply)
49print("Addr Balance:", addr_balance)
50
51weth_contract = w3.eth.contract(address=w3.to_checksum_address(weth_token_addr), abi=simplified_abi)
52symbol = weth_contract.functions.symbol().call()
53decimals = weth_contract.functions.decimals().call()
54totalSupply = weth_contract.functions.totalSupply().call() / 10**decimals
55addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decimals
56
57# WETH
58print("===== %s =====" % symbol)
59print("Total Supply:", totalSupply)
60print("Addr Balance:", addr_balance)
Mostra tutto

Problemi noti

Problema di ricezione dei token ERC-20

Al 20/06/2024, almeno 83.656.418 $ in token ERC-20 sono stati persi a causa di questo problema. Nota che un'implementazione ERC-20 pura è soggetta a questo problema a meno che non si implementi una serie di restrizioni aggiuntive oltre allo standard, come elencato di seguito.

Quando i token ERC-20 vengono inviati a un contratto intelligente che non è progettato per gestire i token ERC-20, tali token possono andare persi in modo permanente. Questo accade perché il contratto ricevente non ha la funzionalità per riconoscere o rispondere ai token in arrivo e non c'è alcun meccanismo nello standard ERC-20 per notificare al contratto ricevente i token in arrivo. I modi principali in cui questo problema prende forma sono attraverso:

  1. Meccanismo di trasferimento dei token
  • I token ERC-20 vengono trasferiti utilizzando le funzioni transfer o transferFrom
    • Quando un utente invia token all'indirizzo del contratto utilizzando queste funzioni, i token vengono trasferiti indipendentemente dal fatto che il contratto ricevente sia progettato per gestirli
  1. Mancanza di notifica
    • Il contratto ricevente non riceve una notifica o un callback che i token gli sono stati inviati
    • Se il contratto ricevente non ha un meccanismo per gestire i token (ad es., una funzione di fallback o una funzione dedicata per gestire la ricezione dei token), i token rimangono effettivamente bloccati nell'indirizzo del contratto
  2. Nessuna gestione integrata
    • Lo standard ERC-20 non include una funzione obbligatoria da implementare per i contratti riceventi, portando a una situazione in cui molti contratti non sono in grado di gestire correttamente i token in arrivo

Possibili Soluzioni

Sebbene non sia possibile prevenire completamente questo problema con l'ERC-20, esistono metodi che consentirebbero di ridurre significativamente la possibilità di perdita di token per l'utente finale:

  • Il problema più comune si verifica quando un utente invia token all'indirizzo del contratto del token stesso (ad es., USDT depositati all'indirizzo del contratto del token USDT). Si consiglia di limitare la funzione transfer(..) per annullare tali tentativi di trasferimento. Considera l'aggiunta del controllo require(_to != address(this)); all'interno dell'implementazione della funzione transfer(..).
  • La funzione transfer(..) in generale non è progettata per depositare token nei contratti. Il pattern approve(..) & transferFrom(..) viene invece utilizzato per depositare token ERC-20 nei contratti. È possibile limitare la funzione di trasferimento per impedire il deposito di token in qualsiasi contratto con essa, tuttavia ciò potrebbe interrompere la compatibilità con i contratti che presumono che i token possano essere depositati nei contratti con la funzione transfer(..) (ad es., le pool di liquidità di Uniswap).
  • Presumi sempre che i token ERC-20 possano finire nel tuo contratto anche se il tuo contratto non dovrebbe mai riceverne. Non c'è modo di prevenire o rifiutare depositi accidentali da parte del destinatario. Si consiglia di implementare una funzione che consenta di estrarre i token ERC-20 depositati accidentalmente.
  • Considera l'utilizzo di standard dei token alternativi.

Da questo problema sono emersi alcuni standard alternativi come l'ERC-223 o l'ERC-1363.

Letture consigliate

Altri standard di token fungibili

Tutorial: Sviluppare con l'ERC-20 su Ethereum

Questo articolo è stato utile?