File 1 of 1: TokenMinter.sol
pragma solidity 0.7.6;
interface ITokenMinter {
function mint(
uint32 sourceDomain,
bytes32 burnToken,
address to,
uint256 amount
) external returns (address mintToken);
function burn(address burnToken, uint256 amount) external;
function getLocalToken(uint32 remoteDomain, bytes32 remoteToken)
external
view
returns (address);
function setTokenController(address newTokenController) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, 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 sender,
address recipient,
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
);
}
interface IMintBurnToken is IERC20 {
function mint(address to, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function 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);
}
}
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(
address indexed previousOwner,
address indexed newOwner
);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner)
public
virtual
override
onlyOwner
{
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() external {
address sender = _msgSender();
require(
pendingOwner() == sender,
"Ownable2Step: caller is not the new owner"
);
_transferOwnership(sender);
}
}
contract Pausable is Ownable2Step {
event Pause();
event Unpause();
event PauserChanged(address indexed newAddress);
address private _pauser;
bool public paused = false;
modifier whenNotPaused() {
require(!paused, "Pausable: paused");
_;
}
modifier onlyPauser() {
require(msg.sender == _pauser, "Pausable: caller is not the pauser");
_;
}
function pauser() external view returns (address) {
return _pauser;
}
function pause() external onlyPauser {
paused = true;
emit Pause();
}
function unpause() external onlyPauser {
paused = false;
emit Unpause();
}
function updatePauser(address _newPauser) external onlyOwner {
require(
_newPauser != address(0),
"Pausable: new pauser is the zero address"
);
_pauser = _newPauser;
emit PauserChanged(_pauser);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
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)
{
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 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
) private 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);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
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).add(
value
);
_callOptionalReturn(
token,
abi.encodeWithSelector(
token.approve.selector,
spender,
newAllowance
)
);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(
value,
"SafeERC20: decreased allowance below zero"
);
_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"
);
}
}
}
contract Rescuable is Ownable2Step {
using SafeERC20 for IERC20;
address private _rescuer;
event RescuerChanged(address indexed newRescuer);
function rescuer() external view returns (address) {
return _rescuer;
}
modifier onlyRescuer() {
require(msg.sender == _rescuer, "Rescuable: caller is not the rescuer");
_;
}
function rescueERC20(
IERC20 tokenContract,
address to,
uint256 amount
) external onlyRescuer {
tokenContract.safeTransfer(to, amount);
}
function updateRescuer(address newRescuer) external onlyOwner {
require(
newRescuer != address(0),
"Rescuable: new rescuer is the zero address"
);
_rescuer = newRescuer;
emit RescuerChanged(newRescuer);
}
}
abstract contract TokenController {
event TokenPairLinked(
address localToken,
uint32 remoteDomain,
bytes32 remoteToken
);
event TokenPairUnlinked(
address localToken,
uint32 remoteDomain,
bytes32 remoteToken
);
event SetBurnLimitPerMessage(
address indexed token,
uint256 burnLimitPerMessage
);
event SetTokenController(address tokenController);
mapping(address => uint256) public burnLimitsPerMessage;
mapping(bytes32 => address) public remoteTokensToLocalTokens;
address private _tokenController;
modifier onlyTokenController() {
require(
msg.sender == _tokenController,
"Caller is not tokenController"
);
_;
}
modifier onlyWithinBurnLimit(address token, uint256 amount) {
uint256 _allowedBurnAmount = burnLimitsPerMessage[token];
require(_allowedBurnAmount > 0, "Burn token not supported");
require(
amount <= _allowedBurnAmount,
"Burn amount exceeds per tx limit"
);
_;
}
function tokenController() external view returns (address) {
return _tokenController;
}
function linkTokenPair(
address localToken,
uint32 remoteDomain,
bytes32 remoteToken
) external onlyTokenController {
bytes32 _remoteTokensKey = _hashRemoteDomainAndToken(
remoteDomain,
remoteToken
);
require(
remoteTokensToLocalTokens[_remoteTokensKey] == address(0),
"Unable to link token pair"
);
remoteTokensToLocalTokens[_remoteTokensKey] = localToken;
emit TokenPairLinked(localToken, remoteDomain, remoteToken);
}
function unlinkTokenPair(
address localToken,
uint32 remoteDomain,
bytes32 remoteToken
) external onlyTokenController {
bytes32 _remoteTokensKey = _hashRemoteDomainAndToken(
remoteDomain,
remoteToken
);
require(
remoteTokensToLocalTokens[_remoteTokensKey] != address(0),
"Unable to unlink token pair"
);
delete remoteTokensToLocalTokens[_remoteTokensKey];
emit TokenPairUnlinked(localToken, remoteDomain, remoteToken);
}
function setMaxBurnAmountPerMessage(
address localToken,
uint256 burnLimitPerMessage
) external onlyTokenController {
burnLimitsPerMessage[localToken] = burnLimitPerMessage;
emit SetBurnLimitPerMessage(localToken, burnLimitPerMessage);
}
function _setTokenController(address newTokenController) internal {
require(
newTokenController != address(0),
"Invalid token controller address"
);
_tokenController = newTokenController;
emit SetTokenController(newTokenController);
}
function _getLocalToken(uint32 remoteDomain, bytes32 remoteToken)
internal
view
returns (address)
{
bytes32 _remoteTokensKey = _hashRemoteDomainAndToken(
remoteDomain,
remoteToken
);
return remoteTokensToLocalTokens[_remoteTokensKey];
}
function _hashRemoteDomainAndToken(uint32 remoteDomain, bytes32 remoteToken)
internal
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(remoteDomain, remoteToken));
}
}
interface IMessageHandler {
function handleReceiveMessage(
uint32 sourceDomain,
bytes32 sender,
bytes calldata messageBody
) external returns (bool);
}
interface IRelayer {
function sendMessage(
uint32 destinationDomain,
bytes32 recipient,
bytes calldata messageBody
) external returns (uint64);
function sendMessageWithCaller(
uint32 destinationDomain,
bytes32 recipient,
bytes32 destinationCaller,
bytes calldata messageBody
) external returns (uint64);
function replaceMessage(
bytes calldata originalMessage,
bytes calldata originalAttestation,
bytes calldata newMessageBody,
bytes32 newDestinationCaller
) external;
}
interface IReceiver {
function receiveMessage(bytes calldata message, bytes calldata signature)
external
returns (bool success);
}
interface IMessageTransmitter is IRelayer, IReceiver {
}
library TypedMemView {
using SafeMath for uint256;
bytes29 public constant NULL =
hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
uint256 constant LOW_12_MASK = 0xffffffffffffffffffffffff;
uint8 constant TWELVE_BYTES = 96;
function nibbleHex(uint8 _b) internal pure returns (uint8 char) {
uint8 _nibble = _b | 0xf0;
if (_nibble == 0xf0) {
return 0x30;
}
if (_nibble == 0xf1) {
return 0x31;
}
if (_nibble == 0xf2) {
return 0x32;
}
if (_nibble == 0xf3) {
return 0x33;
}
if (_nibble == 0xf4) {
return 0x34;
}
if (_nibble == 0xf5) {
return 0x35;
}
if (_nibble == 0xf6) {
return 0x36;
}
if (_nibble == 0xf7) {
return 0x37;
}
if (_nibble == 0xf8) {
return 0x38;
}
if (_nibble == 0xf9) {
return 0x39;
}
if (_nibble == 0xfa) {
return 0x61;
}
if (_nibble == 0xfb) {
return 0x62;
}
if (_nibble == 0xfc) {
return 0x63;
}
if (_nibble == 0xfd) {
return 0x64;
}
if (_nibble == 0xfe) {
return 0x65;
}
if (_nibble == 0xff) {
return 0x66;
}
}
function byteHex(uint8 _b) internal pure returns (uint16 encoded) {
encoded |= nibbleHex(_b >> 4);
encoded <<= 8;
encoded |= nibbleHex(_b);
}
function encodeHex(uint256 _b)
internal
pure
returns (uint256 first, uint256 second)
{
for (uint8 i = 31; i > 15; i -= 1) {
uint8 _byte = uint8(_b >> (i * 8));
first |= byteHex(_byte);
if (i != 16) {
first <<= 16;
}
}
for (uint8 i = 15; i < 255; i -= 1) {
uint8 _byte = uint8(_b >> (i * 8));
second |= byteHex(_byte);
if (i != 0) {
second <<= 16;
}
}
}
function reverseUint256(uint256 _b) internal pure returns (uint256 v) {
v = _b;
v =
((v >> 8) &
0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |
((v &
0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) <<
8);
v =
((v >> 16) &
0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |
((v &
0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) <<
16);
v =
((v >> 32) &
0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |
((v &
0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) <<
32);
v =
((v >> 64) &
0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |
((v &
0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) <<
64);
v = (v >> 128) | (v << 128);
}
function leftMask(uint8 _len) private pure returns (uint256 mask) {
assembly {
mask := sar(
sub(_len, 1),
0x8000000000000000000000000000000000000000000000000000000000000000
)
}
}
function nullView() internal pure returns (bytes29) {
return NULL;
}
function isNull(bytes29 memView) internal pure returns (bool) {
return memView == NULL;
}
function notNull(bytes29 memView) internal pure returns (bool) {
return !isNull(memView);
}
function isValid(bytes29 memView) internal pure returns (bool ret) {
if (typeOf(memView) == 0xffffffffff) {
return false;
}
uint256 _end = end(memView);
assembly {
ret := not(gt(_end, mload(0x40)))
}
}
function assertValid(bytes29 memView) internal pure returns (bytes29) {
require(isValid(memView), "Validity assertion failed");
return memView;
}
function isType(bytes29 memView, uint40 _expected)
internal
pure
returns (bool)
{
return typeOf(memView) == _expected;
}
function assertType(bytes29 memView, uint40 _expected)
internal
pure
returns (bytes29)
{
if (!isType(memView, _expected)) {
(, uint256 g) = encodeHex(uint256(typeOf(memView)));
(, uint256 e) = encodeHex(uint256(_expected));
string memory err = string(
abi.encodePacked(
"Type assertion failed. Got 0x",
uint80(g),
". Expected 0x",
uint80(e)
)
);
revert(err);
}
return memView;
}
function castTo(bytes29 memView, uint40 _newType)
internal
pure
returns (bytes29 newView)
{
assembly {
newView := or(newView, shr(40, shl(40, memView)))
newView := or(newView, shl(216, _newType))
}
}
function unsafeBuildUnchecked(
uint256 _type,
uint256 _loc,
uint256 _len
) private pure returns (bytes29 newView) {
assembly {
newView := shl(96, or(newView, _type))
newView := shl(96, or(newView, _loc))
newView := shl(24, or(newView, _len))
}
}
function build(
uint256 _type,
uint256 _loc,
uint256 _len
) internal pure returns (bytes29 newView) {
uint256 _end = _loc.add(_len);
assembly {
if gt(_end, mload(0x40)) {
_end := 0
}
}
if (_end == 0) {
return NULL;
}
newView = unsafeBuildUnchecked(_type, _loc, _len);
}
function ref(bytes memory arr, uint40 newType)
internal
pure
returns (bytes29)
{
uint256 _len = arr.length;
uint256 _loc;
assembly {
_loc := add(arr, 0x20)
}
return build(newType, _loc, _len);
}
function typeOf(bytes29 memView) internal pure returns (uint40 _type) {
assembly {
_type := shr(216, memView)
}
}
function sameType(bytes29 left, bytes29 right)
internal
pure
returns (bool)
{
return (left ^ right) >> (2 * TWELVE_BYTES) == 0;
}
function loc(bytes29 memView) internal pure returns (uint96 _loc) {
uint256 _mask = LOW_12_MASK;
assembly {
_loc := and(shr(120, memView), _mask)
}
}
function words(bytes29 memView) internal pure returns (uint256) {
return uint256(len(memView)).add(32) / 32;
}
function footprint(bytes29 memView) internal pure returns (uint256) {
return words(memView) * 32;
}
function len(bytes29 memView) internal pure returns (uint96 _len) {
uint256 _mask = LOW_12_MASK;
assembly {
_len := and(shr(24, memView), _mask)
}
}
function end(bytes29 memView) internal pure returns (uint256) {
return loc(memView) + len(memView);
}
function slice(
bytes29 memView,
uint256 _index,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
uint256 _loc = loc(memView);
if (_loc.add(_index).add(_len) > end(memView)) {
return NULL;
}
_loc = _loc.add(_index);
return build(newType, _loc, _len);
}
function prefix(
bytes29 memView,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
return slice(memView, 0, _len, newType);
}
function postfix(
bytes29 memView,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
return slice(memView, uint256(len(memView)).sub(_len), _len, newType);
}
function indexErrOverrun(
uint256 _loc,
uint256 _len,
uint256 _index,
uint256 _slice
) internal pure returns (string memory err) {
(, uint256 a) = encodeHex(_loc);
(, uint256 b) = encodeHex(_len);
(, uint256 c) = encodeHex(_index);
(, uint256 d) = encodeHex(_slice);
err = string(
abi.encodePacked(
"TypedMemView/index - Overran the view. Slice is at 0x",
uint48(a),
" with length 0x",
uint48(b),
". Attempted to index at offset 0x",
uint48(c),
" with length 0x",
uint48(d),
"."
)
);
}
function index(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (bytes32 result) {
if (_bytes == 0) {
return bytes32(0);
}
if (_index.add(_bytes) > len(memView)) {
revert(
indexErrOverrun(
loc(memView),
len(memView),
_index,
uint256(_bytes)
)
);
}
require(
_bytes <= 32,
"TypedMemView/index - Attempted to index more than 32 bytes"
);
uint8 bitLength = _bytes * 8;
uint256 _loc = loc(memView);
uint256 _mask = leftMask(bitLength);
assembly {
result := and(mload(add(_loc, _index)), _mask)
}
}
function indexUint(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (uint256 result) {
return uint256(index(memView, _index, _bytes)) >> ((32 - _bytes) * 8);
}
function indexLEUint(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (uint256 result) {
return reverseUint256(uint256(index(memView, _index, _bytes)));
}
function indexAddress(bytes29 memView, uint256 _index)
internal
pure
returns (address)
{
return address(uint160(indexUint(memView, _index, 20)));
}
function keccak(bytes29 memView) internal pure returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
digest := keccak256(_loc, _len)
}
}
function sha2(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20))
digest := mload(ptr)
}
}
function hash160(bytes29 memView) internal view returns (bytes20 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20))
pop(staticcall(gas(), 3, ptr, 0x20, ptr, 0x20))
digest := mload(add(ptr, 0xc))
}
}
function hash256(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
let ptr := mload(0x40)
pop(staticcall(gas(), 2, _loc, _len, ptr, 0x20))
pop(staticcall(gas(), 2, ptr, 0x20, ptr, 0x20))
digest := mload(ptr)
}
}
function untypedEqual(bytes29 left, bytes29 right)
internal
pure
returns (bool)
{
return
(loc(left) == loc(right) && len(left) == len(right)) ||
keccak(left) == keccak(right);
}
function untypedNotEqual(bytes29 left, bytes29 right)
internal
pure
returns (bool)
{
return !untypedEqual(left, right);
}
function equal(bytes29 left, bytes29 right) internal pure returns (bool) {
return
left == right ||
(typeOf(left) == typeOf(right) && keccak(left) == keccak(right));
}
function notEqual(bytes29 left, bytes29 right)
internal
pure
returns (bool)
{
return !equal(left, right);
}
function unsafeCopyTo(bytes29 memView, uint256 _newLoc)
private
view
returns (bytes29 written)
{
require(notNull(memView), "TypedMemView/copyTo - Null pointer deref");
require(
isValid(memView),
"TypedMemView/copyTo - Invalid pointer deref"
);
uint256 _len = len(memView);
uint256 _oldLoc = loc(memView);
uint256 ptr;
assembly {
ptr := mload(0x40)
if gt(ptr, _newLoc) {
revert(0x60, 0x20)
}
pop(staticcall(gas(), 4, _oldLoc, _len, _newLoc, _len))
}
written = unsafeBuildUnchecked(typeOf(memView), _newLoc, _len);
}
function clone(bytes29 memView) internal view returns (bytes memory ret) {
uint256 ptr;
uint256 _len = len(memView);
assembly {
ptr := mload(0x40)
ret := ptr
}
unsafeCopyTo(memView, ptr + 0x20);
assembly {
mstore(0x40, add(add(ptr, _len), 0x20))
mstore(ptr, _len)
}
}
function unsafeJoin(bytes29[] memory memViews, uint256 _location)
private
view
returns (bytes29 unsafeView)
{
assembly {
let ptr := mload(0x40)
if gt(ptr, _location) {
revert(0x60, 0x20)
}
}
uint256 _offset = 0;
for (uint256 i = 0; i < memViews.length; i++) {
bytes29 memView = memViews[i];
unsafeCopyTo(memView, _location + _offset);
_offset += len(memView);
}
unsafeView = unsafeBuildUnchecked(0, _location, _offset);
}
function joinKeccak(bytes29[] memory memViews)
internal
view
returns (bytes32)
{
uint256 ptr;
assembly {
ptr := mload(0x40)
}
return keccak(unsafeJoin(memViews, ptr));
}
function joinSha2(bytes29[] memory memViews)
internal
view
returns (bytes32)
{
uint256 ptr;
assembly {
ptr := mload(0x40)
}
return sha2(unsafeJoin(memViews, ptr));
}
function join(bytes29[] memory memViews)
internal
view
returns (bytes memory ret)
{
uint256 ptr;
assembly {
ptr := mload(0x40)
}
bytes29 _newView = unsafeJoin(memViews, ptr + 0x20);
uint256 _written = len(_newView);
uint256 _footprint = footprint(_newView);
assembly {
mstore(ptr, _written)
mstore(0x40, add(add(ptr, _footprint), 0x20))
ret := ptr
}
}
}
library BurnMessage {
using TypedMemView for bytes;
using TypedMemView for bytes29;
uint8 private constant VERSION_INDEX = 0;
uint8 private constant VERSION_LEN = 4;
uint8 private constant BURN_TOKEN_INDEX = 4;
uint8 private constant BURN_TOKEN_LEN = 32;
uint8 private constant MINT_RECIPIENT_INDEX = 36;
uint8 private constant MINT_RECIPIENT_LEN = 32;
uint8 private constant AMOUNT_INDEX = 68;
uint8 private constant AMOUNT_LEN = 32;
uint8 private constant MSG_SENDER_INDEX = 100;
uint8 private constant MSG_SENDER_LEN = 32;
uint8 private constant BURN_MESSAGE_LEN = 132;
function _formatMessage(
uint32 _version,
bytes32 _burnToken,
bytes32 _mintRecipient,
uint256 _amount,
bytes32 _messageSender
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_version,
_burnToken,
_mintRecipient,
_amount,
_messageSender
);
}
function _getMessageSender(bytes29 _message)
internal
pure
returns (bytes32)
{
return _message.index(MSG_SENDER_INDEX, MSG_SENDER_LEN);
}
function _getBurnToken(bytes29 _message) internal pure returns (bytes32) {
return _message.index(BURN_TOKEN_INDEX, BURN_TOKEN_LEN);
}
function _getMintRecipient(bytes29 _message)
internal
pure
returns (bytes32)
{
return _message.index(MINT_RECIPIENT_INDEX, MINT_RECIPIENT_LEN);
}
function _getAmount(bytes29 _message) internal pure returns (uint256) {
return _message.indexUint(AMOUNT_INDEX, AMOUNT_LEN);
}
function _getVersion(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(VERSION_INDEX, VERSION_LEN));
}
function _validateBurnMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(_message.len() == BURN_MESSAGE_LEN, "Invalid message length");
}
}
library Message {
using TypedMemView for bytes;
using TypedMemView for bytes29;
uint8 private constant VERSION_INDEX = 0;
uint8 private constant SOURCE_DOMAIN_INDEX = 4;
uint8 private constant DESTINATION_DOMAIN_INDEX = 8;
uint8 private constant NONCE_INDEX = 12;
uint8 private constant SENDER_INDEX = 20;
uint8 private constant RECIPIENT_INDEX = 52;
uint8 private constant DESTINATION_CALLER_INDEX = 84;
uint8 private constant MESSAGE_BODY_INDEX = 116;
function _formatMessage(
uint32 _msgVersion,
uint32 _msgSourceDomain,
uint32 _msgDestinationDomain,
uint64 _msgNonce,
bytes32 _msgSender,
bytes32 _msgRecipient,
bytes32 _msgDestinationCaller,
bytes memory _msgRawBody
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_msgVersion,
_msgSourceDomain,
_msgDestinationDomain,
_msgNonce,
_msgSender,
_msgRecipient,
_msgDestinationCaller,
_msgRawBody
);
}
function _version(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(VERSION_INDEX, 4));
}
function _sourceDomain(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(SOURCE_DOMAIN_INDEX, 4));
}
function _destinationDomain(bytes29 _message)
internal
pure
returns (uint32)
{
return uint32(_message.indexUint(DESTINATION_DOMAIN_INDEX, 4));
}
function _nonce(bytes29 _message) internal pure returns (uint64) {
return uint64(_message.indexUint(NONCE_INDEX, 8));
}
function _sender(bytes29 _message) internal pure returns (bytes32) {
return _message.index(SENDER_INDEX, 32);
}
function _recipient(bytes29 _message) internal pure returns (bytes32) {
return _message.index(RECIPIENT_INDEX, 32);
}
function _destinationCaller(bytes29 _message)
internal
pure
returns (bytes32)
{
return _message.index(DESTINATION_CALLER_INDEX, 32);
}
function _messageBody(bytes29 _message) internal pure returns (bytes29) {
return
_message.slice(
MESSAGE_BODY_INDEX,
_message.len() - MESSAGE_BODY_INDEX,
0
);
}
function addressToBytes32(address addr) external pure returns (bytes32) {
return bytes32(uint256(uint160(addr)));
}
function bytes32ToAddress(bytes32 _buf) public pure returns (address) {
return address(uint160(uint256(_buf)));
}
function _validateMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(
_message.len() >= MESSAGE_BODY_INDEX,
"Invalid message: too short"
);
}
}
contract TokenMessenger is IMessageHandler, Rescuable {
event DepositForBurn(
uint64 indexed nonce,
address indexed burnToken,
uint256 amount,
address indexed depositor,
bytes32 mintRecipient,
uint32 destinationDomain,
bytes32 destinationTokenMessenger,
bytes32 destinationCaller
);
event MintAndWithdraw(
address indexed mintRecipient,
uint256 amount,
address indexed mintToken
);
event RemoteTokenMessengerAdded(uint32 domain, bytes32 tokenMessenger);
event RemoteTokenMessengerRemoved(uint32 domain, bytes32 tokenMessenger);
event LocalMinterAdded(address localMinter);
event LocalMinterRemoved(address localMinter);
using TypedMemView for bytes;
using TypedMemView for bytes29;
using BurnMessage for bytes29;
using Message for bytes29;
IMessageTransmitter public immutable localMessageTransmitter;
uint32 public immutable messageBodyVersion;
ITokenMinter public localMinter;
mapping(uint32 => bytes32) public remoteTokenMessengers;
modifier onlyRemoteTokenMessenger(uint32 domain, bytes32 tokenMessenger) {
require(
_isRemoteTokenMessenger(domain, tokenMessenger),
"Remote TokenMessenger unsupported"
);
_;
}
modifier onlyLocalMessageTransmitter() {
require(_isLocalMessageTransmitter(), "Invalid message transmitter");
_;
}
constructor(address _messageTransmitter, uint32 _messageBodyVersion) {
require(
_messageTransmitter != address(0),
"MessageTransmitter not set"
);
localMessageTransmitter = IMessageTransmitter(_messageTransmitter);
messageBodyVersion = _messageBodyVersion;
}
function depositForBurn(
uint256 amount,
uint32 destinationDomain,
bytes32 mintRecipient,
address burnToken
) external returns (uint64 _nonce) {
return
_depositForBurn(
amount,
destinationDomain,
mintRecipient,
burnToken,
bytes32(0)
);
}
function depositForBurnWithCaller(
uint256 amount,
uint32 destinationDomain,
bytes32 mintRecipient,
address burnToken,
bytes32 destinationCaller
) external returns (uint64 nonce) {
require(destinationCaller != bytes32(0), "Invalid destination caller");
return
_depositForBurn(
amount,
destinationDomain,
mintRecipient,
burnToken,
destinationCaller
);
}
function replaceDepositForBurn(
bytes calldata originalMessage,
bytes calldata originalAttestation,
bytes32 newDestinationCaller,
bytes32 newMintRecipient
) external {
bytes29 _originalMsg = originalMessage.ref(0);
_originalMsg._validateMessageFormat();
bytes29 _originalMsgBody = _originalMsg._messageBody();
_originalMsgBody._validateBurnMessageFormat();
bytes32 _originalMsgSender = _originalMsgBody._getMessageSender();
require(
msg.sender == Message.bytes32ToAddress(_originalMsgSender),
"Invalid sender for message"
);
require(
newMintRecipient != bytes32(0),
"Mint recipient must be nonzero"
);
bytes32 _burnToken = _originalMsgBody._getBurnToken();
uint256 _amount = _originalMsgBody._getAmount();
bytes memory _newMessageBody = BurnMessage._formatMessage(
messageBodyVersion,
_burnToken,
newMintRecipient,
_amount,
_originalMsgSender
);
localMessageTransmitter.replaceMessage(
originalMessage,
originalAttestation,
_newMessageBody,
newDestinationCaller
);
emit DepositForBurn(
_originalMsg._nonce(),
Message.bytes32ToAddress(_burnToken),
_amount,
msg.sender,
newMintRecipient,
_originalMsg._destinationDomain(),
_originalMsg._recipient(),
newDestinationCaller
);
}
function handleReceiveMessage(
uint32 remoteDomain,
bytes32 sender,
bytes calldata messageBody
)
external
override
onlyLocalMessageTransmitter
onlyRemoteTokenMessenger(remoteDomain, sender)
returns (bool)
{
bytes29 _msg = messageBody.ref(0);
_msg._validateBurnMessageFormat();
require(
_msg._getVersion() == messageBodyVersion,
"Invalid message body version"
);
bytes32 _mintRecipient = _msg._getMintRecipient();
bytes32 _burnToken = _msg._getBurnToken();
uint256 _amount = _msg._getAmount();
ITokenMinter _localMinter = _getLocalMinter();
_mintAndWithdraw(
address(_localMinter),
remoteDomain,
_burnToken,
Message.bytes32ToAddress(_mintRecipient),
_amount
);
return true;
}
function addRemoteTokenMessenger(uint32 domain, bytes32 tokenMessenger)
external
onlyOwner
{
require(tokenMessenger != bytes32(0), "bytes32(0) not allowed");
require(
remoteTokenMessengers[domain] == bytes32(0),
"TokenMessenger already set"
);
remoteTokenMessengers[domain] = tokenMessenger;
emit RemoteTokenMessengerAdded(domain, tokenMessenger);
}
function removeRemoteTokenMessenger(uint32 domain) external onlyOwner {
require(
remoteTokenMessengers[domain] != bytes32(0),
"No TokenMessenger set"
);
bytes32 _removedTokenMessenger = remoteTokenMessengers[domain];
delete remoteTokenMessengers[domain];
emit RemoteTokenMessengerRemoved(domain, _removedTokenMessenger);
}
function addLocalMinter(address newLocalMinter) external onlyOwner {
require(newLocalMinter != address(0), "Zero address not allowed");
require(
address(localMinter) == address(0),
"Local minter is already set."
);
localMinter = ITokenMinter(newLocalMinter);
emit LocalMinterAdded(newLocalMinter);
}
function removeLocalMinter() external onlyOwner {
address _localMinterAddress = address(localMinter);
require(_localMinterAddress != address(0), "No local minter is set.");
delete localMinter;
emit LocalMinterRemoved(_localMinterAddress);
}
function _depositForBurn(
uint256 _amount,
uint32 _destinationDomain,
bytes32 _mintRecipient,
address _burnToken,
bytes32 _destinationCaller
) internal returns (uint64 nonce) {
require(_amount > 0, "Amount must be nonzero");
require(_mintRecipient != bytes32(0), "Mint recipient must be nonzero");
bytes32 _destinationTokenMessenger = _getRemoteTokenMessenger(
_destinationDomain
);
ITokenMinter _localMinter = _getLocalMinter();
IMintBurnToken _mintBurnToken = IMintBurnToken(_burnToken);
require(
_mintBurnToken.transferFrom(
msg.sender,
address(_localMinter),
_amount
),
"Transfer operation failed"
);
_localMinter.burn(_burnToken, _amount);
bytes memory _burnMessage = BurnMessage._formatMessage(
messageBodyVersion,
Message.addressToBytes32(_burnToken),
_mintRecipient,
_amount,
Message.addressToBytes32(msg.sender)
);
uint64 _nonceReserved = _sendDepositForBurnMessage(
_destinationDomain,
_destinationTokenMessenger,
_destinationCaller,
_burnMessage
);
emit DepositForBurn(
_nonceReserved,
_burnToken,
_amount,
msg.sender,
_mintRecipient,
_destinationDomain,
_destinationTokenMessenger,
_destinationCaller
);
return _nonceReserved;
}
function _sendDepositForBurnMessage(
uint32 _destinationDomain,
bytes32 _destinationTokenMessenger,
bytes32 _destinationCaller,
bytes memory _burnMessage
) internal returns (uint64 nonce) {
if (_destinationCaller == bytes32(0)) {
return
localMessageTransmitter.sendMessage(
_destinationDomain,
_destinationTokenMessenger,
_burnMessage
);
} else {
return
localMessageTransmitter.sendMessageWithCaller(
_destinationDomain,
_destinationTokenMessenger,
_destinationCaller,
_burnMessage
);
}
}
function _mintAndWithdraw(
address _tokenMinter,
uint32 _remoteDomain,
bytes32 _burnToken,
address _mintRecipient,
uint256 _amount
) internal {
ITokenMinter _minter = ITokenMinter(_tokenMinter);
address _mintToken = _minter.mint(
_remoteDomain,
_burnToken,
_mintRecipient,
_amount
);
emit MintAndWithdraw(_mintRecipient, _amount, _mintToken);
}
function _getRemoteTokenMessenger(uint32 _domain)
internal
view
returns (bytes32)
{
bytes32 _tokenMessenger = remoteTokenMessengers[_domain];
require(_tokenMessenger != bytes32(0), "No TokenMessenger for domain");
return _tokenMessenger;
}
function _getLocalMinter() internal view returns (ITokenMinter) {
require(address(localMinter) != address(0), "Local minter is not set");
return localMinter;
}
function _isRemoteTokenMessenger(uint32 _domain, bytes32 _tokenMessenger)
internal
view
returns (bool)
{
return
_tokenMessenger != bytes32(0) &&
remoteTokenMessengers[_domain] == _tokenMessenger;
}
function _isLocalMessageTransmitter() internal view returns (bool) {
return
address(localMessageTransmitter) != address(0) &&
msg.sender == address(localMessageTransmitter);
}
}
contract TokenMinter is ITokenMinter, TokenController, Pausable, Rescuable {
event LocalTokenMessengerAdded(address localTokenMessenger);
event LocalTokenMessengerRemoved(address localTokenMessenger);
address public localTokenMessenger;
modifier onlyLocalTokenMessenger() {
require(_isLocalTokenMessenger(), "Caller not local TokenMessenger");
_;
}
constructor(address _tokenController) {
_setTokenController(_tokenController);
}
function mint(
uint32 sourceDomain,
bytes32 burnToken,
address to,
uint256 amount
)
external
override
whenNotPaused
onlyLocalTokenMessenger
returns (address mintToken)
{
address _mintToken = _getLocalToken(sourceDomain, burnToken);
require(_mintToken != address(0), "Mint token not supported");
IMintBurnToken _token = IMintBurnToken(_mintToken);
require(_token.mint(to, amount), "Mint operation failed");
return _mintToken;
}
function burn(address burnToken, uint256 burnAmount)
external
override
whenNotPaused
onlyLocalTokenMessenger
onlyWithinBurnLimit(burnToken, burnAmount)
{
IMintBurnToken _token = IMintBurnToken(burnToken);
_token.burn(burnAmount);
}
function addLocalTokenMessenger(address newLocalTokenMessenger)
external
onlyOwner
{
require(
newLocalTokenMessenger != address(0),
"Invalid TokenMessenger address"
);
require(
localTokenMessenger == address(0),
"Local TokenMessenger already set"
);
localTokenMessenger = newLocalTokenMessenger;
emit LocalTokenMessengerAdded(localTokenMessenger);
}
function removeLocalTokenMessenger() external onlyOwner {
address _localTokenMessengerBeforeRemoval = localTokenMessenger;
require(
_localTokenMessengerBeforeRemoval != address(0),
"No local TokenMessenger is set"
);
delete localTokenMessenger;
emit LocalTokenMessengerRemoved(_localTokenMessengerBeforeRemoval);
}
function setTokenController(address newTokenController)
external
override
onlyOwner
{
_setTokenController(newTokenController);
}
function getLocalToken(uint32 remoteDomain, bytes32 remoteToken)
external
view
override
returns (address)
{
return _getLocalToken(remoteDomain, remoteToken);
}
function _isLocalTokenMessenger() internal view returns (bool) {
return
address(localTokenMessenger) != address(0) &&
msg.sender == address(localTokenMessenger);
}
}
