文件 1 的 43：Address.sol
pragma solidity ^0.8.0;
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
) 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);
}
}
}
}
文件 2 的 43：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) {
this;
return msg.data;
}
}
文件 3 的 43：Create2.sol
pragma solidity ^0.8.0;
abstract contract Create2 {
function createClone(bytes32 _salt, address _target) internal returns (address _result) {
bytes20 _targetBytes = bytes20(_target);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), _targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
_result := create2(0, clone, 0x37, _salt)
}
require(_result != address(0), "Create2: Failed on minimal deploy");
}
function minimalProxyCreationCode(address logic) internal pure returns (bytes memory) {
bytes10 creation = 0x3d602d80600a3d3981f3;
bytes10 prefix = 0x363d3d373d3d3d363d73;
bytes20 targetBytes = bytes20(logic);
bytes15 suffix = 0x5af43d82803e903d91602b57fd5bf3;
return abi.encodePacked(creation, prefix, targetBytes, suffix);
}
function computedCreate2Address(
bytes32 salt,
bytes32 bytecodeHash,
address deployer
) public pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint160(uint256(_data)));
}
}
文件 4 的 43：ERC1155.sol
pragma solidity ^0.8.0;
import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./IERC1155MetadataURI.sol";
import "./Address.sol";
import "./Context.sol";
import "./ERC165.sol";
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
_balances[id][from] = fromBalance - amount;
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
_balances[id][from] = fromBalance - amount;
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
_balances[id][account] = accountBalance - amount;
emit TransferSingle(operator, account, address(0), id, amount);
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
_balances[id][account] = accountBalance - amount;
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
function _setupMetaData(string memory uri_) internal virtual {
_setURI(uri_);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver(to).onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver(to).onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
文件 5 的 43：ERC1155Holder.sol
pragma solidity ^0.8.0;
import "./ERC1155Receiver.sol";
contract ERC1155Holder is ERC1155Receiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
}
文件 6 的 43：ERC1155Receiver.sol
pragma solidity ^0.8.0;
import "./IERC1155Receiver.sol";
import "./ERC165.sol";
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
}
}
文件 7 的 43：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 8 的 43：ERC20.sol
pragma solidity ^0.8.0;
import {IERC20} from "./IERC20.sol";
import {SafeMath} from "./SafeMath.sol";
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, 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) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
msg.sender,
_allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")
);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(
msg.sender,
spender,
_allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")
);
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, 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 = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(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);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(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 _setupMetaData(
string memory name_,
string memory symbol_,
uint8 decimals_
) internal virtual {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
文件 9 的 43：ERC721.sol
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
emit Approval(ERC721.ownerOf(tokenId), address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
}
function _setupMetaData(string memory name_, string memory symbol_) internal virtual {
_name = name_;
_symbol = symbol_;
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
文件 10 的 43：ExitPayloadReader.sol
pragma solidity ^0.8.0;
import {RLPReader} from "./RLPReader.sol";
library ExitPayloadReader {
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
uint8 constant WORD_SIZE = 32;
struct ExitPayload {
RLPReader.RLPItem[] data;
}
struct Receipt {
RLPReader.RLPItem[] data;
bytes raw;
uint256 logIndex;
}
struct Log {
RLPReader.RLPItem data;
RLPReader.RLPItem[] list;
}
struct LogTopics {
RLPReader.RLPItem[] data;
}
function copy(
uint256 src,
uint256 dest,
uint256 len
) private pure {
if (len == 0) return;
for (; len >= WORD_SIZE; len -= WORD_SIZE) {
assembly {
mstore(dest, mload(src))
}
src += WORD_SIZE;
dest += WORD_SIZE;
}
uint256 mask = 256**(WORD_SIZE - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toExitPayload(bytes memory data) internal pure returns (ExitPayload memory) {
RLPReader.RLPItem[] memory payloadData = data.toRlpItem().toList();
return ExitPayload(payloadData);
}
function getHeaderNumber(ExitPayload memory payload) internal pure returns (uint256) {
return payload.data[0].toUint();
}
function getBlockProof(ExitPayload memory payload) internal pure returns (bytes memory) {
return payload.data[1].toBytes();
}
function getBlockNumber(ExitPayload memory payload) internal pure returns (uint256) {
return payload.data[2].toUint();
}
function getBlockTime(ExitPayload memory payload) internal pure returns (uint256) {
return payload.data[3].toUint();
}
function getTxRoot(ExitPayload memory payload) internal pure returns (bytes32) {
return bytes32(payload.data[4].toUint());
}
function getReceiptRoot(ExitPayload memory payload) internal pure returns (bytes32) {
return bytes32(payload.data[5].toUint());
}
function getReceipt(ExitPayload memory payload) internal pure returns (Receipt memory receipt) {
receipt.raw = payload.data[6].toBytes();
RLPReader.RLPItem memory receiptItem = receipt.raw.toRlpItem();
if (receiptItem.isList()) {
receipt.data = receiptItem.toList();
} else {
bytes memory typedBytes = receipt.raw;
bytes memory result = new bytes(typedBytes.length - 1);
uint256 srcPtr;
uint256 destPtr;
assembly {
srcPtr := add(33, typedBytes)
destPtr := add(0x20, result)
}
copy(srcPtr, destPtr, result.length);
receipt.data = result.toRlpItem().toList();
}
receipt.logIndex = getReceiptLogIndex(payload);
return receipt;
}
function getReceiptProof(ExitPayload memory payload) internal pure returns (bytes memory) {
return payload.data[7].toBytes();
}
function getBranchMaskAsBytes(ExitPayload memory payload) internal pure returns (bytes memory) {
return payload.data[8].toBytes();
}
function getBranchMaskAsUint(ExitPayload memory payload) internal pure returns (uint256) {
return payload.data[8].toUint();
}
function getReceiptLogIndex(ExitPayload memory payload) internal pure returns (uint256) {
return payload.data[9].toUint();
}
function toBytes(Receipt memory receipt) internal pure returns (bytes memory) {
return receipt.raw;
}
function getLog(Receipt memory receipt) internal pure returns (Log memory) {
RLPReader.RLPItem memory logData = receipt.data[3].toList()[receipt.logIndex];
return Log(logData, logData.toList());
}
function getEmitter(Log memory log) internal pure returns (address) {
return RLPReader.toAddress(log.list[0]);
}
function getTopics(Log memory log) internal pure returns (LogTopics memory) {
return LogTopics(log.list[1].toList());
}
function getData(Log memory log) internal pure returns (bytes memory) {
return log.list[2].toBytes();
}
function toRlpBytes(Log memory log) internal pure returns (bytes memory) {
return log.data.toRlpBytes();
}
function getField(LogTopics memory topics, uint256 index) internal pure returns (RLPReader.RLPItem memory) {
return topics.data[index];
}
}
文件 11 的 43：FxBaseChildTunnel.sol
pragma solidity ^0.8.0;
interface IFxMessageProcessor {
function processMessageFromRoot(
uint256 stateId,
address rootMessageSender,
bytes calldata data
) external;
}
abstract contract FxBaseChildTunnel is IFxMessageProcessor {
event MessageSent(bytes message);
address public fxChild;
address public fxRootTunnel;
constructor(address _fxChild) {
fxChild = _fxChild;
}
modifier validateSender(address sender) {
require(sender == fxRootTunnel, "FxBaseChildTunnel: INVALID_SENDER_FROM_ROOT");
_;
}
function setFxRootTunnel(address _fxRootTunnel) external virtual {
require(fxRootTunnel == address(0x0), "FxBaseChildTunnel: ROOT_TUNNEL_ALREADY_SET");
fxRootTunnel = _fxRootTunnel;
}
function processMessageFromRoot(
uint256 stateId,
address rootMessageSender,
bytes calldata data
) external override {
require(msg.sender == fxChild, "FxBaseChildTunnel: INVALID_SENDER");
_processMessageFromRoot(stateId, rootMessageSender, data);
}
function _sendMessageToRoot(bytes memory message) internal {
emit MessageSent(message);
}
function _processMessageFromRoot(
uint256 stateId,
address sender,
bytes memory message
) internal virtual;
}
文件 12 的 43：FxBaseRootTunnel.sol
pragma solidity ^0.8.0;
import {RLPReader} from "../lib/RLPReader.sol";
import {MerklePatriciaProof} from "../lib/MerklePatriciaProof.sol";
import {Merkle} from "../lib/Merkle.sol";
import "../lib/ExitPayloadReader.sol";
interface IFxStateSender {
function sendMessageToChild(address _receiver, bytes calldata _data) external;
}
contract ICheckpointManager {
struct HeaderBlock {
bytes32 root;
uint256 start;
uint256 end;
uint256 createdAt;
address proposer;
}
mapping(uint256 => HeaderBlock) public headerBlocks;
}
abstract contract FxBaseRootTunnel {
using RLPReader for RLPReader.RLPItem;
using Merkle for bytes32;
using ExitPayloadReader for bytes;
using ExitPayloadReader for ExitPayloadReader.ExitPayload;
using ExitPayloadReader for ExitPayloadReader.Log;
using ExitPayloadReader for ExitPayloadReader.LogTopics;
using ExitPayloadReader for ExitPayloadReader.Receipt;
bytes32 public constant SEND_MESSAGE_EVENT_SIG = 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036;
IFxStateSender public fxRoot;
ICheckpointManager public checkpointManager;
address public fxChildTunnel;
mapping(bytes32 => bool) public processedExits;
constructor(address _checkpointManager, address _fxRoot) {
checkpointManager = ICheckpointManager(_checkpointManager);
fxRoot = IFxStateSender(_fxRoot);
}
function setFxChildTunnel(address _fxChildTunnel) public virtual {
require(fxChildTunnel == address(0x0), "FxBaseRootTunnel: CHILD_TUNNEL_ALREADY_SET");
fxChildTunnel = _fxChildTunnel;
}
function _sendMessageToChild(bytes memory message) internal {
fxRoot.sendMessageToChild(fxChildTunnel, message);
}
function _validateAndExtractMessage(bytes memory inputData) internal returns (bytes memory) {
ExitPayloadReader.ExitPayload memory payload = inputData.toExitPayload();
bytes memory branchMaskBytes = payload.getBranchMaskAsBytes();
uint256 blockNumber = payload.getBlockNumber();
bytes32 exitHash = keccak256(
abi.encodePacked(
blockNumber,
MerklePatriciaProof._getNibbleArray(branchMaskBytes),
payload.getReceiptLogIndex()
)
);
require(processedExits[exitHash] == false, "FxRootTunnel: EXIT_ALREADY_PROCESSED");
processedExits[exitHash] = true;
ExitPayloadReader.Receipt memory receipt = payload.getReceipt();
ExitPayloadReader.Log memory log = receipt.getLog();
require(fxChildTunnel == log.getEmitter(), "FxRootTunnel: INVALID_FX_CHILD_TUNNEL");
bytes32 receiptRoot = payload.getReceiptRoot();
require(
MerklePatriciaProof.verify(receipt.toBytes(), branchMaskBytes, payload.getReceiptProof(), receiptRoot),
"FxRootTunnel: INVALID_RECEIPT_PROOF"
);
_checkBlockMembershipInCheckpoint(
blockNumber,
payload.getBlockTime(),
payload.getTxRoot(),
receiptRoot,
payload.getHeaderNumber(),
payload.getBlockProof()
);
ExitPayloadReader.LogTopics memory topics = log.getTopics();
require(
bytes32(topics.getField(0).toUint()) == SEND_MESSAGE_EVENT_SIG,
"FxRootTunnel: INVALID_SIGNATURE"
);
bytes memory message = abi.decode(log.getData(), (bytes));
return message;
}
function _checkBlockMembershipInCheckpoint(
uint256 blockNumber,
uint256 blockTime,
bytes32 txRoot,
bytes32 receiptRoot,
uint256 headerNumber,
bytes memory blockProof
) private view returns (uint256) {
(bytes32 headerRoot, uint256 startBlock, , uint256 createdAt, ) = checkpointManager.headerBlocks(headerNumber);
require(
keccak256(abi.encodePacked(blockNumber, blockTime, txRoot, receiptRoot)).checkMembership(
blockNumber - startBlock,
headerRoot,
blockProof
),
"FxRootTunnel: INVALID_HEADER"
);
return createdAt;
}
function receiveMessage(bytes memory inputData) public virtual {
bytes memory message = _validateAndExtractMessage(inputData);
_processMessageFromChild(message);
}
function _processMessageFromChild(bytes memory message) internal virtual;
}
文件 13 的 43：FxERC1155.sol
pragma solidity ^0.8.0;
import {ERC1155} from "../lib/ERC1155.sol";
import {IFxERC1155} from "./IFxERC1155.sol";
contract FxERC1155 is ERC1155, IFxERC1155 {
address internal _fxManager;
address internal _connectedToken;
function initialize(
address fxManager_,
address connectedToken_,
string memory uri_
) public override {
require(_fxManager == address(0x0) && _connectedToken == address(0x0), "Token is already initialized");
_fxManager = fxManager_;
_connectedToken = connectedToken_;
setupMetaData(uri_);
}
function fxManager() public view override returns (address) {
return _fxManager;
}
function connectedToken() public view override returns (address) {
return _connectedToken;
}
function setupMetaData(string memory _uri) public {
require(msg.sender == _fxManager, "Invalid sender");
_setupMetaData(_uri);
}
function mint(
address user,
uint256 id,
uint256 amount,
bytes memory data
) public override {
require(msg.sender == _fxManager, "Invalid sender");
_mint(user, id, amount, data);
}
function mintBatch(
address user,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override {
require(msg.sender == _fxManager, "Invalid sender");
_mintBatch(user, ids, amounts, data);
}
function burn(
address user,
uint256 id,
uint256 amount
) public override {
require(msg.sender == _fxManager, "Invalid sender");
_burn(user, id, amount);
}
function burnBatch(
address user,
uint256[] memory ids,
uint256[] memory amounts
) public override {
require(msg.sender == _fxManager, "Invalid sender");
_burnBatch(user, ids, amounts);
}
}
文件 14 的 43：FxERC1155ChildTunnel.sol
pragma solidity ^0.8.0;
import {IFxERC1155} from "../../tokens/IFxERC1155.sol";
import {ERC1155Holder} from "../../lib/ERC1155Holder.sol";
import {Create2} from "../..//lib/Create2.sol";
import {FxBaseChildTunnel} from "../../tunnel/FxBaseChildTunnel.sol";
contract FxERC1155ChildTunnel is FxBaseChildTunnel, Create2, ERC1155Holder {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant DEPOSIT_BATCH = keccak256("DEPOSIT_BATCH");
bytes32 public constant WITHDRAW = keccak256("WITHDRAW");
bytes32 public constant WITHDRAW_BATCH = keccak256("WITHDRAW_BATCH");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
event TokenMapped(address indexed rootToken, address indexed childToken);
mapping(address => address) public rootToChildToken;
address public tokenTemplate;
constructor(address _fxChild, address _tokenTemplate) FxBaseChildTunnel(_fxChild) {
tokenTemplate = _tokenTemplate;
require(_isContract(_tokenTemplate), "Token template is not contract");
}
function withdraw(
address childToken,
uint256 id,
uint256 amount,
bytes memory data
) public {
_withdraw(childToken, msg.sender, id, amount, data);
}
function withdrawTo(
address childToken,
address receiver,
uint256 id,
uint256 amount,
bytes memory data
) public {
_withdraw(childToken, receiver, id, amount, data);
}
function withdrawBatch(
address childToken,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public {
_withdrawBatch(childToken, msg.sender, ids, amounts, data);
}
function withdrawToBatch(
address childToken,
address receiver,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public {
_withdrawBatch(childToken, receiver, ids, amounts, data);
}
function _processMessageFromRoot(
uint256,
address sender,
bytes memory data
) internal override validateSender(sender) {
(bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
if (syncType == MAP_TOKEN) {
_mapToken(syncData);
} else if (syncType == DEPOSIT) {
_syncDeposit(syncData);
} else if (syncType == DEPOSIT_BATCH) {
_syncDepositBatch(syncData);
} else {
revert("FxERC1155ChildTunnel: INVALID_SYNC_TYPE");
}
}
function _mapToken(bytes memory syncData) internal returns (address) {
(address rootToken, string memory uri) = abi.decode(syncData, (address, string));
address childToken = rootToChildToken[rootToken];
require(childToken == address(0x0), "FxERC1155ChildTunnel: ALREADY_MAPPED");
bytes32 salt = keccak256(abi.encodePacked(rootToken));
childToken = createClone(salt, tokenTemplate);
IFxERC1155(childToken).initialize(address(this), rootToken, string(abi.encodePacked(uri)));
rootToChildToken[rootToken] = childToken;
emit TokenMapped(rootToken, childToken);
return childToken;
}
function _syncDeposit(bytes memory syncData) internal {
(address rootToken, address depositor, address user, uint256 id, uint256 amount, bytes memory data) = abi
.decode(syncData, (address, address, address, uint256, uint256, bytes));
address childToken = rootToChildToken[rootToken];
IFxERC1155 childTokenContract = IFxERC1155(childToken);
childTokenContract.mint(user, id, amount, data);
}
function _syncDepositBatch(bytes memory syncData) internal {
(
address rootToken,
address depositor,
address user,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) = abi.decode(syncData, (address, address, address, uint256[], uint256[], bytes));
address childToken = rootToChildToken[rootToken];
IFxERC1155 childTokenContract = IFxERC1155(childToken);
childTokenContract.mintBatch(user, ids, amounts, data);
}
function _withdraw(
address childToken,
address receiver,
uint256 id,
uint256 amount,
bytes memory data
) internal {
IFxERC1155 childTokenContract = IFxERC1155(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC1155ChildTunnel: NO_MAPPED_TOKEN"
);
childTokenContract.burn(msg.sender, id, amount);
bytes memory message = abi.encode(WITHDRAW, abi.encode(rootToken, childToken, receiver, id, amount, data));
_sendMessageToRoot(message);
}
function _withdrawBatch(
address childToken,
address receiver,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal {
IFxERC1155 childTokenContract = IFxERC1155(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC1155ChildTunnel: NO_MAPPED_TOKEN"
);
childTokenContract.burnBatch(msg.sender, ids, amounts);
bytes memory message = abi.encode(
WITHDRAW_BATCH,
abi.encode(rootToken, childToken, receiver, ids, amounts, data)
);
_sendMessageToRoot(message);
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
文件 15 的 43：FxERC1155RootTunnel.sol
pragma solidity ^0.8.0;
import {ERC1155} from "../../lib/ERC1155.sol";
import {ERC1155Holder} from "../../lib/ERC1155Holder.sol";
import {Create2} from "../../lib/Create2.sol";
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
contract FxERC1155RootTunnel is FxBaseRootTunnel, Create2, ERC1155Holder {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant DEPOSIT_BATCH = keccak256("DEPOSIT_BATCH");
bytes32 public constant WITHDRAW = keccak256("WITHDRAW");
bytes32 public constant WITHDRAW_BATCH = keccak256("WITHDRAW_BATCH");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
event TokenMappedERC1155(address indexed rootToken, address indexed childToken);
event FxWithdrawERC1155(
address indexed rootToken,
address indexed childToken,
address indexed userAddress,
uint256 id,
uint256 amount
);
event FxDepositERC1155(
address indexed rootToken,
address indexed depositor,
address indexed userAddress,
uint256 id,
uint256 amount
);
event FxWithdrawBatchERC1155(
address indexed rootToken,
address indexed childToken,
address indexed userAddress,
uint256[] ids,
uint256[] amounts
);
event FxDepositBatchERC1155(
address indexed rootToken,
address indexed userAddress,
uint256[] ids,
uint256[] amounts
);
mapping(address => address) public rootToChildTokens;
bytes32 public childTokenTemplateCodeHash;
constructor(
address _checkpointManager,
address _fxRoot,
address _fxERC1155Token
) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
childTokenTemplateCodeHash = keccak256(minimalProxyCreationCode(_fxERC1155Token));
}
function mapToken(address rootToken) public {
require(rootToChildTokens[rootToken] == address(0x0), "FxERC1155RootTunnel: ALREADY_MAPPED");
ERC1155 rootTokenContract = ERC1155(rootToken);
string memory uri = rootTokenContract.uri(0);
bytes memory message = abi.encode(MAP_TOKEN, abi.encode(rootToken, uri));
_sendMessageToChild(message);
bytes32 salt = keccak256(abi.encodePacked(rootToken));
address childToken = computedCreate2Address(salt, childTokenTemplateCodeHash, fxChildTunnel);
rootToChildTokens[rootToken] = childToken;
emit TokenMappedERC1155(rootToken, childToken);
}
function deposit(
address rootToken,
address user,
uint256 id,
uint256 amount,
bytes memory data
) public {
if (rootToChildTokens[rootToken] == address(0x0)) {
mapToken(rootToken);
}
ERC1155(rootToken).safeTransferFrom(
msg.sender,
address(this),
id,
amount,
data
);
bytes memory message = abi.encode(DEPOSIT, abi.encode(rootToken, msg.sender, user, id, amount, data));
_sendMessageToChild(message);
emit FxDepositERC1155(rootToken, msg.sender, user, id, amount);
}
function depositBatch(
address rootToken,
address user,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public {
if (rootToChildTokens[rootToken] == address(0x0)) {
mapToken(rootToken);
}
ERC1155(rootToken).safeBatchTransferFrom(
msg.sender,
address(this),
ids,
amounts,
data
);
bytes memory message = abi.encode(DEPOSIT_BATCH, abi.encode(rootToken, msg.sender, user, ids, amounts, data));
_sendMessageToChild(message);
emit FxDepositBatchERC1155(rootToken, user, ids, amounts);
}
function _processMessageFromChild(bytes memory data) internal override {
(bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
if (syncType == WITHDRAW) {
_syncWithdraw(syncData);
} else if (syncType == WITHDRAW_BATCH) {
_syncBatchWithdraw(syncData);
} else {
revert("FxERC1155RootTunnel: INVALID_SYNC_TYPE");
}
}
function _syncWithdraw(bytes memory syncData) internal {
(address rootToken, address childToken, address user, uint256 id, uint256 amount, bytes memory data) = abi
.decode(syncData, (address, address, address, uint256, uint256, bytes));
require(rootToChildTokens[rootToken] == childToken, "FxERC1155RootTunnel: INVALID_MAPPING_ON_EXIT");
ERC1155(rootToken).safeTransferFrom(address(this), user, id, amount, data);
emit FxWithdrawERC1155(rootToken, childToken, user, id, amount);
}
function _syncBatchWithdraw(bytes memory syncData) internal {
(
address rootToken,
address childToken,
address user,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) = abi.decode(syncData, (address, address, address, uint256[], uint256[], bytes));
require(rootToChildTokens[rootToken] == childToken, "FxERC1155RootTunnel: INVALID_MAPPING_ON_EXIT");
ERC1155(rootToken).safeBatchTransferFrom(address(this), user, ids, amounts, data);
emit FxWithdrawBatchERC1155(rootToken, childToken, user, ids, amounts);
}
}
文件 16 的 43：FxERC20.sol
pragma solidity ^0.8.0;
import {ERC20} from "../lib/ERC20.sol";
import {IFxERC20} from "./IFxERC20.sol";
contract FxERC20 is IFxERC20, ERC20 {
address internal _fxManager;
address internal _connectedToken;
function initialize(
address fxManager_,
address connectedToken_,
string memory name_,
string memory symbol_,
uint8 decimals_
) public override {
require(_fxManager == address(0x0) && _connectedToken == address(0x0), "Token is already initialized");
_fxManager = fxManager_;
_connectedToken = connectedToken_;
setupMetaData(name_, symbol_, decimals_);
}
function fxManager() public view override returns (address) {
return _fxManager;
}
function connectedToken() public view override returns (address) {
return _connectedToken;
}
function setupMetaData(
string memory _name,
string memory _symbol,
uint8 _decimals
) public {
require(msg.sender == _fxManager, "Invalid sender");
_setupMetaData(_name, _symbol, _decimals);
}
function mint(address user, uint256 amount) public override {
require(msg.sender == _fxManager, "Invalid sender");
_mint(user, amount);
}
function burn(address user, uint256 amount) public override {
require(msg.sender == _fxManager, "Invalid sender");
_burn(user, amount);
}
}
文件 17 的 43：FxERC20ChildTunnel.sol
pragma solidity ^0.8.0;
import {FxBaseChildTunnel} from "../../tunnel/FxBaseChildTunnel.sol";
import {Create2} from "../../lib/Create2.sol";
import {IFxERC20} from "../../tokens/IFxERC20.sol";
contract FxERC20ChildTunnel is FxBaseChildTunnel, Create2 {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
string public constant SUFFIX_NAME = " (FXERC20)";
string public constant PREFIX_SYMBOL = "fx";
event TokenMapped(address indexed rootToken, address indexed childToken);
mapping(address => address) public rootToChildToken;
address public tokenTemplate;
constructor(address _fxChild, address _tokenTemplate) FxBaseChildTunnel(_fxChild) {
tokenTemplate = _tokenTemplate;
require(_isContract(_tokenTemplate), "Token template is not contract");
}
function withdraw(address childToken, uint256 amount) public {
_withdraw(childToken, msg.sender, amount);
}
function withdrawTo(
address childToken,
address receiver,
uint256 amount
) public {
_withdraw(childToken, receiver, amount);
}
function _processMessageFromRoot(
uint256,
address sender,
bytes memory data
) internal override validateSender(sender) {
(bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
if (syncType == DEPOSIT) {
_syncDeposit(syncData);
} else if (syncType == MAP_TOKEN) {
_mapToken(syncData);
} else {
revert("FxERC20ChildTunnel: INVALID_SYNC_TYPE");
}
}
function _mapToken(bytes memory syncData) internal returns (address) {
(address rootToken, string memory name, string memory symbol, uint8 decimals) = abi.decode(
syncData,
(address, string, string, uint8)
);
address childToken = rootToChildToken[rootToken];
require(childToken == address(0x0), "FxERC20ChildTunnel: ALREADY_MAPPED");
bytes32 salt = keccak256(abi.encodePacked(rootToken));
childToken = createClone(salt, tokenTemplate);
IFxERC20(childToken).initialize(
address(this),
rootToken,
string(abi.encodePacked(name, SUFFIX_NAME)),
string(abi.encodePacked(PREFIX_SYMBOL, symbol)),
decimals
);
rootToChildToken[rootToken] = childToken;
emit TokenMapped(rootToken, childToken);
return childToken;
}
function _syncDeposit(bytes memory syncData) internal {
(address rootToken, address depositor, address to, uint256 amount, bytes memory depositData) = abi.decode(
syncData,
(address, address, address, uint256, bytes)
);
address childToken = rootToChildToken[rootToken];
IFxERC20 childTokenContract = IFxERC20(childToken);
childTokenContract.mint(to, amount);
if (_isContract(to)) {
uint256 txGas = 2000000;
bool success = false;
bytes memory data = abi.encodeWithSignature(
"onTokenTransfer(address,address,address,address,uint256,bytes)",
rootToken,
childToken,
depositor,
to,
amount,
depositData
);
assembly {
success := call(txGas, to, 0, add(data, 0x20), mload(data), 0, 0)
}
}
}
function _withdraw(
address childToken,
address receiver,
uint256 amount
) internal {
IFxERC20 childTokenContract = IFxERC20(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC20ChildTunnel: NO_MAPPED_TOKEN"
);
childTokenContract.burn(msg.sender, amount);
_sendMessageToRoot(abi.encode(rootToken, childToken, receiver, amount));
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
文件 18 的 43：FxERC20RootTunnel.sol
pragma solidity ^0.8.0;
import {ERC20} from "../../lib/ERC20.sol";
import {Create2} from "../../lib/Create2.sol";
import {IRootChainManager} from "../../lib/IRootChainManager.sol";
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract FxERC20RootTunnel is FxBaseRootTunnel, Create2 {
using SafeERC20 for IERC20;
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
bytes32 public immutable childTokenTemplateCodeHash;
IRootChainManager public immutable rootChainManager;
event TokenMappedERC20(address indexed rootToken, address indexed childToken);
event FxWithdrawERC20(
address indexed rootToken,
address indexed childToken,
address indexed userAddress,
uint256 amount
);
event FxDepositERC20(
address indexed rootToken,
address indexed depositor,
address indexed userAddress,
uint256 amount
);
mapping(address => address) public rootToChildTokens;
constructor(
address _checkpointManager,
address _fxRoot,
address _fxERC20Token,
IRootChainManager _rootChainManager
) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
rootChainManager = _rootChainManager;
childTokenTemplateCodeHash = keccak256(minimalProxyCreationCode(_fxERC20Token));
}
function mapToken(address rootToken) public {
require(rootToChildTokens[rootToken] == address(0x0), "FxERC20RootTunnel: ALREADY_MAPPED");
require(rootChainManager.rootToChildToken(rootToken) == address(0x0), "FxERC20RootTunnel: MAPPED_ON_POS");
ERC20 rootTokenContract = ERC20(rootToken);
string memory name = rootTokenContract.name();
string memory symbol = rootTokenContract.symbol();
uint8 decimals = rootTokenContract.decimals();
bytes memory message = abi.encode(MAP_TOKEN, abi.encode(rootToken, name, symbol, decimals));
_sendMessageToChild(message);
bytes32 salt = keccak256(abi.encodePacked(rootToken));
address childToken = computedCreate2Address(salt, childTokenTemplateCodeHash, fxChildTunnel);
rootToChildTokens[rootToken] = childToken;
emit TokenMappedERC20(rootToken, childToken);
}
function deposit(
address rootToken,
address user,
uint256 amount,
bytes memory data
) public {
if (rootToChildTokens[rootToken] == address(0x0)) {
mapToken(rootToken);
}
IERC20(rootToken).safeTransferFrom(
msg.sender,
address(this),
amount
);
bytes memory message = abi.encode(DEPOSIT, abi.encode(rootToken, msg.sender, user, amount, data));
_sendMessageToChild(message);
emit FxDepositERC20(rootToken, msg.sender, user, amount);
}
function _processMessageFromChild(bytes memory data) internal override {
(address rootToken, address childToken, address to, uint256 amount) = abi.decode(
data,
(address, address, address, uint256)
);
require(rootToChildTokens[rootToken] == childToken, "FxERC20RootTunnel: INVALID_MAPPING_ON_EXIT");
IERC20(rootToken).safeTransfer(to, amount);
emit FxWithdrawERC20(rootToken, childToken, to, amount);
}
}
文件 19 的 43：FxERC721.sol
pragma solidity ^0.8.0;
import {ERC721} from "../lib/ERC721.sol";
import {IFxERC721} from "./IFxERC721.sol";
contract FxERC721 is IFxERC721, ERC721 {
address internal _fxManager;
address internal _connectedToken;
function initialize(
address fxManager_,
address connectedToken_,
string memory name_,
string memory symbol_
) public override {
require(_fxManager == address(0x0) && _connectedToken == address(0x0), "Token is already initialized");
_fxManager = fxManager_;
_connectedToken = connectedToken_;
setupMetaData(name_, symbol_);
}
function fxManager() public view override returns (address) {
return _fxManager;
}
function connectedToken() public view override returns (address) {
return _connectedToken;
}
function setupMetaData(string memory _name, string memory _symbol) public {
require(msg.sender == _fxManager, "Invalid sender");
_setupMetaData(_name, _symbol);
}
function mint(
address user,
uint256 tokenId,
bytes memory _data
) public override {
require(msg.sender == _fxManager, "Invalid sender");
_safeMint(user, tokenId, _data);
}
function burn(uint256 tokenId) public override {
require(msg.sender == _fxManager, "Invalid sender");
_burn(tokenId);
}
}
文件 20 的 43：FxERC721ChildTunnel.sol
pragma solidity ^0.8.0;
import {FxBaseChildTunnel} from "../../tunnel/FxBaseChildTunnel.sol";
import {Create2} from "../../lib/Create2.sol";
import {IFxERC721} from "../../tokens/IFxERC721.sol";
import {IERC721Receiver} from "../../lib/IERC721Receiver.sol";
contract FxERC721ChildTunnel is FxBaseChildTunnel, Create2, IERC721Receiver {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
string public constant SUFFIX_NAME = " (FXERC721)";
string public constant PREFIX_SYMBOL = "fx";
event TokenMapped(address indexed rootToken, address indexed childToken);
mapping(address => address) public rootToChildToken;
address public tokenTemplate;
constructor(address _fxChild, address _tokenTemplate) FxBaseChildTunnel(_fxChild) {
tokenTemplate = _tokenTemplate;
require(_isContract(_tokenTemplate), "Token template is not contract");
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
return this.onERC721Received.selector;
}
function withdraw(
address childToken,
uint256 tokenId,
bytes memory data
) external {
_withdraw(childToken, msg.sender, tokenId, data);
}
function withdrawTo(
address childToken,
address receiver,
uint256 tokenId,
bytes memory data
) external {
_withdraw(childToken, receiver, tokenId, data);
}
function _processMessageFromRoot(
uint256,
address sender,
bytes memory data
) internal override validateSender(sender) {
(bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
if (syncType == DEPOSIT) {
_syncDeposit(syncData);
} else if (syncType == MAP_TOKEN) {
_mapToken(syncData);
} else {
revert("FxERC721ChildTunnel: INVALID_SYNC_TYPE");
}
}
function _mapToken(bytes memory syncData) internal returns (address) {
(address rootToken, string memory name, string memory symbol) = abi.decode(syncData, (address, string, string));
address childToken = rootToChildToken[rootToken];
require(childToken == address(0x0), "FxERC721ChildTunnel: ALREADY_MAPPED");
bytes32 salt = keccak256(abi.encodePacked(rootToken));
childToken = createClone(salt, tokenTemplate);
IFxERC721(childToken).initialize(
address(this),
rootToken,
string(abi.encodePacked(name, SUFFIX_NAME)),
string(abi.encodePacked(PREFIX_SYMBOL, symbol))
);
rootToChildToken[rootToken] = childToken;
emit TokenMapped(rootToken, childToken);
return childToken;
}
function _syncDeposit(bytes memory syncData) internal {
(address rootToken, address depositor, address to, uint256 tokenId, bytes memory depositData) = abi.decode(
syncData,
(address, address, address, uint256, bytes)
);
address childToken = rootToChildToken[rootToken];
IFxERC721 childTokenContract = IFxERC721(childToken);
childTokenContract.mint(to, tokenId, depositData);
}
function _withdraw(
address childToken,
address receiver,
uint256 tokenId,
bytes memory data
) internal {
IFxERC721 childTokenContract = IFxERC721(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC721ChildTunnel: NO_MAPPED_TOKEN"
);
require(msg.sender == childTokenContract.ownerOf(tokenId));
childTokenContract.burn(tokenId);
_sendMessageToRoot(abi.encode(rootToken, childToken, receiver, tokenId, data));
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
文件 21 的 43：FxERC721RootTunnel.sol
pragma solidity ^0.8.0;
import {ERC721} from "../../lib/ERC721.sol";
import {Create2} from "../../lib/Create2.sol";
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
import {IERC721Receiver} from "../../lib/IERC721Receiver.sol";
contract FxERC721RootTunnel is FxBaseRootTunnel, Create2, IERC721Receiver {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
event TokenMappedERC721(address indexed rootToken, address indexed childToken);
event FxWithdrawERC721(
address indexed rootToken,
address indexed childToken,
address indexed userAddress,
uint256 id
);
event FxDepositERC721(
address indexed rootToken,
address indexed depositor,
address indexed userAddress,
uint256 id
);
mapping(address => address) public rootToChildTokens;
bytes32 public childTokenTemplateCodeHash;
constructor(
address _checkpointManager,
address _fxRoot,
address _fxERC721Token
) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
childTokenTemplateCodeHash = keccak256(minimalProxyCreationCode(_fxERC721Token));
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
return this.onERC721Received.selector;
}
function mapToken(address rootToken) public {
require(rootToChildTokens[rootToken] == address(0x0), "FxERC721RootTunnel: ALREADY_MAPPED");
ERC721 rootTokenContract = ERC721(rootToken);
string memory name = rootTokenContract.name();
string memory symbol = rootTokenContract.symbol();
bytes memory message = abi.encode(MAP_TOKEN, abi.encode(rootToken, name, symbol));
_sendMessageToChild(message);
bytes32 salt = keccak256(abi.encodePacked(rootToken));
address childToken = computedCreate2Address(salt, childTokenTemplateCodeHash, fxChildTunnel);
rootToChildTokens[rootToken] = childToken;
emit TokenMappedERC721(rootToken, childToken);
}
function deposit(
address rootToken,
address user,
uint256 tokenId,
bytes memory data
) public {
if (rootToChildTokens[rootToken] == address(0x0)) {
mapToken(rootToken);
}
ERC721(rootToken).safeTransferFrom(
msg.sender,
address(this),
tokenId,
data
);
bytes memory message = abi.encode(DEPOSIT, abi.encode(rootToken, msg.sender, user, tokenId, data));
_sendMessageToChild(message);
emit FxDepositERC721(rootToken, msg.sender, user, tokenId);
}
function _processMessageFromChild(bytes memory data) internal override {
(address rootToken, address childToken, address to, uint256 tokenId, bytes memory syncData) = abi.decode(
data,
(address, address, address, uint256, bytes)
);
require(rootToChildTokens[rootToken] == childToken, "FxERC721RootTunnel: INVALID_MAPPING_ON_EXIT");
ERC721(rootToken).safeTransferFrom(address(this), to, tokenId, syncData);
emit FxWithdrawERC721(rootToken, childToken, to, tokenId);
}
}
文件 22 的 43：FxMintableERC20ChildTunnel.sol
pragma solidity ^0.8.0;
import {FxBaseChildTunnel} from "../../tunnel/FxBaseChildTunnel.sol";
import {Create2} from "../../lib/Create2.sol";
import {Ownable} from "../../lib/Ownable.sol";
import {FxERC20} from "../../tokens/FxERC20.sol";
contract FxMintableERC20ChildTunnel is Ownable, FxBaseChildTunnel, Create2 {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
event TokenMapped(address indexed rootToken, address indexed childToken);
mapping(address => address) public rootToChildToken;
address public childTokenTemplate;
bytes32 public rootTokenTemplateCodeHash;
constructor(
address _fxChild,
address _childTokenTemplate,
address _rootTokenTemplate
) FxBaseChildTunnel(_fxChild) {
childTokenTemplate = _childTokenTemplate;
require(_isContract(_childTokenTemplate), "Token template is not contract");
rootTokenTemplateCodeHash = keccak256(minimalProxyCreationCode(_rootTokenTemplate));
}
function deployChildToken(
uint256 uniqueId,
string memory name,
string memory symbol,
uint8 decimals
) public onlyOwner returns (address) {
bytes32 childSalt = keccak256(abi.encodePacked(uniqueId));
address childToken = createClone(childSalt, childTokenTemplate);
bytes32 rootSalt = keccak256(abi.encodePacked(childToken));
address rootToken = computedCreate2Address(rootSalt, rootTokenTemplateCodeHash, fxRootTunnel);
require(rootToChildToken[rootToken] == address(0x0), "FxMintableERC20ChildTunnel: ALREADY_MAPPED");
rootToChildToken[rootToken] = childToken;
emit TokenMapped(rootToken, childToken);
FxERC20(childToken).initialize(address(this), rootToken, name, symbol, decimals);
}
function mintToken(address childToken, uint256 amount) public onlyOwner {
FxERC20 childTokenContract = FxERC20(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC20ChildTunnel: NO_MAPPED_TOKEN"
);
childTokenContract.mint(msg.sender, amount);
}
function withdraw(address childToken, uint256 amount) public {
FxERC20 childTokenContract = FxERC20(childToken);
address rootToken = childTokenContract.connectedToken();
require(
childToken != address(0x0) && rootToken != address(0x0) && childToken == rootToChildToken[rootToken],
"FxERC20ChildTunnel: NO_MAPPED_TOKEN"
);
childTokenContract.burn(msg.sender, amount);
FxERC20 rootTokenContract = FxERC20(childToken);
string memory name = rootTokenContract.name();
string memory symbol = rootTokenContract.symbol();
uint8 decimals = rootTokenContract.decimals();
bytes memory metaData = abi.encode(name, symbol, decimals);
_sendMessageToRoot(abi.encode(rootToken, childToken, msg.sender, amount, metaData));
}
function _processMessageFromRoot(
uint256,
address sender,
bytes memory data
) internal override validateSender(sender) {
(bytes32 syncType, bytes memory syncData) = abi.decode(data, (bytes32, bytes));
if (syncType == DEPOSIT) {
_syncDeposit(syncData);
} else {
revert("FxERC20ChildTunnel: INVALID_SYNC_TYPE");
}
}
function _syncDeposit(bytes memory syncData) internal {
(address rootToken, address depositor, address to, uint256 amount, bytes memory depositData) = abi.decode(
syncData,
(address, address, address, uint256, bytes)
);
address childToken = rootToChildToken[rootToken];
FxERC20 childTokenContract = FxERC20(childToken);
childTokenContract.mint(to, amount);
if (_isContract(to)) {
uint256 txGas = 2000000;
bool success = false;
bytes memory data = abi.encodeWithSignature(
"onTokenTransfer(address,address,address,address,uint256,bytes)",
rootToken,
childToken,
depositor,
to,
amount,
depositData
);
assembly {
success := call(txGas, to, 0, add(data, 0x20), mload(data), 0, 0)
}
}
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
文件 23 的 43：FxMintableERC20RootTunnel.sol
pragma solidity ^0.8.0;
import {Create2} from "../../lib/Create2.sol";
import {SafeMath} from "../../lib/SafeMath.sol";
import {FxERC20} from "../../tokens/FxERC20.sol";
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract FxMintableERC20RootTunnel is FxBaseRootTunnel, Create2 {
using SafeMath for uint256;
using SafeERC20 for IERC20;
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
mapping(address => address) public rootToChildTokens;
address public rootTokenTemplate;
bytes32 public childTokenTemplateCodeHash;
constructor(
address _checkpointManager,
address _fxRoot,
address _rootTokenTemplate
) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
rootTokenTemplate = _rootTokenTemplate;
}
function deposit(
address rootToken,
address user,
uint256 amount,
bytes memory data
) public {
require(rootToChildTokens[rootToken] != address(0x0), "FxMintableERC20RootTunnel: NO_MAPPING_FOUND");
IERC20(rootToken).safeTransferFrom(
msg.sender,
address(this),
amount
);
bytes memory message = abi.encode(DEPOSIT, abi.encode(rootToken, msg.sender, user, amount, data));
_sendMessageToChild(message);
}
function _processMessageFromChild(bytes memory data) internal override {
(address rootToken, address childToken, address to, uint256 amount, bytes memory metaData) = abi.decode(
data,
(address, address, address, uint256, bytes)
);
if (!_isContract(rootToken) && rootToChildTokens[rootToken] == address(0x0)) {
(string memory name, string memory symbol, uint8 decimals) = abi.decode(metaData, (string, string, uint8));
address _createdToken = _deployRootToken(childToken, name, symbol, decimals);
require(_createdToken == rootToken, "FxMintableERC20RootTunnel: ROOT_TOKEN_CREATION_MISMATCH");
}
require(rootToChildTokens[rootToken] == childToken, "FxERC20RootTunnel: INVALID_MAPPING_ON_EXIT");
FxERC20 tokenObj = FxERC20(rootToken);
uint256 balanceOf = tokenObj.balanceOf(address(this));
if (balanceOf < amount) {
tokenObj.mint(address(this), amount.sub(balanceOf));
}
tokenObj.approve(address(this), amount);
IERC20(rootToken).safeTransferFrom(address(this), to, amount);
}
function _deployRootToken(
address childToken,
string memory name,
string memory symbol,
uint8 decimals
) internal returns (address) {
bytes32 salt = keccak256(abi.encodePacked(childToken));
address rootToken = createClone(salt, rootTokenTemplate);
FxERC20(rootToken).initialize(address(this), rootToken, name, symbol, decimals);
rootToChildTokens[rootToken] = childToken;
return rootToken;
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
}
文件 24 的 43：FxStateChildTunnel.sol
pragma solidity ^0.8.0;
import {FxBaseChildTunnel} from "../../tunnel/FxBaseChildTunnel.sol";
contract FxStateChildTunnel is FxBaseChildTunnel {
uint256 public latestStateId;
address public latestRootMessageSender;
bytes public latestData;
constructor(address _fxChild) FxBaseChildTunnel(_fxChild) {}
function _processMessageFromRoot(
uint256 stateId,
address sender,
bytes memory data
) internal override validateSender(sender) {
latestStateId = stateId;
latestRootMessageSender = sender;
latestData = data;
}
function sendMessageToRoot(bytes memory message) public {
_sendMessageToRoot(message);
}
}
文件 25 的 43：FxStateRootTunnel.sol
pragma solidity ^0.8.0;
import {FxBaseRootTunnel} from "../../tunnel/FxBaseRootTunnel.sol";
contract FxStateRootTunnel is FxBaseRootTunnel {
bytes public latestData;
constructor(address _checkpointManager, address _fxRoot) FxBaseRootTunnel(_checkpointManager, _fxRoot) {}
function _processMessageFromChild(bytes memory data) internal override {
latestData = data;
}
function sendMessageToChild(bytes memory message) public {
_sendMessageToChild(message);
}
}
文件 26 的 43：IERC1155.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 27 的 43：IERC1155MetadataURI.sol
pragma solidity ^0.8.0;
import "./IERC1155.sol";
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
文件 28 的 43：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 29 的 43：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 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);
}
文件 30 的 43：IERC721.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
文件 31 的 43：IERC721Metadata.sol
pragma solidity ^0.8.0;
import "./IERC721.sol";
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
文件 32 的 43：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 33 的 43：IFxERC1155.sol
pragma solidity ^0.8.0;
import {IERC1155} from "../lib/IERC1155.sol";
interface IFxERC1155 is IERC1155 {
function fxManager() external returns (address);
function initialize(
address fxManager_,
address connectedToken_,
string memory uri_
) external;
function connectedToken() external returns (address);
function mint(
address user,
uint256 id,
uint256 amount,
bytes memory data
) external;
function mintBatch(
address user,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) external;
function burn(
address user,
uint256 id,
uint256 amount
) external;
function burnBatch(
address user,
uint256[] memory ids,
uint256[] memory amounts
) external;
}
文件 34 的 43：IFxERC20.sol
pragma solidity ^0.8.0;
import {IERC20} from "../lib/IERC20.sol";
interface IFxERC20 is IERC20 {
function fxManager() external returns (address);
function connectedToken() external returns (address);
function initialize(
address _fxManager,
address _connectedToken,
string memory _name,
string memory _symbol,
uint8 _decimals
) external;
function mint(address user, uint256 amount) external;
function burn(address user, uint256 amount) external;
}
文件 35 的 43：IFxERC721.sol
pragma solidity ^0.8.0;
import {IERC721} from "../lib/IERC721.sol";
interface IFxERC721 is IERC721 {
function fxManager() external returns (address);
function connectedToken() external returns (address);
function initialize(
address _fxManager,
address _connectedToken,
string memory _name,
string memory _symbol
) external;
function mint(
address user,
uint256 tokenId,
bytes memory _data
) external;
function burn(uint256 tokenId) external;
}
文件 36 的 43：IRootChainManager.sol
pragma solidity ^0.8.0;
interface IRootChainManager {
function rootToChildToken(address _rootToken) external returns (address);
}
文件 37 的 43：Merkle.sol
pragma solidity ^0.8.0;
library Merkle {
function checkMembership(
bytes32 leaf,
uint256 index,
bytes32 rootHash,
bytes memory proof
) internal pure returns (bool) {
require(proof.length % 32 == 0, "Invalid proof length");
uint256 proofHeight = proof.length / 32;
require(index < 2**proofHeight, "Leaf index is too big");
bytes32 proofElement;
bytes32 computedHash = leaf;
for (uint256 i = 32; i <= proof.length; i += 32) {
assembly {
proofElement := mload(add(proof, i))
}
if (index % 2 == 0) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
index = index / 2;
}
return computedHash == rootHash;
}
}
文件 38 的 43：MerklePatriciaProof.sol
pragma solidity ^0.8.0;
import {RLPReader} from "./RLPReader.sol";
library MerklePatriciaProof {
function verify(
bytes memory value,
bytes memory encodedPath,
bytes memory rlpParentNodes,
bytes32 root
) internal pure returns (bool) {
RLPReader.RLPItem memory item = RLPReader.toRlpItem(rlpParentNodes);
RLPReader.RLPItem[] memory parentNodes = RLPReader.toList(item);
bytes memory currentNode;
RLPReader.RLPItem[] memory currentNodeList;
bytes32 nodeKey = root;
uint256 pathPtr = 0;
bytes memory path = _getNibbleArray(encodedPath);
if (path.length == 0) {
return false;
}
for (uint256 i = 0; i < parentNodes.length; i++) {
if (pathPtr > path.length) {
return false;
}
currentNode = RLPReader.toRlpBytes(parentNodes[i]);
if (nodeKey != keccak256(currentNode)) {
return false;
}
currentNodeList = RLPReader.toList(parentNodes[i]);
if (currentNodeList.length == 17) {
if (pathPtr == path.length) {
if (keccak256(RLPReader.toBytes(currentNodeList[16])) == keccak256(value)) {
return true;
} else {
return false;
}
}
uint8 nextPathNibble = uint8(path[pathPtr]);
if (nextPathNibble > 16) {
return false;
}
nodeKey = bytes32(RLPReader.toUintStrict(currentNodeList[nextPathNibble]));
pathPtr += 1;
} else if (currentNodeList.length == 2) {
uint256 traversed = _nibblesToTraverse(RLPReader.toBytes(currentNodeList[0]), path, pathPtr);
if (pathPtr + traversed == path.length) {
if (keccak256(RLPReader.toBytes(currentNodeList[1])) == keccak256(value)) {
return true;
} else {
return false;
}
}
if (traversed == 0) {
return false;
}
pathPtr += traversed;
nodeKey = bytes32(RLPReader.toUintStrict(currentNodeList[1]));
} else {
return false;
}
}
}
function _nibblesToTraverse(
bytes memory encodedPartialPath,
bytes memory path,
uint256 pathPtr
) private pure returns (uint256) {
uint256 len = 0;
bytes memory partialPath = _getNibbleArray(encodedPartialPath);
bytes memory slicedPath = new bytes(partialPath.length);
for (uint256 i = pathPtr; i < pathPtr + partialPath.length; i++) {
bytes1 pathNibble = path[i];
slicedPath[i - pathPtr] = pathNibble;
}
if (keccak256(partialPath) == keccak256(slicedPath)) {
len = partialPath.length;
} else {
len = 0;
}
return len;
}
function _getNibbleArray(bytes memory b) internal pure returns (bytes memory) {
bytes memory nibbles = "";
if (b.length > 0) {
uint8 offset;
uint8 hpNibble = uint8(_getNthNibbleOfBytes(0, b));
if (hpNibble == 1 || hpNibble == 3) {
nibbles = new bytes(b.length * 2 - 1);
bytes1 oddNibble = _getNthNibbleOfBytes(1, b);
nibbles[0] = oddNibble;
offset = 1;
} else {
nibbles = new bytes(b.length * 2 - 2);
offset = 0;
}
for (uint256 i = offset; i < nibbles.length; i++) {
nibbles[i] = _getNthNibbleOfBytes(i - offset + 2, b);
}
}
return nibbles;
}
function _getNthNibbleOfBytes(uint256 n, bytes memory str) private pure returns (bytes1) {
return bytes1(n % 2 == 0 ? uint8(str[n / 2]) / 0x10 : uint8(str[n / 2]) % 0x10);
}
}
文件 39 的 43：Ownable.sol
pragma solidity ^0.8.0;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
文件 40 的 43：RLPReader.sol
pragma solidity ^0.8.0;
library RLPReader {
uint8 constant STRING_SHORT_START = 0x80;
uint8 constant STRING_LONG_START = 0xb8;
uint8 constant LIST_SHORT_START = 0xc0;
uint8 constant LIST_LONG_START = 0xf8;
uint8 constant WORD_SIZE = 32;
struct RLPItem {
uint256 len;
uint256 memPtr;
}
struct Iterator {
RLPItem item;
uint256 nextPtr;
}
function next(Iterator memory self) internal pure returns (RLPItem memory) {
require(hasNext(self));
uint256 ptr = self.nextPtr;
uint256 itemLength = _itemLength(ptr);
self.nextPtr = ptr + itemLength;
return RLPItem(itemLength, ptr);
}
function hasNext(Iterator memory self) internal pure returns (bool) {
RLPItem memory item = self.item;
return self.nextPtr < item.memPtr + item.len;
}
function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
uint256 memPtr;
assembly {
memPtr := add(item, 0x20)
}
return RLPItem(item.length, memPtr);
}
function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
require(isList(self));
uint256 ptr = self.memPtr + _payloadOffset(self.memPtr);
return Iterator(self, ptr);
}
function rlpLen(RLPItem memory item) internal pure returns (uint256) {
return item.len;
}
function payloadLen(RLPItem memory item) internal pure returns (uint256) {
return item.len - _payloadOffset(item.memPtr);
}
function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
require(isList(item));
uint256 items = numItems(item);
RLPItem[] memory result = new RLPItem[](items);
uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
uint256 dataLen;
for (uint256 i = 0; i < items; i++) {
dataLen = _itemLength(memPtr);
result[i] = RLPItem(dataLen, memPtr);
memPtr = memPtr + dataLen;
}
return result;
}
function isList(RLPItem memory item) internal pure returns (bool) {
if (item.len == 0) return false;
uint8 byte0;
uint256 memPtr = item.memPtr;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < LIST_SHORT_START) return false;
return true;
}
function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
uint256 ptr = item.memPtr;
uint256 len = item.len;
bytes32 result;
assembly {
result := keccak256(ptr, len)
}
return result;
}
function payloadLocation(RLPItem memory item) internal pure returns (uint256, uint256) {
uint256 offset = _payloadOffset(item.memPtr);
uint256 memPtr = item.memPtr + offset;
uint256 len = item.len - offset;
return (memPtr, len);
}
function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
(uint256 memPtr, uint256 len) = payloadLocation(item);
bytes32 result;
assembly {
result := keccak256(memPtr, len)
}
return result;
}
function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
bytes memory result = new bytes(item.len);
if (result.length == 0) return result;
uint256 ptr;
assembly {
ptr := add(0x20, result)
}
copy(item.memPtr, ptr, item.len);
return result;
}
function toBoolean(RLPItem memory item) internal pure returns (bool) {
require(item.len == 1);
uint256 result;
uint256 memPtr = item.memPtr;
assembly {
result := byte(0, mload(memPtr))
}
return result == 0 ? false : true;
}
function toAddress(RLPItem memory item) internal pure returns (address) {
require(item.len == 21);
return address(uint160(toUint(item)));
}
function toUint(RLPItem memory item) internal pure returns (uint256) {
require(item.len > 0 && item.len <= 33);
uint256 offset = _payloadOffset(item.memPtr);
uint256 len = item.len - offset;
uint256 result;
uint256 memPtr = item.memPtr + offset;
assembly {
result := mload(memPtr)
if lt(len, 32) {
result := div(result, exp(256, sub(32, len)))
}
}
return result;
}
function toUintStrict(RLPItem memory item) internal pure returns (uint256) {
require(item.len == 33);
uint256 result;
uint256 memPtr = item.memPtr + 1;
assembly {
result := mload(memPtr)
}
return result;
}
function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
require(item.len > 0);
uint256 offset = _payloadOffset(item.memPtr);
uint256 len = item.len - offset;
bytes memory result = new bytes(len);
uint256 destPtr;
assembly {
destPtr := add(0x20, result)
}
copy(item.memPtr + offset, destPtr, len);
return result;
}
function numItems(RLPItem memory item) private pure returns (uint256) {
if (item.len == 0) return 0;
uint256 count = 0;
uint256 currPtr = item.memPtr + _payloadOffset(item.memPtr);
uint256 endPtr = item.memPtr + item.len;
while (currPtr < endPtr) {
currPtr = currPtr + _itemLength(currPtr);
count++;
}
return count;
}
function _itemLength(uint256 memPtr) private pure returns (uint256) {
uint256 itemLen;
uint256 byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START) itemLen = 1;
else if (byte0 < STRING_LONG_START) itemLen = byte0 - STRING_SHORT_START + 1;
else if (byte0 < LIST_SHORT_START) {
assembly {
let byteLen := sub(byte0, 0xb7)
memPtr := add(memPtr, 1)
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen)))
itemLen := add(dataLen, add(byteLen, 1))
}
} else if (byte0 < LIST_LONG_START) {
itemLen = byte0 - LIST_SHORT_START + 1;
} else {
assembly {
let byteLen := sub(byte0, 0xf7)
memPtr := add(memPtr, 1)
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen)))
itemLen := add(dataLen, add(byteLen, 1))
}
}
return itemLen;
}
function _payloadOffset(uint256 memPtr) private pure returns (uint256) {
uint256 byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START) return 0;
else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) return 1;
else if (byte0 < LIST_SHORT_START)
return byte0 - (STRING_LONG_START - 1) + 1;
else return byte0 - (LIST_LONG_START - 1) + 1;
}
function copy(
uint256 src,
uint256 dest,
uint256 len
) private pure {
if (len == 0) return;
for (; len >= WORD_SIZE; len -= WORD_SIZE) {
assembly {
mstore(dest, mload(src))
}
src += WORD_SIZE;
dest += WORD_SIZE;
}
if (len == 0) return;
uint256 mask = 256**(WORD_SIZE - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
}
文件 41 的 43：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");
}
}
}
文件 42 的 43：SafeMath.sol
pragma solidity ^0.8.0;
library SafeMath {
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
文件 43 的 43：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant alphabet = "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] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
