컴파일러
0.8.13+commit.abaa5c0e
파일 1 / 56 : AdapterInterface.sol
pragma solidity ^0.8.0;
interface AdapterInterface {
event MessageRelayed(address target, bytes message);
event TokensRelayed(address l1Token, address l2Token, uint256 amount, address to);
function relayMessage(address target, bytes calldata message) external payable;
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable;
}
파일 2 / 56 : 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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
파일 3 / 56 : AddressWhitelistInterface.sol
pragma solidity ^0.8.0;
interface AddressWhitelistInterface {
function addToWhitelist(address newElement) external;
function removeFromWhitelist(address newElement) external;
function isOnWhitelist(address newElement) external view returns (bool);
function getWhitelist() external view returns (address[] memory);
}
파일 4 / 56 : Arbitrum_Adapter.sol
pragma solidity ^0.8.0;
import "../interfaces/AdapterInterface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface ArbitrumL1InboxLike {
function createRetryableTicket(
address destAddr,
uint256 arbTxCallValue,
uint256 maxSubmissionCost,
address submissionRefundAddress,
address valueRefundAddress,
uint256 maxGas,
uint256 gasPriceBid,
bytes calldata data
) external payable returns (uint256);
}
interface ArbitrumL1ERC20GatewayLike {
function outboundTransfer(
address _token,
address _to,
uint256 _amount,
uint256 _maxGas,
uint256 _gasPriceBid,
bytes calldata _data
) external payable returns (bytes memory);
function getGateway(address _token) external view returns (address);
}
contract Arbitrum_Adapter is AdapterInterface {
using SafeERC20 for IERC20;
uint256 public immutable l2MaxSubmissionCost = 0.01e18;
uint256 public immutable l2GasPrice = 5e9;
uint32 public immutable l2GasLimit = 2_000_000;
address public immutable l2RefundL2Address;
ArbitrumL1InboxLike public immutable l1Inbox;
ArbitrumL1ERC20GatewayLike public immutable l1ERC20GatewayRouter;
constructor(ArbitrumL1InboxLike _l1ArbitrumInbox, ArbitrumL1ERC20GatewayLike _l1ERC20GatewayRouter) {
l1Inbox = _l1ArbitrumInbox;
l1ERC20GatewayRouter = _l1ERC20GatewayRouter;
l2RefundL2Address = msg.sender;
}
function relayMessage(address target, bytes memory message) external payable override {
uint256 requiredL1CallValue = _contractHasSufficientEthBalance();
l1Inbox.createRetryableTicket{ value: requiredL1CallValue }(
target,
0,
l2MaxSubmissionCost,
l2RefundL2Address,
l2RefundL2Address,
l2GasLimit,
l2GasPrice,
message
);
emit MessageRelayed(target, message);
}
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable override {
uint256 requiredL1CallValue = _contractHasSufficientEthBalance();
address erc20Gateway = l1ERC20GatewayRouter.getGateway(l1Token);
IERC20(l1Token).safeIncreaseAllowance(erc20Gateway, amount);
bytes memory data = abi.encode(l2MaxSubmissionCost, "");
l1ERC20GatewayRouter.outboundTransfer{ value: requiredL1CallValue }(
l1Token,
to,
amount,
l2GasLimit,
l2GasPrice,
data
);
emit TokensRelayed(l1Token, l2Token, amount, to);
}
function getL1CallValue() public pure returns (uint256) {
return l2MaxSubmissionCost + l2GasPrice * l2GasLimit;
}
function _contractHasSufficientEthBalance() internal view returns (uint256 requiredL1CallValue) {
requiredL1CallValue = getL1CallValue();
require(address(this).balance >= requiredL1CallValue, "Insufficient ETH balance");
}
}
파일 5 / 56 : Arbitrum_SpokePool.sol
pragma solidity ^0.8.0;
import "./SpokePool.sol";
interface StandardBridgeLike {
function outboundTransfer(
address _l1Token,
address _to,
uint256 _amount,
bytes calldata _data
) external payable returns (bytes memory);
}
contract Arbitrum_SpokePool is SpokePool {
address public l2GatewayRouter;
mapping(address => address) public whitelistedTokens;
event ArbitrumTokensBridged(address indexed l1Token, address target, uint256 numberOfTokensBridged);
event SetL2GatewayRouter(address indexed newL2GatewayRouter);
event WhitelistedTokens(address indexed l2Token, address indexed l1Token);
constructor(
address _l2GatewayRouter,
address _crossDomainAdmin,
address _hubPool,
address _wethAddress,
address timerAddress
) SpokePool(_crossDomainAdmin, _hubPool, _wethAddress, timerAddress) {
_setL2GatewayRouter(_l2GatewayRouter);
}
modifier onlyFromCrossDomainAdmin() {
require(msg.sender == _applyL1ToL2Alias(crossDomainAdmin), "ONLY_COUNTERPART_GATEWAY");
_;
}
function setL2GatewayRouter(address newL2GatewayRouter) public onlyAdmin nonReentrant {
_setL2GatewayRouter(newL2GatewayRouter);
}
function whitelistToken(address l2Token, address l1Token) public onlyAdmin nonReentrant {
_whitelistToken(l2Token, l1Token);
}
function _bridgeTokensToHubPool(RelayerRefundLeaf memory relayerRefundLeaf) internal override {
address ethereumTokenToBridge = whitelistedTokens[relayerRefundLeaf.l2TokenAddress];
require(ethereumTokenToBridge != address(0), "Uninitialized mainnet token");
StandardBridgeLike(l2GatewayRouter).outboundTransfer(
ethereumTokenToBridge,
hubPool,
relayerRefundLeaf.amountToReturn,
""
);
emit ArbitrumTokensBridged(address(0), hubPool, relayerRefundLeaf.amountToReturn);
}
function _setL2GatewayRouter(address _l2GatewayRouter) internal {
l2GatewayRouter = _l2GatewayRouter;
emit SetL2GatewayRouter(l2GatewayRouter);
}
function _whitelistToken(address _l2Token, address _l1Token) internal {
whitelistedTokens[_l2Token] = _l1Token;
emit WhitelistedTokens(_l2Token, _l1Token);
}
function _applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
unchecked {
l2Address = address(uint160(l1Address) + uint160(0x1111000000000000000000000000000000001111));
}
}
function _requireAdminSender() internal override onlyFromCrossDomainAdmin {}
}
파일 6 / 56 : Constants.sol
pragma solidity ^0.8.0;
library OracleInterfaces {
bytes32 public constant Oracle = "Oracle";
bytes32 public constant IdentifierWhitelist = "IdentifierWhitelist";
bytes32 public constant Store = "Store";
bytes32 public constant FinancialContractsAdmin = "FinancialContractsAdmin";
bytes32 public constant Registry = "Registry";
bytes32 public constant CollateralWhitelist = "CollateralWhitelist";
bytes32 public constant OptimisticOracle = "OptimisticOracle";
bytes32 public constant Bridge = "Bridge";
bytes32 public constant GenericHandler = "GenericHandler";
bytes32 public constant SkinnyOptimisticOracle = "SkinnyOptimisticOracle";
bytes32 public constant ChildMessenger = "ChildMessenger";
bytes32 public constant OracleHub = "OracleHub";
bytes32 public constant OracleSpoke = "OracleSpoke";
}
library OptimisticOracleConstraints {
uint256 public constant ancillaryBytesLimit = 8192;
}
파일 7 / 56 : 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;
}
}
파일 8 / 56 : CrossDomainEnabled.sol
pragma solidity >0.5.0 <0.9.0;
import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
contract CrossDomainEnabled {
address public messenger;
constructor(address _messenger) {
messenger = _messenger;
}
modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
require(
msg.sender == address(getCrossDomainMessenger()),
"OVM_XCHAIN: messenger contract unauthenticated"
);
require(
getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
"OVM_XCHAIN: wrong sender of cross-domain message"
);
_;
}
function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
return ICrossDomainMessenger(messenger);
}
function sendCrossDomainMessage(
address _crossDomainTarget,
uint32 _gasLimit,
bytes memory _message
) internal {
getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
}
}
파일 9 / 56 : 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");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' 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 if (signature.length == 64) {
bytes32 r;
bytes32 vs;
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} 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);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
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) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
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) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
파일 10 / 56 : 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, _allowances[owner][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = _allowances[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;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
파일 11 / 56 : Ethereum_Adapter.sol
pragma solidity ^0.8.0;
import "../interfaces/AdapterInterface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract Ethereum_Adapter is AdapterInterface {
using SafeERC20 for IERC20;
function relayMessage(address target, bytes calldata message) external payable override {
_executeCall(target, message);
emit MessageRelayed(target, message);
}
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable override {
IERC20(l1Token).safeTransfer(to, amount);
emit TokensRelayed(l1Token, l2Token, amount, to);
}
function _executeCall(address to, bytes memory data) private {
bool success;
assembly {
let inputData := add(data, 0x20)
let inputDataSize := mload(data)
success := call(gas(), to, 0, inputData, inputDataSize, 0, 0)
}
require(success, "execute call failed");
}
}
파일 12 / 56 : Ethereum_SpokePool.sol
pragma solidity ^0.8.0;
import "./SpokePool.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Ethereum_SpokePool is SpokePool, Ownable {
constructor(
address _hubPool,
address _wethAddress,
address timerAddress
) SpokePool(msg.sender, _hubPool, _wethAddress, timerAddress) {}
function _bridgeTokensToHubPool(RelayerRefundLeaf memory relayerRefundLeaf) internal override {
IERC20(relayerRefundLeaf.l2TokenAddress).transfer(hubPool, relayerRefundLeaf.amountToReturn);
}
function _requireAdminSender() internal override onlyOwner {}
}
파일 13 / 56 : ExpandedERC20.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./MultiRole.sol";
import "../interfaces/ExpandedIERC20.sol";
contract ExpandedERC20 is ExpandedIERC20, ERC20, MultiRole {
enum Roles {
Owner,
Minter,
Burner
}
uint8 _decimals;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint8 _tokenDecimals
) ERC20(_tokenName, _tokenSymbol) {
_decimals = _tokenDecimals;
_createExclusiveRole(uint256(Roles.Owner), uint256(Roles.Owner), msg.sender);
_createSharedRole(uint256(Roles.Minter), uint256(Roles.Owner), new address[](0));
_createSharedRole(uint256(Roles.Burner), uint256(Roles.Owner), new address[](0));
}
function decimals() public view virtual override(ERC20) returns (uint8) {
return _decimals;
}
function mint(address recipient, uint256 value)
external
override
onlyRoleHolder(uint256(Roles.Minter))
returns (bool)
{
_mint(recipient, value);
return true;
}
function burn(uint256 value) external override onlyRoleHolder(uint256(Roles.Burner)) {
_burn(msg.sender, value);
}
function burnFrom(address recipient, uint256 value)
external
override
onlyRoleHolder(uint256(Roles.Burner))
returns (bool)
{
_burn(recipient, value);
return true;
}
function addMinter(address account) external virtual override {
addMember(uint256(Roles.Minter), account);
}
function addBurner(address account) external virtual override {
addMember(uint256(Roles.Burner), account);
}
function resetOwner(address account) external virtual override {
resetMember(uint256(Roles.Owner), account);
}
}
파일 14 / 56 : ExpandedIERC20.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
abstract contract ExpandedIERC20 is IERC20 {
function burn(uint256 value) external virtual;
function burnFrom(address recipient, uint256 value) external virtual returns (bool);
function mint(address to, uint256 value) external virtual returns (bool);
function addMinter(address account) external virtual;
function addBurner(address account) external virtual;
function resetOwner(address account) external virtual;
}
파일 15 / 56 : FinderInterface.sol
pragma solidity ^0.8.0;
interface FinderInterface {
function changeImplementationAddress(bytes32 interfaceName, address implementationAddress) external;
function getImplementationAddress(bytes32 interfaceName) external view returns (address);
}
파일 16 / 56 : FixedPoint.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/SignedSafeMath.sol";
library FixedPoint {
using SafeMath for uint256;
using SignedSafeMath for int256;
uint256 private constant FP_SCALING_FACTOR = 10**18;
struct Unsigned {
uint256 rawValue;
}
function fromUnscaledUint(uint256 a) internal pure returns (Unsigned memory) {
return Unsigned(a.mul(FP_SCALING_FACTOR));
}
function isEqual(Unsigned memory a, uint256 b) internal pure returns (bool) {
return a.rawValue == fromUnscaledUint(b).rawValue;
}
function isEqual(Unsigned memory a, Unsigned memory b) internal pure returns (bool) {
return a.rawValue == b.rawValue;
}
function isGreaterThan(Unsigned memory a, Unsigned memory b) internal pure returns (bool) {
return a.rawValue > b.rawValue;
}
function isGreaterThan(Unsigned memory a, uint256 b) internal pure returns (bool) {
return a.rawValue > fromUnscaledUint(b).rawValue;
}
function isGreaterThan(uint256 a, Unsigned memory b) internal pure returns (bool) {
return fromUnscaledUint(a).rawValue > b.rawValue;
}
function isGreaterThanOrEqual(Unsigned memory a, Unsigned memory b) internal pure returns (bool) {
return a.rawValue >= b.rawValue;
}
function isGreaterThanOrEqual(Unsigned memory a, uint256 b) internal pure returns (bool) {
return a.rawValue >= fromUnscaledUint(b).rawValue;
}
function isGreaterThanOrEqual(uint256 a, Unsigned memory b) internal pure returns (bool) {
return fromUnscaledUint(a).rawValue >= b.rawValue;
}
function isLessThan(Unsigned memory a, Unsigned memory b) internal pure returns (bool) {
return a.rawValue < b.rawValue;
}
function isLessThan(Unsigned memory a, uint256 b) internal pure returns (bool) {
return a.rawValue < fromUnscaledUint(b).rawValue;
}
function isLessThan(uint256 a, Unsigned memory b) internal pure returns (bool) {
return fromUnscaledUint(a).rawValue < b.rawValue;
}
function isLessThanOrEqual(Unsigned memory a, Unsigned memory b) internal pure returns (bool) {
return a.rawValue <= b.rawValue;
}
function isLessThanOrEqual(Unsigned memory a, uint256 b) internal pure returns (bool) {
return a.rawValue <= fromUnscaledUint(b).rawValue;
}
function isLessThanOrEqual(uint256 a, Unsigned memory b) internal pure returns (bool) {
return fromUnscaledUint(a).rawValue <= b.rawValue;
}
function min(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return a.rawValue < b.rawValue ? a : b;
}
function max(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return a.rawValue > b.rawValue ? a : b;
}
function add(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.add(b.rawValue));
}
function add(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return add(a, fromUnscaledUint(b));
}
function sub(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.sub(b.rawValue));
}
function sub(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return sub(a, fromUnscaledUint(b));
}
function sub(uint256 a, Unsigned memory b) internal pure returns (Unsigned memory) {
return sub(fromUnscaledUint(a), b);
}
function mul(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.mul(b.rawValue) / FP_SCALING_FACTOR);
}
function mul(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.mul(b));
}
function mulCeil(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
uint256 mulRaw = a.rawValue.mul(b.rawValue);
uint256 mulFloor = mulRaw / FP_SCALING_FACTOR;
uint256 mod = mulRaw.mod(FP_SCALING_FACTOR);
if (mod != 0) {
return Unsigned(mulFloor.add(1));
} else {
return Unsigned(mulFloor);
}
}
function mulCeil(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.mul(b));
}
function div(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.mul(FP_SCALING_FACTOR).div(b.rawValue));
}
function div(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return Unsigned(a.rawValue.div(b));
}
function div(uint256 a, Unsigned memory b) internal pure returns (Unsigned memory) {
return div(fromUnscaledUint(a), b);
}
function divCeil(Unsigned memory a, Unsigned memory b) internal pure returns (Unsigned memory) {
uint256 aScaled = a.rawValue.mul(FP_SCALING_FACTOR);
uint256 divFloor = aScaled.div(b.rawValue);
uint256 mod = aScaled.mod(b.rawValue);
if (mod != 0) {
return Unsigned(divFloor.add(1));
} else {
return Unsigned(divFloor);
}
}
function divCeil(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory) {
return divCeil(a, fromUnscaledUint(b));
}
function pow(Unsigned memory a, uint256 b) internal pure returns (Unsigned memory output) {
output = fromUnscaledUint(1);
for (uint256 i = 0; i < b; i = i.add(1)) {
output = mul(output, a);
}
}
int256 private constant SFP_SCALING_FACTOR = 10**18;
struct Signed {
int256 rawValue;
}
function fromSigned(Signed memory a) internal pure returns (Unsigned memory) {
require(a.rawValue >= 0, "Negative value provided");
return Unsigned(uint256(a.rawValue));
}
function fromUnsigned(Unsigned memory a) internal pure returns (Signed memory) {
require(a.rawValue <= uint256(type(int256).max), "Unsigned too large");
return Signed(int256(a.rawValue));
}
function fromUnscaledInt(int256 a) internal pure returns (Signed memory) {
return Signed(a.mul(SFP_SCALING_FACTOR));
}
function isEqual(Signed memory a, int256 b) internal pure returns (bool) {
return a.rawValue == fromUnscaledInt(b).rawValue;
}
function isEqual(Signed memory a, Signed memory b) internal pure returns (bool) {
return a.rawValue == b.rawValue;
}
function isGreaterThan(Signed memory a, Signed memory b) internal pure returns (bool) {
return a.rawValue > b.rawValue;
}
function isGreaterThan(Signed memory a, int256 b) internal pure returns (bool) {
return a.rawValue > fromUnscaledInt(b).rawValue;
}
function isGreaterThan(int256 a, Signed memory b) internal pure returns (bool) {
return fromUnscaledInt(a).rawValue > b.rawValue;
}
function isGreaterThanOrEqual(Signed memory a, Signed memory b) internal pure returns (bool) {
return a.rawValue >= b.rawValue;
}
function isGreaterThanOrEqual(Signed memory a, int256 b) internal pure returns (bool) {
return a.rawValue >= fromUnscaledInt(b).rawValue;
}
function isGreaterThanOrEqual(int256 a, Signed memory b) internal pure returns (bool) {
return fromUnscaledInt(a).rawValue >= b.rawValue;
}
function isLessThan(Signed memory a, Signed memory b) internal pure returns (bool) {
return a.rawValue < b.rawValue;
}
function isLessThan(Signed memory a, int256 b) internal pure returns (bool) {
return a.rawValue < fromUnscaledInt(b).rawValue;
}
function isLessThan(int256 a, Signed memory b) internal pure returns (bool) {
return fromUnscaledInt(a).rawValue < b.rawValue;
}
function isLessThanOrEqual(Signed memory a, Signed memory b) internal pure returns (bool) {
return a.rawValue <= b.rawValue;
}
function isLessThanOrEqual(Signed memory a, int256 b) internal pure returns (bool) {
return a.rawValue <= fromUnscaledInt(b).rawValue;
}
function isLessThanOrEqual(int256 a, Signed memory b) internal pure returns (bool) {
return fromUnscaledInt(a).rawValue <= b.rawValue;
}
function min(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return a.rawValue < b.rawValue ? a : b;
}
function max(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return a.rawValue > b.rawValue ? a : b;
}
function add(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return Signed(a.rawValue.add(b.rawValue));
}
function add(Signed memory a, int256 b) internal pure returns (Signed memory) {
return add(a, fromUnscaledInt(b));
}
function sub(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return Signed(a.rawValue.sub(b.rawValue));
}
function sub(Signed memory a, int256 b) internal pure returns (Signed memory) {
return sub(a, fromUnscaledInt(b));
}
function sub(int256 a, Signed memory b) internal pure returns (Signed memory) {
return sub(fromUnscaledInt(a), b);
}
function mul(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return Signed(a.rawValue.mul(b.rawValue) / SFP_SCALING_FACTOR);
}
function mul(Signed memory a, int256 b) internal pure returns (Signed memory) {
return Signed(a.rawValue.mul(b));
}
function mulAwayFromZero(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
int256 mulRaw = a.rawValue.mul(b.rawValue);
int256 mulTowardsZero = mulRaw / SFP_SCALING_FACTOR;
int256 mod = mulRaw % SFP_SCALING_FACTOR;
if (mod != 0) {
bool isResultPositive = isLessThan(a, 0) == isLessThan(b, 0);
int256 valueToAdd = isResultPositive ? int256(1) : int256(-1);
return Signed(mulTowardsZero.add(valueToAdd));
} else {
return Signed(mulTowardsZero);
}
}
function mulAwayFromZero(Signed memory a, int256 b) internal pure returns (Signed memory) {
return Signed(a.rawValue.mul(b));
}
function div(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
return Signed(a.rawValue.mul(SFP_SCALING_FACTOR).div(b.rawValue));
}
function div(Signed memory a, int256 b) internal pure returns (Signed memory) {
return Signed(a.rawValue.div(b));
}
function div(int256 a, Signed memory b) internal pure returns (Signed memory) {
return div(fromUnscaledInt(a), b);
}
function divAwayFromZero(Signed memory a, Signed memory b) internal pure returns (Signed memory) {
int256 aScaled = a.rawValue.mul(SFP_SCALING_FACTOR);
int256 divTowardsZero = aScaled.div(b.rawValue);
int256 mod = aScaled % b.rawValue;
if (mod != 0) {
bool isResultPositive = isLessThan(a, 0) == isLessThan(b, 0);
int256 valueToAdd = isResultPositive ? int256(1) : int256(-1);
return Signed(divTowardsZero.add(valueToAdd));
} else {
return Signed(divTowardsZero);
}
}
function divAwayFromZero(Signed memory a, int256 b) internal pure returns (Signed memory) {
return divAwayFromZero(a, fromUnscaledInt(b));
}
function pow(Signed memory a, uint256 b) internal pure returns (Signed memory output) {
output = fromUnscaledInt(1);
for (uint256 i = 0; i < b; i = i.add(1)) {
output = mul(output, a);
}
}
}
파일 17 / 56 : HubPoolInterface.sol
pragma solidity ^0.8.0;
import "./interfaces/AdapterInterface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface HubPoolInterface {
struct PoolRebalanceLeaf {
uint256 chainId;
uint256[] bundleLpFees;
int256[] netSendAmounts;
int256[] runningBalances;
uint256 groupIndex;
uint8 leafId;
address[] l1Tokens;
}
struct RootBundle {
bytes32 poolRebalanceRoot;
bytes32 relayerRefundRoot;
bytes32 slowRelayRoot;
uint256 claimedBitMap;
address proposer;
uint8 unclaimedPoolRebalanceLeafCount;
uint32 challengePeriodEndTimestamp;
}
struct PooledToken {
address lpToken;
bool isEnabled;
uint32 lastLpFeeUpdate;
int256 utilizedReserves;
uint256 liquidReserves;
uint256 undistributedLpFees;
}
struct CrossChainContract {
address adapter;
address spokePool;
}
function setPaused(bool pause) external;
function emergencyDeleteProposal() external;
function relaySpokePoolAdminFunction(uint256 chainId, bytes memory functionData) external;
function setProtocolFeeCapture(address newProtocolFeeCaptureAddress, uint256 newProtocolFeeCapturePct) external;
function setBond(IERC20 newBondToken, uint256 newBondAmount) external;
function setLiveness(uint32 newLiveness) external;
function setIdentifier(bytes32 newIdentifier) external;
function setCrossChainContracts(
uint256 l2ChainId,
address adapter,
address spokePool
) external;
function enableL1TokenForLiquidityProvision(address l1Token) external;
function disableL1TokenForLiquidityProvision(address l1Token) external;
function addLiquidity(address l1Token, uint256 l1TokenAmount) external payable;
function removeLiquidity(
address l1Token,
uint256 lpTokenAmount,
bool sendEth
) external;
function exchangeRateCurrent(address l1Token) external returns (uint256);
function liquidityUtilizationCurrent(address l1Token) external returns (uint256);
function liquidityUtilizationPostRelay(address l1Token, uint256 relayedAmount) external returns (uint256);
function sync(address l1Token) external;
function proposeRootBundle(
uint256[] memory bundleEvaluationBlockNumbers,
uint8 poolRebalanceLeafCount,
bytes32 poolRebalanceRoot,
bytes32 relayerRefundRoot,
bytes32 slowRelayRoot
) external;
function executeRootBundle(
uint256 chainId,
uint256 groupIndex,
uint256[] memory bundleLpFees,
int256[] memory netSendAmounts,
int256[] memory runningBalances,
uint8 leafId,
address[] memory l1Tokens,
bytes32[] memory proof
) external;
function disputeRootBundle() external;
function claimProtocolFeesCaptured(address l1Token) external;
function setPoolRebalanceRoute(
uint256 destinationChainId,
address l1Token,
address destinationToken
) external;
function setDepositRoute(
uint256 originChainId,
uint256 destinationChainId,
address originToken,
bool depositsEnabled
) external;
function poolRebalanceRoute(uint256 destinationChainId, address l1Token)
external
view
returns (address destinationToken);
function loadEthForL2Calls() external payable;
}
파일 18 / 56 : ICrossDomainMessenger.sol
pragma solidity >0.5.0 <0.9.0;
interface ICrossDomainMessenger {
event SentMessage(
address indexed target,
address sender,
bytes message,
uint256 messageNonce,
uint256 gasLimit
);
event RelayedMessage(bytes32 indexed msgHash);
event FailedRelayedMessage(bytes32 indexed msgHash);
function xDomainMessageSender() external view returns (address);
function sendMessage(
address _target,
bytes calldata _message,
uint32 _gasLimit
) external;
}
파일 19 / 56 : IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
파일 20 / 56 : 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 / 56 : IL1ERC20Bridge.sol
pragma solidity >0.5.0 <0.9.0;
interface IL1ERC20Bridge {
event ERC20DepositInitiated(
address indexed _l1Token,
address indexed _l2Token,
address indexed _from,
address _to,
uint256 _amount,
bytes _data
);
event ERC20WithdrawalFinalized(
address indexed _l1Token,
address indexed _l2Token,
address indexed _from,
address _to,
uint256 _amount,
bytes _data
);
function l2TokenBridge() external returns (address);
function depositERC20(
address _l1Token,
address _l2Token,
uint256 _amount,
uint32 _l2Gas,
bytes calldata _data
) external;
function depositERC20To(
address _l1Token,
address _l2Token,
address _to,
uint256 _amount,
uint32 _l2Gas,
bytes calldata _data
) external;
function finalizeERC20Withdrawal(
address _l1Token,
address _l2Token,
address _from,
address _to,
uint256 _amount,
bytes calldata _data
) external;
}
파일 22 / 56 : IL1StandardBridge.sol
pragma solidity >0.5.0 <0.9.0;
import "./IL1ERC20Bridge.sol";
interface IL1StandardBridge is IL1ERC20Bridge {
event ETHDepositInitiated(
address indexed _from,
address indexed _to,
uint256 _amount,
bytes _data
);
event ETHWithdrawalFinalized(
address indexed _from,
address indexed _to,
uint256 _amount,
bytes _data
);
function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
function depositETHTo(
address _to,
uint32 _l2Gas,
bytes calldata _data
) external payable;
function finalizeETHWithdrawal(
address _from,
address _to,
uint256 _amount,
bytes calldata _data
) external;
}
파일 23 / 56 : IL2ERC20Bridge.sol
pragma solidity ^0.8.9;
interface IL2ERC20Bridge {
event WithdrawalInitiated(
address indexed _l1Token,
address indexed _l2Token,
address indexed _from,
address _to,
uint256 _amount,
bytes _data
);
event DepositFinalized(
address indexed _l1Token,
address indexed _l2Token,
address indexed _from,
address _to,
uint256 _amount,
bytes _data
);
event DepositFailed(
address indexed _l1Token,
address indexed _l2Token,
address indexed _from,
address _to,
uint256 _amount,
bytes _data
);
function l1TokenBridge() external returns (address);
function withdraw(
address _l2Token,
uint256 _amount,
uint32 _l1Gas,
bytes calldata _data
) external;
function withdrawTo(
address _l2Token,
address _to,
uint256 _amount,
uint32 _l1Gas,
bytes calldata _data
) external;
function finalizeDeposit(
address _l1Token,
address _l2Token,
address _from,
address _to,
uint256 _amount,
bytes calldata _data
) external;
}
파일 24 / 56 : IdentifierWhitelistInterface.sol
pragma solidity ^0.8.0;
interface IdentifierWhitelistInterface {
function addSupportedIdentifier(bytes32 identifier) external;
function removeSupportedIdentifier(bytes32 identifier) external;
function isIdentifierSupported(bytes32 identifier) external view returns (bool);
}
파일 25 / 56 : Lib_PredeployAddresses.sol
pragma solidity ^0.8.9;
library Lib_PredeployAddresses {
address internal constant L2_TO_L1_MESSAGE_PASSER = 0x4200000000000000000000000000000000000000;
address internal constant L1_MESSAGE_SENDER = 0x4200000000000000000000000000000000000001;
address internal constant DEPLOYER_WHITELIST = 0x4200000000000000000000000000000000000002;
address payable internal constant OVM_ETH = payable(0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000);
address internal constant L2_CROSS_DOMAIN_MESSENGER =
0x4200000000000000000000000000000000000007;
address internal constant LIB_ADDRESS_MANAGER = 0x4200000000000000000000000000000000000008;
address internal constant PROXY_EOA = 0x4200000000000000000000000000000000000009;
address internal constant L2_STANDARD_BRIDGE = 0x4200000000000000000000000000000000000010;
address internal constant SEQUENCER_FEE_WALLET = 0x4200000000000000000000000000000000000011;
address internal constant L2_STANDARD_TOKEN_FACTORY =
0x4200000000000000000000000000000000000012;
address internal constant L1_BLOCK_NUMBER = 0x4200000000000000000000000000000000000013;
}
파일 26 / 56 : Lockable.sol
pragma solidity ^0.8.0;
contract Lockable {
bool internal _notEntered;
constructor() {
_notEntered = true;
}
modifier nonReentrant() {
_preEntranceCheck();
_preEntranceSet();
_;
_postEntranceReset();
}
modifier nonReentrantView() {
_preEntranceCheck();
_;
}
function functionCallStackOriginatesFromOutsideThisContract() internal view returns (bool) {
return _notEntered;
}
function _preEntranceCheck() internal view {
require(_notEntered, "ReentrancyGuard: reentrant call");
}
function _preEntranceSet() internal {
_notEntered = false;
}
function _postEntranceReset() internal {
_notEntered = true;
}
}
파일 27 / 56 : LpTokenFactory.sol
pragma solidity ^0.8.0;
import "./interfaces/LpTokenFactoryInterface.sol";
import "@uma/core/contracts/common/implementation/ExpandedERC20.sol";
contract LpTokenFactory is LpTokenFactoryInterface {
function createLpToken(address l1Token) public returns (address) {
ExpandedERC20 lpToken = new ExpandedERC20(
_concatenate("Across V2 ", IERC20Metadata(l1Token).name(), " LP Token"),
_concatenate("Av2-", IERC20Metadata(l1Token).symbol(), "-LP"),
IERC20Metadata(l1Token).decimals()
);
lpToken.addMinter(msg.sender);
lpToken.addBurner(msg.sender);
lpToken.resetOwner(msg.sender);
return address(lpToken);
}
function _concatenate(
string memory a,
string memory b,
string memory c
) internal pure returns (string memory) {
return string(abi.encodePacked(a, b, c));
}
}
파일 28 / 56 : LpTokenFactoryInterface.sol
pragma solidity ^0.8.0;
interface LpTokenFactoryInterface {
function createLpToken(address l1Token) external returns (address);
}
파일 29 / 56 : MerkleLib.sol
pragma solidity ^0.8.0;
import "./SpokePoolInterface.sol";
import "./HubPoolInterface.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
library MerkleLib {
function verifyPoolRebalance(
bytes32 root,
HubPoolInterface.PoolRebalanceLeaf memory rebalance,
bytes32[] memory proof
) internal pure returns (bool) {
return MerkleProof.verify(proof, root, keccak256(abi.encode(rebalance)));
}
function verifyRelayerRefund(
bytes32 root,
SpokePoolInterface.RelayerRefundLeaf memory refund,
bytes32[] memory proof
) internal pure returns (bool) {
return MerkleProof.verify(proof, root, keccak256(abi.encode(refund)));
}
function verifySlowRelayFulfillment(
bytes32 root,
SpokePoolInterface.RelayData memory slowRelayFulfillment,
bytes32[] memory proof
) internal pure returns (bool) {
return MerkleProof.verify(proof, root, keccak256(abi.encode(slowRelayFulfillment)));
}
function isClaimed(mapping(uint256 => uint256) storage claimedBitMap, uint256 index) internal view returns (bool) {
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
uint256 claimedWord = claimedBitMap[claimedWordIndex];
uint256 mask = (1 << claimedBitIndex);
return claimedWord & mask == mask;
}
function setClaimed(mapping(uint256 => uint256) storage claimedBitMap, uint256 index) internal {
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);
}
function isClaimed1D(uint256 claimedBitMap, uint8 index) internal pure returns (bool) {
uint256 mask = (1 << index);
return claimedBitMap & mask == mask;
}
function setClaimed1D(uint256 claimedBitMap, uint8 index) internal pure returns (uint256) {
return claimedBitMap | (1 << index % 256);
}
}
파일 30 / 56 : MerkleLibTest.sol
pragma solidity ^0.8.0;
import "../MerkleLib.sol";
import "../HubPoolInterface.sol";
import "../SpokePoolInterface.sol";
contract MerkleLibTest {
mapping(uint256 => uint256) public claimedBitMap;
uint256 public claimedBitMap1D;
function verifyPoolRebalance(
bytes32 root,
HubPoolInterface.PoolRebalanceLeaf memory rebalance,
bytes32[] memory proof
) public pure returns (bool) {
return MerkleLib.verifyPoolRebalance(root, rebalance, proof);
}
function verifyRelayerRefund(
bytes32 root,
SpokePoolInterface.RelayerRefundLeaf memory refund,
bytes32[] memory proof
) public pure returns (bool) {
return MerkleLib.verifyRelayerRefund(root, refund, proof);
}
function verifySlowRelayFulfillment(
bytes32 root,
SpokePoolInterface.RelayData memory slowRelayFulfillment,
bytes32[] memory proof
) public pure returns (bool) {
return MerkleLib.verifySlowRelayFulfillment(root, slowRelayFulfillment, proof);
}
function isClaimed(uint256 index) public view returns (bool) {
return MerkleLib.isClaimed(claimedBitMap, index);
}
function setClaimed(uint256 index) public {
MerkleLib.setClaimed(claimedBitMap, index);
}
function isClaimed1D(uint8 index) public view returns (bool) {
return MerkleLib.isClaimed1D(claimedBitMap1D, index);
}
function setClaimed1D(uint8 index) public {
claimedBitMap1D = MerkleLib.setClaimed1D(claimedBitMap1D, index);
}
}
파일 31 / 56 : MerkleProof.sol
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = _efficientHash(computedHash, proofElement);
} else {
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
파일 32 / 56 : MockSpokePool.sol
pragma solidity ^0.8.0;
import "../SpokePool.sol";
import "../SpokePoolInterface.sol";
contract MockSpokePool is SpokePool {
uint256 private chainId_;
constructor(
address _crossDomainAdmin,
address _hubPool,
address _wethAddress,
address timerAddress
) SpokePool(_crossDomainAdmin, _hubPool, _wethAddress, timerAddress) {}
function _bridgeTokensToHubPool(RelayerRefundLeaf memory relayerRefundLeaf) internal override {}
function _requireAdminSender() internal override {}
function chainId() public view override(SpokePool) returns (uint256) {
return chainId_ == 0 ? super.chainId() : chainId_;
}
function setChainId(uint256 _chainId) public {
chainId_ = _chainId;
}
}
파일 33 / 56 : Mock_Adapter.sol
pragma solidity ^0.8.0;
import "../interfaces/AdapterInterface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract Mock_Adapter is AdapterInterface {
event RelayMessageCalled(address target, bytes message, address caller);
event RelayTokensCalled(address l1Token, address l2Token, uint256 amount, address to, address caller);
Mock_Bridge public immutable bridge;
constructor() {
bridge = new Mock_Bridge();
}
function relayMessage(address target, bytes calldata message) external payable override {
bridge.bridgeMessage(target, message);
emit RelayMessageCalled(target, message, msg.sender);
}
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable override {
IERC20(l1Token).approve(address(bridge), amount);
bridge.bridgeTokens(l1Token, amount);
emit RelayTokensCalled(l1Token, l2Token, amount, to, msg.sender);
}
}
contract Mock_Bridge {
event BridgedTokens(address token, uint256 amount);
event BridgedMessage(address target, bytes message);
mapping(address => uint256) public deposits;
function bridgeTokens(address token, uint256 amount) public {
IERC20(token).transferFrom(msg.sender, address(this), amount);
deposits[token] += amount;
emit BridgedTokens(token, amount);
}
function bridgeMessage(address target, bytes calldata message) public {
emit BridgedMessage(target, message);
}
}
파일 34 / 56 : MultiCaller.sol
pragma solidity ^0.8.0;
contract MultiCaller {
function multicall(bytes[] calldata data) external payable returns (bytes[] memory results) {
require(msg.value == 0, "Only multicall with 0 value");
results = new bytes[](data.length);
for (uint256 i = 0; i < data.length; i++) {
(bool success, bytes memory result) = address(this).delegatecall(data[i]);
if (!success) {
if (result.length < 68) revert();
assembly {
result := add(result, 0x04)
}
revert(abi.decode(result, (string)));
}
results[i] = result;
}
}
}
파일 35 / 56 : MultiRole.sol
pragma solidity ^0.8.0;
library Exclusive {
struct RoleMembership {
address member;
}
function isMember(RoleMembership storage roleMembership, address memberToCheck) internal view returns (bool) {
return roleMembership.member == memberToCheck;
}
function resetMember(RoleMembership storage roleMembership, address newMember) internal {
require(newMember != address(0x0), "Cannot set an exclusive role to 0x0");
roleMembership.member = newMember;
}
function getMember(RoleMembership storage roleMembership) internal view returns (address) {
return roleMembership.member;
}
function init(RoleMembership storage roleMembership, address initialMember) internal {
resetMember(roleMembership, initialMember);
}
}
library Shared {
struct RoleMembership {
mapping(address => bool) members;
}
function isMember(RoleMembership storage roleMembership, address memberToCheck) internal view returns (bool) {
return roleMembership.members[memberToCheck];
}
function addMember(RoleMembership storage roleMembership, address memberToAdd) internal {
require(memberToAdd != address(0x0), "Cannot add 0x0 to a shared role");
roleMembership.members[memberToAdd] = true;
}
function removeMember(RoleMembership storage roleMembership, address memberToRemove) internal {
roleMembership.members[memberToRemove] = false;
}
function init(RoleMembership storage roleMembership, address[] memory initialMembers) internal {
for (uint256 i = 0; i < initialMembers.length; i++) {
addMember(roleMembership, initialMembers[i]);
}
}
}
abstract contract MultiRole {
using Exclusive for Exclusive.RoleMembership;
using Shared for Shared.RoleMembership;
enum RoleType { Invalid, Exclusive, Shared }
struct Role {
uint256 managingRole;
RoleType roleType;
Exclusive.RoleMembership exclusiveRoleMembership;
Shared.RoleMembership sharedRoleMembership;
}
mapping(uint256 => Role) private roles;
event ResetExclusiveMember(uint256 indexed roleId, address indexed newMember, address indexed manager);
event AddedSharedMember(uint256 indexed roleId, address indexed newMember, address indexed manager);
event RemovedSharedMember(uint256 indexed roleId, address indexed oldMember, address indexed manager);
modifier onlyRoleHolder(uint256 roleId) {
require(holdsRole(roleId, msg.sender), "Sender does not hold required role");
_;
}
modifier onlyRoleManager(uint256 roleId) {
require(holdsRole(roles[roleId].managingRole, msg.sender), "Can only be called by a role manager");
_;
}
modifier onlyExclusive(uint256 roleId) {
require(roles[roleId].roleType == RoleType.Exclusive, "Must be called on an initialized Exclusive role");
_;
}
modifier onlyShared(uint256 roleId) {
require(roles[roleId].roleType == RoleType.Shared, "Must be called on an initialized Shared role");
_;
}
function holdsRole(uint256 roleId, address memberToCheck) public view returns (bool) {
Role storage role = roles[roleId];
if (role.roleType == RoleType.Exclusive) {
return role.exclusiveRoleMembership.isMember(memberToCheck);
} else if (role.roleType == RoleType.Shared) {
return role.sharedRoleMembership.isMember(memberToCheck);
}
revert("Invalid roleId");
}
function resetMember(uint256 roleId, address newMember) public onlyExclusive(roleId) onlyRoleManager(roleId) {
roles[roleId].exclusiveRoleMembership.resetMember(newMember);
emit ResetExclusiveMember(roleId, newMember, msg.sender);
}
function getMember(uint256 roleId) public view onlyExclusive(roleId) returns (address) {
return roles[roleId].exclusiveRoleMembership.getMember();
}
function addMember(uint256 roleId, address newMember) public onlyShared(roleId) onlyRoleManager(roleId) {
roles[roleId].sharedRoleMembership.addMember(newMember);
emit AddedSharedMember(roleId, newMember, msg.sender);
}
function removeMember(uint256 roleId, address memberToRemove) public onlyShared(roleId) onlyRoleManager(roleId) {
roles[roleId].sharedRoleMembership.removeMember(memberToRemove);
emit RemovedSharedMember(roleId, memberToRemove, msg.sender);
}
function renounceMembership(uint256 roleId) public onlyShared(roleId) onlyRoleHolder(roleId) {
roles[roleId].sharedRoleMembership.removeMember(msg.sender);
emit RemovedSharedMember(roleId, msg.sender, msg.sender);
}
modifier onlyValidRole(uint256 roleId) {
require(roles[roleId].roleType != RoleType.Invalid, "Attempted to use an invalid roleId");
_;
}
modifier onlyInvalidRole(uint256 roleId) {
require(roles[roleId].roleType == RoleType.Invalid, "Cannot use a pre-existing role");
_;
}
function _createSharedRole(
uint256 roleId,
uint256 managingRoleId,
address[] memory initialMembers
) internal onlyInvalidRole(roleId) {
Role storage role = roles[roleId];
role.roleType = RoleType.Shared;
role.managingRole = managingRoleId;
role.sharedRoleMembership.init(initialMembers);
require(
roles[managingRoleId].roleType != RoleType.Invalid,
"Attempted to use an invalid role to manage a shared role"
);
}
function _createExclusiveRole(
uint256 roleId,
uint256 managingRoleId,
address initialMember
) internal onlyInvalidRole(roleId) {
Role storage role = roles[roleId];
role.roleType = RoleType.Exclusive;
role.managingRole = managingRoleId;
role.exclusiveRoleMembership.init(initialMember);
require(
roles[managingRoleId].roleType != RoleType.Invalid,
"Attempted to use an invalid role to manage an exclusive role"
);
}
}
파일 36 / 56 : Optimism_Adapter.sol
pragma solidity ^0.8.0;
import "../interfaces/AdapterInterface.sol";
import "../interfaces/WETH9.sol";
import "./CrossDomainEnabled.sol";
import "@eth-optimism/contracts/L1/messaging/IL1StandardBridge.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract Optimism_Adapter is CrossDomainEnabled, AdapterInterface {
using SafeERC20 for IERC20;
uint32 public immutable l2GasLimit = 2_000_000;
WETH9 public immutable l1Weth;
IL1StandardBridge public immutable l1StandardBridge;
address public immutable dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public immutable daiOptimismBridge = 0x10E6593CDda8c58a1d0f14C5164B376352a55f2F;
address public immutable snx = 0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F;
address public immutable snxOptimismBridge = 0xCd9D4988C0AE61887B075bA77f08cbFAd2b65068;
constructor(
WETH9 _l1Weth,
address _crossDomainMessenger,
IL1StandardBridge _l1StandardBridge
) CrossDomainEnabled(_crossDomainMessenger) {
l1Weth = _l1Weth;
l1StandardBridge = _l1StandardBridge;
}
function relayMessage(address target, bytes calldata message) external payable override {
sendCrossDomainMessage(target, uint32(l2GasLimit), message);
emit MessageRelayed(target, message);
}
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable override {
if (l1Token == address(l1Weth)) {
l1Weth.withdraw(amount);
l1StandardBridge.depositETHTo{ value: amount }(to, l2GasLimit, "");
} else {
IL1StandardBridge _l1StandardBridge = l1StandardBridge;
if (l1Token == dai) _l1StandardBridge = IL1StandardBridge(daiOptimismBridge);
if (l1Token == snx) _l1StandardBridge = IL1StandardBridge(snxOptimismBridge);
IERC20(l1Token).safeIncreaseAllowance(address(_l1StandardBridge), amount);
_l1StandardBridge.depositERC20To(l1Token, l2Token, to, amount, l2GasLimit, "");
}
emit TokensRelayed(l1Token, l2Token, amount, to);
}
}
파일 37 / 56 : Optimism_SpokePool.sol
pragma solidity ^0.8.0;
import "./SpokePool.sol";
import "./interfaces/WETH9.sol";
import "@eth-optimism/contracts/libraries/bridge/CrossDomainEnabled.sol";
import "@eth-optimism/contracts/libraries/constants/Lib_PredeployAddresses.sol";
import "@eth-optimism/contracts/L2/messaging/IL2ERC20Bridge.sol";
contract Optimism_SpokePool is CrossDomainEnabled, SpokePool {
uint32 public l1Gas = 5_000_000;
address public immutable l2Eth = address(Lib_PredeployAddresses.OVM_ETH);
mapping(address => address) public tokenBridges;
event OptimismTokensBridged(address indexed l2Token, address target, uint256 numberOfTokensBridged, uint256 l1Gas);
event SetL1Gas(uint32 indexed newL1Gas);
event SetL2TokenBridge(address indexed l2Token, address indexed tokenBridge);
constructor(
address _crossDomainAdmin,
address _hubPool,
address timerAddress
)
CrossDomainEnabled(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER)
SpokePool(_crossDomainAdmin, _hubPool, 0x4200000000000000000000000000000000000006, timerAddress)
{}
function setL1GasLimit(uint32 newl1Gas) public onlyAdmin nonReentrant {
l1Gas = newl1Gas;
emit SetL1Gas(newl1Gas);
}
function setTokenBridge(address l2Token, address tokenBridge) public onlyAdmin nonReentrant {
tokenBridges[l2Token] = tokenBridge;
emit SetL2TokenBridge(l2Token, tokenBridge);
}
function executeSlowRelayLeaf(
address depositor,
address recipient,
address destinationToken,
uint256 totalRelayAmount,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId,
uint32 rootBundleId,
bytes32[] memory proof
) public override(SpokePool) nonReentrant {
if (destinationToken == address(wrappedNativeToken)) _depositEthToWeth();
_executeSlowRelayLeaf(
depositor,
recipient,
destinationToken,
totalRelayAmount,
originChainId,
chainId(),
realizedLpFeePct,
relayerFeePct,
depositId,
rootBundleId,
proof
);
}
function executeRelayerRefundLeaf(
uint32 rootBundleId,
SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
bytes32[] memory proof
) public override(SpokePool) nonReentrant {
if (relayerRefundLeaf.l2TokenAddress == address(wrappedNativeToken)) _depositEthToWeth();
_executeRelayerRefundLeaf(rootBundleId, relayerRefundLeaf, proof);
}
function _depositEthToWeth() internal {
if (address(this).balance > 0) wrappedNativeToken.deposit{ value: address(this).balance }();
}
function _bridgeTokensToHubPool(RelayerRefundLeaf memory relayerRefundLeaf) internal override {
if (relayerRefundLeaf.l2TokenAddress == address(wrappedNativeToken)) {
WETH9(relayerRefundLeaf.l2TokenAddress).withdraw(relayerRefundLeaf.amountToReturn);
relayerRefundLeaf.l2TokenAddress = l2Eth;
}
IL2ERC20Bridge(
tokenBridges[relayerRefundLeaf.l2TokenAddress] == address(0)
? Lib_PredeployAddresses.L2_STANDARD_BRIDGE
: tokenBridges[relayerRefundLeaf.l2TokenAddress]
).withdrawTo(
relayerRefundLeaf.l2TokenAddress,
hubPool,
relayerRefundLeaf.amountToReturn,
l1Gas,
""
);
emit OptimismTokensBridged(relayerRefundLeaf.l2TokenAddress, hubPool, relayerRefundLeaf.amountToReturn, l1Gas);
}
function _requireAdminSender() internal override onlyFromCrossDomainAccount(crossDomainAdmin) {}
}
파일 38 / 56 : OptimisticOracleInterface.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
abstract contract OptimisticOracleInterface {
enum State {
Invalid,
Requested,
Proposed,
Expired,
Disputed,
Resolved,
Settled
}
struct Request {
address proposer;
address disputer;
IERC20 currency;
bool settled;
bool refundOnDispute;
int256 proposedPrice;
int256 resolvedPrice;
uint256 expirationTime;
uint256 reward;
uint256 finalFee;
uint256 bond;
uint256 customLiveness;
}
uint256 public constant ancillaryBytesLimit = 8192;
function requestPrice(
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData,
IERC20 currency,
uint256 reward
) external virtual returns (uint256 totalBond);
function setBond(
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData,
uint256 bond
) external virtual returns (uint256 totalBond);
function setRefundOnDispute(
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) external virtual;
function setCustomLiveness(
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData,
uint256 customLiveness
) external virtual;
function proposePriceFor(
address proposer,
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData,
int256 proposedPrice
) public virtual returns (uint256 totalBond);
function proposePrice(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData,
int256 proposedPrice
) external virtual returns (uint256 totalBond);
function disputePriceFor(
address disputer,
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) public virtual returns (uint256 totalBond);
function disputePrice(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) external virtual returns (uint256 totalBond);
function settleAndGetPrice(
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) external virtual returns (int256);
function settle(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) external virtual returns (uint256 payout);
function getRequest(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) public view virtual returns (Request memory);
function getState(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) public view virtual returns (State);
function hasPrice(
address requester,
bytes32 identifier,
uint256 timestamp,
bytes memory ancillaryData
) public view virtual returns (bool);
function stampAncillaryData(bytes memory ancillaryData, address requester)
public
view
virtual
returns (bytes memory);
}
파일 39 / 56 : 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());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
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);
}
}
파일 40 / 56 : PolygonERC20Test.sol
pragma solidity ^0.8.0;
import "@uma/core/contracts/common/implementation/ExpandedERC20.sol";
import "../PolygonTokenBridger.sol";
contract PolygonERC20Test is ExpandedERC20, PolygonIERC20 {
constructor() ExpandedERC20("Polygon Test", "POLY_TEST", 18) {}
function withdraw(uint256 amount) public {
_burn(msg.sender, amount);
}
}
파일 41 / 56 : PolygonMocks.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract RootChainManagerMock {
function depositEtherFor(address user) external payable {}
function depositFor(
address user,
address rootToken,
bytes calldata depositData
) external {}
}
contract FxStateSenderMock {
function sendMessageToChild(address _receiver, bytes calldata _data) external {}
}
contract DepositManagerMock {
function depositERC20ForUser(
address token,
address user,
uint256 amount
) external {}
}
contract PolygonRegistryMock {
function erc20Predicate() external returns (address predicate) {}
}
contract PolygonERC20PredicateMock {
function startExitWithBurntTokens(bytes calldata data) external {}
}
contract PolygonERC20Mock is ERC20 {
constructor() ERC20("Test ERC20", "TEST") {}
function withdraw(uint256 amount) external {}
}
파일 42 / 56 : PolygonTokenBridger.sol
pragma solidity ^0.8.0;
import "./Lockable.sol";
import "./interfaces/WETH9.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface PolygonRegistry {
function erc20Predicate() external returns (address);
}
interface PolygonERC20Predicate {
function startExitWithBurntTokens(bytes calldata data) external;
}
interface PolygonIERC20 is IERC20 {
function withdraw(uint256 amount) external;
}
interface MaticToken {
function withdraw(uint256 amount) external payable;
}
contract PolygonTokenBridger is Lockable {
using SafeERC20 for PolygonIERC20;
using SafeERC20 for IERC20;
MaticToken public constant maticToken = MaticToken(0x0000000000000000000000000000000000001010);
address public immutable destination;
PolygonRegistry public immutable l1PolygonRegistry;
WETH9 public immutable l1Weth;
address public immutable l2WrappedMatic;
uint256 public immutable l1ChainId;
uint256 public immutable l2ChainId;
modifier onlyChainId(uint256 chainId) {
_requireChainId(chainId);
_;
}
constructor(
address _destination,
PolygonRegistry _l1PolygonRegistry,
WETH9 _l1Weth,
address _l2WrappedMatic,
uint256 _l1ChainId,
uint256 _l2ChainId
) {
destination = _destination;
l1PolygonRegistry = _l1PolygonRegistry;
l1Weth = _l1Weth;
l2WrappedMatic = _l2WrappedMatic;
l1ChainId = _l1ChainId;
l2ChainId = _l2ChainId;
}
function send(PolygonIERC20 token, uint256 amount) public nonReentrant onlyChainId(l2ChainId) {
token.safeTransferFrom(msg.sender, address(this), amount);
token.withdraw(token.balanceOf(address(this)));
if (address(token) == l2WrappedMatic)
maticToken.withdraw{ value: address(this).balance }(address(this).balance);
}
function retrieve(IERC20 token) public nonReentrant onlyChainId(l1ChainId) {
if (address(token) == address(l1Weth)) {
l1Weth.deposit{ value: address(this).balance }();
}
token.safeTransfer(destination, token.balanceOf(address(this)));
}
function callExit(bytes memory data) public nonReentrant onlyChainId(l1ChainId) {
PolygonERC20Predicate erc20Predicate = PolygonERC20Predicate(l1PolygonRegistry.erc20Predicate());
erc20Predicate.startExitWithBurntTokens(data);
}
receive() external payable {
}
function _requireChainId(uint256 chainId) internal view {
require(block.chainid == chainId, "Cannot run method on this chain");
}
}
파일 43 / 56 : Polygon_Adapter.sol
pragma solidity ^0.8.0;
import "../interfaces/AdapterInterface.sol";
import "../interfaces/WETH9.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IRootChainManager {
function depositEtherFor(address user) external payable;
function depositFor(
address user,
address rootToken,
bytes calldata depositData
) external;
}
interface IFxStateSender {
function sendMessageToChild(address _receiver, bytes calldata _data) external;
}
interface DepositManager {
function depositERC20ForUser(
address token,
address user,
uint256 amount
) external;
}
contract Polygon_Adapter is AdapterInterface {
using SafeERC20 for IERC20;
IRootChainManager public immutable rootChainManager;
IFxStateSender public immutable fxStateSender;
DepositManager public immutable depositManager;
address public immutable erc20Predicate;
address public immutable l1Matic;
WETH9 public immutable l1Weth;
constructor(
IRootChainManager _rootChainManager,
IFxStateSender _fxStateSender,
DepositManager _depositManager,
address _erc20Predicate,
address _l1Matic,
WETH9 _l1Weth
) {
rootChainManager = _rootChainManager;
fxStateSender = _fxStateSender;
depositManager = _depositManager;
erc20Predicate = _erc20Predicate;
l1Matic = _l1Matic;
l1Weth = _l1Weth;
}
function relayMessage(address target, bytes calldata message) external payable override {
fxStateSender.sendMessageToChild(target, message);
emit MessageRelayed(target, message);
}
function relayTokens(
address l1Token,
address l2Token,
uint256 amount,
address to
) external payable override {
if (l1Token == address(l1Weth)) {
l1Weth.withdraw(amount);
rootChainManager.depositEtherFor{ value: amount }(to);
} else if (l1Token == l1Matic) {
IERC20(l1Token).safeIncreaseAllowance(address(depositManager), amount);
depositManager.depositERC20ForUser(l1Token, to, amount);
} else {
IERC20(l1Token).safeIncreaseAllowance(erc20Predicate, amount);
rootChainManager.depositFor(to, l1Token, abi.encode(amount));
}
emit TokensRelayed(l1Token, l2Token, amount, to);
}
}
파일 44 / 56 : Polygon_SpokePool.sol
pragma solidity ^0.8.0;
import "./SpokePool.sol";
import "./PolygonTokenBridger.sol";
import "./interfaces/WETH9.sol";
import "./SpokePoolInterface.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IFxMessageProcessor {
function processMessageFromRoot(
uint256 stateId,
address rootMessageSender,
bytes calldata data
) external;
}
contract Polygon_SpokePool is IFxMessageProcessor, SpokePool {
using SafeERC20 for PolygonIERC20;
address public fxChild;
PolygonTokenBridger public polygonTokenBridger;
bool private callValidated = false;
event PolygonTokensBridged(address indexed token, address indexed receiver, uint256 amount);
event SetFxChild(address indexed newFxChild);
event SetPolygonTokenBridger(address indexed polygonTokenBridger);
modifier validateInternalCalls() {
require(!callValidated, "callValidated already set");
callValidated = true;
_;
callValidated = false;
}
constructor(
PolygonTokenBridger _polygonTokenBridger,
address _crossDomainAdmin,
address _hubPool,
address _wmaticAddress,
address _fxChild,
address timerAddress
) SpokePool(_crossDomainAdmin, _hubPool, _wmaticAddress, timerAddress) {
polygonTokenBridger = _polygonTokenBridger;
fxChild = _fxChild;
}
function setFxChild(address newFxChild) public onlyAdmin nonReentrant {
fxChild = newFxChild;
emit SetFxChild(newFxChild);
}
function setPolygonTokenBridger(address payable newPolygonTokenBridger) public onlyAdmin nonReentrant {
polygonTokenBridger = PolygonTokenBridger(newPolygonTokenBridger);
emit SetPolygonTokenBridger(address(newPolygonTokenBridger));
}
function processMessageFromRoot(
uint256,
address rootMessageSender,
bytes calldata data
) public validateInternalCalls {
require(msg.sender == fxChild, "Not from fxChild");
require(rootMessageSender == crossDomainAdmin, "Not from mainnet admin");
(bool success, ) = address(this).delegatecall(data);
require(success, "delegatecall failed");
}
function wrap() public nonReentrant {
_wrap();
}
function executeRelayerRefundLeaf(
uint32 rootBundleId,
SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
bytes32[] memory proof
) public override nonReentrant {
_wrap();
_executeRelayerRefundLeaf(rootBundleId, relayerRefundLeaf, proof);
}
function executeSlowRelayLeaf(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId,
uint32 rootBundleId,
bytes32[] memory proof
) public virtual override nonReentrant {
_wrap();
_executeSlowRelayLeaf(
depositor,
recipient,
destinationToken,
amount,
originChainId,
chainId(),
realizedLpFeePct,
relayerFeePct,
depositId,
rootBundleId,
proof
);
}
function _bridgeTokensToHubPool(RelayerRefundLeaf memory relayerRefundLeaf) internal override {
PolygonIERC20(relayerRefundLeaf.l2TokenAddress).safeIncreaseAllowance(
address(polygonTokenBridger),
relayerRefundLeaf.amountToReturn
);
polygonTokenBridger.send(PolygonIERC20(relayerRefundLeaf.l2TokenAddress), relayerRefundLeaf.amountToReturn);
emit PolygonTokensBridged(relayerRefundLeaf.l2TokenAddress, address(this), relayerRefundLeaf.amountToReturn);
}
function _wrap() internal {
uint256 balance = address(this).balance;
if (balance > 0) wrappedNativeToken.deposit{ value: balance }();
}
function _requireAdminSender() internal view override {
require(callValidated, "Must call processMessageFromRoot");
}
}
파일 45 / 56 : RateModelStore.sol
pragma solidity ^0.8.0;
import "@uma/core/contracts/common/implementation/MultiCaller.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract RateModelStore is Ownable, MultiCaller {
mapping(address => string) public l1TokenRateModels;
event UpdatedRateModel(address indexed l1Token, string rateModel);
function updateRateModel(address l1Token, string memory rateModel) external onlyOwner {
l1TokenRateModels[l1Token] = rateModel;
emit UpdatedRateModel(l1Token, rateModel);
}
}
파일 46 / 56 : SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.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 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
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");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
파일 47 / 56 : SafeMath.sol
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
파일 48 / 56 : SignedSafeMath.sol
pragma solidity ^0.8.0;
library SignedSafeMath {
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
파일 49 / 56 : SkinnyOptimisticOracleInterface.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/OptimisticOracleInterface.sol";
abstract contract SkinnyOptimisticOracleInterface {
struct Request {
address proposer;
address disputer;
IERC20 currency;
bool settled;
int256 proposedPrice;
int256 resolvedPrice;
uint256 expirationTime;
uint256 reward;
uint256 finalFee;
uint256 bond;
uint256 customLiveness;
}
uint256 public constant ancillaryBytesLimit = 8192;
function requestPrice(
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
IERC20 currency,
uint256 reward,
uint256 bond,
uint256 customLiveness
) external virtual returns (uint256 totalBond);
function proposePriceFor(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request,
address proposer,
int256 proposedPrice
) public virtual returns (uint256 totalBond);
function proposePrice(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request,
int256 proposedPrice
) external virtual returns (uint256 totalBond);
function requestAndProposePriceFor(
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
IERC20 currency,
uint256 reward,
uint256 bond,
uint256 customLiveness,
address proposer,
int256 proposedPrice
) external virtual returns (uint256 totalBond);
function disputePriceFor(
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request,
address disputer,
address requester
) public virtual returns (uint256 totalBond);
function disputePrice(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request
) external virtual returns (uint256 totalBond);
function settle(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request
) external virtual returns (uint256 payout, int256 resolvedPrice);
function getState(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request
) external virtual returns (OptimisticOracleInterface.State);
function hasPrice(
address requester,
bytes32 identifier,
uint32 timestamp,
bytes memory ancillaryData,
Request memory request
) public virtual returns (bool);
function stampAncillaryData(bytes memory ancillaryData, address requester)
public
pure
virtual
returns (bytes memory);
}
파일 50 / 56 : SpokePool.sol
pragma solidity ^0.8.0;
import "./MerkleLib.sol";
import "./interfaces/WETH9.sol";
import "./Lockable.sol";
import "./SpokePoolInterface.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@uma/core/contracts/common/implementation/Testable.sol";
import "@uma/core/contracts/common/implementation/MultiCaller.sol";
abstract contract SpokePool is SpokePoolInterface, Testable, Lockable, MultiCaller {
using SafeERC20 for IERC20;
using Address for address;
address public crossDomainAdmin;
address public hubPool;
WETH9 public immutable wrappedNativeToken;
uint32 public depositQuoteTimeBuffer = 600;
uint32 public numberOfDeposits;
RootBundle[] public rootBundles;
mapping(address => mapping(uint256 => bool)) public enabledDepositRoutes;
mapping(bytes32 => uint256) public relayFills;
event SetXDomainAdmin(address indexed newAdmin);
event SetHubPool(address indexed newHubPool);
event EnabledDepositRoute(address indexed originToken, uint256 indexed destinationChainId, bool enabled);
event SetDepositQuoteTimeBuffer(uint32 newBuffer);
event FundsDeposited(
uint256 amount,
uint256 originChainId,
uint256 destinationChainId,
uint64 relayerFeePct,
uint32 indexed depositId,
uint32 quoteTimestamp,
address indexed originToken,
address recipient,
address indexed depositor
);
event RequestedSpeedUpDeposit(
uint64 newRelayerFeePct,
uint32 indexed depositId,
address indexed depositor,
bytes depositorSignature
);
event FilledRelay(
uint256 amount,
uint256 totalFilledAmount,
uint256 fillAmount,
uint256 repaymentChainId,
uint256 originChainId,
uint256 destinationChainId,
uint64 relayerFeePct,
uint64 appliedRelayerFeePct,
uint64 realizedLpFeePct,
uint32 depositId,
address destinationToken,
address indexed relayer,
address indexed depositor,
address recipient,
bool isSlowRelay
);
event RelayedRootBundle(
uint32 indexed rootBundleId,
bytes32 indexed relayerRefundRoot,
bytes32 indexed slowRelayRoot
);
event ExecutedRelayerRefundRoot(
uint256 amountToReturn,
uint256 indexed chainId,
uint256[] refundAmounts,
uint32 indexed rootBundleId,
uint32 indexed leafId,
address l2TokenAddress,
address[] refundAddresses,
address caller
);
event TokensBridged(
uint256 amountToReturn,
uint256 indexed chainId,
uint32 indexed leafId,
address indexed l2TokenAddress,
address caller
);
event EmergencyDeleteRootBundle(uint256 indexed rootBundleId);
constructor(
address _crossDomainAdmin,
address _hubPool,
address _wrappedNativeTokenAddress,
address timerAddress
) Testable(timerAddress) {
_setCrossDomainAdmin(_crossDomainAdmin);
_setHubPool(_hubPool);
wrappedNativeToken = WETH9(_wrappedNativeTokenAddress);
}
modifier onlyAdmin() {
_requireAdminSender();
_;
}
function setCrossDomainAdmin(address newCrossDomainAdmin) public override onlyAdmin nonReentrant {
_setCrossDomainAdmin(newCrossDomainAdmin);
}
function setHubPool(address newHubPool) public override onlyAdmin nonReentrant {
_setHubPool(newHubPool);
}
function setEnableRoute(
address originToken,
uint256 destinationChainId,
bool enabled
) public override onlyAdmin nonReentrant {
enabledDepositRoutes[originToken][destinationChainId] = enabled;
emit EnabledDepositRoute(originToken, destinationChainId, enabled);
}
function setDepositQuoteTimeBuffer(uint32 newDepositQuoteTimeBuffer) public override onlyAdmin nonReentrant {
depositQuoteTimeBuffer = newDepositQuoteTimeBuffer;
emit SetDepositQuoteTimeBuffer(newDepositQuoteTimeBuffer);
}
function relayRootBundle(bytes32 relayerRefundRoot, bytes32 slowRelayRoot) public override onlyAdmin nonReentrant {
uint32 rootBundleId = uint32(rootBundles.length);
RootBundle storage rootBundle = rootBundles.push();
rootBundle.relayerRefundRoot = relayerRefundRoot;
rootBundle.slowRelayRoot = slowRelayRoot;
emit RelayedRootBundle(rootBundleId, relayerRefundRoot, slowRelayRoot);
}
function emergencyDeleteRootBundle(uint256 rootBundleId) public override onlyAdmin nonReentrant {
delete rootBundles[rootBundleId];
emit EmergencyDeleteRootBundle(rootBundleId);
}
function deposit(
address recipient,
address originToken,
uint256 amount,
uint256 destinationChainId,
uint64 relayerFeePct,
uint32 quoteTimestamp
) public payable override nonReentrant {
require(enabledDepositRoutes[originToken][destinationChainId], "Disabled route");
require(relayerFeePct < 0.5e18, "invalid relayer fee");
require(
getCurrentTime() >= quoteTimestamp - depositQuoteTimeBuffer &&
getCurrentTime() <= quoteTimestamp + depositQuoteTimeBuffer,
"invalid quote time"
);
if (originToken == address(wrappedNativeToken) && msg.value > 0) {
require(msg.value == amount, "msg.value must match amount");
wrappedNativeToken.deposit{ value: msg.value }();
} else IERC20(originToken).safeTransferFrom(msg.sender, address(this), amount);
_emitDeposit(
amount,
chainId(),
destinationChainId,
relayerFeePct,
numberOfDeposits,
quoteTimestamp,
originToken,
recipient,
msg.sender
);
++numberOfDeposits;
}
function speedUpDeposit(
address depositor,
uint64 newRelayerFeePct,
uint32 depositId,
bytes memory depositorSignature
) public override nonReentrant {
require(newRelayerFeePct < 0.5e18, "invalid relayer fee");
_verifyUpdateRelayerFeeMessage(depositor, chainId(), newRelayerFeePct, depositId, depositorSignature);
emit RequestedSpeedUpDeposit(newRelayerFeePct, depositId, depositor, depositorSignature);
}
function fillRelay(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 maxTokensToSend,
uint256 repaymentChainId,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId
) public nonReentrant {
SpokePoolInterface.RelayData memory relayData = SpokePoolInterface.RelayData({
depositor: depositor,
recipient: recipient,
destinationToken: destinationToken,
amount: amount,
realizedLpFeePct: realizedLpFeePct,
relayerFeePct: relayerFeePct,
depositId: depositId,
originChainId: originChainId,
destinationChainId: chainId()
});
bytes32 relayHash = _getRelayHash(relayData);
uint256 fillAmountPreFees = _fillRelay(relayHash, relayData, maxTokensToSend, relayerFeePct, false);
_emitFillRelay(relayHash, fillAmountPreFees, repaymentChainId, relayerFeePct, relayData, false);
}
function fillRelayWithUpdatedFee(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 maxTokensToSend,
uint256 repaymentChainId,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint64 newRelayerFeePct,
uint32 depositId,
bytes memory depositorSignature
) public override nonReentrant {
_verifyUpdateRelayerFeeMessage(depositor, originChainId, newRelayerFeePct, depositId, depositorSignature);
RelayData memory relayData = RelayData({
depositor: depositor,
recipient: recipient,
destinationToken: destinationToken,
amount: amount,
realizedLpFeePct: realizedLpFeePct,
relayerFeePct: relayerFeePct,
depositId: depositId,
originChainId: originChainId,
destinationChainId: chainId()
});
bytes32 relayHash = _getRelayHash(relayData);
uint256 fillAmountPreFees = _fillRelay(relayHash, relayData, maxTokensToSend, newRelayerFeePct, false);
_emitFillRelay(relayHash, fillAmountPreFees, repaymentChainId, newRelayerFeePct, relayData, false);
}
function executeSlowRelayLeaf(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId,
uint32 rootBundleId,
bytes32[] memory proof
) public virtual override nonReentrant {
_executeSlowRelayLeaf(
depositor,
recipient,
destinationToken,
amount,
originChainId,
chainId(),
realizedLpFeePct,
relayerFeePct,
depositId,
rootBundleId,
proof
);
}
function executeRelayerRefundLeaf(
uint32 rootBundleId,
SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
bytes32[] memory proof
) public virtual override nonReentrant {
_executeRelayerRefundLeaf(rootBundleId, relayerRefundLeaf, proof);
}
function chainId() public view virtual override returns (uint256) {
return block.chainid;
}
function _executeRelayerRefundLeaf(
uint32 rootBundleId,
SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
bytes32[] memory proof
) internal {
require(relayerRefundLeaf.chainId == chainId(), "Invalid chainId");
require(relayerRefundLeaf.refundAddresses.length == relayerRefundLeaf.refundAmounts.length, "invalid leaf");
RootBundle storage rootBundle = rootBundles[rootBundleId];
require(MerkleLib.verifyRelayerRefund(rootBundle.relayerRefundRoot, relayerRefundLeaf, proof), "Bad Proof");
require(!MerkleLib.isClaimed(rootBundle.claimedBitmap, relayerRefundLeaf.leafId), "Already claimed");
MerkleLib.setClaimed(rootBundle.claimedBitmap, relayerRefundLeaf.leafId);
uint256 length = relayerRefundLeaf.refundAmounts.length;
for (uint256 i = 0; i < length; ) {
uint256 amount = relayerRefundLeaf.refundAmounts[i];
if (amount > 0)
IERC20(relayerRefundLeaf.l2TokenAddress).safeTransfer(relayerRefundLeaf.refundAddresses[i], amount);
unchecked {
++i;
}
}
if (relayerRefundLeaf.amountToReturn > 0) {
_bridgeTokensToHubPool(relayerRefundLeaf);
emit TokensBridged(
relayerRefundLeaf.amountToReturn,
relayerRefundLeaf.chainId,
relayerRefundLeaf.leafId,
relayerRefundLeaf.l2TokenAddress,
msg.sender
);
}
emit ExecutedRelayerRefundRoot(
relayerRefundLeaf.amountToReturn,
relayerRefundLeaf.chainId,
relayerRefundLeaf.refundAmounts,
rootBundleId,
relayerRefundLeaf.leafId,
relayerRefundLeaf.l2TokenAddress,
relayerRefundLeaf.refundAddresses,
msg.sender
);
}
function _executeSlowRelayLeaf(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 originChainId,
uint256 destinationChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId,
uint32 rootBundleId,
bytes32[] memory proof
) internal {
RelayData memory relayData = RelayData({
depositor: depositor,
recipient: recipient,
destinationToken: destinationToken,
amount: amount,
originChainId: originChainId,
destinationChainId: destinationChainId,
realizedLpFeePct: realizedLpFeePct,
relayerFeePct: relayerFeePct,
depositId: depositId
});
require(
MerkleLib.verifySlowRelayFulfillment(rootBundles[rootBundleId].slowRelayRoot, relayData, proof),
"Invalid proof"
);
bytes32 relayHash = _getRelayHash(relayData);
uint256 fillAmountPreFees = _fillRelay(relayHash, relayData, relayData.amount, 0, true);
_emitFillRelay(relayHash, fillAmountPreFees, 0, 0, relayData, true);
}
function _setCrossDomainAdmin(address newCrossDomainAdmin) internal {
require(newCrossDomainAdmin != address(0), "Bad bridge router address");
crossDomainAdmin = newCrossDomainAdmin;
emit SetXDomainAdmin(newCrossDomainAdmin);
}
function _setHubPool(address newHubPool) internal {
require(newHubPool != address(0), "Bad hub pool address");
hubPool = newHubPool;
emit SetHubPool(newHubPool);
}
function _bridgeTokensToHubPool(SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf) internal virtual;
function _verifyUpdateRelayerFeeMessage(
address depositor,
uint256 originChainId,
uint64 newRelayerFeePct,
uint32 depositId,
bytes memory depositorSignature
) internal view {
bytes32 expectedDepositorMessageHash = keccak256(
abi.encode("ACROSS-V2-FEE-1.0", newRelayerFeePct, depositId, originChainId)
);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(expectedDepositorMessageHash);
_verifyDepositorUpdateFeeMessage(depositor, ethSignedMessageHash, depositorSignature);
}
function _verifyDepositorUpdateFeeMessage(
address depositor,
bytes32 ethSignedMessageHash,
bytes memory depositorSignature
) internal view virtual {
require(depositor == ECDSA.recover(ethSignedMessageHash, depositorSignature), "invalid signature");
}
function _computeAmountPreFees(uint256 amount, uint64 feesPct) private pure returns (uint256) {
return (1e18 * amount) / (1e18 - feesPct);
}
function _computeAmountPostFees(uint256 amount, uint64 feesPct) private pure returns (uint256) {
return (amount * (1e18 - feesPct)) / 1e18;
}
function _getRelayHash(SpokePoolInterface.RelayData memory relayData) private pure returns (bytes32) {
return keccak256(abi.encode(relayData));
}
function _unwrapwrappedNativeTokenTo(address payable to, uint256 amount) internal {
if (address(to).isContract()) {
IERC20(address(wrappedNativeToken)).safeTransfer(to, amount);
} else {
wrappedNativeToken.withdraw(amount);
to.transfer(amount);
}
}
function _fillRelay(
bytes32 relayHash,
RelayData memory relayData,
uint256 maxTokensToSend,
uint64 updatableRelayerFeePct,
bool useContractFunds
) internal returns (uint256 fillAmountPreFees) {
require(updatableRelayerFeePct < 0.5e18 && relayData.realizedLpFeePct < 0.5e18, "invalid fees");
require(relayFills[relayHash] < relayData.amount, "relay filled");
if (maxTokensToSend == 0) return 0;
fillAmountPreFees = _computeAmountPreFees(
maxTokensToSend,
(relayData.realizedLpFeePct + updatableRelayerFeePct)
);
uint256 amountToSend = maxTokensToSend;
uint256 amountRemainingInRelay = relayData.amount - relayFills[relayHash];
if (amountRemainingInRelay < fillAmountPreFees) {
fillAmountPreFees = amountRemainingInRelay;
amountToSend = _computeAmountPostFees(
fillAmountPreFees,
relayData.realizedLpFeePct + updatableRelayerFeePct
);
}
relayFills[relayHash] += fillAmountPreFees;
if (relayData.destinationToken == address(wrappedNativeToken)) {
if (!useContractFunds)
IERC20(relayData.destinationToken).safeTransferFrom(msg.sender, address(this), amountToSend);
_unwrapwrappedNativeTokenTo(payable(relayData.recipient), amountToSend);
} else {
if (!useContractFunds)
IERC20(relayData.destinationToken).safeTransferFrom(msg.sender, relayData.recipient, amountToSend);
else IERC20(relayData.destinationToken).safeTransfer(relayData.recipient, amountToSend);
}
}
function _emitFillRelay(
bytes32 relayHash,
uint256 fillAmount,
uint256 repaymentChainId,
uint64 appliedRelayerFeePct,
RelayData memory relayData,
bool isSlowRelay
) internal {
emit FilledRelay(
relayData.amount,
relayFills[relayHash],
fillAmount,
repaymentChainId,
relayData.originChainId,
relayData.destinationChainId,
relayData.relayerFeePct,
appliedRelayerFeePct,
relayData.realizedLpFeePct,
relayData.depositId,
relayData.destinationToken,
msg.sender,
relayData.depositor,
relayData.recipient,
isSlowRelay
);
}
function _emitDeposit(
uint256 amount,
uint256 originChainId,
uint256 destinationChainId,
uint64 relayerFeePct,
uint32 depositId,
uint32 quoteTimestamp,
address originToken,
address recipient,
address depositor
) internal {
emit FundsDeposited(
amount,
originChainId,
destinationChainId,
relayerFeePct,
depositId,
quoteTimestamp,
originToken,
recipient,
depositor
);
}
function _requireAdminSender() internal virtual;
receive() external payable {}
}
파일 51 / 56 : SpokePoolInterface.sol
pragma solidity ^0.8.0;
interface SpokePoolInterface {
struct RelayerRefundLeaf {
uint256 amountToReturn;
uint256 chainId;
uint256[] refundAmounts;
uint32 leafId;
address l2TokenAddress;
address[] refundAddresses;
}
struct RelayData {
address depositor;
address recipient;
address destinationToken;
uint256 amount;
uint256 originChainId;
uint256 destinationChainId;
uint64 realizedLpFeePct;
uint64 relayerFeePct;
uint32 depositId;
}
struct RootBundle {
bytes32 slowRelayRoot;
bytes32 relayerRefundRoot;
mapping(uint256 => uint256) claimedBitmap;
}
function setCrossDomainAdmin(address newCrossDomainAdmin) external;
function setHubPool(address newHubPool) external;
function setEnableRoute(
address originToken,
uint256 destinationChainId,
bool enable
) external;
function setDepositQuoteTimeBuffer(uint32 buffer) external;
function relayRootBundle(bytes32 relayerRefundRoot, bytes32 slowRelayRoot) external;
function emergencyDeleteRootBundle(uint256 rootBundleId) external;
function deposit(
address recipient,
address originToken,
uint256 amount,
uint256 destinationChainId,
uint64 relayerFeePct,
uint32 quoteTimestamp
) external payable;
function speedUpDeposit(
address depositor,
uint64 newRelayerFeePct,
uint32 depositId,
bytes memory depositorSignature
) external;
function fillRelay(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 maxTokensToSend,
uint256 repaymentChainId,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId
) external;
function fillRelayWithUpdatedFee(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 maxTokensToSend,
uint256 repaymentChainId,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint64 newRelayerFeePct,
uint32 depositId,
bytes memory depositorSignature
) external;
function executeSlowRelayLeaf(
address depositor,
address recipient,
address destinationToken,
uint256 amount,
uint256 originChainId,
uint64 realizedLpFeePct,
uint64 relayerFeePct,
uint32 depositId,
uint32 rootBundleId,
bytes32[] memory proof
) external;
function executeRelayerRefundLeaf(
uint32 rootBundleId,
SpokePoolInterface.RelayerRefundLeaf memory relayerRefundLeaf,
bytes32[] memory proof
) external;
function chainId() external view returns (uint256);
}
파일 52 / 56 : StoreInterface.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../../common/implementation/FixedPoint.sol";
interface StoreInterface {
function payOracleFees() external payable;
function payOracleFeesErc20(address erc20Address, FixedPoint.Unsigned calldata amount) external;
function computeRegularFee(
uint256 startTime,
uint256 endTime,
FixedPoint.Unsigned calldata pfc
) external view returns (FixedPoint.Unsigned memory regularFee, FixedPoint.Unsigned memory latePenalty);
function computeFinalFee(address currency) external view returns (FixedPoint.Unsigned memory);
}
파일 53 / 56 : Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
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] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
파일 54 / 56 : Testable.sol
pragma solidity ^0.8.0;
import "./Timer.sol";
abstract contract Testable {
address public timerAddress;
constructor(address _timerAddress) {
timerAddress = _timerAddress;
}
modifier onlyIfTest {
require(timerAddress != address(0x0));
_;
}
function setCurrentTime(uint256 time) external onlyIfTest {
Timer(timerAddress).setCurrentTime(time);
}
function getCurrentTime() public view virtual returns (uint256) {
if (timerAddress != address(0x0)) {
return Timer(timerAddress).getCurrentTime();
} else {
return block.timestamp;
}
}
}
파일 55 / 56 : Timer.sol
pragma solidity ^0.8.0;
contract Timer {
uint256 private currentTime;
constructor() {
currentTime = block.timestamp;
}
function setCurrentTime(uint256 time) external {
currentTime = time;
}
function getCurrentTime() public view returns (uint256) {
return currentTime;
}
}
파일 56 / 56 : WETH9.sol
pragma solidity ^0.8.0;
interface WETH9 {
function withdraw(uint256 wad) external;
function deposit() external payable;
function balanceOf(address guy) external view returns (uint256 wad);
function transfer(address guy, uint256 wad) external;
}
{
"compilationTarget": {
"@uma/core/contracts/common/implementation/ExpandedERC20.sol": "ExpandedERC20"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 1000000
},
"remappings": []
}[{"inputs":[{"internalType":"string","name":"_tokenName","type":"string"},{"internalType":"string","name":"_tokenSymbol","type":"string"},{"internalType":"uint8","name":"_tokenDecimals","type":"uint8"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roleId","type":"uint256"},{"indexed":true,"internalType":"address","name":"newMember","type":"address"},{"indexed":true,"internalType":"address","name":"manager","type":"address"}],"name":"AddedSharedMember","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roleId","type":"uint256"},{"indexed":true,"internalType":"address","name":"oldMember","type":"address"},{"indexed":true,"internalType":"address","name":"manager","type":"address"}],"name":"RemovedSharedMember","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roleId","type":"uint256"},{"indexed":true,"internalType":"address","name":"newMember","type":"address"},{"indexed":true,"internalType":"address","name":"manager","type":"address"}],"name":"ResetExclusiveMember","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addBurner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"},{"internalType":"address","name":"newMember","type":"address"}],"name":"addMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"}],"name":"getMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"},{"internalType":"address","name":"memberToCheck","type":"address"}],"name":"holdsRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"},{"internalType":"address","name":"memberToRemove","type":"address"}],"name":"removeMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"}],"name":"renounceMembership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roleId","type":"uint256"},{"internalType":"address","name":"newMember","type":"address"}],"name":"resetMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"resetOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
