Norme de jeton payable ERC-1363

Introduction

Qu'est-ce que l'ERC-1363 ?

L'ERC-1363 est une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution d'une logique personnalisée sur un contrat destinataire après les transferts, ou sur un contrat dépensier après les approbations, le tout au sein d'une seule transaction.

Différences par rapport à l'ERC-20

Les opérations standard ERC-20 telles que transfer, transferFrom et approve ne permettent pas l'exécution de code sur le contrat destinataire ou dépensier sans une transaction distincte. Cela introduit de la complexité dans le développement de l'interface utilisateur et des frictions lors de l'adoption, car les utilisateurs doivent attendre que la première transaction soit exécutée pour ensuite soumettre la seconde. Ils doivent également payer le GAS deux fois.

L'ERC-1363 permet aux jetons fongibles d'effectuer des actions plus facilement et de fonctionner sans l'utilisation d'un auditeur hors chaîne. Il permet d'effectuer un rappel sur un contrat récepteur ou dépensier, après un transfert ou une approbation, en une seule transaction.

Prérequis

Pour mieux comprendre cette page, nous vous recommandons de lire d'abord ce qui suit :

Corps

L'ERC-1363 introduit une API standard pour que les jetons ERC-20 interagissent avec les contrats intelligents après transfer, transferFrom ou approve.

Cette norme fournit une fonctionnalité de base pour transférer des jetons, ainsi que pour permettre l'approbation de jetons afin qu'ils puissent être dépensés par un tiers sur la chaîne, puis effectuer un rappel sur le contrat récepteur ou dépensier.

Il existe de nombreuses utilisations proposées de contrats intelligents pouvant accepter les rappels ERC-20.

Par exemple :

Ventes participatives : les jetons envoyés déclenchent une allocation de récompense instantanée.
Services : le paiement active l'accès au service en une seule étape.
Factures : les jetons règlent les factures automatiquement.
Abonnements : l'approbation du tarif annuel active l'abonnement dès le paiement du premier mois.

Pour ces raisons, il a été initialement nommé "Jeton payable".

Le comportement de rappel étend encore son utilité, permettant des interactions transparentes comme :

Jalonnement : les jetons transférés déclenchent un verrouillage automatique dans un contrat de jalonnement.
Vote : les jetons reçus enregistrent les votes dans un système de gouvernance.
Échange : les approbations de jetons activent la logique d'échange en une seule étape.

Les jetons ERC-1363 peuvent être utilisés pour des utilitaires spécifiques dans tous les cas qui nécessitent l'exécution d'un rappel après un transfert ou une approbation reçue. L'ERC-1363 est également utile pour éviter la perte ou le verrouillage de jetons dans les contrats intelligents en vérifiant la capacité du destinataire à gérer les jetons.

Contrairement à d'autres propositions d'extension ERC-20, l'ERC-1363 ne remplace pas les méthodes transfer et transferFrom de l'ERC-20 et définit les ID d'interfaces à implémenter tout en maintenant la rétrocompatibilité avec l'ERC-20.

Provenant de l'EIP-1363 (opens in a new tab):

Méthodes

Les contrats intelligents qui implémentent la norme ERC-1363 DOIVENT implémenter toutes les fonctions de l'interface ERC1363, ainsi que les interfaces ERC20 et ERC165.

1pragma solidity ^0.8.0;
2
3/**
4 * @title ERC1363
5 * @dev Une interface d'extension pour les jetons ERC-20 qui prend en charge l'exécution de code sur un contrat destinataire
6 * après `transfer` ou `transferFrom`, ou de code sur un contrat dépensier après `approve`, en une seule transaction.
7 */
8interface ERC1363 is ERC20, ERC165 {
9  /*
10   * NOTE : l'identifiant ERC-165 pour cette interface est 0xb0202a11.
11   * 0xb0202a11 ===
12   *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
13   *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
14   *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
15   *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
16   *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
17   *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
18   */
19
20  /**
21   * @dev Déplace un montant `value` de jetons du compte de l'appelant vers `to`
22   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
23   * @param to L'adresse à laquelle les jetons sont transférés.
24   * @param value Le montant de jetons à transférer.
25   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
26   */
27  function transferAndCall(address to, uint256 value) external returns (bool);
28
29  /**
30   * @dev Déplace un montant `value` de jetons du compte de l'appelant vers `to`
31   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
32   * @param to L'adresse à laquelle les jetons sont transférés.
33   * @param value Le montant de jetons à transférer.
34   * @param data Données supplémentaires sans format spécifié, envoyées dans l'appel à `to`.
35   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
36   */
37  function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
38
39  /**
40   * @dev Déplace un montant `value` de jetons de `from` vers `to` en utilisant le mécanisme d'autorisation
41   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
42   * @param from L'adresse à partir de laquelle envoyer les jetons.
43   * @param to L'adresse à laquelle les jetons sont transférés.
44   * @param value Le montant de jetons à transférer.
45   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
46   */
47  function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
48
49  /**
50   * @dev Déplace un montant `value` de jetons de `from` vers `to` en utilisant le mécanisme d'autorisation
51   * et puis appelle `ERC1363Receiver::onTransferReceived` sur `to`.
52   * @param from L'adresse à partir de laquelle envoyer les jetons.
53   * @param to L'adresse à laquelle les jetons sont transférés.
54   * @param value Le montant de jetons à transférer.
55   * @param data Données supplémentaires sans format spécifié, envoyées dans l'appel à `to`.
56   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
57   */
58  function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
59
60  /**
61   * @dev Définit un montant `value` de jetons comme autorisation de `spender` sur les jetons de l'appelant
62   * et puis appelle `ERC1363Spender::onApprovalReceived` sur `spender`.
63   * @param spender L'adresse qui dépensera les fonds.
64   * @param value Le montant des jetons à dépenser.
65   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
66   */
67  function approveAndCall(address spender, uint256 value) external returns (bool);
68
69  /**
70   * @dev Définit un montant `value` de jetons comme autorisation de `spender` sur les jetons de l'appelant
71   * et puis appelle `ERC1363Spender::onApprovalReceived` sur `spender`.
72   * @param spender L'adresse qui dépensera les fonds.
73   * @param value Le montant des jetons à dépenser.
74   * @param data Données supplémentaires sans format spécifié, envoyées lors de l'appel à `spender`.
75   * @return Une valeur booléenne indiquant que l'opération a réussi, sauf en cas d'erreur.
76   */
77  function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
78}
79
80interface ERC20 {
81  event Transfer(address indexed from, address indexed to, uint256 value);
82  event Approval(address indexed owner, address indexed spender, uint256 value);
83  function transfer(address to, uint256 value) external returns (bool);
84  function transferFrom(address from, address to, uint256 value) external returns (bool);
85  function approve(address spender, uint256 value) external returns (bool);
86  function totalSupply() external view returns (uint256);
87  function balanceOf(address account) external view returns (uint256);
88  function allowance(address owner, address spender) external view returns (uint256);
89}
90
91interface ERC165 {
92  function supportsInterface(bytes4 interfaceId) external view returns (bool);
93}
Afficher tout

Un contrat intelligent qui veut accepter les jetons ERC-1363 via transferAndCall ou transferFromAndCall DOIT implémenter l'interface ERC1363Receiver :

1/**
2 * @title ERC1363Receiver
3 * @dev Interface pour tout contrat qui veut prendre en charge `transferAndCall` ou `transferFromAndCall` à partir de contrats de jeton ERC-1363.
4 */
5interface ERC1363Receiver {
6  /**
7   * @dev Chaque fois que des jetons ERC-1363 sont transférés à ce contrat via `ERC1363::transferAndCall` ou `ERC1363::transferFromAndCall`
8   * par `operator` depuis `from`, cette fonction est appelée.
9   *
10   * NOTE : pour accepter le transfert, cette fonction doit retourner
11   * `bytes4(keccak256(\"onTransferReceived(address,address,uint256,bytes)\"))`
12   * (c.-à-d. 0x88a7ca5c, ou son propre sélecteur de fonction).
13   *
14   * @param operator L'adresse qui a appelé la fonction `transferAndCall` ou `transferFromAndCall`.
15   * @param from L'adresse depuis laquelle les jetons sont transférés.
16   * @param value Le montant des jetons transférés.
17   * @param data Données supplémentaires sans format spécifié.
18   * @return `bytes4(keccak256(\"onTransferReceived(address,address,uint256,bytes)\"))` si le transfert est autorisé, sauf en cas d'erreur.
19   */
20  function onTransferReceived(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4);
21}
Afficher tout

Un contrat intelligent qui veut accepter les jetons ERC-1363 via approveAndCall DOIT implémenter l'interface ERC1363Spender :

1/**
2 * @title ERC1363Spender
3 * @dev Interface pour tout contrat qui veut prendre en charge `approveAndCall` à partir de contrats de jeton ERC-1363.
4 */
5interface ERC1363Spender {
6  /**
7   * @dev Chaque fois qu'un `owner` de jetons ERC-1363 approuve ce contrat via `ERC1363::approveAndCall`
8   * pour dépenser ses jetons, cette fonction est appelée.
9   *
10   * NOTE : pour accepter l'approbation, cette fonction doit retourner
11   * `bytes4(keccak256(\"onApprovalReceived(address,uint256,bytes)\"))`
12   * (c.-à-d. 0x7b04a2d0, ou son propre sélecteur de fonction).
13   *
14   * @param owner L'adresse qui a appelé la fonction `approveAndCall` et qui possédait auparavant les jetons.
15   * @param value Le montant des jetons à dépenser.
16   * @param data Données supplémentaires sans format spécifié.
17   * @return `bytes4(keccak256(\"onApprovalReceived(address,uint256,bytes)\"))` si l'approbation est autorisée, sauf en cas d'erreur.
18   */
19  function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4);
20}
Afficher tout