编译器
0.8.24+commit.e11b9ed9
文件 1 的 17：Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 2 的 17：ECDSA.sol
pragma solidity ^0.8.20;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
error ECDSAInvalidSignature();
error ECDSAInvalidSignatureLength(uint256 length);
error ECDSAInvalidSignatureS(bytes32 s);
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
文件 3 的 17：IDelegateRegistry.sol
pragma solidity >=0.8.13;
interface IDelegateRegistry {
enum DelegationType {
NONE,
ALL,
CONTRACT,
ERC721,
ERC20,
ERC1155
}
struct Delegation {
DelegationType type_;
address to;
address from;
bytes32 rights;
address contract_;
uint256 tokenId;
uint256 amount;
}
event DelegateAll(address indexed from, address indexed to, bytes32 rights, bool enable);
event DelegateContract(address indexed from, address indexed to, address indexed contract_, bytes32 rights, bool enable);
event DelegateERC721(address indexed from, address indexed to, address indexed contract_, uint256 tokenId, bytes32 rights, bool enable);
event DelegateERC20(address indexed from, address indexed to, address indexed contract_, bytes32 rights, uint256 amount);
event DelegateERC1155(address indexed from, address indexed to, address indexed contract_, uint256 tokenId, bytes32 rights, uint256 amount);
error MulticallFailed();
function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
function delegateAll(address to, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);
function delegateContract(address to, address contract_, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);
function delegateERC721(address to, address contract_, uint256 tokenId, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);
function delegateERC20(address to, address contract_, bytes32 rights, uint256 amount) external payable returns (bytes32 delegationHash);
function delegateERC1155(address to, address contract_, uint256 tokenId, bytes32 rights, uint256 amount) external payable returns (bytes32 delegationHash);
function checkDelegateForAll(address to, address from, bytes32 rights) external view returns (bool);
function checkDelegateForContract(address to, address from, address contract_, bytes32 rights) external view returns (bool);
function checkDelegateForERC721(address to, address from, address contract_, uint256 tokenId, bytes32 rights) external view returns (bool);
function checkDelegateForERC20(address to, address from, address contract_, bytes32 rights) external view returns (uint256);
function checkDelegateForERC1155(address to, address from, address contract_, uint256 tokenId, bytes32 rights) external view returns (uint256);
function getIncomingDelegations(address to) external view returns (Delegation[] memory delegations);
function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations);
function getIncomingDelegationHashes(address to) external view returns (bytes32[] memory delegationHashes);
function getOutgoingDelegationHashes(address from) external view returns (bytes32[] memory delegationHashes);
function getDelegationsFromHashes(bytes32[] calldata delegationHashes) external view returns (Delegation[] memory delegations);
function readSlot(bytes32 location) external view returns (bytes32);
function readSlots(bytes32[] calldata locations) external view returns (bytes32[] memory);
}
文件 4 的 17：IDelegationRegistry.sol
pragma solidity ^0.8.17;
interface IDelegationRegistry {
enum DelegationType {
NONE,
ALL,
CONTRACT,
TOKEN
}
struct DelegationInfo {
DelegationType type_;
address vault;
address delegate;
address contract_;
uint256 tokenId;
}
struct ContractDelegation {
address contract_;
address delegate;
}
struct TokenDelegation {
address contract_;
uint256 tokenId;
address delegate;
}
event DelegateForAll(address vault, address delegate, bool value);
event DelegateForContract(
address vault,
address delegate,
address contract_,
bool value
);
event DelegateForToken(
address vault,
address delegate,
address contract_,
uint256 tokenId,
bool value
);
event RevokeAllDelegates(address vault);
event RevokeDelegate(address vault, address delegate);
function delegateForAll(address delegate, bool value) external;
function delegateForContract(
address delegate,
address contract_,
bool value
) external;
function delegateForToken(
address delegate,
address contract_,
uint256 tokenId,
bool value
) external;
function revokeAllDelegates() external;
function revokeDelegate(address delegate) external;
function revokeSelf(address vault) external;
function getDelegationsByDelegate(
address delegate
) external view returns (DelegationInfo[] memory);
function getDelegatesForAll(
address vault
) external view returns (address[] memory);
function getDelegatesForContract(
address vault,
address contract_
) external view returns (address[] memory);
function getDelegatesForToken(
address vault,
address contract_,
uint256 tokenId
) external view returns (address[] memory);
function getContractLevelDelegations(
address vault
) external view returns (ContractDelegation[] memory delegations);
function getTokenLevelDelegations(
address vault
) external view returns (TokenDelegation[] memory delegations);
function checkDelegateForAll(
address delegate,
address vault
) external view returns (bool);
function checkDelegateForContract(
address delegate,
address vault,
address contract_
) external view returns (bool);
function checkDelegateForToken(
address delegate,
address vault,
address contract_,
uint256 tokenId
) external view returns (bool);
}
文件 5 的 17：IERC165.sol
pragma solidity ^0.8.20;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 6 的 17：IERC721.sol
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
文件 7 的 17：Math.sol
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
文件 8 的 17：MerkleProof.sol
pragma solidity ^0.8.20;
library MerkleProof {
error MerkleProofInvalidMultiproof();
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
if (leavesLen + proofLen != totalHashes + 1) {
revert MerkleProofInvalidMultiproof();
}
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
if (proofPos != proofLen) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
if (leavesLen + proofLen != totalHashes + 1) {
revert MerkleProofInvalidMultiproof();
}
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
if (proofPos != proofLen) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
文件 9 的 17：MessageHashUtils.sol
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
library MessageHashUtils {
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
文件 10 的 17：Ownable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 11 的 17：Ownable2Step.sol
pragma solidity ^0.8.20;
import {Ownable} from "./Ownable.sol";
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
文件 12 的 17：Pausable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Pausable is Context {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 13 的 17：Presale.sol
pragma solidity 0.8.24;
import {MerkleProof} from "lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol";
import {ECDSA} from "lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol";
import {MessageHashUtils} from "lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC721} from "lib/openzeppelin-contracts/contracts/token/ERC721/IERC721.sol";
import {ReentrancyGuard} from "lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol";
import {Ownable2Step, Ownable} from "lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol";
import {Pausable} from "lib/openzeppelin-contracts/contracts/utils/Pausable.sol";
import {IDelegationRegistry} from "src/lib/IDelegationRegistry.sol";
import {IDelegateRegistry} from "lib/delegate-registry/src/IDelegateRegistry.sol";
contract Presale is Ownable2Step, Pausable, ReentrancyGuard {
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
bytes32 public immutable cachedDomainSeparator;
uint256 public immutable cachedChainId;
address public immutable cachedThis;
address public immutable diceNFT;
address public immutable treasury;
IDelegationRegistry public immutable delegateRegistryV1;
IDelegateRegistry public immutable delegateRegistryV2;
struct BuyWithDiceNFTParams {
bytes32[] proof;
uint256 tokenId;
uint256 amount;
uint256 maxAmount;
}
struct BuyWithAllowedNFTParams {
bytes32[] proof;
address collection;
uint256 tokenId;
uint256 amount;
uint256 maxAmount;
}
struct AllowedWalletParams {
bytes32[] proof;
uint256 amount;
uint256 maxAmount;
}
enum Phase {
Guaranteed,
Lucky,
Open
}
bytes32 public allowedWalletsMerkleRoot;
bytes32 public diceNFTsMerkleRoot;
bytes32 public allowedNFTsMerkleRoot;
bytes32 public openPhaseAllocationsMerkleRoot;
bytes32 public diceNFTsTokensEligibleMerkleRoot;
uint256 public guaranteedAllocation;
uint256 public luckyAllocationTier1;
uint256 public luckyAllocationTier2;
uint256 public luckyAllocationTier3;
address public luckySigner;
uint256 public guaranteedStart;
uint256 public guaranteedEnd;
uint256 public luckyStart;
uint256 public luckyEnd;
uint256 public openStart;
uint256 public openEnd;
uint256 public openPhaseWalletCap;
uint256 public openPhaseContributionStep;
uint256 public guaranteedExchangeRate;
uint256 public luckyExchangeRate1;
uint256 public luckyExchangeRate2;
uint256 public luckyExchangeRate3;
uint256 public guaranteedRaisedETH;
uint256 public luckyRaisedETH;
uint256 public openRaisedETH;
mapping(uint256 => uint256) public diceNFTContributed;
mapping(address => uint256) public allowedWalletContributed;
mapping(address => mapping(uint256 => uint256)) public allowedNFTContributed;
mapping(address => uint256) public luckyPhaseContributed;
mapping(bytes => uint256) public raffleTicketContributed;
mapping(address => uint256) public openPhaseContributed;
mapping(address => uint256) public tokensEligible;
modifier phaseGuard(Phase _phase) {
bool isPhaseActive = isPhaseActive(_phase);
if (!isPhaseActive) {
revert PhaseNotActive(_phase);
}
_;
}
modifier onlyBeforePresale() {
if (
(guaranteedStart != 0 && block.timestamp > guaranteedStart)
|| (luckyStart != 0 && block.timestamp > luckyStart) || (openStart != 0 && block.timestamp > openStart)
) {
revert OnlyBeforePresale();
}
_;
}
modifier onlyAfterPresale() {
if (
(guaranteedEnd != 0 && block.timestamp < guaranteedEnd) || (luckyEnd != 0 && block.timestamp < luckyEnd)
|| (openEnd != 0 && block.timestamp < openEnd)
) {
revert OnlyAfterPresale();
}
_;
}
constructor(
address _diceNFT,
address _treasury,
address _initialOwner,
address _delegateRegistryV1,
address _delegateRegistryV2
) Ownable(_initialOwner) {
diceNFT = _diceNFT;
treasury = _treasury;
delegateRegistryV1 = IDelegationRegistry(_delegateRegistryV1);
delegateRegistryV2 = IDelegateRegistry(_delegateRegistryV2);
cachedChainId = block.chainid;
cachedDomainSeparator = _constructDomainSeparator();
cachedThis = address(this);
}
function buyWithDiceNFTs(BuyWithDiceNFTParams[] calldata _params) public payable {
uint256 ethContributed;
for (uint256 i = 0; i < _params.length; i++) {
_buyWithDiceNFT(_params[i].amount, _params[i].proof, _params[i].tokenId, _params[i].maxAmount);
ethContributed += _params[i].amount;
}
if (ethContributed != msg.value) {
revert ContributionAmountMismatch();
}
}
function buyWithDiceNFT(bytes32[] calldata _proof, uint256 _tokenId, uint256 _maxAmount) external payable {
_buyWithDiceNFT(msg.value, _proof, _tokenId, _maxAmount);
}
function buyWithAllowedWallet(bytes32[] calldata _proof, uint256 _maxAmount) external payable {
_buyWithAllowedWallet(msg.value, _proof, _maxAmount);
}
function buyWithAllowedNFTs(BuyWithAllowedNFTParams[] calldata _params) external payable {
uint256 ethContributed;
for (uint256 i = 0; i < _params.length; i++) {
_buyWithAllowedNFT(
_params[i].amount, _params[i].proof, _params[i].collection, _params[i].tokenId, _params[i].maxAmount
);
ethContributed += _params[i].amount;
}
if (ethContributed != msg.value) {
revert ContributionAmountMismatch();
}
}
function buyWithAllowedNFT(bytes32[] calldata _proof, address _collection, uint256 _tokenId, uint256 _maxAmount)
external
payable
{
_buyWithAllowedNFT(msg.value, _proof, _collection, _tokenId, _maxAmount);
}
function buyLuckyTier(uint256 _maxAmount, bytes calldata _signature) external payable {
_buyLuckyTier(msg.value, _maxAmount, _signature);
}
function buyOpenPhase() external payable {
_buyOpenPhase(msg.value);
}
function buyAllPhases(
BuyWithDiceNFTParams[] calldata _diceNFTParams,
BuyWithAllowedNFTParams[] calldata _allowedNFTParams,
AllowedWalletParams calldata _allowedWalletParams,
bytes calldata _luckyPhaseSignature,
uint256 _luckyPhaseAmount,
uint256 _luckyPhaseMaxAmount,
uint256 _openPhaseAmount
) external payable {
uint256 ethContributed;
uint256 diceNFTParamsLength = _diceNFTParams.length;
for (uint256 i = 0; i < diceNFTParamsLength; i++) {
BuyWithDiceNFTParams memory param = _diceNFTParams[i];
_buyWithDiceNFT(param.amount, _diceNFTParams[i].proof, param.tokenId, param.maxAmount);
ethContributed += param.amount;
}
uint256 allowedNFTParamsLength = _allowedNFTParams.length;
for (uint256 i = 0; i < allowedNFTParamsLength; i++) {
BuyWithAllowedNFTParams memory param = _allowedNFTParams[i];
_buyWithAllowedNFT(
param.amount, _allowedNFTParams[i].proof, param.collection, param.tokenId, param.maxAmount
);
ethContributed += param.amount;
}
if (_allowedWalletParams.proof.length > 0) {
_buyWithAllowedWallet(
_allowedWalletParams.amount, _allowedWalletParams.proof, _allowedWalletParams.maxAmount
);
ethContributed += _allowedWalletParams.amount;
}
if (_luckyPhaseSignature.length > 0) {
_buyLuckyTier(_luckyPhaseAmount, _luckyPhaseMaxAmount, _luckyPhaseSignature);
ethContributed += _luckyPhaseAmount;
}
if (_openPhaseAmount > 0) {
_buyOpenPhase(_openPhaseAmount);
ethContributed += _openPhaseAmount;
}
if (ethContributed != msg.value) {
revert ContributionAmountMismatch();
}
}
function calculateTokens(uint256 _amount, Phase _phase) public view returns (uint256 tokens) {
if (_phase == Phase.Guaranteed) {
tokens = _amount * guaranteedExchangeRate;
} else {
uint256 remainingETH = _amount;
uint256 luckyRaisedETH_ = luckyRaisedETH;
uint256 tier1Space = luckyAllocationTier1 > luckyRaisedETH_ ? luckyAllocationTier1 - luckyRaisedETH_ : 0;
if (tier1Space > 0) {
uint256 tier1ETH = remainingETH > tier1Space ? tier1Space : remainingETH;
tokens = tier1ETH * luckyExchangeRate1;
remainingETH -= tier1ETH;
luckyRaisedETH_ += tier1Space;
}
if (remainingETH > 0) {
uint256 tier2Space = luckyAllocationTier1 + luckyAllocationTier2 > luckyRaisedETH_
? luckyAllocationTier1 + luckyAllocationTier2 - luckyRaisedETH_
: 0;
if (tier2Space > 0) {
uint256 tier2ETH = remainingETH > tier2Space ? tier2Space : remainingETH;
tokens += tier2ETH * luckyExchangeRate2;
remainingETH -= tier2ETH;
}
}
if (remainingETH > 0) {
tokens += remainingETH * luckyExchangeRate3;
}
}
}
function isPhaseActive(Phase _phase) public view returns (bool) {
if (_phase == Phase.Guaranteed) {
if (
guaranteedRaisedETH > guaranteedAllocation
|| (block.timestamp < guaranteedStart || block.timestamp > guaranteedEnd)
) {
return false;
}
} else if (_phase == Phase.Lucky) {
if (
luckyRaisedETH > luckyAllocationTier1 + luckyAllocationTier2 + luckyAllocationTier3
|| (block.timestamp < luckyStart || block.timestamp > luckyEnd)
) {
return false;
}
} else if (_phase == Phase.Open) {
if (block.timestamp < openStart || block.timestamp > openEnd) {
return false;
}
}
return true;
}
function setAllowedWalletsMerkleRoot(bytes32 _allowedWalletsMerkleRoot) external onlyOwner onlyBeforePresale {
allowedWalletsMerkleRoot = _allowedWalletsMerkleRoot;
emit AllowedWalletsMerkleRootSet(_allowedWalletsMerkleRoot);
}
function setDiceNFTsMerkleRoot(bytes32 _diceNFTsMerkleRoot) external onlyOwner onlyBeforePresale {
diceNFTsMerkleRoot = _diceNFTsMerkleRoot;
emit DiceNFTsMerkleRootSet(_diceNFTsMerkleRoot);
}
function setAllowedNFTsMerkleRoot(bytes32 _allowedNFTsMerkleRoot) external onlyOwner onlyBeforePresale {
allowedNFTsMerkleRoot = _allowedNFTsMerkleRoot;
emit AllowedNFTsMerkleRootSet(_allowedNFTsMerkleRoot);
}
function setOpenPhaseAllocationsMerkleRoot(bytes32 _openPhaseAllocationsMerkleRoot)
external
onlyOwner
onlyAfterPresale
{
openPhaseAllocationsMerkleRoot = _openPhaseAllocationsMerkleRoot;
emit OpenPhaseAllocationsMerkleRootSet(_openPhaseAllocationsMerkleRoot);
}
function setDiceNFTsTokensEligibleMerkleRoot(bytes32 _diceNFTsTokensEligibleMerkleRoot)
external
onlyOwner
onlyAfterPresale
{
diceNFTsTokensEligibleMerkleRoot = _diceNFTsTokensEligibleMerkleRoot;
emit DiceNFTsTokensEligibleMerkleRootSet(_diceNFTsTokensEligibleMerkleRoot);
}
function setGuaranteedPhase(uint256 _guaranteedStart, uint256 _guaranteedEnd, uint256 _guaranteedAllocation)
external
onlyOwner
onlyBeforePresale
{
guaranteedStart = _guaranteedStart;
guaranteedEnd = _guaranteedEnd;
guaranteedAllocation = _guaranteedAllocation;
emit GuaranteedPhaseSet(guaranteedStart, guaranteedEnd, guaranteedAllocation);
}
function setLuckyPhase(
uint256 _luckyStart,
uint256 _luckyEnd,
uint256 _luckyAllocationTier1,
uint256 _luckyAllocationTier2,
uint256 _luckyAllocationTier3,
address _luckySigner
) external onlyOwner onlyBeforePresale {
luckyStart = _luckyStart;
luckyEnd = _luckyEnd;
luckyAllocationTier1 = _luckyAllocationTier1;
luckyAllocationTier2 = _luckyAllocationTier2;
luckyAllocationTier3 = _luckyAllocationTier3;
luckySigner = _luckySigner;
emit LuckyPhaseSet(
_luckyStart, _luckyEnd, _luckyAllocationTier1, _luckyAllocationTier2, _luckyAllocationTier3, _luckySigner
);
}
function setOpenPhase(
uint256 _openStart,
uint256 _openEnd,
uint256 _openPhaseWalletCap,
uint256 _openPhaseContributionStep
) external onlyOwner onlyBeforePresale {
openStart = _openStart;
openEnd = _openEnd;
openPhaseWalletCap = _openPhaseWalletCap;
openPhaseContributionStep = _openPhaseContributionStep;
emit OpenPhaseSet(_openStart, _openEnd, _openPhaseWalletCap, _openPhaseContributionStep);
}
function setExchangeRates(
uint256 _guaranteedExchangeRate,
uint256 _luckyExchangeRate1,
uint256 _luckyExchangeRate2,
uint256 _luckyExchangeRate3
) external onlyOwner onlyBeforePresale {
guaranteedExchangeRate = _guaranteedExchangeRate;
luckyExchangeRate1 = _luckyExchangeRate1;
luckyExchangeRate2 = _luckyExchangeRate2;
luckyExchangeRate3 = _luckyExchangeRate3;
emit ExchangeRatesSet(_guaranteedExchangeRate, _luckyExchangeRate1, _luckyExchangeRate2, _luckyExchangeRate3);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function _buyWithDiceNFT(uint256 _amount, bytes32[] calldata _proof, uint256 _tokenId, uint256 _maxAmount)
internal
nonReentrant
whenNotPaused
phaseGuard(Phase.Guaranteed)
{
_verifyTokenOwner(diceNFT, _tokenId);
_verifyDiceNFTProof(_proof, _tokenId, _maxAmount);
if (diceNFTContributed[_tokenId] + _amount > _maxAmount) {
revert ExceededDiceNFTCap(_tokenId);
}
if (guaranteedRaisedETH + _amount > guaranteedAllocation) {
revert ExceededGuaranteedAllocation();
}
uint256 tokensAmount = calculateTokens(_amount, Phase.Guaranteed);
tokensEligible[msg.sender] += tokensAmount;
diceNFTContributed[_tokenId] += _amount;
guaranteedRaisedETH += _amount;
(bool success,) = treasury.call{value: _amount}("");
if (!success) {
revert TransferFailed(treasury, _amount);
}
emit ContributedDiceNFT(msg.sender, _amount, tokensAmount, _tokenId);
}
function _buyWithAllowedNFT(
uint256 _amount,
bytes32[] calldata _proof,
address _collection,
uint256 _tokenId,
uint256 _maxAmount
) internal nonReentrant whenNotPaused phaseGuard(Phase.Guaranteed) {
_verifyTokenOwner(_collection, _tokenId);
_verifyAllowedNFTProof(_proof, _collection, _maxAmount);
if (guaranteedRaisedETH + _amount > guaranteedAllocation) {
revert ExceededGuaranteedAllocation();
}
if (allowedNFTContributed[_collection][_tokenId] + _amount > _maxAmount) {
revert ExceededNFTCap(_collection, _tokenId);
}
uint256 tokensAmount = calculateTokens(_amount, Phase.Guaranteed);
tokensEligible[msg.sender] += tokensAmount;
allowedNFTContributed[_collection][_tokenId] += _amount;
guaranteedRaisedETH += _amount;
(bool success,) = treasury.call{value: _amount}("");
if (!success) {
revert TransferFailed(treasury, _amount);
}
emit ContributedAllowedNFT(msg.sender, _amount, tokensAmount, _collection, _tokenId);
}
function _buyWithAllowedWallet(uint256 _amount, bytes32[] calldata _proof, uint256 _maxAmount)
internal
nonReentrant
whenNotPaused
phaseGuard(Phase.Guaranteed)
{
_verifyAllowedWalletProof(_proof, _maxAmount);
if (allowedWalletContributed[msg.sender] + _amount > _maxAmount) {
revert ExceededAllowedWalletCap(msg.sender);
}
if (guaranteedRaisedETH + _amount > guaranteedAllocation) {
revert ExceededGuaranteedAllocation();
}
uint256 tokensAmount = calculateTokens(_amount, Phase.Guaranteed);
tokensEligible[msg.sender] += tokensAmount;
allowedWalletContributed[msg.sender] += _amount;
guaranteedRaisedETH += _amount;
(bool success,) = treasury.call{value: _amount}("");
if (!success) {
revert TransferFailed(treasury, _amount);
}
emit ContributedAllowedWallet(msg.sender, _amount, tokensAmount);
}
function _buyLuckyTier(uint256 _amount, uint256 _maxAmount, bytes calldata _signature)
internal
nonReentrant
whenNotPaused
phaseGuard(Phase.Lucky)
{
_verifyLuckySignature(_maxAmount, _signature);
if (raffleTicketContributed[_signature] + _amount > _maxAmount) {
revert ExceededRaffleTicketContribution();
} else if (luckyRaisedETH + _amount > luckyAllocationTier1 + luckyAllocationTier2 + luckyAllocationTier3) {
revert ExceededLuckyAllocation();
}
uint256 tokensAmount = calculateTokens(_amount, Phase.Lucky);
tokensEligible[msg.sender] += tokensAmount;
raffleTicketContributed[_signature] += _amount;
luckyPhaseContributed[msg.sender] += _amount;
luckyRaisedETH += _amount;
(bool success,) = treasury.call{value: _amount}("");
if (!success) {
revert TransferFailed(treasury, _amount);
}
emit ContributedLuckyPhase(msg.sender, _amount, tokensAmount);
}
function _buyOpenPhase(uint256 _amount) internal nonReentrant whenNotPaused phaseGuard(Phase.Open) {
if (_amount % openPhaseContributionStep != 0) {
revert IncorrectContributionStep();
}
if (openPhaseContributed[msg.sender] + _amount > openPhaseWalletCap) {
revert ExceededOpenPhaseWalletCap(msg.sender);
}
openPhaseContributed[msg.sender] += _amount;
openRaisedETH += _amount;
(bool success,) = treasury.call{value: _amount}("");
if (!success) {
revert TransferFailed(treasury, _amount);
}
emit ContributedOpenPhase(msg.sender, _amount);
}
function _verifyTokenOwner(address _collection, uint256 _tokenId) internal view {
address _tokenOwner = IERC721(_collection).ownerOf(_tokenId);
if (_tokenOwner == msg.sender) {
return;
}
if (delegateRegistryV2.checkDelegateForERC721(msg.sender, _tokenOwner, _collection, _tokenId, "")) {
return;
}
if (delegateRegistryV1.checkDelegateForToken(msg.sender, _tokenOwner, _collection, _tokenId)) {
return;
}
revert NotTokenOwner(_collection, _tokenId);
}
function _verifyLuckySignature(uint256 _maxAmount, bytes calldata _signature) internal view {
bytes32 signedMessageHash = MessageHashUtils.toEthSignedMessageHash(
keccak256(abi.encode(_getDomainSeparator(), _maxAmount, msg.sender))
);
address recoveredOwner = ECDSA.recover(signedMessageHash, _signature);
if (recoveredOwner != luckySigner) {
revert InvalidSignature();
}
}
function _verifyAllowedWalletProof(bytes32[] calldata _proof, uint256 _maxAmount) internal view {
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender, _maxAmount))));
if (!MerkleProof.verify(_proof, allowedWalletsMerkleRoot, leaf)) {
revert InvalidAllowedWalletProof();
}
}
function _verifyDiceNFTProof(bytes32[] calldata _proof, uint256 _tokenId, uint256 _maxAmount) internal view {
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_tokenId, _maxAmount))));
if (!MerkleProof.verify(_proof, diceNFTsMerkleRoot, leaf)) {
revert InvalidDiceNFTProof();
}
}
function _verifyAllowedNFTProof(bytes32[] calldata _proof, address _collection, uint256 _maxAmount) internal view {
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_collection, _maxAmount))));
if (!MerkleProof.verify(_proof, allowedNFTsMerkleRoot, leaf)) {
revert InvalidAllowedNFTProof();
}
}
function _getDomainSeparator() internal view returns (bytes32) {
if (address(this) == cachedThis && block.chainid == cachedChainId) {
return cachedDomainSeparator;
} else {
return _constructDomainSeparator();
}
}
function _constructDomainSeparator() internal view returns (bytes32) {
return keccak256(abi.encode(DOMAIN_TYPEHASH, block.chainid, address(this)));
}
event AllowedWalletsMerkleRootSet(bytes32 indexed allowedWalletsMerkleRoot);
event DiceNFTsMerkleRootSet(bytes32 indexed diceNFTsMerkleRoot);
event AllowedNFTsMerkleRootSet(bytes32 indexed allowedNFTsMerkleRoot);
event OpenPhaseAllocationsMerkleRootSet(bytes32 indexed openPhaseAllocationsMerkleRoot);
event DiceNFTsTokensEligibleMerkleRootSet(bytes32 indexed diceNFTsTokensEligibleMerkleRootSet);
event ExchangeRatesSet(
uint256 guaranteedExchangeRate,
uint256 luckyExchangeRate1,
uint256 luckyExchangeRate2,
uint256 luckyExchangeRate3
);
event GuaranteedPhaseSet(
uint256 indexed guaranteedStart, uint256 indexed guaranteedEnd, uint256 indexed guaranteedAllocation
);
event LuckyPhaseSet(
uint256 luckyStart,
uint256 luckyEnd,
uint256 luckyAllocationTier1,
uint256 luckyAllocationTier2,
uint256 luckyAllocationTier3,
address luckySigner
);
event OpenPhaseSet(
uint256 openStart, uint256 openEnd, uint256 openPhaseWalletCap, uint256 openPhaseContributionStep
);
event Contributed(address indexed contributor, uint256 indexed amount);
event ContributedAllowedWallet(address indexed contributor, uint256 indexed amount, uint256 indexed tokensAmount);
event ContributedDiceNFT(
address indexed contributor, uint256 indexed amount, uint256 indexed tokensAmount, uint256 tokenId
);
event ContributedAllowedNFT(
address indexed contributor,
uint256 indexed amount,
uint256 indexed tokensAmount,
address collection,
uint256 tokenId
);
event ContributedLuckyPhase(address indexed contributor, uint256 indexed amount, uint256 indexed tokensAmount);
event ContributedOpenPhase(address indexed contributor, uint256 indexed amount);
error TransferFailed(address recipient, uint256 amount);
error InvalidSignature();
error InvalidAllowedWalletProof();
error InvalidDiceNFTProof();
error InvalidAllowedNFTProof();
error ExceededDiceNFTCap(uint256 tokenId);
error ExceededNFTCap(address collection, uint256 tokenId);
error ExceededGuaranteedAllocation();
error ContributionAmountMismatch();
error ExceededLuckyAllocation();
error ExceededAllowedWalletCap(address wallet);
error ExceededOpenPhaseWalletCap(address wallet);
error IncorrectContributionStep();
error ExceededRaffleTicketContribution();
error PhaseNotActive(Phase phase);
error NotTokenOwner(address collection, uint256 tokenId);
error OnlyBeforePresale();
error OnlyAfterPresale();
}
文件 14 的 17：ReentrancyGuard.sol
pragma solidity ^0.8.20;
abstract contract ReentrancyGuard {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = ENTERED;
}
function _nonReentrantAfter() private {
_status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
文件 15 的 17：Refunds.sol
pragma solidity 0.8.24;
import {ReentrancyGuard} from "lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol";
import {Ownable2Step, Ownable} from "lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol";
import {MerkleProof} from "lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol";
import {Presale} from "src/Presale.sol";
contract Refunds is Ownable2Step, ReentrancyGuard {
Presale public immutable presale;
mapping(address => bool) public refunded;
uint256 public refundsStartedAt;
constructor(address _initialOwner, address _presale) payable Ownable(_initialOwner) {
presale = Presale(_presale);
}
function claimRefund(bytes32[] calldata _proof, uint256 _ethAmount, uint256 _tokensAmount) external nonReentrant {
if (refundsStartedAt == 0) {
revert RefundsNotStarted();
} else if (block.timestamp > refundsStartedAt + 30 days) {
revert RefundsEnded();
} else if (refunded[msg.sender]) {
revert AlreadyRefunded(msg.sender);
}
_verifyOpenTierAllocation(_proof, _ethAmount, _tokensAmount);
uint256 refundable = _refundableAmount(_ethAmount);
if (refundable == 0) {
revert NothingToRefund(msg.sender);
}
refunded[msg.sender] = true;
(bool success,) = msg.sender.call{value: refundable}("");
if (!success) {
revert TransferFailed(msg.sender, refundable);
}
emit Refunded(msg.sender, refundable);
}
function refundableAmount(bytes32[] calldata _proof, uint256 _ethAmount, uint256 _tokensAmount)
external
view
returns (uint256)
{
_verifyOpenTierAllocation(_proof, _ethAmount, _tokensAmount);
return _refundableAmount(_ethAmount);
}
function startRefunds() external onlyOwner {
if (refundsStartedAt != 0) {
revert RefundsAlreadyStarted();
}
refundsStartedAt = block.timestamp;
emit RefundsStarted();
}
function withdraw() external onlyOwner {
if (refundsStartedAt == 0 || block.timestamp <= refundsStartedAt + 30 days) {
revert RefundsNotEnded();
}
uint256 balance = address(this).balance;
(bool success,) = owner().call{value: balance}("");
if (!success) {
revert TransferFailed(owner(), balance);
}
emit RefundsWithdrawn(balance);
}
receive() external payable {}
function _verifyOpenTierAllocation(bytes32[] calldata _proof, uint256 _ethAmount, uint256 _tokensAmount)
internal
view
{
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender, _ethAmount, _tokensAmount))));
bytes32 root = presale.openPhaseAllocationsMerkleRoot();
if (!MerkleProof.verify(_proof, root, leaf)) {
revert InvalidOpenTierAllocationsMerkleProof();
}
}
function _refundableAmount(uint256 _allocation) internal view returns (uint256) {
uint256 contributed = presale.openPhaseContributed(msg.sender);
if (_allocation >= contributed) {
return 0;
}
return contributed - _allocation;
}
event RefundsStarted();
event Refunded(address indexed recipient, uint256 indexed amount);
event RefundsWithdrawn(uint256 indexed amount);
error TransferFailed(address recipient, uint256 amount);
error RefundsNotStarted();
error RefundsAlreadyStarted();
error RefundsEnded();
error RefundsNotEnded();
error AlreadyRefunded(address recipient);
error NothingToRefund(address recipient);
error InvalidOpenTierAllocationsMerkleProof();
}
文件 16 的 17：SignedMath.sol
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 17 的 17：Strings.sol
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
{
"compilationTarget": {
"src/Refunds.sol": "Refunds"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 10000000
},
"remappings": [
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":LayerZero-v2/=lib/LayerZero-v2/",
":delegate-registry/=lib/delegate-registry/src/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":murky/=lib/delegate-registry/lib/murky/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/delegate-registry/lib/openzeppelin-contracts/contracts/"
]
}[{"inputs":[{"internalType":"address","name":"_initialOwner","type":"address"},{"internalType":"address","name":"_presale","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"AlreadyRefunded","type":"error"},{"inputs":[],"name":"InvalidOpenTierAllocationsMerkleProof","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"NothingToRefund","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"RefundsAlreadyStarted","type":"error"},{"inputs":[],"name":"RefundsEnded","type":"error"},{"inputs":[],"name":"RefundsNotEnded","type":"error"},{"inputs":[],"name":"RefundsNotStarted","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Refunded","type":"event"},{"anonymous":false,"inputs":[],"name":"RefundsStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RefundsWithdrawn","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"},{"internalType":"uint256","name":"_ethAmount","type":"uint256"},{"internalType":"uint256","name":"_tokensAmount","type":"uint256"}],"name":"claimRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"presale","outputs":[{"internalType":"contract Presale","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"},{"internalType":"uint256","name":"_ethAmount","type":"uint256"},{"internalType":"uint256","name":"_tokensAmount","type":"uint256"}],"name":"refundableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"refunded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundsStartedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startRefunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
