Standard dei Token Pagabili ERC-1363

Introduzione

Cos'è l'ERC-1363?

L'ERC-1363 è un'interfaccia di estensione per i token ERC-20 che supporta l'esecuzione di logica personalizzata su un contratto ricevente dopo i trasferimenti, o su un contratto di spesa dopo le approvazioni, tutto all'interno di una singola transazione.

Differenze rispetto all'ERC-20

Le operazioni standard dell'ERC-20 come transfer, transferFrom e approve, non consentono l'esecuzione di codice sul contratto ricevente o di spesa senza una transazione separata. Ciò introduce complessità nello sviluppo dell'interfaccia utente (UI) e attrito nell'adozione, poiché gli utenti devono attendere l'esecuzione della prima transazione per poi inviare la seconda. Devono inoltre pagare il gas due volte.

L'ERC-1363 rende i token fungibili capaci di eseguire azioni più facilmente e di funzionare senza l'uso di alcun listener fuori catena. Consente di effettuare una callback su un contratto ricevente o di spesa, dopo un trasferimento o un'approvazione, in una singola transazione.

Prerequisiti

Per comprendere meglio questa pagina, ti consigliamo di leggere prima:

Corpo

L'ERC-1363 introduce un'API standard per i token ERC-20 per interagire con i contratti intelligenti dopo transfer, transferFrom o approve.

Questo standard fornisce funzionalità di base per trasferire token, oltre a consentire l'approvazione dei token in modo che possano essere spesi da un'altra terza parte on-chain, per poi effettuare una callback sul contratto ricevente o di spesa.

Ci sono molti usi proposti per i contratti intelligenti che possono accettare callback ERC-20.

Alcuni esempi potrebbero essere:

Crowdsale: i token inviati innescano l'allocazione istantanea delle ricompense.
Servizi: il pagamento attiva l'accesso al servizio in un solo passaggio.
Fatture: i token saldano le fatture automaticamente.
Abbonamenti: l'approvazione della tariffa annuale attiva l'abbonamento con il pagamento del primo mese.

Per questi motivi è stato originariamente chiamato "Token Pagabile".

Il comportamento della callback espande ulteriormente la sua utilità, consentendo interazioni fluide come:

Staking: i token trasferiti innescano il blocco automatico in un contratto di staking.
Votazione: i token ricevuti registrano i voti in un sistema di governance.
Scambio: le approvazioni dei token attivano la logica di scambio in un singolo passaggio.

I token ERC-1363 possono essere utilizzati per utilità specifiche in tutti i casi che richiedono l'esecuzione di una callback dopo un trasferimento o un'approvazione ricevuta. L'ERC-1363 è utile anche per evitare la perdita o il blocco dei token nei contratti intelligenti verificando la capacità del destinatario di gestire i token.

A differenza di altre proposte di estensione dell'ERC-20, l'ERC-1363 non sovrascrive i metodi transfer e transferFrom dell'ERC-20 e definisce gli ID delle interfacce da implementare mantenendo la retrocompatibilità con l'ERC-20.

Dall'EIP-1363 (opens in a new tab):

Metodi

I contratti intelligenti che implementano lo standard ERC-1363 DEVONO implementare tutte le funzioni nell'interfaccia ERC1363, così come le interfacce ERC20 e ERC165.

1pragma solidity ^0.8.0;
2
3/* *
4 * @title ERC1363
5 * @dev Un'interfaccia di estensione per i token ERC-20 che supporta l'esecuzione di codice su un contratto destinatario
6 * dopo `transfer` o `transferFrom`, o di codice su un contratto spenditore dopo `approve`, in una singola transazione. */
7
8
9
10
11
12interface ERC1363 is ERC20, ERC165 {
13  /* * NOTE: l'identificatore ERC-165 per questa interfaccia è 0xb0202a11.
14   * 0xb0202a11 ===
15   *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
16   *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
17   *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
18   *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
19   *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
20   *   bytes4(keccak256('approveAndCall(address,uint256,bytes)')) */
21  
22
23
24
25
26
27
28
29
30
31
32  /* *
33   * @dev Sposta una quantità `value` di token dall'account del chiamante a `to`
34   * e poi chiama `ERC1363Receiver::onTransferReceived` su `to`.
35   * @param to L'indirizzo a cui vengono trasferiti i token.
36   * @param value La quantità di token da trasferire.
37   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
38  
39
40
41
42
43
44
45  function transferAndCall(address to, uint256 value) external returns (bool);
46
47  /* *
48   * @dev Sposta una quantità `value` di token dall'account del chiamante a `to`
49   * e poi chiama `ERC1363Receiver::onTransferReceived` su `to`.
50   * @param to L'indirizzo a cui vengono trasferiti i token.
51   * @param value La quantità di token da trasferire.
52   * @param data Dati aggiuntivi senza formato specificato, inviati nella chiamata a `to`.
53   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
54  
55
56
57
58
59
60
61
62  function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
63
64  /* *
65   * @dev Sposta una quantità `value` di token da `from` a `to` utilizzando il meccanismo di allowance
66   * e poi chiama `ERC1363Receiver::onTransferReceived` su `to`.
67   * @param from L'indirizzo da cui inviare i token.
68   * @param to L'indirizzo a cui vengono trasferiti i token.
69   * @param value La quantità di token da trasferire.
70   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
71  
72
73
74
75
76
77
78
79  function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
80
81  /* *
82   * @dev Sposta una quantità `value` di token da `from` a `to` utilizzando il meccanismo di allowance
83   * e poi chiama `ERC1363Receiver::onTransferReceived` su `to`.
84   * @param from L'indirizzo da cui inviare i token.
85   * @param to L'indirizzo a cui vengono trasferiti i token.
86   * @param value La quantità di token da trasferire.
87   * @param data Dati aggiuntivi senza formato specificato, inviati nella chiamata a `to`.
88   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
89  
90
91
92
93
94
95
96
97
98  function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
99
100  /* *
101   * @dev Imposta una quantità `value` di token come allowance di `spender` sui token del chiamante
102   * e poi chiama `ERC1363Spender::onApprovalReceived` su `spender`.
103   * @param spender L'indirizzo che spenderà i fondi.
104   * @param value La quantità di token da spendere.
105   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
106  
107
108
109
110
111
112
113  function approveAndCall(address spender, uint256 value) external returns (bool);
114
115  /* *
116   * @dev Imposta una quantità `value` di token come allowance di `spender` sui token del chiamante
117   * e poi chiama `ERC1363Spender::onApprovalReceived` su `spender`.
118   * @param spender L'indirizzo che spenderà i fondi.
119   * @param value La quantità di token da spendere.
120   * @param data Dati aggiuntivi senza formato specificato, inviati nella chiamata a `spender`.
121   * @return Un valore booleano che indica che l'operazione ha avuto successo a meno che non venga lanciata un'eccezione. */
122  
123
124
125
126
127
128
129
130  function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
131}
132
133interface ERC20 {
134  event Transfer(address indexed from, address indexed to, uint256 value);
135  event Approval(address indexed owner, address indexed spender, uint256 value);
136  function transfer(address to, uint256 value) external returns (bool);
137  function transferFrom(address from, address to, uint256 value) external returns (bool);
138  function approve(address spender, uint256 value) external returns (bool);
139  function totalSupply() external view returns (uint256);
140  function balanceOf(address account) external view returns (uint256);
141  function allowance(address owner, address spender) external view returns (uint256);
142}
143
144interface ERC165 {
145  function supportsInterface(bytes4 interfaceId) external view returns (bool);
146}
Mostra tutto

Un contratto intelligente che desidera accettare token ERC-1363 tramite transferAndCall o transferFromAndCall DEVE implementare l'interfaccia ERC1363Receiver:

1/* *
2 * @title ERC1363Receiver
3 * @dev Interfaccia per qualsiasi contratto che desidera supportare `transferAndCall` o `transferFromAndCall` dai contratti token ERC-1363. */
4
5
6
7
8interface ERC1363Receiver {
9  /* *
10   * @dev Ogni volta che i token ERC-1363 vengono trasferiti a questo contratto tramite `ERC1363::transferAndCall` o `ERC1363::transferFromAndCall`
11   * da `operator` da `from`, viene chiamata questa funzione.
12   *
13   * NOTE: Per accettare il trasferimento, questa deve restituire
14   * `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
15   * (cioè 0x88a7ca5c, o il proprio selettore di funzione).
16   *
17   * @param operator L'indirizzo che ha chiamato la funzione `transferAndCall` o `transferFromAndCall`.
18   * @param from L'indirizzo da cui vengono trasferiti i token.
19   * @param value La quantità di token trasferiti.
20   * @param data Dati aggiuntivi senza formato specificato.
21   * @return `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` se il trasferimento è consentito a meno che non venga lanciata un'eccezione. */
22  
23
24
25
26
27
28
29
30
31
32
33
34
35
36  function onTransferReceived(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4);
37}
Mostra tutto

Un contratto intelligente che desidera accettare token ERC-1363 tramite approveAndCall DEVE implementare l'interfaccia ERC1363Spender:

1/* *
2 * @title ERC1363Spender
3 * @dev Interfaccia per qualsiasi contratto che desidera supportare `approveAndCall` dai contratti token ERC-1363. */
4
5
6
7
8interface ERC1363Spender {
9  /* *
10   * @dev Ogni volta che un `owner` di token ERC-1363 approva questo contratto tramite `ERC1363::approveAndCall`
11   * per spendere i propri token, viene chiamata questa funzione.
12   *
13   * NOTE: Per accettare l'approvazione, questa deve restituire
14   * `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
15   * (cioè 0x7b04a2d0, o il proprio selettore di funzione).
16   *
17   * @param owner L'indirizzo che ha chiamato la funzione `approveAndCall` e che in precedenza possedeva i token.
18   * @param value La quantità di token da spendere.
19   * @param data Dati aggiuntivi senza formato specificato.
20   * @return `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` se l'approvazione è consentita a meno che non venga lanciata un'eccezione. */
21  
22
23
24
25
26
27
28
29
30
31
32
33
34  function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4);
35}
Mostra tutto