编译器
0.8.19+commit.7dd6d404
文件 1 的 45：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 45：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 3 的 45：ConfigurablePause.sol
pragma solidity 0.8.19;
import {PausableUpgradeable} from "@openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol";
contract ConfigurablePause is PausableUpgradeable {
uint128 public pauseStartTime;
uint128 public pauseDuration;
event PauseTimeUpdated(uint256 indexed newPauseStartTime);
event PauseDurationUpdated(
uint256 oldPauseDuration,
uint256 newPauseDuration
);
function paused() public view virtual override returns (bool) {
return
pauseStartTime == 0
? false
: block.timestamp <= pauseStartTime + pauseDuration;
}
function _updatePauseDuration(uint128 newPauseDuration) internal virtual {
uint256 oldPauseDuration = pauseDuration;
pauseDuration = newPauseDuration;
emit PauseDurationUpdated(oldPauseDuration, pauseDuration);
}
function _setPauseTime(uint128 newPauseStartTime) internal {
pauseStartTime = newPauseStartTime;
emit PauseTimeUpdated(newPauseStartTime);
}
}
文件 4 的 45：ConfigurablePauseGuardian.sol
pragma solidity 0.8.19;
import {ConfigurablePause} from "@protocol/xPOKT/ConfigurablePause.sol";
contract ConfigurablePauseGuardian is ConfigurablePause {
address public pauseGuardian;
event PauseGuardianUpdated(
address indexed oldPauseGuardian,
address indexed newPauseGuardian
);
function pauseUsed() public view returns (bool) {
return pauseStartTime != 0;
}
function kickGuardian() public whenNotPaused {
require(
pauseUsed(),
"ConfigurablePauseGuardian: did not pause, so cannot kick"
);
_resetPauseState();
}
function _resetPauseState() internal {
address previousPauseGuardian = pauseGuardian;
pauseGuardian = address(0);
_setPauseTime(0);
emit PauseGuardianUpdated(previousPauseGuardian, address(0));
}
function pause() public virtual whenNotPaused {
require(
msg.sender == pauseGuardian,
"ConfigurablePauseGuardian: only pause guardian"
);
require(!pauseUsed(), "ConfigurablePauseGuardian: pause already used");
_setPauseTime(uint128(block.timestamp));
emit Paused(msg.sender);
}
function unpause() external whenPaused {
require(
msg.sender == pauseGuardian,
"ConfigurablePauseGuardian: only pause guardian"
);
_resetPauseState();
emit Unpaused(msg.sender);
}
function _grantGuardian(address newPauseGuardian) internal {
address previousPauseGuardian = pauseGuardian;
pauseGuardian = newPauseGuardian;
_setPauseTime(0);
emit PauseGuardianUpdated(previousPauseGuardian, newPauseGuardian);
}
}
文件 5 的 45：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 6 的 45：ContextUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
文件 7 的 45：CountersUpgradeable.sol
pragma solidity ^0.8.0;
library CountersUpgradeable {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
文件 8 的 45：ECDSAUpgradeable.sol
pragma solidity ^0.8.0;
import "../StringsUpgradeable.sol";
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
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);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
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) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 9 的 45：EIP712Upgradeable.sol
pragma solidity ^0.8.8;
import "./ECDSAUpgradeable.sol";
import "../../interfaces/IERC5267Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
abstract contract EIP712Upgradeable is Initializable, IERC5267Upgradeable {
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private _hashedName;
bytes32 private _hashedVersion;
string private _name;
string private _version;
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
_name = name;
_version = version;
_hashedName = 0;
_hashedVersion = 0;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator();
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
require(_hashedName == 0 && _hashedVersion == 0, "EIP712: Uninitialized");
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal virtual view returns (string memory) {
return _name;
}
function _EIP712Version() internal virtual view returns (string memory) {
return _version;
}
function _EIP712NameHash() internal view returns (bytes32) {
string memory name = _EIP712Name();
if (bytes(name).length > 0) {
return keccak256(bytes(name));
} else {
bytes32 hashedName = _hashedName;
if (hashedName != 0) {
return hashedName;
} else {
return keccak256("");
}
}
}
function _EIP712VersionHash() internal view returns (bytes32) {
string memory version = _EIP712Version();
if (bytes(version).length > 0) {
return keccak256(bytes(version));
} else {
bytes32 hashedVersion = _hashedVersion;
if (hashedVersion != 0) {
return hashedVersion;
} else {
return keccak256("");
}
}
}
uint256[48] private __gap;
}
文件 10 的 45：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 11 的 45：ERC20PermitUpgradeable.sol
pragma solidity ^0.8.0;
import "./IERC20PermitUpgradeable.sol";
import "../ERC20Upgradeable.sol";
import "../../../utils/cryptography/ECDSAUpgradeable.sol";
import "../../../utils/cryptography/EIP712Upgradeable.sol";
import "../../../utils/CountersUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
function __ERC20Permit_init(string memory name) internal onlyInitializing {
__EIP712_init_unchained(name, "1");
}
function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
文件 12 的 45：ERC20Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
uint256[45] private __gap;
}
文件 13 的 45：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 14 的 45：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 15 的 45：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 16 的 45：IERC20MetadataUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 17 的 45：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 18 的 45：IERC20PermitUpgradeable.sol
pragma solidity ^0.8.0;
interface IERC20PermitUpgradeable {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 19 的 45：IERC20Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 20 的 45：IERC5267Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC5267Upgradeable {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 21 的 45：IWormholeReceiver.sol
pragma solidity ^0.8.0;
interface IWormholeReceiver {
function receiveWormholeMessages(
bytes memory payload,
bytes[] memory additionalMessages,
bytes32 sourceAddress,
uint16 sourceChain,
bytes32 deliveryHash
) external payable;
}
文件 22 的 45：IWormholeRelayer.sol
pragma solidity ^0.8.0;
struct VaaKey {
uint16 chainId;
bytes32 emitterAddress;
uint64 sequence;
}
uint8 constant VAA_KEY_TYPE = 1;
struct MessageKey {
uint8 keyType;
bytes encodedKey;
}
interface IWormholeRelayerBase {
event SendEvent(
uint64 indexed sequence,
uint256 deliveryQuote,
uint256 paymentForExtraReceiverValue
);
function getRegisteredWormholeRelayerContract(
uint16 chainId
) external view returns (bytes32);
function deliveryAttempted(
bytes32 deliveryHash
) external view returns (bool attempted);
function deliverySuccessBlock(
bytes32 deliveryHash
) external view returns (uint256 blockNumber);
function deliveryFailureBlock(
bytes32 deliveryHash
) external view returns (uint256 blockNumber);
}
interface IWormholeRelayerSend is IWormholeRelayerBase {
function sendPayloadToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit
) external payable returns (uint64 sequence);
function sendPayloadToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress
) external payable returns (uint64 sequence);
function sendVaasToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
VaaKey[] memory vaaKeys
) external payable returns (uint64 sequence);
function sendVaasToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 gasLimit,
VaaKey[] memory vaaKeys,
uint16 refundChain,
address refundAddress
) external payable returns (uint64 sequence);
function sendToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
function sendToEvm(
uint16 targetChain,
address targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
uint256 gasLimit,
uint16 refundChain,
address refundAddress,
address deliveryProviderAddress,
MessageKey[] memory messageKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
function send(
uint16 targetChain,
bytes32 targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
bytes memory encodedExecutionParameters,
uint16 refundChain,
bytes32 refundAddress,
address deliveryProviderAddress,
VaaKey[] memory vaaKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
function send(
uint16 targetChain,
bytes32 targetAddress,
bytes memory payload,
uint256 receiverValue,
uint256 paymentForExtraReceiverValue,
bytes memory encodedExecutionParameters,
uint16 refundChain,
bytes32 refundAddress,
address deliveryProviderAddress,
MessageKey[] memory messageKeys,
uint8 consistencyLevel
) external payable returns (uint64 sequence);
function resendToEvm(
VaaKey memory deliveryVaaKey,
uint16 targetChain,
uint256 newReceiverValue,
uint256 newGasLimit,
address newDeliveryProviderAddress
) external payable returns (uint64 sequence);
function resend(
VaaKey memory deliveryVaaKey,
uint16 targetChain,
uint256 newReceiverValue,
bytes memory newEncodedExecutionParameters,
address newDeliveryProviderAddress
) external payable returns (uint64 sequence);
function quoteEVMDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
uint256 gasLimit
)
external
view
returns (
uint256 nativePriceQuote,
uint256 targetChainRefundPerGasUnused
);
function quoteEVMDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
uint256 gasLimit,
address deliveryProviderAddress
)
external
view
returns (
uint256 nativePriceQuote,
uint256 targetChainRefundPerGasUnused
);
function quoteDeliveryPrice(
uint16 targetChain,
uint256 receiverValue,
bytes memory encodedExecutionParameters,
address deliveryProviderAddress
)
external
view
returns (uint256 nativePriceQuote, bytes memory encodedExecutionInfo);
function quoteNativeForChain(
uint16 targetChain,
uint256 currentChainAmount,
address deliveryProviderAddress
) external view returns (uint256 targetChainAmount);
function getDefaultDeliveryProvider()
external
view
returns (address deliveryProvider);
}
interface IWormholeRelayerDelivery is IWormholeRelayerBase {
enum DeliveryStatus {
SUCCESS,
RECEIVER_FAILURE
}
enum RefundStatus {
REFUND_SENT,
REFUND_FAIL,
CROSS_CHAIN_REFUND_SENT,
CROSS_CHAIN_REFUND_FAIL_PROVIDER_NOT_SUPPORTED,
CROSS_CHAIN_REFUND_FAIL_NOT_ENOUGH,
NO_REFUND_REQUESTED
}
event Delivery(
address indexed recipientContract,
uint16 indexed sourceChain,
uint64 indexed sequence,
bytes32 deliveryVaaHash,
DeliveryStatus status,
uint256 gasUsed,
RefundStatus refundStatus,
bytes additionalStatusInfo,
bytes overridesInfo
);
function deliver(
bytes[] memory encodedVMs,
bytes memory encodedDeliveryVAA,
address payable relayerRefundAddress,
bytes memory deliveryOverrides
) external payable;
}
interface IWormholeRelayer is IWormholeRelayerDelivery, IWormholeRelayerSend {}
文件 23 的 45：IWormholeTrustedSender.sol
pragma solidity 0.8.19;
interface IWormholeTrustedSender {
function isTrustedSender(
uint16 chainId,
bytes32 addr
) external view returns (bool);
function isTrustedSender(
uint16 chainId,
address addr
) external view returns (bool);
function allTrustedSenders(
uint16 chainId
) external view returns (bytes32[] memory);
function addressToBytes(address addr) external pure returns (bytes32);
}
文件 24 的 45：IXERC20.sol
pragma solidity 0.8.19;
interface IXERC20 {
event BridgeLimitsSet(address indexed bridge, uint256 bufferCap);
function mintingMaxLimitOf(
address _minter
) external view returns (uint256 _limit);
function burningMaxLimitOf(
address _bridge
) external view returns (uint256 _limit);
function mintingCurrentLimitOf(
address _minter
) external view returns (uint256 _limit);
function burningCurrentLimitOf(
address _bridge
) external view returns (uint256 _limit);
function mint(address _user, uint256 _amount) external;
function burn(address _user, uint256 _amount) external;
}
文件 25 的 45：IXERC20Lockbox.sol
pragma solidity 0.8.19;
interface IXERC20Lockbox {
event Deposit(address _sender, uint256 _amount);
event Withdraw(address _sender, uint256 _amount);
function deposit(uint256 _amount) external;
function depositTo(address _user, uint256 _amount) external;
function withdraw(uint256 _amount) external;
function withdrawTo(address _user, uint256 _amount) external;
}
文件 26 的 45：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 27 的 45：Math.sol
pragma solidity =0.8.19;
library Math {
function min(uint256 a, uint256 b) public pure returns (uint256) {
return a > b ? b : a;
}
}
文件 28 的 45：MathUpgradeable.sol
pragma solidity ^0.8.0;
library MathUpgradeable {
enum Rounding {
Down,
Up,
Zero
}
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) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
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 (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 29 的 45：MintLimits.sol
pragma solidity 0.8.19;
import {RateLimitedMidpointLibrary} from "@zelt/src/lib/RateLimitedMidpointLibrary.sol";
import {RateLimitMidPoint, RateLimitMidpointCommonLibrary} from "@zelt/src/lib/RateLimitMidpointCommonLibrary.sol";
abstract contract MintLimits {
using RateLimitMidpointCommonLibrary for RateLimitMidPoint;
using RateLimitedMidpointLibrary for RateLimitMidPoint;
struct RateLimitMidPointInfo {
uint112 bufferCap;
uint128 rateLimitPerSecond;
address bridge;
}
mapping(address bridge => RateLimitMidPoint bridgeRateLimit)
public rateLimits;
event ConfigurationChanged(
address indexed bridge,
uint112 bufferCap,
uint128 rateLimitPerSecond
);
function buffer(address from) public view returns (uint256) {
return rateLimits[from].buffer();
}
function bufferCap(address from) public view returns (uint256) {
return rateLimits[from].bufferCap;
}
function rateLimitPerSecond(address from) public view returns (uint256) {
return rateLimits[from].rateLimitPerSecond;
}
function _depleteBuffer(address from, uint256 amount) internal {
require(amount != 0, "MintLimits: deplete amount cannot be 0");
rateLimits[from].depleteBuffer(amount);
}
function _replenishBuffer(address from, uint256 amount) internal {
require(amount != 0, "MintLimits: replenish amount cannot be 0");
rateLimits[from].replenishBuffer(amount);
}
function _setRateLimitPerSecond(
address from,
uint128 newRateLimitPerSecond
) internal {
require(
newRateLimitPerSecond <= maxRateLimitPerSecond(),
"MintLimits: rateLimitPerSecond too high"
);
require(
rateLimits[from].bufferCap != 0,
"MintLimits: non-existent rate limit"
);
rateLimits[from].setRateLimitPerSecond(newRateLimitPerSecond);
emit ConfigurationChanged(
from,
rateLimits[from].bufferCap,
newRateLimitPerSecond
);
}
function _setBufferCap(address from, uint112 newBufferCap) internal {
require(newBufferCap != 0, "MintLimits: bufferCap cannot be 0");
require(
rateLimits[from].bufferCap != 0,
"MintLimits: non-existent rate limit"
);
require(
newBufferCap > minBufferCap(),
"MintLimits: buffer cap below min"
);
rateLimits[from].setBufferCap(newBufferCap);
emit ConfigurationChanged(
from,
newBufferCap,
rateLimits[from].rateLimitPerSecond
);
}
function _addLimits(RateLimitMidPointInfo[] memory _rateLimits) internal {
for (uint256 i = 0; i < _rateLimits.length; i++) {
_addLimit(_rateLimits[i]);
}
}
function _addLimit(RateLimitMidPointInfo memory rateLimit) internal {
require(
rateLimit.rateLimitPerSecond <= maxRateLimitPerSecond(),
"MintLimits: rateLimitPerSecond too high"
);
require(
rateLimit.bridge != address(0),
"MintLimits: invalid bridge address"
);
require(
rateLimits[rateLimit.bridge].bufferCap == 0,
"MintLimits: rate limit already exists"
);
require(
rateLimit.bufferCap > minBufferCap(),
"MintLimits: buffer cap below min"
);
rateLimits[rateLimit.bridge] = RateLimitMidPoint({
bufferCap: rateLimit.bufferCap,
lastBufferUsedTime: uint32(block.timestamp),
bufferStored: uint112(rateLimit.bufferCap / 2),
midPoint: uint112(rateLimit.bufferCap / 2),
rateLimitPerSecond: rateLimit.rateLimitPerSecond
});
emit ConfigurationChanged(
rateLimit.bridge,
rateLimit.bufferCap,
rateLimit.rateLimitPerSecond
);
}
function _removeLimits(address[] memory bridges) internal {
for (uint256 i = 0; i < bridges.length; i++) {
_removeLimit(bridges[i]);
}
}
function _removeLimit(address bridge) internal {
require(
rateLimits[bridge].bufferCap != 0,
"MintLimits: cannot remove non-existent rate limit"
);
delete rateLimits[bridge];
emit ConfigurationChanged(bridge, 0, 0);
}
function maxRateLimitPerSecond() public pure virtual returns (uint128);
function minBufferCap() public pure virtual returns (uint112);
}
文件 30 的 45：Ownable2StepUpgradeable.sol
pragma solidity ^0.8.0;
import "./OwnableUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
function __Ownable2Step_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable2Step_init_unchained() internal onlyInitializing {
}
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();
require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
_transferOwnership(sender);
}
uint256[49] private __gap;
}
文件 31 的 45：OwnableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
文件 32 的 45：PausableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
文件 33 的 45：RateLimitMidpointCommonLibrary.sol
pragma solidity =0.8.19;
import {Math} from "@zelt-src/util/Math.sol";
struct RateLimitMidPoint {
uint128 rateLimitPerSecond;
uint112 bufferCap;
uint32 lastBufferUsedTime;
uint112 bufferStored;
uint112 midPoint;
}
library RateLimitMidpointCommonLibrary {
event BufferCapUpdate(uint256 oldBufferCap, uint256 newBufferCap);
event RateLimitPerSecondUpdate(
uint256 oldRateLimitPerSecond,
uint256 newRateLimitPerSecond
);
function buffer(
RateLimitMidPoint storage limit
) public view returns (uint256) {
uint256 elapsed;
unchecked {
elapsed = uint32(block.timestamp) - limit.lastBufferUsedTime;
}
uint256 accrued = uint256(limit.rateLimitPerSecond) * elapsed;
if (limit.bufferStored < limit.midPoint) {
return
Math.min(
uint256(limit.bufferStored) + accrued,
uint256(limit.midPoint)
);
} else if (limit.bufferStored > limit.midPoint) {
if (
accrued > limit.bufferStored ||
limit.bufferStored - accrued < limit.midPoint
) {
return limit.midPoint;
} else {
return limit.bufferStored - accrued;
}
} else {
return limit.bufferStored;
}
}
function sync(RateLimitMidPoint storage limit) internal {
uint112 newBuffer = uint112(buffer(limit));
uint32 blockTimestamp = uint32(block.timestamp);
limit.lastBufferUsedTime = blockTimestamp;
limit.bufferStored = newBuffer;
}
function setRateLimitPerSecond(
RateLimitMidPoint storage limit,
uint128 newRateLimitPerSecond
) internal {
sync(limit);
uint256 oldRateLimitPerSecond = limit.rateLimitPerSecond;
limit.rateLimitPerSecond = newRateLimitPerSecond;
emit RateLimitPerSecondUpdate(
oldRateLimitPerSecond,
newRateLimitPerSecond
);
}
function setBufferCap(
RateLimitMidPoint storage limit,
uint112 newBufferCap
) internal {
sync(limit);
uint256 oldBufferCap = limit.bufferCap;
limit.bufferCap = newBufferCap;
limit.midPoint = uint112(newBufferCap / 2);
if (limit.bufferStored > newBufferCap) {
limit.bufferStored = newBufferCap;
}
emit BufferCapUpdate(oldBufferCap, newBufferCap);
}
}
文件 34 的 45：RateLimitedMidpointLibrary.sol
pragma solidity =0.8.19;
import {Math} from "@zelt-src/util/Math.sol";
import {RateLimitMidPoint, RateLimitMidpointCommonLibrary} from "@zelt-src/lib/RateLimitMidpointCommonLibrary.sol";
library RateLimitedMidpointLibrary {
using RateLimitMidpointCommonLibrary for RateLimitMidPoint;
event BufferUsed(uint256 amountUsed, uint256 bufferRemaining);
event BufferReplenished(uint256 amountReplenished, uint256 bufferRemaining);
function depleteBuffer(
RateLimitMidPoint storage limit,
uint256 amount
) internal {
uint256 newBuffer = limit.buffer();
require(amount <= newBuffer, "RateLimited: rate limit hit");
uint32 blockTimestamp = uint32(block.timestamp);
uint112 newBufferStored = uint112(newBuffer - amount);
limit.lastBufferUsedTime = blockTimestamp;
limit.bufferStored = newBufferStored;
emit BufferUsed(amount, newBufferStored);
}
function replenishBuffer(
RateLimitMidPoint storage limit,
uint256 amount
) internal {
uint256 buffer = limit.buffer();
uint256 _bufferCap = limit.bufferCap;
uint256 newBuffer = buffer + amount;
require(newBuffer <= _bufferCap, "RateLimited: buffer cap overflow");
uint32 blockTimestamp = uint32(block.timestamp);
uint112 newBufferStored = uint112(newBuffer);
limit.lastBufferUsedTime = blockTimestamp;
limit.bufferStored = newBufferStored;
emit BufferReplenished(amount, newBufferStored);
}
}
文件 35 的 45：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 36 的 45：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 37 的 45：SignedMathUpgradeable.sol
pragma solidity ^0.8.0;
library SignedMathUpgradeable {
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);
}
}
}
文件 38 的 45：StringsUpgradeable.sol
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.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), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
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] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
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 keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 39 的 45：WPOKTRouter.sol
pragma solidity 0.8.19;
import {SafeERC20} from "@openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import {ERC20} from "@openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
import {xPOKT} from "@protocol/xPOKT/xPOKT.sol";
import {XERC20Lockbox} from "@protocol/xPOKT/XERC20Lockbox.sol";
import {WormholeBridgeAdapter} from "@protocol/xPOKT/WormholeBridgeAdapter.sol";
contract WPOKTRouter {
using SafeERC20 for ERC20;
xPOKT public immutable xpokt;
ERC20 public immutable wpokt;
XERC20Lockbox public immutable lockbox;
WormholeBridgeAdapter public wormholeBridge;
event BridgeOutSuccess(uint16 chainId, address indexed to, uint256 amount);
constructor(
address _xpokt,
address _wpokt,
address _lockbox,
address _wormholeBridge
) {
xpokt = xPOKT(_xpokt);
wpokt = ERC20(_wpokt);
lockbox = XERC20Lockbox(_lockbox);
wormholeBridge = WormholeBridgeAdapter(_wormholeBridge);
}
function bridgeCost(uint16 chainId) external view returns (uint256) {
return wormholeBridge.bridgeCost(chainId);
}
function bridgeTo(uint16 chainId, uint256 amount) external payable {
_bridgeTo(chainId, msg.sender, amount);
}
function bridgeTo(
uint16 chainId,
address to,
uint256 amount
) external payable {
_bridgeTo(chainId, to, amount);
}
function _bridgeTo(uint16 chainId, address to, uint256 amount) private {
uint256 bridgeCostFee = wormholeBridge.bridgeCost(chainId);
require(
bridgeCostFee == msg.value,
"WPOKTRouter: cost not equal to quote"
);
wpokt.safeTransferFrom(msg.sender, address(this), amount);
wpokt.approve(address(lockbox), amount);
lockbox.deposit(amount);
uint256 xpoktAmount = xpokt.balanceOf(address(this));
xpokt.approve(address(wormholeBridge), xpoktAmount);
wormholeBridge.bridge{value: bridgeCostFee}(chainId, xpoktAmount, to);
emit BridgeOutSuccess(chainId, to, amount);
}
}
文件 40 的 45：WormholeBridgeAdapter.sol
pragma solidity 0.8.19;
import {xERC20BridgeAdapter} from "@protocol/xPOKT/xERC20BridgeAdapter.sol";
import {SafeCast} from "@openzeppelin-contracts/contracts/utils/math/SafeCast.sol";
import {IWormholeRelayer} from "@protocol/wormhole/IWormholeRelayer.sol";
import {IWormholeReceiver} from "@protocol/wormhole/IWormholeReceiver.sol";
import {WormholeTrustedSender} from "@protocol/governance/WormholeTrustedSender.sol";
contract WormholeBridgeAdapter is
IWormholeReceiver,
xERC20BridgeAdapter,
WormholeTrustedSender
{
using SafeCast for uint256;
uint96 public gasLimit = 300_000;
IWormholeRelayer public wormholeRelayer;
mapping(bytes32 => bool) public processedNonces;
mapping(uint16 => address) public targetAddress;
mapping(uint16 => uint96) public customGasLimits;
event TokensSent(
uint16 indexed targetChainId,
address indexed tokenReceiver,
uint256 amount
);
event TargetAddressUpdated(
uint16 indexed targetChainId,
address indexed target
);
event GasLimitUpdated(uint96 oldGasLimit, uint96 newGasLimit);
function initialize(
address newxerc20,
address newOwner,
address wormholeRelayerAddress,
uint16[] memory targetChains
) public initializer {
__Ownable_init();
_transferOwnership(newOwner);
_setxERC20(newxerc20);
wormholeRelayer = IWormholeRelayer(wormholeRelayerAddress);
for (uint256 i = 0; i < targetChains.length; i++) {
targetAddress[targetChains[i]] = address(this);
_addTrustedSender(address(this), targetChains[i]);
}
gasLimit = 300_000;
}
function setGasLimit(uint96 newGasLimit) external onlyOwner {
uint96 oldGasLimit = gasLimit;
gasLimit = newGasLimit;
emit GasLimitUpdated(oldGasLimit, newGasLimit);
}
function setCustomGasLimit(uint16 chainId, uint96 newGasLimit) external onlyOwner {
customGasLimits[chainId] = newGasLimit;
}
function removeTrustedSenders(
WormholeTrustedSender.TrustedSender[] memory _trustedSenders
) external onlyOwner {
_removeTrustedSenders(_trustedSenders);
}
function addTrustedSenders(
WormholeTrustedSender.TrustedSender[] memory _trustedSenders
) external onlyOwner {
_addTrustedSenders(_trustedSenders);
}
function setTargetAddresses(
WormholeTrustedSender.TrustedSender[] memory _chainConfig
) external onlyOwner {
for (uint256 i = 0; i < _chainConfig.length; i++) {
targetAddress[_chainConfig[i].chainId] = _chainConfig[i].addr;
emit TargetAddressUpdated(
_chainConfig[i].chainId,
_chainConfig[i].addr
);
}
}
function bridgeCost(
uint16 targetChainId
) public view returns (uint256 gasCost) {
uint96 _gasLimit = chainGasLimit(targetChainId);
(gasCost, ) = wormholeRelayer.quoteEVMDeliveryPrice(
targetChainId,
0,
_gasLimit
);
}
function chainGasLimit(
uint16 targetChainId
) public view returns (uint96) {
if (customGasLimits[targetChainId] != 0) {
return customGasLimits[targetChainId];
}
return gasLimit;
}
function _bridgeOut(
address user,
uint256 targetChain,
uint256 amount,
address to
) internal override {
uint16 targetChainId = targetChain.toUint16();
uint96 _gasLimit = chainGasLimit(targetChainId);
uint256 cost = bridgeCost(targetChainId);
require(msg.value == cost, "WormholeBridge: cost not equal to quote");
require(
targetAddress[targetChainId] != address(0),
"WormholeBridge: invalid target chain"
);
_burnTokens(user, amount);
wormholeRelayer.sendPayloadToEvm{value: cost}(
targetChainId,
targetAddress[targetChainId],
abi.encode(to, amount),
0,
_gasLimit,
targetChainId,
to
);
emit TokensSent(targetChainId, to, amount);
}
function receiveWormholeMessages(
bytes memory payload,
bytes[] memory,
bytes32 senderAddress,
uint16 sourceChain,
bytes32 nonce
) external payable override {
require(msg.value == 0, "WormholeBridge: no value allowed");
require(
msg.sender == address(wormholeRelayer),
"WormholeBridge: only relayer allowed"
);
require(
isTrustedSender(sourceChain, senderAddress),
"WormholeBridge: sender not trusted"
);
require(
!processedNonces[nonce],
"WormholeBridge: message already processed"
);
processedNonces[nonce] = true;
(address to, uint256 amount) = abi.decode(payload, (address, uint256));
_bridgeIn(sourceChain, to, amount);
}
}
文件 41 的 45：WormholeTrustedSender.sol
pragma solidity 0.8.19;
import {EnumerableSet} from "@openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol";
import {IWormholeTrustedSender} from "@protocol/governance/IWormholeTrustedSender.sol";
contract WormholeTrustedSender is IWormholeTrustedSender {
using EnumerableSet for EnumerableSet.Bytes32Set;
event TrustedSenderUpdated(uint16 chainId, address addr, bool added);
mapping(uint16 => EnumerableSet.Bytes32Set) private trustedSenders;
struct TrustedSender {
uint16 chainId;
address addr;
}
function _addTrustedSenders(
TrustedSender[] memory _trustedSenders
) internal {
unchecked {
for (uint256 i = 0; i < _trustedSenders.length; i++) {
_addTrustedSender(
_trustedSenders[i].addr,
_trustedSenders[i].chainId
);
}
}
}
function _addTrustedSender(address trustedSender, uint16 chainId) internal {
require(
trustedSenders[chainId].add(addressToBytes(trustedSender)),
"WormholeTrustedSender: already in list"
);
emit TrustedSenderUpdated(chainId, trustedSender, true);
}
function _removeTrustedSender(
address trustedSender,
uint16 chainId
) internal {
require(
trustedSenders[chainId].remove(addressToBytes(trustedSender)),
"WormholeTrustedSender: not in list"
);
emit TrustedSenderUpdated(chainId, trustedSender, false);
}
function _removeTrustedSenders(
TrustedSender[] memory _trustedSenders
) internal {
unchecked {
for (uint256 i = 0; i < _trustedSenders.length; i++) {
_removeTrustedSender(
_trustedSenders[i].addr,
_trustedSenders[i].chainId
);
}
}
}
function isTrustedSender(
uint16 chainId,
bytes32 addr
) public view override returns (bool) {
return trustedSenders[chainId].contains(addr);
}
function isTrustedSender(
uint16 chainId,
address addr
) public view override returns (bool) {
return isTrustedSender(chainId, addressToBytes(addr));
}
function allTrustedSenders(
uint16 chainId
) external view override returns (bytes32[] memory) {
bytes32[] memory trustedSendersList = new bytes32[](
trustedSenders[chainId].length()
);
unchecked {
for (uint256 i = 0; i < trustedSendersList.length; i++) {
trustedSendersList[i] = trustedSenders[chainId].at(i);
}
}
return trustedSendersList;
}
function addressToBytes(
address addr
) public pure override returns (bytes32) {
return bytes32(bytes20(addr)) >> 96;
}
}
文件 42 的 45：XERC20Lockbox.sol
pragma solidity 0.8.19;
import {SafeERC20} from "@openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
import {IXERC20} from "@protocol/xPOKT/interfaces/IXERC20.sol";
import {IXERC20Lockbox} from "@protocol/xPOKT/interfaces/IXERC20Lockbox.sol";
contract XERC20Lockbox is IXERC20Lockbox {
using SafeERC20 for IERC20;
IXERC20 public immutable XERC20;
IERC20 public immutable ERC20;
constructor(address xpokt, address wpokt) {
XERC20 = IXERC20(xpokt);
ERC20 = IERC20(wpokt);
}
function deposit(uint256 amount) external {
_deposit(msg.sender, amount);
}
function depositTo(address to, uint256 amount) external {
_deposit(to, amount);
}
function withdraw(uint256 amount) external {
_withdraw(msg.sender, amount);
}
function withdrawTo(address to, uint256 amount) external {
_withdraw(to, amount);
}
function _withdraw(address to, uint256 amount) internal {
emit Withdraw(to, amount);
XERC20.burn(msg.sender, amount);
ERC20.safeTransfer(to, amount);
}
function _deposit(address to, uint256 amount) internal {
ERC20.safeTransferFrom(msg.sender, address(this), amount);
XERC20.mint(to, amount);
emit Deposit(to, amount);
}
}
文件 43 的 45：xERC20.sol
pragma solidity 0.8.19;
import {SafeCast} from "@openzeppelin-contracts/contracts/utils/math/SafeCast.sol";
import {IXERC20} from "@protocol/xPOKT/interfaces/IXERC20.sol";
import {MintLimits} from "@protocol/xPOKT/MintLimits.sol";
abstract contract xERC20 is IXERC20, MintLimits {
using SafeCast for uint256;
function mintingMaxLimitOf(
address minter
) external view returns (uint256 limit) {
return bufferCap(minter);
}
function burningMaxLimitOf(
address bridge
) external view returns (uint256 limit) {
return bufferCap(bridge);
}
function mintingCurrentLimitOf(
address minter
) external view returns (uint256 limit) {
return buffer(minter);
}
function burningCurrentLimitOf(
address bridge
) external view returns (uint256 limit) {
return bufferCap(bridge) - buffer(bridge);
}
function mint(address user, uint256 amount) public virtual {
_depleteBuffer(msg.sender, amount);
_mint(user, amount);
}
function burn(address user, uint256 amount) public virtual {
_replenishBuffer(msg.sender, amount);
_spendAllowance(user, msg.sender, amount);
_burn(user, amount);
}
function _mint(address, uint256) internal virtual;
function totalSupply() public view virtual returns (uint256);
function maxPauseDuration() public pure virtual returns (uint256);
function _burn(address user, uint256 amount) internal virtual;
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual;
}
文件 44 的 45：xERC20BridgeAdapter.sol
pragma solidity 0.8.19;
import {Ownable2StepUpgradeable} from "@openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol";
import {SafeERC20} from "@openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {IXERC20} from "@protocol/xPOKT/interfaces/IXERC20.sol";
abstract contract xERC20BridgeAdapter is Ownable2StepUpgradeable {
using SafeERC20 for IERC20;
IXERC20 public xERC20;
event BridgedOut(
uint256 indexed dstChainId,
address indexed bridgeUser,
address indexed tokenReceiver,
uint256 amount
);
event BridgedIn(
uint256 indexed srcChainId,
address indexed tokenReceiver,
uint256 amount
);
constructor() {
_disableInitializers();
}
function bridge(
uint256 dstChainId,
uint256 amount,
address to
) external payable virtual {
_bridgeOut(msg.sender, dstChainId, amount, to);
emit BridgedOut(dstChainId, msg.sender, to, amount);
}
function _setxERC20(address newxerc20) internal {
xERC20 = IXERC20(newxerc20);
}
function _burnTokens(address user, uint256 amount) internal {
xERC20.burn(user, amount);
}
function _bridgeIn(
uint256 chainId,
address user,
uint256 amount
) internal virtual {
xERC20.mint(user, amount);
emit BridgedIn(chainId, user, amount);
}
function _bridgeOut(
address user,
uint256 dstChainId,
uint256 amount,
address to
) internal virtual;
}
文件 45 的 45：xPOKT.sol
pragma solidity 0.8.19;
import {Ownable2StepUpgradeable} from "@openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol";
import {ERC20Upgradeable} from "@openzeppelin-contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol";
import {ERC20PermitUpgradeable} from "@openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/ERC20PermitUpgradeable.sol";
import {SafeCast} from "@openzeppelin-contracts/contracts/utils/math/SafeCast.sol";
import {Initializable} from "@openzeppelin-contracts/contracts/proxy/utils/Initializable.sol";
import {xERC20} from "@protocol/xPOKT/xERC20.sol";
import {MintLimits} from "@protocol/xPOKT/MintLimits.sol";
import {ConfigurablePauseGuardian} from "@protocol/xPOKT/ConfigurablePauseGuardian.sol";
contract xPOKT is
xERC20,
ERC20PermitUpgradeable,
Ownable2StepUpgradeable,
ConfigurablePauseGuardian
{
using SafeCast for uint256;
uint128 public constant MAX_RATE_LIMIT_PER_SECOND = 25_000 * 1e6;
uint112 public constant MIN_BUFFER_CAP = 1_000 * 1e6;
uint256 public constant MAX_PAUSE_DURATION = 30 days;
constructor() {
_disableInitializers();
}
function decimals() public view virtual override returns (uint8) {
return 6;
}
function initialize(
string memory tokenName,
string memory tokenSymbol,
address tokenOwner,
MintLimits.RateLimitMidPointInfo[] memory newRateLimits,
uint128 newPauseDuration,
address newPauseGuardian
) external initializer {
require(
newPauseDuration <= MAX_PAUSE_DURATION,
"xPOKT: pause duration too long"
);
__ERC20_init(tokenName, tokenSymbol);
__ERC20Permit_init(tokenName);
__Ownable_init();
_addLimits(newRateLimits);
__Pausable_init();
_grantGuardian(newPauseGuardian);
_updatePauseDuration(newPauseDuration);
_transferOwnership(tokenOwner);
}
function maxPauseDuration() public pure override returns (uint256) {
return MAX_PAUSE_DURATION;
}
function maxRateLimitPerSecond() public pure override returns (uint128) {
return MAX_RATE_LIMIT_PER_SECOND;
}
function minBufferCap() public pure override returns (uint112) {
return MIN_BUFFER_CAP;
}
function totalSupply()
public
view
override(ERC20Upgradeable, xERC20)
returns (uint256)
{
return super.totalSupply();
}
function mint(address user, uint256 amount) public override whenNotPaused {
super.mint(user, amount);
}
function burn(address user, uint256 amount) public override whenNotPaused {
super.burn(user, amount);
}
function setBufferCap(
address bridge,
uint256 newBufferCap
) public onlyOwner {
_setBufferCap(bridge, newBufferCap.toUint112());
emit BridgeLimitsSet(bridge, newBufferCap);
}
function setRateLimitPerSecond(
address bridge,
uint128 newRateLimitPerSecond
) external onlyOwner {
_setRateLimitPerSecond(bridge, newRateLimitPerSecond);
}
function grantPauseGuardian(
address newPauseGuardian
) external onlyOwner whenNotPaused {
_grantGuardian(newPauseGuardian);
}
function ownerUnpause() external onlyOwner whenPaused {
_resetPauseState();
}
function setPauseDuration(uint128 newPauseDuration) external onlyOwner {
require(
newPauseDuration <= MAX_PAUSE_DURATION,
"xPOKT: pause duration too long"
);
_updatePauseDuration(newPauseDuration);
}
function addBridge(
RateLimitMidPointInfo memory newBridge
) external onlyOwner {
_addLimit(newBridge);
}
function addBridges(
RateLimitMidPointInfo[] memory newBridges
) external onlyOwner {
_addLimits(newBridges);
}
function removeBridge(address bridge) external onlyOwner {
_removeLimit(bridge);
}
function removeBridges(address[] memory bridges) external onlyOwner {
_removeLimits(bridges);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override {
super._beforeTokenTransfer(from, to, amount);
require(
to != address(this),
"xERC20: cannot transfer to token contract"
);
}
function _mint(
address user,
uint256 amount
) internal override(ERC20Upgradeable, xERC20) {
super._mint(user, amount);
}
function _burn(
address user,
uint256 amount
) internal override(ERC20Upgradeable, xERC20) {
super._burn(user, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual override(ERC20Upgradeable, xERC20) {
super._spendAllowance(owner, spender, amount);
}
}
{
"compilationTarget": {
"src/xPOKT/WPOKTRouter.sol": "WPOKTRouter"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 1
},
"remappings": [
":@addresses/=addresses/",
":@deployments/=src/deployments/",
":@forge-std/=lib/forge-std/src/",
":@generated/=generated/",
":@openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":@openzeppelin-contracts/=lib/openzeppelin-contracts/",
":@proposals/=src/proposals/",
":@protocol/=src/",
":@safe-singleton/=lib/safe-singleton-deployer-sol/src/",
":@test/=test/",
":@utils/=src/utils/",
":@wormhole/=lib/wormhole/ethereum/contracts/",
":@zelt-src/=lib/zelt/src/",
":@zelt-test/=lib/zelt/test/",
":@zelt/=lib/zelt/",
":ds-test/=lib/zelt/lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
":safe-singleton-deployer-sol/=lib/safe-singleton-deployer-sol/",
":wormhole/=lib/wormhole/",
":zelt/=lib/zelt/src/"
]
}[{"inputs":[{"internalType":"address","name":"_xpokt","type":"address"},{"internalType":"address","name":"_wpokt","type":"address"},{"internalType":"address","name":"_lockbox","type":"address"},{"internalType":"address","name":"_wormholeBridge","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"chainId","type":"uint16"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BridgeOutSuccess","type":"event"},{"inputs":[{"internalType":"uint16","name":"chainId","type":"uint16"}],"name":"bridgeCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId","type":"uint16"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"bridgeTo","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId","type":"uint16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"bridgeTo","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"lockbox","outputs":[{"internalType":"contract XERC20Lockbox","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wormholeBridge","outputs":[{"internalType":"contract WormholeBridgeAdapter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wpokt","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xpokt","outputs":[{"internalType":"contract xPOKT","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
