ERC-1363 Payable Token Standard

Einführung

Was ist ERC-1363?

ERC-1363 ist eine Erweiterungsschnittstelle für ERC-20-Token, die die Ausführung benutzerdefinierter Logik auf einem Empfängervertrag nach Übertragungen oder auf einem Ausgabevertrag nach Genehmigungen unterstützt, alles innerhalb einer einzigen Transaktion.

Unterschiede zu ERC-20

Standardmäßige ERC-20-Operationen wie transfer, transferFrom und approve erlauben keine Codeausführung auf dem Empfänger- oder Ausgabevertrag ohne eine separate Transaktion. Dies führt zu Komplexität bei der UI-Entwicklung und Reibungsverlusten bei der Akzeptanz, da Benutzer warten müssen, bis die erste Transaktion ausgeführt wurde, und dann die zweite einreichen müssen. Sie müssen außerdem zweimal Gas bezahlen.

ERC-1363 ermöglicht es fungiblen Token, Aktionen einfacher auszuführen und ohne die Verwendung eines Off-Chain-Listeners zu funktionieren. Es erlaubt einen Callback auf einem Empfänger- oder Ausgabevertrag nach einer Übertragung oder einer Genehmigung in einer einzigen Transaktion.

Voraussetzungen

Um diese Seite besser zu verstehen, empfehlen wir Ihnen, sich zunächst über Folgendes zu informieren:

Hauptteil

ERC-1363 führt eine Standard-API für ERC-20-Token ein, um nach transfer, transferFrom oder approve mit Smart Contracts zu interagieren.

Dieser Standard bietet grundlegende Funktionen zur Übertragung von Token sowie die Möglichkeit, Token zu genehmigen, damit sie von einem anderen Dritten auf der Blockchain ausgegeben werden können, und anschließend einen Callback auf dem Empfänger- oder Ausgabevertrag durchzuführen.

Es gibt viele vorgeschlagene Verwendungszwecke für Smart Contracts, die ERC-20-Callbacks akzeptieren können.

Beispiele könnten sein:

Crowdsales: Gesendete Token lösen eine sofortige Zuweisung von Belohnungen aus.
Dienstleistungen: Die Zahlung aktiviert den Zugang zum Dienst in einem Schritt.
Rechnungen: Token begleichen Rechnungen automatisch.
Abonnements: Die Genehmigung des Jahresbeitrags aktiviert das Abonnement mit der Zahlung des ersten Monats.

Aus diesen Gründen wurde er ursprünglich „Payable Token“ genannt.

Das Callback-Verhalten erweitert seinen Nutzen weiter und ermöglicht nahtlose Interaktionen wie:

Staking: Übertragene Token lösen eine automatische Sperrung in einem Staking-Vertrag aus.
Abstimmungen: Empfangene Token registrieren Stimmen in einem Governance-System.
Tauschen: Token-Genehmigungen aktivieren die Tausch-Logik in einem einzigen Schritt.

ERC-1363-Token können für spezifische Dienstprogramme in allen Fällen verwendet werden, die die Ausführung eines Callbacks nach einer Übertragung oder einer erhaltenen Genehmigung erfordern. ERC-1363 ist auch nützlich, um Token-Verlust oder das Sperren von Token in Smart Contracts zu vermeiden, indem die Fähigkeit des Empfängers zum Umgang mit Token überprüft wird.

Im Gegensatz zu anderen Vorschlägen für ERC-20-Erweiterungen überschreibt ERC-1363 die Methoden transfer und transferFrom von ERC-20 nicht und definiert die zu implementierenden Schnittstellen-IDs unter Beibehaltung der Abwärtskompatibilität mit ERC-20.

Aus EIP-1363 (opens in a new tab):

Methoden

Smart Contracts, die den ERC-1363-Standard implementieren, MÜSSEN alle Funktionen in der ERC1363-Schnittstelle sowie die ERC20- und ERC165-Schnittstellen implementieren.

1pragma solidity ^0.8.0;
2
3/* *
4 * @title ERC1363
5 * @dev Eine Erweiterungsschnittstelle für ERC-20-Token, die das Ausführen von Code auf einem Empfängervertrag
6 * nach `transfer` oder `transferFrom` oder von Code auf einem ausgebenden Vertrag nach `approve` in einer einzigen Transaktion unterstützt. */
7
8
9
10
11
12interface ERC1363 is ERC20, ERC165 {
13  /* * NOTE: Der ERC-165-Identifikator für diese Schnittstelle ist 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 Verschiebt eine Menge `value` an Token vom Konto des Aufrufers nach `to`
34   * und ruft dann `ERC1363Receiver::onTransferReceived` auf `to` auf.
35   * @param to Die Adresse, an die die Token übertragen werden.
36   * @param value Die Menge der zu übertragenden Token.
37   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
38  
39
40
41
42
43
44
45  function transferAndCall(address to, uint256 value) external returns (bool);
46
47  /* *
48   * @dev Verschiebt eine Menge `value` an Token vom Konto des Aufrufers nach `to`
49   * und ruft dann `ERC1363Receiver::onTransferReceived` auf `to` auf.
50   * @param to Die Adresse, an die die Token übertragen werden.
51   * @param value Die Menge der zu übertragenden Token.
52   * @param data Zusätzliche Daten ohne spezifiziertes Format, die im Aufruf an `to` gesendet werden.
53   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
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 Verschiebt eine Menge `value` an Token von `from` nach `to` unter Verwendung des Allowance-Mechanismus
66   * und ruft dann `ERC1363Receiver::onTransferReceived` auf `to` auf.
67   * @param from Die Adresse, von der Token gesendet werden sollen.
68   * @param to Die Adresse, an die die Token übertragen werden.
69   * @param value Die Menge der zu übertragenden Token.
70   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
71  
72
73
74
75
76
77
78
79  function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
80
81  /* *
82   * @dev Verschiebt eine Menge `value` an Token von `from` nach `to` unter Verwendung des Allowance-Mechanismus
83   * und ruft dann `ERC1363Receiver::onTransferReceived` auf `to` auf.
84   * @param from Die Adresse, von der Token gesendet werden sollen.
85   * @param to Die Adresse, an die die Token übertragen werden.
86   * @param value Die Menge der zu übertragenden Token.
87   * @param data Zusätzliche Daten ohne spezifiziertes Format, die im Aufruf an `to` gesendet werden.
88   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
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 Legt eine Menge `value` an Token als Allowance für `spender` über die Token des Aufrufers fest
102   * und ruft dann `ERC1363Spender::onApprovalReceived` auf `spender` auf.
103   * @param spender Die Adresse, die die Mittel ausgeben wird.
104   * @param value Die Menge der auszugebenden Token.
105   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
106  
107
108
109
110
111
112
113  function approveAndCall(address spender, uint256 value) external returns (bool);
114
115  /* *
116   * @dev Legt eine Menge `value` an Token als Allowance für `spender` über die Token des Aufrufers fest
117   * und ruft dann `ERC1363Spender::onApprovalReceived` auf `spender` auf.
118   * @param spender Die Adresse, die die Mittel ausgeben wird.
119   * @param value Die Menge der auszugebenden Token.
120   * @param data Zusätzliche Daten ohne spezifiziertes Format, die im Aufruf an `spender` gesendet werden.
121   * @return Ein boolescher Wert, der anzeigt, dass die Operation erfolgreich war, sofern kein Fehler ausgelöst wird. */
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}
Alle anzeigen

Ein Smart Contract, der ERC-1363-Token über transferAndCall oder transferFromAndCall akzeptieren möchte, MUSS die ERC1363Receiver-Schnittstelle implementieren:

1/* *
2 * @title ERC1363Receiver
3 * @dev Schnittstelle für jeden Vertrag, der `transferAndCall` oder `transferFromAndCall` von ERC-1363-Token-Verträgen unterstützen möchte. */
4
5
6
7
8interface ERC1363Receiver {
9  /* *
10   * @dev Wann immer ERC-1363-Token über `ERC1363::transferAndCall` oder `ERC1363::transferFromAndCall`
11   * durch `operator` von `from` an diesen Vertrag übertragen werden, wird diese Funktion aufgerufen.
12   *
13   * NOTE: Um die Übertragung zu akzeptieren, muss dies
14   * `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
15   * (d. h. 0x88a7ca5c oder seinen eigenen Funktionsselektor) zurückgeben.
16   *
17   * @param operator Die Adresse, die die Funktion `transferAndCall` oder `transferFromAndCall` aufgerufen hat.
18   * @param from Die Adresse, von der die Token übertragen werden.
19   * @param value Die Menge der übertragenen Token.
20   * @param data Zusätzliche Daten ohne spezifiziertes Format.
21   * @return `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`, wenn die Übertragung erlaubt ist, sofern kein Fehler ausgelöst wird. */
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}
Alle anzeigen

Ein Smart Contract, der ERC-1363-Token über approveAndCall akzeptieren möchte, MUSS die ERC1363Spender-Schnittstelle implementieren:

1/* *
2 * @title ERC1363Spender
3 * @dev Schnittstelle für jeden Vertrag, der `approveAndCall` von ERC-1363-Token-Verträgen unterstützen möchte. */
4
5
6
7
8interface ERC1363Spender {
9  /* *
10   * @dev Wann immer ein `owner` von ERC-1363-Token diesen Vertrag über `ERC1363::approveAndCall` autorisiert,
11   * seine Token auszugeben, wird diese Funktion aufgerufen.
12   *
13   * NOTE: Um die Genehmigung zu akzeptieren, muss dies
14   * `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
15   * (d. h. 0x7b04a2d0 oder seinen eigenen Funktionsselektor) zurückgeben.
16   *
17   * @param owner Die Adresse, die die Funktion `approveAndCall` aufgerufen hat und zuvor die Token besaß.
18   * @param value Die Menge der auszugebenden Token.
19   * @param data Zusätzliche Daten ohne spezifiziertes Format.
20   * @return `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`, wenn die Genehmigung erlaubt ist, sofern kein Fehler ausgelöst wird. */
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}
Alle anzeigen