编译器
0.8.20+commit.a1b79de6
文件 1 的 52：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 的 52：BridgeFactory.sol
pragma solidity ^0.8.20;
import "solmate/src/utils/CREATE3.sol";
import "../XERC20/XERC20.sol";
import "../XERC20/XERC20Lockbox.sol";
import "../interfaces/IFactory.sol";
contract BridgeFactory is IFactory {
bytes32 public bridgeSalt = "InceptionLRT Factory";
function deployCreate2(
bytes calldata creationCode
) external returns (address) {
return _deployCreate2(creationCode, msg.sender);
}
function _deployCreate2(
bytes memory bytecode,
address _sender
) internal returns (address) {
address addr = _create2(bytecode, _sender);
emit ContractCreated(addr);
return addr;
}
function _create2(
bytes memory bytecode,
address _sender
) internal returns (address) {
address payable addr;
bytes32 salt = _getSalt(_sender);
assembly {
addr := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
if iszero(extcodesize(addr)) {
revert(0, 0)
}
}
return addr;
}
function getDeploymentCreate2Address(
bytes memory bytecode,
address _sender
) external view returns (address) {
bytes32 salt = _getSalt(_sender);
bytes32 rawAddress = keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
keccak256(bytecode)
)
);
return address(bytes20(rawAddress << 96));
}
function _getSalt(address _sender) internal view returns (bytes32) {
return keccak256(abi.encodePacked(bridgeSalt, _sender));
}
function deployXERC20(
string memory _name,
string memory _symbol
) external returns (address _xerc20) {
_xerc20 = _deployXERC20(_name, _symbol);
emit XERC20Deployed(_xerc20);
}
function deployLockbox(
address _xerc20,
address _baseToken,
bool _isNative
) external returns (address _lockbox) {
if (
(_baseToken == address(0) && !_isNative) ||
(_isNative && _baseToken != address(0))
) revert IXERC20Factory_BadTokenAddress();
if (XERC20(_xerc20).owner() != msg.sender)
revert IXERC20Factory_NotOwner();
_lockbox = _deployLockbox(_xerc20, _baseToken, _isNative);
emit LockboxDeployed(_lockbox);
}
function _deployXERC20(
string memory _name,
string memory _symbol
) internal returns (address _xerc20) {
address deployer = msg.sender;
bytes32 _salt = keccak256(abi.encodePacked(_name, _symbol, deployer));
bytes memory _creation = type(XERC20).creationCode;
bytes memory _bytecode = abi.encodePacked(
_creation,
abi.encode(_name, _symbol, address(this))
);
_xerc20 = CREATE3.deploy(_salt, _bytecode, 0);
XERC20(_xerc20).transferOwnership(deployer);
}
function _deployLockbox(
address _xerc20,
address _baseToken,
bool _isNative
) internal returns (address _lockbox) {
address deployer = msg.sender;
bytes32 _salt = keccak256(
abi.encodePacked(_xerc20, _baseToken, deployer)
);
bytes memory _bytecode = abi.encodePacked(
type(XERC20Lockbox).creationCode,
abi.encode(_xerc20, _baseToken, _isNative)
);
_lockbox = CREATE3.deploy(_salt, _bytecode, 0);
XERC20(_xerc20).setLockbox(_lockbox);
}
function deployCreate3(
bytes calldata creationCode,
bytes32 _salt
) external returns (address) {
return _deployCreate3(creationCode, _salt);
}
function _deployCreate3(
bytes memory bytecode,
bytes32 _salt
) internal returns (address) {
address addr = CREATE3.deploy(_salt, bytecode, 0);
emit ContractCreated(addr);
return addr;
}
}
文件 3 的 52：Bytes32AddressLib.sol
pragma solidity >=0.8.0;
library Bytes32AddressLib {
function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
return address(uint160(uint256(bytesValue)));
}
function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
return bytes32(bytes20(addressValue));
}
}
文件 4 的 52：CREATE3.sol
pragma solidity >=0.8.0;
import {Bytes32AddressLib} from "./Bytes32AddressLib.sol";
library CREATE3 {
using Bytes32AddressLib for bytes32;
bytes internal constant PROXY_BYTECODE = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";
bytes32 internal constant PROXY_BYTECODE_HASH = keccak256(PROXY_BYTECODE);
function deploy(
bytes32 salt,
bytes memory creationCode,
uint256 value
) internal returns (address deployed) {
bytes memory proxyChildBytecode = PROXY_BYTECODE;
address proxy;
assembly {
proxy := create2(0, add(proxyChildBytecode, 32), mload(proxyChildBytecode), salt)
}
require(proxy != address(0), "DEPLOYMENT_FAILED");
deployed = getDeployed(salt);
(bool success, ) = proxy.call{value: value}(creationCode);
require(success && deployed.code.length != 0, "INITIALIZATION_FAILED");
}
function getDeployed(bytes32 salt) internal view returns (address) {
address proxy = keccak256(
abi.encodePacked(
bytes1(0xFF),
address(this),
salt,
PROXY_BYTECODE_HASH
)
).fromLast20Bytes();
return
keccak256(
abi.encodePacked(
hex"d6_94",
proxy,
hex"01"
)
).fromLast20Bytes();
}
}
文件 5 的 52：CallDataRLPReader.sol
pragma solidity ^0.8.20;
library CallDataRLPReader {
uint8 constant STRING_SHORT_START = 0x80;
uint8 constant STRING_LONG_START = 0xb8;
uint8 constant LIST_SHORT_START = 0xc0;
uint8 constant LIST_LONG_START = 0xf8;
uint8 constant WORD_SIZE = 32;
function beginIteration(
uint256 listOffset
) internal pure returns (uint256 iter) {
return listOffset + _payloadOffset(listOffset);
}
function next(uint256 iter) internal pure returns (uint256 nextIter) {
return iter + itemLength(iter);
}
function payloadLen(
uint256 ptr,
uint256 len
) internal pure returns (uint256) {
return len - _payloadOffset(ptr);
}
function receiver(uint256 ptr) internal pure returns (address) {
return address(uint160(toUint(ptr, 21)));
}
function toUint(uint256 ptr, uint256 len) internal pure returns (uint256) {
require(len > 0 && len <= 33);
uint256 offset = _payloadOffset(ptr);
uint256 numLen = len - offset;
uint256 result;
assembly {
result := calldataload(add(ptr, offset))
result := shr(mul(8, sub(32, numLen)), result)
}
return result;
}
function toUintStrict(uint256 ptr) internal pure returns (uint256) {
uint256 result;
assembly {
result := calldataload(add(ptr, 1))
}
return result;
}
function rawDataPtr(uint256 ptr) internal pure returns (uint256) {
return ptr + _payloadOffset(ptr);
}
function itemLength(uint256 callDataPtr) internal pure returns (uint256) {
uint256 itemLen;
uint256 byte0;
assembly {
byte0 := byte(0, calldataload(callDataPtr))
}
if (byte0 < STRING_SHORT_START) itemLen = 1;
else if (byte0 < STRING_LONG_START)
itemLen = byte0 - STRING_SHORT_START + 1;
else if (byte0 < LIST_SHORT_START) {
assembly {
let byteLen := sub(byte0, 0xb7)
callDataPtr := add(callDataPtr, 1)
let dataLen := shr(
mul(8, sub(32, byteLen)),
calldataload(callDataPtr)
)
itemLen := add(dataLen, add(byteLen, 1))
}
} else if (byte0 < LIST_LONG_START) {
itemLen = byte0 - LIST_SHORT_START + 1;
} else {
assembly {
let byteLen := sub(byte0, 0xf7)
callDataPtr := add(callDataPtr, 1)
let dataLen := shr(
mul(8, sub(32, byteLen)),
calldataload(callDataPtr)
)
itemLen := add(dataLen, add(byteLen, 1))
}
}
return itemLen;
}
function _payloadOffset(
uint256 callDataPtr
) private pure returns (uint256) {
uint256 byte0;
assembly {
byte0 := byte(0, calldataload(callDataPtr))
}
if (byte0 < STRING_SHORT_START) return 0;
else if (
byte0 < STRING_LONG_START ||
(byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)
) return 1;
else if (byte0 < LIST_SHORT_START)
return byte0 - (STRING_LONG_START - 1) + 1;
else return byte0 - (LIST_LONG_START - 1) + 1;
}
}
文件 6 的 52：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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 7 的 52：ContextUpgradeable.sol
pragma solidity ^0.8.20;
import {Initializable} from "../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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 8 的 52：Counters.sol
pragma solidity ^0.8.0;
library Counters {
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;
}
}
文件 9 的 52：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
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", Strings.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));
}
}
文件 10 的 52：EIP712.sol
pragma solidity ^0.8.8;
import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.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
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
}
文件 11 的 52：ERC1967Proxy.sol
pragma solidity ^0.8.0;
import "../Proxy.sol";
import "./ERC1967Upgrade.sol";
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
文件 12 的 52：ERC1967Upgrade.sol
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
abstract contract ERC1967Upgrade is IERC1967 {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
文件 13 的 52：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 {}
}
文件 14 的 52：ERC20Mintable.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
contract ERC20Mintable is ERC20 {
constructor(
string memory name_,
string memory symbol_
) payable ERC20(name_, symbol_) {}
function mint(address usr, uint wad) external {
_mint(usr, wad);
}
function burn(address usr, uint wad) external {
_burn(usr, wad);
}
}
文件 15 的 52：ERC20Permit.sol
pragma solidity ^0.8.0;
import "./IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/cryptography/EIP712.sol";
import "../../../utils/Counters.sol";
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.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;
constructor(string memory name) EIP712(name, "1") {}
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 = ECDSA.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) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
文件 16 的 52：EthereumVerifier.sol
pragma solidity ^0.8.20;
import "./CallDataRLPReader.sol";
import "./Utils.sol";
import "../interfaces/IInceptionBridge.sol";
library EthereumVerifier {
bytes32 constant TOPIC_DEPOSITED =
keccak256(
"Deposited(uint256,address,address,address,address,address,uint256,uint256,(bytes32,bytes32,uint256,address))"
);
enum DepositType {
None,
TokenDeposit
}
struct State {
bytes32 receiptHash;
address contractAddress;
address destinationContract;
uint256 chainId;
address sender;
address receiver;
address fromToken;
address toToken;
uint256 amount;
uint256 nonce;
bytes32 symbol;
bytes32 name;
uint256 originChain;
address originToken;
}
function getMetadata(
State memory state
) internal pure returns (IInceptionBridgeStorage.Metadata memory) {
IInceptionBridgeStorage.Metadata memory metadata;
assembly {
metadata := add(state, 0x120)
}
return metadata;
}
function parseTransactionReceipt(
uint256 receiptOffset
) internal pure returns (State memory state, DepositType depositType) {
uint256 iter = CallDataRLPReader.beginIteration(receiptOffset + 0x20);
{
uint256 statusOffset = iter;
iter = CallDataRLPReader.next(iter);
require(
CallDataRLPReader.payloadLen(
statusOffset,
iter - statusOffset
) == 1,
"EthereumVerifier: tx is reverted"
);
}
iter = CallDataRLPReader.next(iter);
uint256 logs = iter;
iter = CallDataRLPReader.next(iter);
uint256 logsIter = CallDataRLPReader.beginIteration(logs);
for (; logsIter < iter; ) {
uint256 log = logsIter;
logsIter = CallDataRLPReader.next(logsIter);
DepositType logType = _decodeReceiptLogs(state, log);
if (logType != DepositType.None) {
require(
depositType == DepositType.None,
"EthereumVerifier: multiple logs"
);
depositType = logType;
}
}
require(
depositType != DepositType.None,
"EthereumVerifier: missing logs"
);
return (state, depositType);
}
function _decodeReceiptLogs(
State memory state,
uint256 log
) internal pure returns (DepositType depositType) {
uint256 logIter = CallDataRLPReader.beginIteration(log);
address contractAddress;
{
uint256 addressOffset = logIter;
logIter = CallDataRLPReader.next(logIter);
contractAddress = CallDataRLPReader.receiver(addressOffset);
}
bytes32 mainTopic;
address destinationContract;
address sender;
address receiver;
{
uint256 topicsIter = logIter;
logIter = CallDataRLPReader.next(logIter);
if (CallDataRLPReader.itemLength(topicsIter) != 134) {
return DepositType.None;
}
topicsIter = CallDataRLPReader.beginIteration(topicsIter);
mainTopic = bytes32(CallDataRLPReader.toUintStrict(topicsIter));
topicsIter = CallDataRLPReader.next(topicsIter);
destinationContract = address(
bytes20(uint160(CallDataRLPReader.toUintStrict(topicsIter)))
);
topicsIter = CallDataRLPReader.next(topicsIter);
sender = address(
bytes20(uint160(CallDataRLPReader.toUintStrict(topicsIter)))
);
topicsIter = CallDataRLPReader.next(topicsIter);
receiver = address(
bytes20(uint160(CallDataRLPReader.toUintStrict(topicsIter)))
);
topicsIter = CallDataRLPReader.next(topicsIter);
require(topicsIter == logIter);
}
uint256 ptr = CallDataRLPReader.rawDataPtr(logIter);
logIter = CallDataRLPReader.next(logIter);
uint256 len = logIter - ptr;
{
uint256 expectedLen;
if (mainTopic == TOPIC_DEPOSITED) {
expectedLen = 0x120;
depositType = DepositType.TokenDeposit;
} else {
return DepositType.None;
}
if (len != expectedLen) {
return DepositType.None;
}
}
{
uint256 chainId;
assembly {
chainId := calldataload(ptr)
}
state.chainId = chainId;
ptr += 0x20;
len -= 0x20;
}
{
uint256 structOffset;
assembly {
structOffset := add(state, 0xc0)
calldatacopy(structOffset, ptr, len)
}
}
state.destinationContract = destinationContract;
state.contractAddress = contractAddress;
state.sender = sender;
state.receiver = receiver;
return depositType;
}
}
文件 17 的 52：IBeacon.sol
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
}
文件 18 的 52：IERC1967.sol
pragma solidity ^0.8.0;
interface IERC1967 {
event Upgraded(address indexed implementation);
event AdminChanged(address previousAdmin, address newAdmin);
event BeaconUpgraded(address indexed beacon);
}
文件 19 的 52：IERC20.sol
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20.sol";
文件 20 的 52：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);
}
文件 21 的 52：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);
}
文件 22 的 52：IERC5267.sol
pragma solidity ^0.8.0;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 23 的 52：IFactory.sol
pragma solidity ^0.8.20;
interface ICREATE2Factory {
event ContractCreated(address indexed addr);
function deployCreate2(
bytes calldata creationCode
) external returns (address);
}
interface ICREATE3Factory {
event XERC20Deployed(address _xerc20);
event LockboxDeployed(address _lockbox);
error IXERC20Factory_NotOwner();
error IXERC20Factory_BadTokenAddress();
error IXERC20Factory_LockboxAlreadyDeployed();
error IXERC20Factory_InvalidLength();
function deployXERC20(
string memory _name,
string memory _symbol
) external returns (address _xerc20);
function deployLockbox(
address _xerc20,
address _baseToken,
bool _isNative
) external returns (address _lockbox);
}
interface IFactory is ICREATE2Factory, ICREATE3Factory {}
文件 24 的 52：IInceptionBridge.sol
pragma solidity ^0.8.20;
import "./IERC20.sol";
interface IInceptionBridgeStorage {
struct Metadata {
bytes32 name;
bytes32 symbol;
uint256 originChain;
address originAddress;
}
event ShortCapChanged(
address indexed token,
uint256 prevValue,
uint256 newValue
);
event LongCapChanged(
address indexed token,
uint256 prevValue,
uint256 newValue
);
event ShortCapDurationChanged(uint256 prevValue, uint256 newValue);
event LongCapDurationChanged(uint256 prevValue, uint256 newValue);
event BridgeAdded(address indexed bridge, uint256 destinationChain);
event BridgeRemoved(address indexed bridge, uint256 destinationChain);
event DestinationAdded(
address indexed fromToken,
address indexed toToken,
uint256 toChain
);
event DestinationRemoved(
address indexed fromToken,
address indexed toToken,
uint256 toChain
);
event NotaryChanged(address indexed prevValue, address indexed newValue);
event XERC20LockboxAdded(address indexed token, address indexed lockbox);
}
interface IInceptionBridge {
event Deposited(
uint256 destinationChain,
address indexed destinationBridge,
address indexed sender,
address indexed receiver,
address fromToken,
address toToken,
uint256 amount,
uint256 nonce,
IInceptionBridgeStorage.Metadata metadata
);
event Withdrawn(
bytes32 receiptHash,
address indexed sender,
address indexed receiver,
address fromToken,
address toToken,
uint256 amount
);
function deposit(
address fromToken,
uint256 destinationChain,
address receiver,
uint256 amount
) external;
function withdraw(
bytes calldata encodedProof,
bytes calldata rawReceipt,
bytes memory receiptRootSignature
) external;
}
文件 25 的 52：IInceptionBridgeErrors.sol
pragma solidity ^0.8.20;
interface IInceptionBridgeErrors {
error ShortCapExceeded(uint256 limit, uint256 current);
error LongCapExceeded(uint256 limit, uint256 current);
error BridgeAlreadyAdded();
error BridgeNotExist();
error InvalidChain();
error MultipleDeposits();
error ReceiptWrongChain(uint256 required, uint256 provided);
error InvalidContractAddress();
error NullAddress();
error UnknownBridge();
error WrongSignature();
error WithdrawalProofUsed();
error InvalidAssetType();
error InvalidFromTokenAddress();
error UnknownDestination();
error WrongDestinationBridge();
error XERC20LockboxAlreadyAdded();
error XERC20ZeroAddress();
error UnknownDestinationChain();
error DestinationAlreadyExists();
error BurnFailed();
error MintFailed();
}
文件 26 的 52：IXERC20.sol
pragma solidity ^0.8.20;
interface IERC20Errors {
error IXERC20_NotHighEnoughLimits();
error IXERC20_NotFactory();
error IXERC20_WrongBridgeLimit();
}
interface IXERC20 is IERC20Errors {
struct Bridge {
BridgeParameters minterParams;
BridgeParameters burnerParams;
}
event LockboxSet(address _lockbox);
event BridgeLimitsSet(
uint256 _mintingLimit,
uint256 _burningLimit,
address indexed _bridge
);
struct BridgeParameters {
uint256 timestamp;
uint256 ratePerSecond;
uint256 maxLimit;
uint256 currentLimit;
}
function setLockbox(address _lockbox) external;
function setBridgeLimits(
address _bridge,
uint256 _mintingLimit,
uint256 _burningLimit
) external;
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;
}
文件 27 的 52：IXERC20Lockbox.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "./IXERC20.sol";
interface IXERC20LockboxErrors {
error IXERC20Lockbox_NotNative();
error IXERC20Lockbox_Native();
error IXERC20Lockbox_WithdrawFailed();
error IXERC20Lockbox_WrongReceiver();
}
interface IXERC20Lockbox is IXERC20LockboxErrors {
event Deposit(address _sender, uint256 _amount);
event Withdraw(address _sender, uint256 _amount);
function XERC20() external view returns (IXERC20 xerc20);
function ERC20() external view returns (IERC20 erc20);
function deposit(uint256 _amount) external;
function depositTo(address _user, uint256 _amount) external;
function depositNativeTo(address _user) external payable;
function withdraw(uint256 _amount) external;
function withdrawTo(address _user, uint256 _amount) external;
}
文件 28 的 52：InceptionBridge.sol
pragma solidity ^0.8.20;
pragma abicoder v2;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./InceptionBridgeStorage.sol";
import "../interfaces/IInceptionBridge.sol";
import "../interfaces/IXERC20Lockbox.sol";
import "../lib/EthereumVerifier.sol";
import "../lib/ProofParser.sol";
import "../lib/Utils.sol";
contract InceptionBridge is
OwnableUpgradeable,
PausableUpgradeable,
ReentrancyGuardUpgradeable,
InceptionBridgeStorage,
IInceptionBridge
{
using SafeERC20 for IERC20;
constructor() payable {
_disableInitializers();
}
function initialize(
address initialOwner,
address notary
) external initializer {
__Ownable_init(initialOwner);
__Pausable_init();
__ReentrancyGuard_init();
__initInceptionBridgeStorage(notary);
}
function deposit(
address fromToken,
uint256 destinationChain,
address receiver,
uint256 amount
) external override nonReentrant whenNotPaused {
_beforeDeposit();
_updateDepositCaps(fromToken, amount);
if (getDestination(fromToken, destinationChain) != address(0)) {
_deposit(fromToken, destinationChain, receiver, amount);
} else revert UnknownDestinationChain();
}
function _deposit(
address fromToken,
uint256 destinationChain,
address receiver,
uint256 amount
) internal {
if (_bridgeAddressByChainId[destinationChain] == address(0)) {
revert UnknownDestinationChain();
}
address sender = msg.sender;
address lockbox = xerc20TokenRegistry[fromToken];
if (lockbox == address(0)) {
_safeBurn(fromToken, sender, amount);
} else {
_depositIntoLockbox(lockbox, fromToken, sender, amount);
}
Metadata memory metaData = Metadata(
Utils.stringToBytes32(IERC20Extra(fromToken).name()),
Utils.stringToBytes32(IERC20Extra(fromToken).symbol()),
0,
address(0)
);
unchecked {
++_globalNonce;
}
emit Deposited(
destinationChain,
_bridgeAddressByChainId[destinationChain],
sender,
receiver,
fromToken,
getDestination(fromToken, destinationChain),
amount,
_globalNonce,
metaData
);
}
function _depositIntoLockbox(
address lockbox,
address fromToken,
address sender,
uint256 amount
) internal {
address xerc20 = address(IXERC20Lockbox(lockbox).XERC20());
if (xerc20 == address(0)) revert XERC20ZeroAddress();
IERC20(fromToken).safeTransferFrom(sender, address(this), amount);
IERC20(fromToken).safeApprove(lockbox, amount);
IXERC20Lockbox(lockbox).deposit(amount);
_safeBurn(xerc20, address(this), amount);
}
function withdraw(
bytes calldata,
bytes calldata rawReceipt,
bytes memory proofSignature
) external override nonReentrant whenNotPaused {
uint256 proofOffset;
uint256 receiptOffset;
assembly {
proofOffset := add(0x4, calldataload(4))
receiptOffset := add(0x4, calldataload(36))
}
(
EthereumVerifier.State memory state,
EthereumVerifier.DepositType depositType
) = EthereumVerifier.parseTransactionReceipt(receiptOffset);
if (state.chainId != block.chainid)
revert ReceiptWrongChain(block.chainid, state.chainId);
ProofParser.Proof memory proof = ProofParser.parseProof(proofOffset);
if (state.contractAddress == address(0))
revert InvalidContractAddress();
if (state.destinationContract != address(this))
revert WrongDestinationBridge();
if (_bridgeAddressByChainId[proof.chainId] != state.contractAddress)
revert UnknownBridge();
state.receiptHash = keccak256(rawReceipt);
proof.status = 0x01;
proof.receiptHash = state.receiptHash;
bytes32 proofHash;
assembly {
proofHash := keccak256(proof, _PROOF_LENGTH)
}
if (ECDSA.recover(proofHash, proofSignature) != notary)
revert WrongSignature();
_withdraw(state, depositType, proof, proofHash);
}
function _withdraw(
EthereumVerifier.State memory state,
EthereumVerifier.DepositType depositType,
ProofParser.Proof memory proof,
bytes32 payload
) internal {
if (_usedProofs[payload]) {
revert WithdrawalProofUsed();
}
_usedProofs[payload] = true;
if (depositType == EthereumVerifier.DepositType.TokenDeposit) {
_withdraw(state, proof);
} else revert InvalidAssetType();
}
function _withdraw(
EthereumVerifier.State memory state,
ProofParser.Proof memory proof
) internal {
if (state.fromToken == address(0)) revert InvalidFromTokenAddress();
if (getDestination(state.toToken, proof.chainId) != state.fromToken)
revert UnknownDestination();
_updateWithdrawCaps(state.toToken, state.amount);
address lockbox = xerc20TokenRegistry[state.toToken];
if (lockbox == address(0)) {
_safeMint(state.toToken, state.receiver, state.amount);
} else {
address xerc20 = address(IXERC20Lockbox(lockbox).XERC20());
if (xerc20 == address(0)) revert XERC20ZeroAddress();
_safeMint(xerc20, address(this), state.amount);
IXERC20Lockbox(lockbox).withdrawTo(state.receiver, state.amount);
}
emit Withdrawn(
state.receiptHash,
state.sender,
state.receiver,
state.fromToken,
state.toToken,
state.amount
);
}
function getDestination(
address fromToken,
uint256 destinationChain
) public view returns (address) {
return
_destinationTokens[
keccak256(
abi.encodePacked(
fromToken,
block.chainid,
_bridgeAddressByChainId[destinationChain],
destinationChain
)
)
];
}
function setNotary(address notaryAddress) external onlyOwner {
_setNotary(notaryAddress);
}
function setShortCap(
address tokenAddress,
uint256 amount
) external onlyOwner {
_setShortCap(tokenAddress, amount);
}
function setShortCapDuration(uint256 duration) external onlyOwner {
_setShortCapDuration(duration);
}
function setLongCapDuration(uint256 duration) external onlyOwner {
_setLongCapDuration(duration);
}
function setLongCap(address token, uint256 amount) external onlyOwner {
_setLongCap(token, amount);
}
function addBridge(
address bridge,
uint256 destinationChain
) external onlyOwner {
_addBridge(bridge, destinationChain);
}
function removeBridge(uint256 destinationChain) external onlyOwner {
_removeBridge(destinationChain);
}
function addDestination(
address fromToken,
uint256 destinationChain,
address toToken
) external onlyOwner {
_addDestination(fromToken, destinationChain, toToken);
}
function removeDestination(
address fromToken,
uint256 destinationChain,
address toToken
) external onlyOwner {
_removeDestination(fromToken, destinationChain, toToken);
}
function setXERC20Lockbox(
address token,
address xerc20Lockbox
) external onlyOwner {
_setXERC20Lockbox(token, xerc20Lockbox);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function _safeBurn(
address token,
address account,
uint256 amount
) internal {
uint256 balanceBefore = IERC20(token).balanceOf(account);
IERC20Mintable(token).burn(account, amount);
uint256 balanceAfter = IERC20(token).balanceOf(account);
if (balanceAfter + amount != balanceBefore) {
revert BurnFailed();
}
}
function _safeMint(
address token,
address account,
uint256 amount
) internal {
uint256 balanceBefore = IERC20(token).balanceOf(account);
IERC20Mintable(token).mint(account, amount);
uint256 balanceAfter = IERC20(token).balanceOf(account);
if (balanceBefore + amount != balanceAfter) {
revert MintFailed();
}
}
}
文件 29 的 52：InceptionBridgeStorage.sol
pragma solidity ^0.8.20;
pragma abicoder v2;
import "../interfaces/IInceptionBridge.sol";
import "../interfaces/IInceptionBridgeErrors.sol";
abstract contract InceptionBridgeStorage is
IInceptionBridgeStorage,
IInceptionBridgeErrors
{
uint256 internal constant _PROOF_LENGTH = 0x100;
uint256 internal _globalNonce;
address public notary;
mapping(bytes32 => bool) internal _usedProofs;
mapping(uint256 => address) internal _bridgeAddressByChainId;
mapping(bytes32 => address) internal _destinationTokens;
uint256 public shortCapDuration;
mapping(address => uint256) public shortCaps;
mapping(address => mapping(uint256 => uint256)) public shortCapsDeposit;
mapping(address => mapping(uint256 => uint256)) public shortCapsWithdraw;
uint256 public longCapDuration;
mapping(address => uint256) public longCaps;
mapping(address => mapping(uint256 => uint256)) public longCapsDeposit;
mapping(address => mapping(uint256 => uint256)) public longCapsWithdraw;
address internal _previousSender;
uint256 internal _previousDepositBlockNum;
mapping(address => address) public xerc20TokenRegistry;
uint256[50 - 16] private __gap;
function __initInceptionBridgeStorage(address notaryAddress) internal {
_setNotary(notaryAddress);
_setDefaultCrosschainThreshold();
}
function _beforeDeposit() internal {
if (_previousSender != address(0) && _previousDepositBlockNum != 0) {
if (
_previousSender == tx.origin &&
_previousDepositBlockNum == block.number
) {
revert MultipleDeposits();
}
}
_previousSender = tx.origin;
_previousDepositBlockNum = block.number;
}
function _updateDepositCaps(address fromToken, uint256 amount) internal {
if (
shortCapsDeposit[fromToken][getCurrentStamp(shortCapDuration)] +
amount >
shortCaps[fromToken]
) {
revert ShortCapExceeded(
shortCaps[fromToken],
shortCapsDeposit[fromToken][getCurrentStamp(shortCapDuration)] +
amount
);
}
shortCapsDeposit[fromToken][
getCurrentStamp(shortCapDuration)
] += amount;
if (
longCapsDeposit[fromToken][getCurrentStamp(longCapDuration)] +
amount >
longCaps[fromToken]
) {
revert LongCapExceeded(
longCaps[fromToken],
longCapsDeposit[fromToken][getCurrentStamp(longCapDuration)] +
amount
);
}
longCapsDeposit[fromToken][getCurrentStamp(longCapDuration)] += amount;
}
function _updateWithdrawCaps(address token, uint256 amount) internal {
if (
shortCapsWithdraw[token][getCurrentStamp(shortCapDuration)] +
amount >
shortCaps[token]
) {
revert ShortCapExceeded(
shortCaps[token],
shortCapsWithdraw[token][getCurrentStamp(shortCapDuration)] +
amount
);
}
shortCapsWithdraw[token][getCurrentStamp(shortCapDuration)] += amount;
if (
longCapsWithdraw[token][getCurrentStamp(longCapDuration)] + amount >
longCaps[token]
) {
revert LongCapExceeded(
longCaps[token],
longCapsWithdraw[token][getCurrentStamp(longCapDuration)] +
amount
);
}
longCapsWithdraw[token][getCurrentStamp(longCapDuration)] += amount;
}
function _setNotary(address notaryAddress) internal {
if (notaryAddress == address(0x0)) revert NullAddress();
emit NotaryChanged(notary, notaryAddress);
notary = notaryAddress;
}
function _setShortCap(address token, uint256 newValue) internal {
if (token == address(0x0)) revert NullAddress();
uint256 prevValue = shortCaps[token];
emit ShortCapChanged(token, prevValue, newValue);
shortCaps[token] = newValue;
}
function _setShortCapDuration(uint256 newValue) internal {
emit ShortCapDurationChanged(shortCapDuration, newValue);
shortCapDuration = newValue;
}
function _setLongCapDuration(uint256 newValue) internal {
emit LongCapDurationChanged(longCapDuration, newValue);
longCapDuration = newValue;
}
function _setLongCap(address token, uint256 newValue) internal {
if (token == address(0x0)) {
revert NullAddress();
}
emit LongCapChanged(token, longCaps[token], newValue);
longCaps[token] = newValue;
}
function _setDefaultCrosschainThreshold() internal {
shortCapDuration = 1 hours;
longCapDuration = 1 days;
}
function _addBridge(address bridge, uint256 destinationChain) internal {
if (bridge == address(0x0)) {
revert NullAddress();
}
if (destinationChain == 0) {
revert InvalidChain();
}
if (_bridgeAddressByChainId[destinationChain] != address(0x00)) {
revert BridgeAlreadyAdded();
}
_bridgeAddressByChainId[destinationChain] = bridge;
emit BridgeAdded(bridge, destinationChain);
}
function _removeBridge(uint256 destinationChain) internal {
if (_bridgeAddressByChainId[destinationChain] == address(0x00)) {
revert BridgeNotExist();
}
address bridge = _bridgeAddressByChainId[destinationChain];
delete _bridgeAddressByChainId[destinationChain];
emit BridgeRemoved(bridge, destinationChain);
}
function _addDestination(
address fromToken,
uint256 destinationChain,
address toToken
) internal {
if (_bridgeAddressByChainId[destinationChain] == address(0))
revert UnknownDestinationChain();
if (fromToken == address(0) || toToken == address(0))
revert NullAddress();
bytes32 direction = keccak256(
abi.encodePacked(
fromToken,
block.chainid,
_bridgeAddressByChainId[destinationChain],
destinationChain
)
);
if (_destinationTokens[direction] != address(0))
revert DestinationAlreadyExists();
_destinationTokens[direction] = toToken;
emit DestinationAdded(fromToken, toToken, destinationChain);
}
function _removeDestination(
address fromToken,
uint256 destinationChain,
address toToken
) internal {
if (_bridgeAddressByChainId[destinationChain] == address(0))
revert UnknownDestinationChain();
bytes32 direction = keccak256(
abi.encodePacked(
fromToken,
block.chainid,
_bridgeAddressByChainId[destinationChain],
destinationChain
)
);
if (_destinationTokens[direction] != toToken)
revert UnknownDestination();
delete _destinationTokens[direction];
emit DestinationRemoved(fromToken, toToken, destinationChain);
}
function _setXERC20Lockbox(address token, address lockbox) internal {
if (address(token) == address(0) || address(lockbox) == address(0))
revert NullAddress();
if (xerc20TokenRegistry[token] != address(0))
revert XERC20LockboxAlreadyAdded();
emit XERC20LockboxAdded(token, lockbox);
xerc20TokenRegistry[token] = lockbox;
}
function getCurrentStamp(uint256 duration) public view returns (uint256) {
return (block.timestamp / duration) * duration;
}
}
文件 30 的 52：Initializable.sol
pragma solidity ^0.8.20;
abstract contract Initializable {
struct InitializableStorage {
uint64 _initialized;
bool _initializing;
}
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
error InvalidInitialization();
error NotInitializing();
event Initialized(uint64 version);
modifier initializer() {
InitializableStorage storage $ = _getInitializableStorage();
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint64 version) {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
_checkInitializing();
_;
}
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
function _disableInitializers() internal virtual {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
文件 31 的 52：InitializableERC1967Proxy.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/proxy/Proxy.sol";
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";
contract InitializableERC1967Proxy is Proxy, ERC1967Upgrade {
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
文件 32 的 52：InitializableTransparentUpgradeableProxy.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
import "./InitializableERC1967Proxy.sol";
contract InceptionProxyAdmin is ProxyAdmin {}
contract InitializableTransparentUpgradeableProxy is InitializableERC1967Proxy {
function initialize(
address _logic,
address admin_,
bytes memory _data
) external payable {
require(
_implementation() == address(0),
"implementation has already been set"
);
_upgradeToAndCall(_logic, _data, false);
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function _fallback() internal virtual override {
if (msg.sender == _getAdmin()) {
bytes memory ret;
bytes4 selector = msg.sig;
if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {
ret = _dispatchUpgradeTo();
} else if (
selector ==
ITransparentUpgradeableProxy.upgradeToAndCall.selector
) {
ret = _dispatchUpgradeToAndCall();
} else if (
selector == ITransparentUpgradeableProxy.changeAdmin.selector
) {
ret = _dispatchChangeAdmin();
} else if (
selector == ITransparentUpgradeableProxy.admin.selector
) {
ret = _dispatchAdmin();
} else if (
selector == ITransparentUpgradeableProxy.implementation.selector
) {
ret = _dispatchImplementation();
} else {
revert(
"TransparentUpgradeableProxy: admin cannot fallback to proxy target"
);
}
assembly {
return(add(ret, 0x20), mload(ret))
}
} else {
super._fallback();
}
}
function _dispatchAdmin() private returns (bytes memory) {
_requireZeroValue();
address admin = _getAdmin();
return abi.encode(admin);
}
function _dispatchImplementation() private returns (bytes memory) {
_requireZeroValue();
address implementation = _implementation();
return abi.encode(implementation);
}
function _dispatchChangeAdmin() private returns (bytes memory) {
_requireZeroValue();
address newAdmin = abi.decode(msg.data[4:], (address));
_changeAdmin(newAdmin);
return "";
}
function _dispatchUpgradeTo() private returns (bytes memory) {
_requireZeroValue();
address newImplementation = abi.decode(msg.data[4:], (address));
_upgradeToAndCall(newImplementation, bytes(""), false);
return "";
}
function _dispatchUpgradeToAndCall() private returns (bytes memory) {
(address newImplementation, bytes memory data) = abi.decode(
msg.data[4:],
(address, bytes)
);
_upgradeToAndCall(newImplementation, data, true);
return "";
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _requireZeroValue() private {
require(msg.value == 0, "zero value is required");
}
}
文件 33 的 52：Math.sol
pragma solidity ^0.8.0;
library Math {
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);
}
}
}
文件 34 的 52：MultipleDepositor.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "../interfaces/IInceptionBridge.sol";
contract MultipleDepositor {
IInceptionBridge internal _bridge;
constructor(IInceptionBridge bridge) {
_bridge = bridge;
}
function deposit(
address fromToken,
uint256 destinationChain,
address receiver,
uint256 amount,
uint256 numOfDeposits
) external {
IERC20(fromToken).transferFrom(
msg.sender,
address(this),
numOfDeposits * amount
);
IERC20(fromToken).approve(address(_bridge), numOfDeposits * amount);
for (uint256 i = 0; i < numOfDeposits; i++) {
_bridge.deposit(fromToken, destinationChain, receiver, amount);
}
}
}
文件 35 的 52：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_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);
}
}
文件 36 的 52：OwnableUpgradeable.sol
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
struct OwnableStorage {
address _owner;
}
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 37 的 52：PausableUpgradeable.sol
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
struct PausableStorage {
bool _paused;
}
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}
文件 38 的 52：ProofParser.sol
pragma solidity ^0.8.20;
import "./CallDataRLPReader.sol";
import "./Utils.sol";
library ProofParser {
struct Proof {
uint256 chainId;
uint256 status;
bytes32 transactionHash;
uint256 blockNumber;
bytes32 blockHash;
uint256 transactionIndex;
bytes32 receiptHash;
uint256 transferAmount;
}
function parseProof(
uint256 proofOffset
) internal pure returns (Proof memory) {
Proof memory proof;
uint256 dataOffset = proofOffset + 0x20;
assembly {
calldatacopy(proof, dataOffset, 0x20)
dataOffset := add(dataOffset, 0x40)
calldatacopy(add(proof, 0x40), dataOffset, 0x80)
dataOffset := add(dataOffset, 0xa0)
calldatacopy(add(proof, 0xe0), dataOffset, 0x20)
}
return proof;
}
}
文件 39 的 52：Proxy.sol
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
文件 40 的 52：ProxyAdmin.sol
pragma solidity ^0.8.0;
import "./TransparentUpgradeableProxy.sol";
import "../../access/Ownable.sol";
contract ProxyAdmin is Ownable {
function getProxyImplementation(ITransparentUpgradeableProxy proxy) public view virtual returns (address) {
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(ITransparentUpgradeableProxy proxy) public view virtual returns (address) {
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(ITransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(ITransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(
ITransparentUpgradeableProxy proxy,
address implementation,
bytes memory data
) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
文件 41 的 52：ReentrancyGuardUpgradeable.sol
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract ReentrancyGuardUpgradeable is Initializable {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
struct ReentrancyGuardStorage {
uint256 _status;
}
bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
assembly {
$.slot := ReentrancyGuardStorageLocation
}
}
error ReentrancyGuardReentrantCall();
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
if ($._status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
$._status = ENTERED;
}
function _nonReentrantAfter() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
return $._status == ENTERED;
}
}
文件 42 的 52：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);
}
}
文件 43 的 52：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));
}
}
文件 44 的 52：ShortStrings.sol
pragma solidity ^0.8.8;
import "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 45 的 52：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 46 的 52：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 47 的 52：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _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(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
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));
}
}
文件 48 的 52：TransparentUpgradeableProxy.sol
pragma solidity ^0.8.0;
import "../ERC1967/ERC1967Proxy.sol";
interface ITransparentUpgradeableProxy is IERC1967 {
function admin() external view returns (address);
function implementation() external view returns (address);
function changeAdmin(address) external;
function upgradeTo(address) external;
function upgradeToAndCall(address, bytes memory) external payable;
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function _fallback() internal virtual override {
if (msg.sender == _getAdmin()) {
bytes memory ret;
bytes4 selector = msg.sig;
if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {
ret = _dispatchUpgradeTo();
} else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) {
ret = _dispatchUpgradeToAndCall();
} else if (selector == ITransparentUpgradeableProxy.changeAdmin.selector) {
ret = _dispatchChangeAdmin();
} else if (selector == ITransparentUpgradeableProxy.admin.selector) {
ret = _dispatchAdmin();
} else if (selector == ITransparentUpgradeableProxy.implementation.selector) {
ret = _dispatchImplementation();
} else {
revert("TransparentUpgradeableProxy: admin cannot fallback to proxy target");
}
assembly {
return(add(ret, 0x20), mload(ret))
}
} else {
super._fallback();
}
}
function _dispatchAdmin() private returns (bytes memory) {
_requireZeroValue();
address admin = _getAdmin();
return abi.encode(admin);
}
function _dispatchImplementation() private returns (bytes memory) {
_requireZeroValue();
address implementation = _implementation();
return abi.encode(implementation);
}
function _dispatchChangeAdmin() private returns (bytes memory) {
_requireZeroValue();
address newAdmin = abi.decode(msg.data[4:], (address));
_changeAdmin(newAdmin);
return "";
}
function _dispatchUpgradeTo() private returns (bytes memory) {
_requireZeroValue();
address newImplementation = abi.decode(msg.data[4:], (address));
_upgradeToAndCall(newImplementation, bytes(""), false);
return "";
}
function _dispatchUpgradeToAndCall() private returns (bytes memory) {
(address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));
_upgradeToAndCall(newImplementation, data, true);
return "";
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _requireZeroValue() private {
require(msg.value == 0);
}
}
文件 49 的 52：Utils.sol
pragma solidity ^0.8.20;
library Utils {
function currentChain() internal view returns (uint256) {
uint256 chain;
assembly {
chain := chainid()
}
return chain;
}
function stringToBytes32(
string memory source
) internal pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function saturatingMultiply(
uint256 a,
uint256 b
) internal pure returns (uint256) {
unchecked {
if (a == 0) return 0;
uint256 c = a * b;
if (c / a != b) return type(uint256).max;
return c;
}
}
function saturatingAdd(
uint256 a,
uint256 b
) internal pure returns (uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return type(uint256).max;
return c;
}
}
function multiplyAndDivideFloor(
uint256 a,
uint256 b,
uint256 c
) internal pure returns (uint256) {
return
saturatingAdd(
saturatingMultiply(a / c, b),
((a % c) * b) / c
);
}
function multiplyAndDivideCeil(
uint256 a,
uint256 b,
uint256 c
) internal pure returns (uint256) {
return
saturatingAdd(
saturatingMultiply(a / c, b),
((a % c) * b + (c - 1)) / c
);
}
}
文件 50 的 52：XERC20.sol
pragma solidity ^0.8.20;
import "../interfaces/IXERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract XERC20 is ERC20, Ownable, IXERC20, ERC20Permit {
uint256 private constant _DURATION = 1 days;
address public immutable FACTORY;
address public lockbox;
mapping(address => Bridge) public bridges;
constructor(
string memory _name,
string memory _symbol,
address _factory
) ERC20(_name, _symbol) ERC20Permit(_name) {
_transferOwnership(_factory);
FACTORY = _factory;
}
function mint(address _user, uint256 _amount) external {
_mintWithCaller(msg.sender, _user, _amount);
}
function burn(address _user, uint256 _amount) external {
_burnWithCaller(msg.sender, _user, _amount);
}
function setLockbox(address _lockbox) external {
if (msg.sender != FACTORY) revert IXERC20_NotFactory();
lockbox = _lockbox;
emit LockboxSet(_lockbox);
}
function setBridgeLimits(
address _bridge,
uint256 _mintingLimit,
uint256 _burningLimit
) external onlyOwner {
_changeMinterLimit(_bridge, _mintingLimit);
_changeBurnerLimit(_bridge, _burningLimit);
emit BridgeLimitsSet(_mintingLimit, _burningLimit, _bridge);
}
function mintingMaxLimitOf(
address _bridge
) external view returns (uint256 _limit) {
_limit = bridges[_bridge].minterParams.maxLimit;
}
function burningMaxLimitOf(
address _bridge
) external view returns (uint256 _limit) {
_limit = bridges[_bridge].burnerParams.maxLimit;
}
function mintingCurrentLimitOf(
address _bridge
) public view returns (uint256 _limit) {
_limit = _getCurrentLimit(
bridges[_bridge].minterParams.currentLimit,
bridges[_bridge].minterParams.maxLimit,
bridges[_bridge].minterParams.timestamp,
bridges[_bridge].minterParams.ratePerSecond
);
}
function burningCurrentLimitOf(
address _bridge
) public view returns (uint256 _limit) {
_limit = _getCurrentLimit(
bridges[_bridge].burnerParams.currentLimit,
bridges[_bridge].burnerParams.maxLimit,
bridges[_bridge].burnerParams.timestamp,
bridges[_bridge].burnerParams.ratePerSecond
);
}
function _useMinterLimits(address _bridge, uint256 _change) internal {
uint256 _currentLimit = mintingCurrentLimitOf(_bridge);
bridges[_bridge].minterParams.timestamp = block.timestamp;
bridges[_bridge].minterParams.currentLimit = _currentLimit - _change;
}
function _useBurnerLimits(address _bridge, uint256 _change) internal {
uint256 _currentLimit = burningCurrentLimitOf(_bridge);
bridges[_bridge].burnerParams.timestamp = block.timestamp;
bridges[_bridge].burnerParams.currentLimit = _currentLimit - _change;
}
function _changeMinterLimit(address _bridge, uint256 _limit) internal {
if (_limit < _DURATION && _limit > 0) revert IXERC20_WrongBridgeLimit();
uint256 _oldLimit = bridges[_bridge].minterParams.maxLimit;
uint256 _currentLimit = mintingCurrentLimitOf(_bridge);
bridges[_bridge].minterParams.maxLimit = _limit;
bridges[_bridge].minterParams.currentLimit = _calculateNewCurrentLimit(
_limit,
_oldLimit,
_currentLimit
);
bridges[_bridge].minterParams.ratePerSecond = _limit / _DURATION;
bridges[_bridge].minterParams.timestamp = block.timestamp;
}
function _changeBurnerLimit(address _bridge, uint256 _limit) internal {
if (_limit < _DURATION && _limit > 0) revert IXERC20_WrongBridgeLimit();
uint256 _oldLimit = bridges[_bridge].burnerParams.maxLimit;
uint256 _currentLimit = burningCurrentLimitOf(_bridge);
bridges[_bridge].burnerParams.maxLimit = _limit;
bridges[_bridge].burnerParams.currentLimit = _calculateNewCurrentLimit(
_limit,
_oldLimit,
_currentLimit
);
bridges[_bridge].burnerParams.ratePerSecond = _limit / _DURATION;
bridges[_bridge].burnerParams.timestamp = block.timestamp;
}
function _calculateNewCurrentLimit(
uint256 _limit,
uint256 _oldLimit,
uint256 _currentLimit
) internal pure returns (uint256 _newCurrentLimit) {
uint256 _difference;
if (_oldLimit > _limit) {
_difference = _oldLimit - _limit;
_newCurrentLimit = _currentLimit > _difference
? _currentLimit - _difference
: 0;
} else {
_difference = _limit - _oldLimit;
_newCurrentLimit = _currentLimit + _difference;
}
}
function _getCurrentLimit(
uint256 _currentLimit,
uint256 _maxLimit,
uint256 _timestamp,
uint256 _ratePerSecond
) internal view returns (uint256 _limit) {
_limit = _currentLimit;
if (_limit == _maxLimit) {
return _limit;
} else if (_timestamp + _DURATION <= block.timestamp) {
_limit = _maxLimit;
} else if (_timestamp + _DURATION > block.timestamp) {
uint256 _timePassed = block.timestamp - _timestamp;
uint256 _calculatedLimit = _limit + (_timePassed * _ratePerSecond);
_limit = _calculatedLimit > _maxLimit
? _maxLimit
: _calculatedLimit;
}
}
function _burnWithCaller(
address _caller,
address _user,
uint256 _amount
) internal {
if (_caller != lockbox) {
uint256 _currentLimit = burningCurrentLimitOf(_caller);
if (_currentLimit < _amount) revert IXERC20_NotHighEnoughLimits();
_useBurnerLimits(_caller, _amount);
}
_burn(_user, _amount);
}
function _mintWithCaller(
address _caller,
address _user,
uint256 _amount
) internal {
if (_caller != lockbox) {
uint256 _currentLimit = mintingCurrentLimitOf(_caller);
if (_currentLimit < _amount) revert IXERC20_NotHighEnoughLimits();
_useMinterLimits(_caller, _amount);
}
_mint(_user, _amount);
}
}
文件 51 的 52：XERC20Lockbox.sol
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../interfaces/IXERC20Lockbox.sol";
import "../interfaces/IXERC20.sol";
contract XERC20Lockbox is IXERC20Lockbox {
using SafeERC20 for IERC20;
using SafeCast for uint256;
IXERC20 public immutable XERC20;
IERC20 public immutable ERC20;
bool public immutable IS_NATIVE;
constructor(address _xerc20, address _erc20, bool _isNative) payable {
XERC20 = IXERC20(_xerc20);
ERC20 = IERC20(_erc20);
IS_NATIVE = _isNative;
}
function depositNative() public payable {
if (!IS_NATIVE) revert IXERC20Lockbox_NotNative();
_deposit(msg.sender, msg.value);
}
function deposit(uint256 _amount) external {
if (IS_NATIVE) revert IXERC20Lockbox_Native();
_deposit(msg.sender, _amount);
}
function depositTo(address _to, uint256 _amount) external {
if (IS_NATIVE) revert IXERC20Lockbox_Native();
_deposit(_to, _amount);
}
function depositNativeTo(address _to) external payable {
if (!IS_NATIVE) revert IXERC20Lockbox_NotNative();
_deposit(_to, msg.value);
}
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 {
if (_to == address(this)) revert IXERC20Lockbox_WrongReceiver();
XERC20.burn(msg.sender, _amount);
if (IS_NATIVE) {
(bool _success, ) = payable(_to).call{value: _amount}("");
if (!_success) revert IXERC20Lockbox_WithdrawFailed();
} else {
ERC20.safeTransfer(_to, _amount);
}
emit Withdraw(_to, _amount);
}
function _deposit(address _to, uint256 _amount) internal {
if (_to == address(this)) revert IXERC20Lockbox_WrongReceiver();
if (!IS_NATIVE)
ERC20.safeTransferFrom(msg.sender, address(this), _amount);
XERC20.mint(_to, _amount);
emit Deposit(_to, _amount);
}
receive() external payable {
depositNative();
}
}
文件 52 的 52：draft-IERC1822.sol
pragma solidity ^0.8.0;
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
{
"compilationTarget": {
"contracts/proxy/InitializableTransparentUpgradeableProxy.sol": "InitializableTransparentUpgradeableProxy"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"address","name":"admin_","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]
