文件 2 的 11：AdvancedERC20.sol
pragma solidity ^0.8.4;
import "../interfaces/ERC1363Spec.sol";
import "../interfaces/EIP2612.sol";
import "../interfaces/EIP3009.sol";
import "../lib/ECDSA.sol";
import "@lazy-sol/access-control-upgradeable/contracts/InitializableAccessControlCore.sol";
contract AdvancedERC20 is MintableERC1363, MintableBurnableERC20, EIP2612, EIP3009, InitializableAccessControlCore {
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
mapping(address => uint256) private tokenBalances;
mapping(address => address) public votingDelegates;
struct KV {
uint64 k;
uint192 v;
}
mapping(address => KV[]) public votingPowerHistory;
KV[] public totalSupplyHistory;
mapping(address => uint256) public override nonces;
mapping(address => mapping(bytes32 => bool)) private usedNonces;
mapping(address => mapping(address => uint256)) private transferAllowances;
uint32 public constant FEATURE_TRANSFERS = 0x0000_0001;
uint32 public constant FEATURE_TRANSFERS_ON_BEHALF = 0x0000_0002;
uint32 public constant FEATURE_UNSAFE_TRANSFERS = 0x0000_0004;
uint32 public constant FEATURE_OWN_BURNS = 0x0000_0008;
uint32 public constant FEATURE_BURNS_ON_BEHALF = 0x0000_0010;
uint32 public constant FEATURE_DELEGATIONS = 0x0000_0020;
uint32 public constant FEATURE_DELEGATIONS_ON_BEHALF = 0x0000_0040;
uint32 public constant FEATURE_ERC1363_TRANSFERS = 0x0000_0080;
uint32 public constant FEATURE_ERC1363_APPROVALS = 0x0000_0100;
uint32 public constant FEATURE_EIP2612_PERMITS = 0x0000_0200;
uint32 public constant FEATURE_EIP3009_TRANSFERS = 0x0000_0400;
uint32 public constant FEATURE_EIP3009_RECEPTIONS = 0x0000_0800;
uint32 public constant ROLE_TOKEN_CREATOR = 0x0001_0000;
uint32 public constant ROLE_TOKEN_DESTROYER = 0x0002_0000;
uint32 public constant ROLE_ERC20_RECEIVER = 0x0004_0000;
uint32 public constant ROLE_ERC20_SENDER = 0x0008_0000;
bytes32 public constant DOMAIN_TYPEHASH = 0x8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a866;
function DOMAIN_SEPARATOR() public view override returns(bytes32) {
return keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes("AdvancedERC20v1")), block.chainid, address(this)));
}
bytes32 public constant DELEGATION_TYPEHASH = 0xff41620983935eb4d4a3c7384a066ca8c1d10cef9a5eca9eb97ca735cd14a755;
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;
bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = 0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;
bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;
event Minted(address indexed by, address indexed to, uint256 value);
event Burnt(address indexed by, address indexed from, uint256 value);
event Transfer(address indexed by, address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 oldValue, uint256 value);
event DelegateChanged(address indexed source, address indexed from, address indexed to);
event VotingPowerChanged(address indexed by, address indexed target, uint256 fromVal, uint256 toVal);
constructor(
address contractOwner,
string memory _name,
string memory _symbol,
address initialHolder,
uint256 initialSupply,
uint256 initialFeatures
) {
postConstruct(contractOwner, _name, _symbol, initialHolder, initialSupply, initialFeatures);
}
function postConstruct(
address contractOwner,
string memory _name,
string memory _symbol,
address initialHolder,
uint256 initialSupply,
uint256 initialFeatures
) public initializer {
require(bytes(_name).length > 0, "token name is not set");
require(bytes(_symbol).length > 0, "token symbol is not set");
name = _name;
symbol = _symbol;
require(initialSupply == 0 || initialHolder != address(0), "_initialHolder not set (zero address)");
if(initialSupply != 0) {
__mint(initialHolder, initialSupply);
}
if(contractOwner != address(0) || initialFeatures != 0) {
_postConstruct(contractOwner, initialFeatures);
}
}
function supportsInterface(bytes4 interfaceId) public pure virtual override returns (bool) {
return interfaceId == type(ERC165).interfaceId
|| interfaceId == type(ERC20).interfaceId
|| interfaceId == type(ERC1363).interfaceId
|| interfaceId == type(EIP2612).interfaceId
|| interfaceId == type(EIP3009).interfaceId;
}
function transferAndCall(address to, uint256 value) public override returns (bool) {
return transferFromAndCall(msg.sender, to, value);
}
function transferAndCall(address to, uint256 value, bytes memory data) public override returns (bool) {
return transferFromAndCall(msg.sender, to, value, data);
}
function transferFromAndCall(address from, address to, uint256 value) public override returns (bool) {
return transferFromAndCall(from, to, value, "");
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public override returns (bool) {
require(_isFeatureEnabled(FEATURE_ERC1363_TRANSFERS), "ERC1363 transfers are disabled");
unsafeTransferFrom(from, to, value);
_notifyTransferred(from, to, value, data, false);
return true;
}
function approveAndCall(address spender, uint256 value) public override returns (bool) {
return approveAndCall(spender, value, "");
}
function approveAndCall(address spender, uint256 value, bytes memory data) public override returns (bool) {
require(_isFeatureEnabled(FEATURE_ERC1363_APPROVALS), "ERC1363 approvals are disabled");
approve(spender, value);
_notifyApproved(spender, value, data);
return true;
}
function _notifyTransferred(address from, address to, uint256 value, bytes memory data, bool allowEoa) private {
if(to.code.length == 0) {
require(allowEoa, "EOA recipient");
return;
}
bytes4 response = ERC1363Receiver(to).onTransferReceived(msg.sender, from, value, data);
require(response == ERC1363Receiver(to).onTransferReceived.selector, "invalid onTransferReceived response");
}
function _notifyApproved(address spender, uint256 value, bytes memory data) private {
require(spender.code.length > 0, "EOA spender");
bytes4 response = ERC1363Spender(spender).onApprovalReceived(msg.sender, value, data);
require(response == ERC1363Spender(spender).onApprovalReceived.selector, "invalid onApprovalReceived response");
}
function balanceOf(address owner) public view override returns (uint256 balance) {
return tokenBalances[owner];
}
function transfer(address to, uint256 value) public override returns (bool success) {
return transferFrom(msg.sender, to, value);
}
function transferFrom(address from, address to, uint256 value) public override returns (bool success) {
if(_isFeatureEnabled(FEATURE_UNSAFE_TRANSFERS)
|| _isOperatorInRole(to, ROLE_ERC20_RECEIVER)
|| _isSenderInRole(ROLE_ERC20_SENDER)) {
unsafeTransferFrom(from, to, value);
}
else {
safeTransferFrom(from, to, value, "");
}
return true;
}
function safeTransferFrom(address from, address to, uint256 value, bytes memory data) public returns (bool) {
unsafeTransferFrom(from, to, value);
_notifyTransferred(from, to, value, data, true);
return true;
}
function unsafeTransferFrom(address from, address to, uint256 value) public {
__transferFrom(msg.sender, from, to, value);
}
function __transferFrom(address by, address from, address to, uint256 value) private {
require(from == by && _isFeatureEnabled(FEATURE_TRANSFERS)
|| from != by && _isFeatureEnabled(FEATURE_TRANSFERS_ON_BEHALF),
from == by ? "transfers are disabled": "transfers on behalf are disabled");
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
require(to != address(this), "invalid recipient (transfer to the token smart contract itself)");
if(value == 0) {
emit Transfer(by, from, to, value);
emit Transfer(from, to, value);
return;
}
if(from != by) {
uint256 _allowance = transferAllowances[from][by];
require(_allowance >= value, "transfer amount exceeds allowance");
if(_allowance < type(uint256).max) {
_allowance -= value;
transferAllowances[from][by] = _allowance;
emit Approval(from, by, _allowance + value, _allowance);
emit Approval(from, by, _allowance);
}
}
require(tokenBalances[from] >= value, "transfer amount exceeds balance");
tokenBalances[from] -= value;
tokenBalances[to] += value;
__moveVotingPower(by, votingDelegates[from], votingDelegates[to], value);
emit Transfer(by, from, to, value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) public override returns (bool success) {
__approve(msg.sender, spender, value);
return true;
}
function __approve(address owner, address spender, uint256 value) private {
require(spender != address(0), "approve to the zero address");
uint256 oldValue = transferAllowances[owner][spender];
transferAllowances[owner][spender] = value;
emit Approval(owner, spender, oldValue, value);
emit Approval(owner, spender, value);
}
function allowance(address owner, address spender) public view override returns (uint256 remaining) {
return transferAllowances[owner][spender];
}
function increaseAllowance(address spender, uint256 value) public returns (bool) {
uint256 currentVal = transferAllowances[msg.sender][spender];
unchecked {
require(currentVal + value > currentVal, "zero value approval increase or arithmetic overflow");
}
return approve(spender, currentVal + value);
}
function decreaseAllowance(address spender, uint256 value) public returns (bool) {
uint256 currentVal = transferAllowances[msg.sender][spender];
require(value > 0, "zero value approval decrease");
require(currentVal >= value, "ERC20: decreased allowance below zero");
return approve(spender, currentVal - value);
}
function mint(address to, uint256 value) public override virtual returns(bool success) {
require(_isSenderInRole(ROLE_TOKEN_CREATOR), "access denied");
__mint(to, value);
return true;
}
function safeMint(address to, uint256 value, bytes memory data) public virtual returns(bool success) {
mint(to, value);
_notifyTransferred(address(0), to, value, data, true);
return true;
}
function mintAndCall(address to, uint256 value) public override virtual returns (bool success) {
return mintAndCall(to, value, "");
}
function mintAndCall(address to, uint256 value, bytes memory data) public override virtual returns (bool success) {
mint(to, value);
_notifyTransferred(address(0), to, value, data, false);
return true;
}
function __mint(address to, uint256 value) private {
require(to != address(0), "zero address");
unchecked {
require(totalSupply + value > totalSupply, "zero value or arithmetic overflow");
}
require(totalSupply + value <= type(uint192).max, "total supply overflow (uint192)");
totalSupply += value;
tokenBalances[to] += value;
__updateHistory(totalSupplyHistory, add, value);
__moveVotingPower(msg.sender, address(0), votingDelegates[to], value);
emit Minted(msg.sender, to, value);
emit Transfer(msg.sender, address(0), to, value);
emit Transfer(address(0), to, value);
}
function burn(address from, uint256 value) public override virtual returns(bool success) {
if(!_isSenderInRole(ROLE_TOKEN_DESTROYER)) {
require(from == msg.sender && _isFeatureEnabled(FEATURE_OWN_BURNS)
|| from != msg.sender && _isFeatureEnabled(FEATURE_BURNS_ON_BEHALF),
from == msg.sender? "burns are disabled": "burns on behalf are disabled");
if(from != msg.sender) {
uint256 _allowance = transferAllowances[from][msg.sender];
require(_allowance >= value, "burn amount exceeds allowance");
if(_allowance < type(uint256).max) {
_allowance -= value;
transferAllowances[from][msg.sender] = _allowance;
emit Approval(msg.sender, from, _allowance + value, _allowance);
emit Approval(from, msg.sender, _allowance);
}
}
}
require(value != 0, "zero value burn");
require(from != address(0), "burn from the zero address");
require(tokenBalances[from] >= value, "burn amount exceeds balance");
tokenBalances[from] -= value;
totalSupply -= value;
__updateHistory(totalSupplyHistory, sub, value);
__moveVotingPower(msg.sender, votingDelegates[from], address(0), value);
emit Burnt(msg.sender, from, value);
emit Transfer(msg.sender, from, address(0), value);
emit Transfer(from, address(0), value);
return true;
}
function permit(address owner, address spender, uint256 value, uint256 exp, uint8 v, bytes32 r, bytes32 s) public override {
require(_isFeatureEnabled(FEATURE_EIP2612_PERMITS), "EIP2612 permits are disabled");
address signer = __deriveSigner(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, exp), v, r, s);
require(signer == owner, "invalid signature");
require(block.timestamp < exp, "signature expired");
__approve(owner, spender, value);
}
function authorizationState(address authorizer, bytes32 nonce) public override view returns (bool) {
return usedNonces[authorizer][nonce];
}
function transferWithAuthorization(
address from,
address to,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) public override {
require(_isFeatureEnabled(FEATURE_EIP3009_TRANSFERS), "EIP3009 transfers are disabled");
address signer = __deriveSigner(abi.encode(TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce), v, r, s);
require(signer == from, "invalid signature");
require(block.timestamp > validAfter, "signature not yet valid");
require(block.timestamp < validBefore, "signature expired");
__useNonce(from, nonce, false);
__transferFrom(signer, from, to, value);
}
function receiveWithAuthorization(
address from,
address to,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) public override {
require(_isFeatureEnabled(FEATURE_EIP3009_RECEPTIONS), "EIP3009 receptions are disabled");
address signer = __deriveSigner(abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce), v, r, s);
require(signer == from, "invalid signature");
require(block.timestamp > validAfter, "signature not yet valid");
require(block.timestamp < validBefore, "signature expired");
require(to == msg.sender, "access denied");
__useNonce(from, nonce, false);
__transferFrom(signer, from, to, value);
}
function cancelAuthorization(
address authorizer,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) public override {
address signer = __deriveSigner(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce), v, r, s);
require(signer == authorizer, "invalid signature");
__useNonce(authorizer, nonce, true);
}
function __deriveSigner(bytes memory abiEncodedTypehash, uint8 v, bytes32 r, bytes32 s) private view returns(address) {
bytes32 hashStruct = keccak256(abiEncodedTypehash);
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), hashStruct));
address signer = ECDSA.recover(digest, v, r, s);
return signer;
}
function __useNonce(address authorizer, bytes32 nonce, bool cancellation) private {
require(!usedNonces[authorizer][nonce], "invalid nonce");
usedNonces[authorizer][nonce] = true;
if(cancellation) {
emit AuthorizationCanceled(authorizer, nonce);
}
else {
emit AuthorizationUsed(authorizer, nonce);
}
}
function votingPowerOf(address holder) public view returns (uint256) {
KV[] storage history = votingPowerHistory[holder];
return history.length == 0? 0: history[history.length - 1].v;
}
function votingPowerAt(address holder, uint256 blockNum) public view returns (uint256) {
require(blockNum < block.number, "block not yet mined");
return __binaryLookup(votingPowerHistory[holder], blockNum);
}
function votingPowerHistoryOf(address holder) public view returns(KV[] memory) {
return votingPowerHistory[holder];
}
function votingPowerHistoryLength(address holder) public view returns(uint256) {
return votingPowerHistory[holder].length;
}
function totalSupplyAt(uint256 blockNum) public view returns(uint256) {
require(blockNum < block.number, "block not yet mined");
return __binaryLookup(totalSupplyHistory, blockNum);
}
function entireSupplyHistory() public view returns(KV[] memory) {
return totalSupplyHistory;
}
function totalSupplyHistoryLength() public view returns(uint256) {
return totalSupplyHistory.length;
}
function delegate(address to) public {
require(_isFeatureEnabled(FEATURE_DELEGATIONS), "delegations are disabled");
__delegate(msg.sender, to);
}
function __delegate(address from, address to) private {
address fromDelegate = votingDelegates[from];
uint256 value = tokenBalances[from];
votingDelegates[from] = to;
__moveVotingPower(from, fromDelegate, to, value);
emit DelegateChanged(from, fromDelegate, to);
}
function delegateWithAuthorization(address to, bytes32 nonce, uint256 exp, uint8 v, bytes32 r, bytes32 s) public {
require(_isFeatureEnabled(FEATURE_DELEGATIONS_ON_BEHALF), "delegations on behalf are disabled");
address signer = __deriveSigner(abi.encode(DELEGATION_TYPEHASH, to, nonce, exp), v, r, s);
require(block.timestamp < exp, "signature expired");
__useNonce(signer, nonce, false);
__delegate(signer, to);
}
function __moveVotingPower(address by, address from, address to, uint256 value) private {
if(from == to || value == 0) {
return;
}
if(from != address(0)) {
KV[] storage h = votingPowerHistory[from];
(uint256 fromVal, uint256 toVal) = __updateHistory(h, sub, value);
emit VotingPowerChanged(by, from, fromVal, toVal);
}
if(to != address(0)) {
KV[] storage h = votingPowerHistory[to];
(uint256 fromVal, uint256 toVal) = __updateHistory(h, add, value);
emit VotingPowerChanged(by, to, fromVal, toVal);
}
}
function __updateHistory(
KV[] storage h,
function(uint256,uint256) pure returns(uint256) op,
uint256 delta
) private returns(uint256 fromVal, uint256 toVal) {
fromVal = h.length == 0? 0: h[h.length - 1].v;
toVal = op(fromVal, delta);
if(h.length != 0 && h[h.length - 1].k == block.number) {
h[h.length - 1].v = uint192(toVal);
}
else {
h.push(KV(uint64(block.number), uint192(toVal)));
}
}
function __binaryLookup(KV[] storage h, uint256 k) private view returns(uint256) {
if(h.length == 0) {
return 0;
}
if(h[h.length - 1].k <= k) {
return h[h.length - 1].v;
}
if(h[0].k > k) {
return 0;
}
uint256 i = 0;
uint256 j = h.length - 1;
while(j > i) {
uint256 m = j - (j - i) / 2;
KV memory kv = h[m];
if(kv.k == k) {
return kv.v;
}
else if(kv.k < k) {
i = m;
}
else {
j = m - 1;
}
}
return h[i].v;
}
function add(uint256 a, uint256 b) private pure returns(uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) private pure returns(uint256) {
return a - b;
}
}
