컴파일러
0.8.2+commit.661d1103
파일 1 / 14 : Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
파일 2 / 14 : ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
파일 3 / 14 : IERC1271.sol
pragma solidity ^0.8.0;
interface IERC1271 {
function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4 magicValue);
}파일 4 / 14 : IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
파일 5 / 14 : IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
파일 6 / 14 : IZkLink.sol
pragma solidity ^0.8.0;
interface IZkLink {
struct RegisteredToken {
bool registered;
bool paused;
address tokenAddress;
uint8 decimals;
}
function acceptETH(
address payable receiver,
uint128 amount,
uint16 withdrawFeeRate,
uint32 accountIdOfNonce,
uint8 subAccountIdOfNonce,
uint32 nonce
) external payable;
function acceptERC20(
address receiver,
address token,
uint128 amount,
uint16 withdrawFeeRate,
uint32 accountIdOfNonce,
uint8 subAccountIdOfNonce,
uint32 nonce
) external;
function withdrawToL1(
address owner,
address token,
uint128 amount,
uint16 fastWithdrawFeeRate,
uint32 accountIdOfNonce,
uint8 subAccountIdOfNonce,
uint32 nonce
) external payable;
function tokens(
uint16 tokenId
) external view returns (RegisteredToken memory);
function tokenIds(
address token
) external view returns (uint16 tokenId);
function getPendingBalance(
bytes32 _address,
uint16 _tokenId
) external view returns (uint128);
function withdrawPendingBalance(
address payable _owner,
uint16 _tokenId,
uint128 _amount
) external returns (uint128);
}
파일 7 / 14 : Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
파일 8 / 14 : ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
파일 9 / 14 : SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "16");
return uint128(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "17");
return uint64(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "18");
return uint32(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "19");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "1a");
return uint8(value);
}
}파일 10 / 14 : SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
파일 11 / 14 : SafeMath.sol
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
파일 12 / 14 : SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
파일 13 / 14 : Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
파일 14 / 14 : ZklinkFastPool.sol
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "../interfaces/IERC1271.sol";
import '../interfaces/IZkLink.sol';
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./SafeCast.sol";
contract ZklinkFastPool is ReentrancyGuard,IERC1271 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
uint16 internal constant MAX_ACCEPT_FEE_RATE = 10000;
uint8 internal constant TOKEN_DECIMALS_OF_LAYER2 = 18;
bytes4 public constant ACCEPT_ETH =
bytes4(
keccak256(bytes('acceptETH(address,uint128,uint16,uint32,uint8,uint32)'))
);
bytes4 public constant ACCEPT_ERC20 =
bytes4(
keccak256(
bytes('acceptERC20(address,address,uint128,uint16,uint32,uint8,uint32)')
)
);
event WithdrawETH(uint256 orderId, address to, uint256 amount);
event WithdrawERC20(uint256 orderId, address token, address to, uint256 amount);
event FastTransferErc20(uint256 orderId, address token, address to, uint256 amount);
event FastTransferETH(uint256 orderId, address token, address to, uint256 amount);
event Claim(address token, address to, uint256 amount);
address[] public signers;
mapping(uint256 => order) orders;
address public ZKLINK_ADDRESS;
IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
IERC20 private constant ZERO_ADDRESS = IERC20(address(0));
struct order{
address to;
uint256 amount;
address token;
bool executed;
}
struct fastParams{
address receiver;
address token;
uint128 amount;
uint16 withdrawFeeRate;
uint32 accountIdOfNonce;
uint8 subAccountIdOfNonce;
uint32 nonce;
}
constructor(address[] memory allowedSigners,address zklink) {
require(allowedSigners.length == 3, "invalid allSigners length");
require(allowedSigners[0] != allowedSigners[1], "must be different signers");
require(allowedSigners[0] != allowedSigners[2], "must be different signers");
require(allowedSigners[1] != allowedSigners[2], "must be different signers");
signers = allowedSigners;
ZKLINK_ADDRESS = zklink;
}
receive() external payable { }
fallback() external payable {}
function withdrawETH(
address payable to,
uint256 amount,
uint256 expireTime,
uint256 orderId,
address[] memory allSigners,
bytes[] memory signatures
) public nonReentrant {
require(allSigners.length >= 2, "invalid allSigners length");
require(allSigners.length == signatures.length, "invalid signatures length");
require(allSigners[0] != allSigners[1],"can not be same signer");
require(expireTime >= block.timestamp,"expired transaction");
bytes32 operationHash = keccak256(abi.encodePacked("ETHER", to, amount, expireTime, orderId, address(this),block.chainid));
operationHash = ECDSA.toEthSignedMessageHash(operationHash);
for (uint8 index = 0; index < allSigners.length; index++) {
address signer = ECDSA.recover(operationHash, signatures[index]);
require(signer == allSigners[index], "invalid signer");
require(isAllowedSigner(signer), "not allowed signer");
}
tryInsertOrderId(orderId, to, amount, address(0));
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = to.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
emit WithdrawETH(orderId, to, amount);
}
function withdrawErc20(
address to,
uint256 amount,
address token,
uint256 expireTime,
uint256 orderId,
address[] memory allSigners,
bytes[] memory signatures
) public nonReentrant {
require(allSigners.length >=2, "invalid allSigners length");
require(allSigners.length == signatures.length, "invalid signatures length");
require(allSigners[0] != allSigners[1],"can not be same signer");
require(expireTime >= block.timestamp,"expired transaction");
bytes32 operationHash = keccak256(abi.encodePacked("ERC20", to, amount, token, expireTime, orderId, address(this),block.chainid));
operationHash = ECDSA.toEthSignedMessageHash(operationHash);
for (uint8 index = 0; index < allSigners.length; index++) {
address signer = ECDSA.recover(operationHash, signatures[index]);
require(signer == allSigners[index], "invalid signer");
require(isAllowedSigner(signer),"not allowed signer");
}
tryInsertOrderId(orderId, to, amount, token);
IERC20(token).safeTransfer(to, amount);
emit WithdrawERC20(orderId, token, to, amount);
}
function fastTransferErc20(
address to,
uint256 orderId,
uint256 expireTime,
fastParams memory params,
bytes memory transferData,
address[] memory allSigners,
bytes[] memory signatures,
bool autlClaim
) public nonReentrant {
require(to == ZKLINK_ADDRESS,"invalid zklink address");
require(allSigners.length >=2, "invalid allSigners length");
require(allSigners.length == signatures.length, "invalid signatures length");
require(allSigners[0] != allSigners[1],"can not be same signer");
require(expireTime >= block.timestamp,"expired transaction");
require(params.withdrawFeeRate < MAX_ACCEPT_FEE_RATE, "invalid fee rate");
bytes32 operationHash = keccak256(abi.encodePacked("FAST-ERC20",to,orderId,expireTime,transferData,address(this),block.chainid));
operationHash = ECDSA.toEthSignedMessageHash(operationHash);
for (uint8 index = 0; index < allSigners.length; index++) {
address signer = ECDSA.recover(operationHash, signatures[index]);
require(signer == allSigners[index], "invalid signer");
require(isAllowedSigner(signer),"not allowed signer");
}
tryInsertOrderId(orderId, to, params.amount, params.token);
IERC20(params.token).safeApprove(ZKLINK_ADDRESS, 0);
IERC20(params.token).safeApprove(ZKLINK_ADDRESS, params.amount);
require(IERC20(params.token).balanceOf(address(this)) >= params.amount, "Address: insufficient balance");
(bool success, ) = to.call{value: 0}(transferData);
require(success, "Address: unable to send value, recipient may have reverted");
emit FastTransferErc20(orderId, params.token, to, params.amount);
if (autlClaim){
uint16 tokenId = IZkLink(to).tokenIds(params.token);
uint128 pendingBalance = IZkLink(to).getPendingBalance(bytes32(uint256(uint160(address(this)))),tokenId);
if (pendingBalance > 0 ){
IZkLink.RegisteredToken memory rt = IZkLink(to).tokens(tokenId);
uint128 actualPendingBalance = pendingBalance / SafeCast.toUint128((10 ** (TOKEN_DECIMALS_OF_LAYER2 - rt.decimals)));
IZkLink(to).withdrawPendingBalance(payable(address(this)), tokenId, actualPendingBalance);
emit Claim(params.token,address(this),actualPendingBalance);
}
}
}
function fastTransferETH(
address to,
uint256 orderId,
uint256 expireTime,
fastParams memory params,
bytes memory transferData,
address[] memory allSigners,
bytes[] memory signatures,
bool autlClaim
) public nonReentrant {
require(to == ZKLINK_ADDRESS,"invalid zklink address");
require(params.token == address(ETH_ADDRESS),"invalid params token");
require(allSigners.length >=2, "invalid allSigners length");
require(allSigners.length == signatures.length, "invalid signatures length");
require(allSigners[0] != allSigners[1],"can not be same signer");
require(expireTime >= block.timestamp,"expired transaction");
require(params.withdrawFeeRate < MAX_ACCEPT_FEE_RATE, "invalid fee rate");
bytes32 operationHash = keccak256(abi.encodePacked("FAST-ETH",to, orderId, expireTime,transferData, address(this), block.chainid));
operationHash = ECDSA.toEthSignedMessageHash(operationHash);
for (uint8 index = 0; index < allSigners.length; index++) {
address signer = ECDSA.recover(operationHash, signatures[index]);
require(signer == allSigners[index], "invalid signer");
require(isAllowedSigner(signer),"not allowed signer");
}
tryInsertOrderId(orderId, to, params.amount, params.token);
require(address(this).balance >= params.amount, "Address: insufficient balance");
(bool success, ) = to.call{value: params.amount}(transferData);
require(success, "Address: unable to send value, recipient may have reverted");
emit FastTransferETH(orderId, params.token, to, params.amount);
if (autlClaim){
uint16 tokenId = IZkLink(to).tokenIds(params.token);
uint128 pendingBalance = IZkLink(to).getPendingBalance(bytes32(uint256(uint160(address(this)))),tokenId);
if (pendingBalance > 0){
IZkLink(to).withdrawPendingBalance(payable(address(this)), tokenId, pendingBalance);
emit Claim(params.token,address(this),pendingBalance);
}
}
}
function claimFromZklink(
address owner,
uint16 tokenId,
uint128 amount
) public nonReentrant {
uint128 pendingBalance = IZkLink(ZKLINK_ADDRESS).getPendingBalance(bytes32(uint256(uint160(owner))),tokenId);
IZkLink.RegisteredToken memory rt = IZkLink(ZKLINK_ADDRESS).tokens(tokenId);
uint128 actualPendingBalance = pendingBalance / SafeCast.toUint128((10 ** (TOKEN_DECIMALS_OF_LAYER2 - rt.decimals)));
require(amount > 0 && amount <= actualPendingBalance, "invalid amount");
IZkLink(ZKLINK_ADDRESS).withdrawPendingBalance(payable(owner), tokenId, amount);
emit Claim(IZkLink(ZKLINK_ADDRESS).tokens(tokenId).tokenAddress,owner,amount);
}
function isAllowedSigner(address signer) public view returns (bool) {
for (uint i = 0; i < signers.length; i++) {
if (signers[i] == signer) {
return true;
}
}
return false;
}
function isValidSignature(
bytes32 _hash,
bytes calldata _signature
) external override view returns (bytes4) {
address signer = ECDSA.recover(_hash, _signature);
if (signer == signers[0]) {
return 0x1626ba7e;
} else {
return 0xffffffff;
}
}
function tryInsertOrderId(
uint256 orderId,
address to,
uint256 amount,
address token
) internal {
if (orders[orderId].executed) {
revert("repeated order");
}
orders[orderId].executed = true;
orders[orderId].to = to;
orders[orderId].amount = amount;
orders[orderId].token = token;
}
function calcSigHash(
address to,
uint256 amount,
address token,
uint256 expireTime,
uint256 orderId,
bool isFast,
bytes memory transferData
) public view returns (bytes32) {
bytes32 operationHash;
if (isFast) {
if (token == address(ETH_ADDRESS)){
operationHash = keccak256(abi.encodePacked("FAST-ETH",to, orderId, expireTime,transferData, address(this), block.chainid));
}else{
operationHash = keccak256(abi.encodePacked("FAST-ERC20",to,orderId,expireTime,transferData,address(this),block.chainid));
}
} else if (token == address(0)) {
operationHash = keccak256(abi.encodePacked("ETHER", to, amount, expireTime, orderId, address(this),block.chainid));
} else {
operationHash = keccak256(abi.encodePacked("ERC20", to, amount, token, expireTime, orderId, address(this),block.chainid));
}
return operationHash;
}
function calcFastData(
address token,
fastParams memory params
) public pure returns (bytes memory) {
if (token == address(ETH_ADDRESS)){
return abi.encodePacked(ACCEPT_ETH,params.receiver,params.amount,params.withdrawFeeRate,params.accountIdOfNonce,params.subAccountIdOfNonce,params.nonce);
}
return abi.encodePacked(ACCEPT_ERC20,params.receiver,params.token,params.amount,params.withdrawFeeRate,params.accountIdOfNonce,params.subAccountIdOfNonce,params.nonce);
}
function getPendingBalance(uint16 tokenId) public view returns (bytes32,uint128) {
bytes32 paddingAddress = bytes32(uint256(uint160(address(this))));
uint128 pendingBalance = IZkLink(ZKLINK_ADDRESS).getPendingBalance(paddingAddress,tokenId);
return (paddingAddress,pendingBalance);
}
}{
"compilationTarget": {
"contracts/core/ZklinkFastPool.sol": "ZklinkFastPool"
},
"evmVersion": "istanbul",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": false,
"runs": 200
},
"remappings": []
}[{"inputs":[{"internalType":"address[]","name":"allowedSigners","type":"address[]"},{"internalType":"address","name":"zklink","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FastTransferETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FastTransferErc20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawETH","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"ACCEPT_ERC20","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACCEPT_ETH","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ZKLINK_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint16","name":"withdrawFeeRate","type":"uint16"},{"internalType":"uint32","name":"accountIdOfNonce","type":"uint32"},{"internalType":"uint8","name":"subAccountIdOfNonce","type":"uint8"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"internalType":"struct ZklinkFastPool.fastParams","name":"params","type":"tuple"}],"name":"calcFastData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"expireTime","type":"uint256"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"bool","name":"isFast","type":"bool"},{"internalType":"bytes","name":"transferData","type":"bytes"}],"name":"calcSigHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"claimFromZklink","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"uint256","name":"expireTime","type":"uint256"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint16","name":"withdrawFeeRate","type":"uint16"},{"internalType":"uint32","name":"accountIdOfNonce","type":"uint32"},{"internalType":"uint8","name":"subAccountIdOfNonce","type":"uint8"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"internalType":"struct ZklinkFastPool.fastParams","name":"params","type":"tuple"},{"internalType":"bytes","name":"transferData","type":"bytes"},{"internalType":"address[]","name":"allSigners","type":"address[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"},{"internalType":"bool","name":"autlClaim","type":"bool"}],"name":"fastTransferETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"uint256","name":"expireTime","type":"uint256"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint16","name":"withdrawFeeRate","type":"uint16"},{"internalType":"uint32","name":"accountIdOfNonce","type":"uint32"},{"internalType":"uint8","name":"subAccountIdOfNonce","type":"uint8"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"internalType":"struct ZklinkFastPool.fastParams","name":"params","type":"tuple"},{"internalType":"bytes","name":"transferData","type":"bytes"},{"internalType":"address[]","name":"allSigners","type":"address[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"},{"internalType":"bool","name":"autlClaim","type":"bool"}],"name":"fastTransferErc20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"getPendingBalance","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"isAllowedSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"signers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"expireTime","type":"uint256"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"address[]","name":"allSigners","type":"address[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"expireTime","type":"uint256"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"address[]","name":"allSigners","type":"address[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"}],"name":"withdrawErc20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
