generated from PaulRBerg/hardhat-template
-
-
Notifications
You must be signed in to change notification settings - Fork 26
/
IErc20.sol
161 lines (135 loc) · 6.81 KB
/
IErc20.sol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
/// @title IErc20
/// @author Paul Razvan Berg
/// @notice Implementation for the Erc20 standard.
///
/// We have followed general OpenZeppelin guidelines: functions revert instead of returning
/// `false` on failure. This behavior is nonetheless conventional and does not conflict with
/// the with the expectations of Erc20 applications.
///
/// Additionally, an {Approval} event is emitted on calls to {transferFrom}. This allows
/// applications to reconstruct the allowance for all accounts just by listening to said
/// events. Other implementations of the Erc may not emit these events, as it isn't
/// required by the specification.
///
/// Finally, the non-standard {decreaseAllowance} and {increaseAllowance} functions have been
/// added to mitigate the well-known issues around setting allowances.
///
/// @dev Forked from OpenZeppelin
/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC20/ERC20.sol
interface IErc20 {
/// CUSTOM ERRORS ///
/// @notice Emitted when the owner is the zero address.
error Erc20__ApproveOwnerZeroAddress();
/// @notice Emitted when the spender is the zero address.
error Erc20__ApproveSpenderZeroAddress();
/// @notice Emitted when burning more tokens than are in the account.
error Erc20__BurnUnderflow(uint256 accountBalance, uint256 burnAmount);
/// @notice Emitted when the holder is the zero address.
error Erc20__BurnZeroAddress();
/// @notice Emitted when the owner did not give the spender sufficient allowance.
error Erc20__InsufficientAllowance(uint256 allowance, uint256 amount);
/// @notice Emitted when tranferring more tokens than there are in the account.
error Erc20__InsufficientBalance(uint256 senderBalance, uint256 amount);
/// @notice Emitted when the beneficiary is the zero address.
error Erc20__MintZeroAddress();
/// @notice Emitted when the sender is the zero address.
error Erc20__TransferSenderZeroAddress();
/// @notice Emitted when the recipient is the zero address.
error Erc20__TransferRecipientZeroAddress();
/// EVENTS ///
/// @notice Emitted when an approval happens.
/// @param owner The address of the owner of the tokens.
/// @param spender The address of the spender.
/// @param amount The maximum amount that can be spent.
event Approval(address indexed owner, address indexed spender, uint256 amount);
/// @notice Emitted when a transfer happens.
/// @param from The account sending the tokens.
/// @param to The account receiving the tokens.
/// @param amount The amount of tokens transferred.
event Transfer(address indexed from, address indexed to, uint256 amount);
/// CONSTANT FUNCTIONS ///
/// @notice Returns the remaining number of tokens that `spender` will be allowed to spend
/// on behalf of `owner` through {transferFrom}. This is zero by default.
///
/// @dev This value changes when {approve} or {transferFrom} are called.
function allowance(address owner, address spender) external view returns (uint256);
/// @notice Returns the amount of tokens owned by `account`.
function balanceOf(address account) external view returns (uint256);
/// @notice Returns the number of decimals used to get its user representation.
function decimals() external view returns (uint8);
/// @notice Returns the name of the token.
function name() external view returns (string memory);
/// @notice Returns the symbol of the token, usually a shorter version of the name.
function symbol() external view returns (string memory);
/// @notice Returns the amount of tokens in existence.
function totalSupply() external view returns (uint256);
/// NON-CONSTANT FUNCTIONS ///
/// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
///
/// @dev Emits an {Approval} event.
///
/// IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may
/// use both the old and the new allowance by unfortunate transaction ordering. One possible solution
/// to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired
/// value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
///
/// @return a boolean value indicating whether the operation succeeded.
function approve(address spender, uint256 amount) external returns (bool);
/// @notice Atomically decreases the allowance granted to `spender` by the caller.
///
/// @dev Emits an {Approval} event indicating the updated allowance.
///
/// This is an alternative to {approve} that can be used as a mitigation for problems described
/// in {Erc20Interface-approve}.
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
/// - `spender` must have allowance for the caller of at least `subtractedAmount`.
function decreaseAllowance(address spender, uint256 subtractedAmount) external returns (bool);
/// @notice Atomically increases the allowance granted to `spender` by the caller.
///
/// @dev Emits an {Approval} event indicating the updated allowance.
///
/// This is an alternative to {approve} that can be used as a mitigation for the problems described above.
///
/// Requirements:
///
/// - `spender` cannot be the zero address.
function increaseAllowance(address spender, uint256 addedAmount) external returns (bool);
/// @notice Moves `amount` tokens from the caller's account to `recipient`.
///
/// @dev Emits a {Transfer} event.
///
/// Requirements:
///
/// - `recipient` cannot be the zero address.
/// - The caller must have a balance of at least `amount`.
///
/// @return a boolean value indicating whether the operation succeeded.
function transfer(address recipient, uint256 amount) external returns (bool);
/// @notice Moves `amount` tokens from `sender` to `recipient` using the allowance mechanism. `amount`
/// `is then deducted from the caller's allowance.
///
/// @dev Emits a {Transfer} event and an {Approval} event indicating the updated allowance. This is
/// not required by the Erc. See the note at the beginning of {Erc20}.
///
/// Requirements:
///
/// - `sender` and `recipient` cannot be the zero address.
/// - `sender` must have a balance of at least `amount`.
/// - The caller must have approed `sender` to spent at least `amount` tokens.
///
/// @return a boolean value indicating whether the operation succeeded.
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}