File 1 of 1: AggregationRouterV6.mainnet.sol
pragma solidity 0.8.23;
type MakerTraits is uint256;
library MakerTraitsLib {
uint256 private constant _ALLOWED_SENDER_MASK = type(uint80).max;
uint256 private constant _EXPIRATION_OFFSET = 80;
uint256 private constant _EXPIRATION_MASK = type(uint40).max;
uint256 private constant _NONCE_OR_EPOCH_OFFSET = 120;
uint256 private constant _NONCE_OR_EPOCH_MASK = type(uint40).max;
uint256 private constant _SERIES_OFFSET = 160;
uint256 private constant _SERIES_MASK = type(uint40).max;
uint256 private constant _NO_PARTIAL_FILLS_FLAG = 1 << 255;
uint256 private constant _ALLOW_MULTIPLE_FILLS_FLAG = 1 << 254;
uint256 private constant _PRE_INTERACTION_CALL_FLAG = 1 << 252;
uint256 private constant _POST_INTERACTION_CALL_FLAG = 1 << 251;
uint256 private constant _NEED_CHECK_EPOCH_MANAGER_FLAG = 1 << 250;
uint256 private constant _HAS_EXTENSION_FLAG = 1 << 249;
uint256 private constant _USE_PERMIT2_FLAG = 1 << 248;
uint256 private constant _UNWRAP_WETH_FLAG = 1 << 247;
function hasExtension(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _HAS_EXTENSION_FLAG) != 0;
}
function isAllowedSender(MakerTraits makerTraits, address sender) internal pure returns (bool) {
uint160 allowedSender = uint160(MakerTraits.unwrap(makerTraits) & _ALLOWED_SENDER_MASK);
return allowedSender == 0 || allowedSender == uint160(sender) & _ALLOWED_SENDER_MASK;
}
function isExpired(MakerTraits makerTraits) internal view returns (bool) {
uint256 expiration = (MakerTraits.unwrap(makerTraits) >> _EXPIRATION_OFFSET) & _EXPIRATION_MASK;
return expiration != 0 && expiration < block.timestamp;
}
function nonceOrEpoch(MakerTraits makerTraits) internal pure returns (uint256) {
return (MakerTraits.unwrap(makerTraits) >> _NONCE_OR_EPOCH_OFFSET) & _NONCE_OR_EPOCH_MASK;
}
function series(MakerTraits makerTraits) internal pure returns (uint256) {
return (MakerTraits.unwrap(makerTraits) >> _SERIES_OFFSET) & _SERIES_MASK;
}
function allowPartialFills(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _NO_PARTIAL_FILLS_FLAG) == 0;
}
function needPreInteractionCall(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _PRE_INTERACTION_CALL_FLAG) != 0;
}
function needPostInteractionCall(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _POST_INTERACTION_CALL_FLAG) != 0;
}
function allowMultipleFills(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _ALLOW_MULTIPLE_FILLS_FLAG) != 0;
}
function useBitInvalidator(MakerTraits makerTraits) internal pure returns (bool) {
return !allowPartialFills(makerTraits) || !allowMultipleFills(makerTraits);
}
function needCheckEpochManager(MakerTraits makerTraits) internal pure returns (bool) {
return (MakerTraits.unwrap(makerTraits) & _NEED_CHECK_EPOCH_MANAGER_FLAG) != 0;
}
function usePermit2(MakerTraits makerTraits) internal pure returns (bool) {
return MakerTraits.unwrap(makerTraits) & _USE_PERMIT2_FLAG != 0;
}
function unwrapWeth(MakerTraits makerTraits) internal pure returns (bool) {
return MakerTraits.unwrap(makerTraits) & _UNWRAP_WETH_FLAG != 0;
}
}
type TakerTraits is uint256;
library TakerTraitsLib {
uint256 private constant _MAKER_AMOUNT_FLAG = 1 << 255;
uint256 private constant _UNWRAP_WETH_FLAG = 1 << 254;
uint256 private constant _SKIP_ORDER_PERMIT_FLAG = 1 << 253;
uint256 private constant _USE_PERMIT2_FLAG = 1 << 252;
uint256 private constant _ARGS_HAS_TARGET = 1 << 251;
uint256 private constant _ARGS_EXTENSION_LENGTH_OFFSET = 224;
uint256 private constant _ARGS_EXTENSION_LENGTH_MASK = 0xffffff;
uint256 private constant _ARGS_INTERACTION_LENGTH_OFFSET = 200;
uint256 private constant _ARGS_INTERACTION_LENGTH_MASK = 0xffffff;
uint256 private constant _AMOUNT_MASK = 0x000000000000000000ffffffffffffffffffffffffffffffffffffffffffffff;
function argsHasTarget(TakerTraits takerTraits) internal pure returns (bool) {
return (TakerTraits.unwrap(takerTraits) & _ARGS_HAS_TARGET) != 0;
}
function argsExtensionLength(TakerTraits takerTraits) internal pure returns (uint256) {
return (TakerTraits.unwrap(takerTraits) >> _ARGS_EXTENSION_LENGTH_OFFSET) & _ARGS_EXTENSION_LENGTH_MASK;
}
function argsInteractionLength(TakerTraits takerTraits) internal pure returns (uint256) {
return (TakerTraits.unwrap(takerTraits) >> _ARGS_INTERACTION_LENGTH_OFFSET) & _ARGS_INTERACTION_LENGTH_MASK;
}
function isMakingAmount(TakerTraits takerTraits) internal pure returns (bool) {
return (TakerTraits.unwrap(takerTraits) & _MAKER_AMOUNT_FLAG) != 0;
}
function unwrapWeth(TakerTraits takerTraits) internal pure returns (bool) {
return (TakerTraits.unwrap(takerTraits) & _UNWRAP_WETH_FLAG) != 0;
}
function skipMakerPermit(TakerTraits takerTraits) internal pure returns (bool) {
return (TakerTraits.unwrap(takerTraits) & _SKIP_ORDER_PERMIT_FLAG) != 0;
}
function usePermit2(TakerTraits takerTraits) internal pure returns (bool) {
return (TakerTraits.unwrap(takerTraits) & _USE_PERMIT2_FLAG) != 0;
}
function threshold(TakerTraits takerTraits) internal pure returns (uint256) {
return TakerTraits.unwrap(takerTraits) & _AMOUNT_MASK;
}
}
type Address is uint256;
library AddressLib {
uint256 private constant _LOW_160_BIT_MASK = (1 << 160) - 1;
function get(Address a) internal pure returns (address) {
return address(uint160(Address.unwrap(a) & _LOW_160_BIT_MASK));
}
function getFlag(Address a, uint256 flag) internal pure returns (bool) {
return (Address.unwrap(a) & flag) != 0;
}
function getUint32(Address a, uint256 offset) internal pure returns (uint32) {
return uint32(Address.unwrap(a) >> offset);
}
function getUint64(Address a, uint256 offset) internal pure returns (uint64) {
return uint64(Address.unwrap(a) >> offset);
}
}
interface IOrderMixin {
struct Order {
uint256 salt;
Address maker;
Address receiver;
Address makerAsset;
Address takerAsset;
uint256 makingAmount;
uint256 takingAmount;
MakerTraits makerTraits;
}
error InvalidatedOrder();
error TakingAmountExceeded();
error PrivateOrder();
error BadSignature();
error OrderExpired();
error WrongSeriesNonce();
error SwapWithZeroAmount();
error PartialFillNotAllowed();
error OrderIsNotSuitableForMassInvalidation();
error EpochManagerAndBitInvalidatorsAreIncompatible();
error ReentrancyDetected();
error PredicateIsNotTrue();
error TakingAmountTooHigh();
error MakingAmountTooLow();
error TransferFromMakerToTakerFailed();
error TransferFromTakerToMakerFailed();
error MismatchArraysLengths();
error InvalidPermit2Transfer();
error SimulationResults(bool success, bytes res);
event OrderFilled(
bytes32 orderHash,
uint256 remainingAmount
);
event OrderCancelled(
bytes32 orderHash
);
event BitInvalidatorUpdated(
address indexed maker,
uint256 slotIndex,
uint256 slotValue
);
function bitInvalidatorForOrder(address maker, uint256 slot) external view returns(uint256 result);
function remainingInvalidatorForOrder(address maker, bytes32 orderHash) external view returns(uint256 remaining);
function rawRemainingInvalidatorForOrder(address maker, bytes32 orderHash) external view returns(uint256 remainingRaw);
function cancelOrder(MakerTraits makerTraits, bytes32 orderHash) external;
function cancelOrders(MakerTraits[] calldata makerTraits, bytes32[] calldata orderHashes) external;
function bitsInvalidateForOrder(MakerTraits makerTraits, uint256 additionalMask) external;
function hashOrder(IOrderMixin.Order calldata order) external view returns(bytes32 orderHash);
function simulate(address target, bytes calldata data) external;
function fillOrder(
Order calldata order,
bytes32 r,
bytes32 vs,
uint256 amount,
TakerTraits takerTraits
) external payable returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash);
function fillOrderArgs(
IOrderMixin.Order calldata order,
bytes32 r,
bytes32 vs,
uint256 amount,
TakerTraits takerTraits,
bytes calldata args
) external payable returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash);
function fillContractOrder(
Order calldata order,
bytes calldata signature,
uint256 amount,
TakerTraits takerTraits
) external returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash);
function fillContractOrderArgs(
Order calldata order,
bytes calldata signature,
uint256 amount,
TakerTraits takerTraits,
bytes calldata args
) external returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash);
}
interface IAmountGetter {
function getMakingAmount(
IOrderMixin.Order calldata order,
bytes calldata extension,
bytes32 orderHash,
address taker,
uint256 takingAmount,
uint256 remainingMakingAmount,
bytes calldata extraData
) external view returns (uint256);
function getTakingAmount(
IOrderMixin.Order calldata order,
bytes calldata extension,
bytes32 orderHash,
address taker,
uint256 makingAmount,
uint256 remainingMakingAmount,
bytes calldata extraData
) external view returns (uint256);
}
interface IPostInteraction {
function postInteraction(
IOrderMixin.Order calldata order,
bytes calldata extension,
bytes32 orderHash,
address taker,
uint256 makingAmount,
uint256 takingAmount,
uint256 remainingMakingAmount,
bytes calldata extraData
) external;
}
interface IPreInteraction {
function preInteraction(
IOrderMixin.Order calldata order,
bytes calldata extension,
bytes32 orderHash,
address taker,
uint256 makingAmount,
uint256 takingAmount,
uint256 remainingMakingAmount,
bytes calldata extraData
) external;
}
interface ITakerInteraction {
function takerInteraction(
IOrderMixin.Order calldata order,
bytes calldata extension,
bytes32 orderHash,
address taker,
uint256 makingAmount,
uint256 takingAmount,
uint256 remainingMakingAmount,
bytes calldata extraData
) external;
}
type Offsets is uint256;
library OffsetsLib {
error OffsetOutOfBounds();
function get(Offsets offsets, bytes calldata concat, uint256 index) internal pure returns(bytes calldata result) {
bytes4 exception = OffsetOutOfBounds.selector;
assembly ("memory-safe") {
let bitShift := shl(5, index)
let begin := and(0xffffffff, shr(bitShift, shl(32, offsets)))
let end := and(0xffffffff, shr(bitShift, offsets))
result.offset := add(concat.offset, begin)
result.length := sub(end, begin)
if gt(end, concat.length) {
mstore(0, exception)
revert(0, 4)
}
}
}
}
library ExtensionLib {
using AddressLib for Address;
using OffsetsLib for Offsets;
enum DynamicField {
MakerAssetSuffix,
TakerAssetSuffix,
MakingAmountData,
TakingAmountData,
Predicate,
MakerPermit,
PreInteractionData,
PostInteractionData,
CustomData
}
function makerAssetSuffix(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.MakerAssetSuffix);
}
function takerAssetSuffix(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.TakerAssetSuffix);
}
function makingAmountData(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.MakingAmountData);
}
function takingAmountData(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.TakingAmountData);
}
function predicate(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.Predicate);
}
function makerPermit(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.MakerPermit);
}
function preInteractionTargetAndData(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.PreInteractionData);
}
function postInteractionTargetAndData(bytes calldata extension) internal pure returns(bytes calldata) {
return _get(extension, DynamicField.PostInteractionData);
}
function customData(bytes calldata extension) internal pure returns(bytes calldata) {
if (extension.length < 0x20) return msg.data[:0];
uint256 offsets = uint256(bytes32(extension));
unchecked {
return extension[0x20 + (offsets >> 224):];
}
}
function _get(bytes calldata extension, DynamicField field) private pure returns(bytes calldata) {
if (extension.length < 0x20) return msg.data[:0];
Offsets offsets;
bytes calldata concat;
assembly ("memory-safe") {
offsets := calldataload(extension.offset)
concat.offset := add(extension.offset, 0x20)
concat.length := sub(extension.length, 0x20)
}
return offsets.get(concat, uint256(field));
}
}
library AmountCalculatorLib {
function getMakingAmount(uint256 orderMakerAmount, uint256 orderTakerAmount, uint256 swapTakerAmount) internal pure returns(uint256) {
if ((swapTakerAmount | orderMakerAmount) >> 128 == 0) {
unchecked {
return (swapTakerAmount * orderMakerAmount) / orderTakerAmount;
}
}
return swapTakerAmount * orderMakerAmount / orderTakerAmount;
}
function getTakingAmount(uint256 orderMakerAmount, uint256 orderTakerAmount, uint256 swapMakerAmount) internal pure returns(uint256) {
if ((swapMakerAmount | orderTakerAmount) >> 128 == 0) {
unchecked {
return (swapMakerAmount * orderTakerAmount + orderMakerAmount - 1) / orderMakerAmount;
}
}
return (swapMakerAmount * orderTakerAmount + orderMakerAmount - 1) / orderMakerAmount;
}
}
interface IERC1271 {
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}
library ECDSA {
uint256 private constant _S_BOUNDARY = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 + 1;
uint256 private constant _COMPACT_S_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 private constant _COMPACT_V_SHIFT = 255;
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal view returns (address signer) {
assembly ("memory-safe") {
if lt(s, _S_BOUNDARY) {
let ptr := mload(0x40)
mstore(ptr, hash)
mstore(add(ptr, 0x20), v)
mstore(add(ptr, 0x40), r)
mstore(add(ptr, 0x60), s)
mstore(0, 0)
pop(staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20))
signer := mload(0)
}
}
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal view returns (address signer) {
assembly ("memory-safe") {
let s := and(vs, _COMPACT_S_MASK)
if lt(s, _S_BOUNDARY) {
let ptr := mload(0x40)
mstore(ptr, hash)
mstore(add(ptr, 0x20), add(27, shr(_COMPACT_V_SHIFT, vs)))
mstore(add(ptr, 0x40), r)
mstore(add(ptr, 0x60), s)
mstore(0, 0)
pop(staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20))
signer := mload(0)
}
}
}
function recover(bytes32 hash, bytes calldata signature) internal view returns (address signer) {
assembly ("memory-safe") {
let ptr := mload(0x40)
switch signature.length
case 65 {
mstore(add(ptr, 0x20), byte(0, calldataload(add(signature.offset, 0x40))))
calldatacopy(add(ptr, 0x40), signature.offset, 0x40)
}
case 64 {
let vs := calldataload(add(signature.offset, 0x20))
mstore(add(ptr, 0x20), add(27, shr(_COMPACT_V_SHIFT, vs)))
calldatacopy(add(ptr, 0x40), signature.offset, 0x20)
mstore(add(ptr, 0x60), and(vs, _COMPACT_S_MASK))
}
default {
ptr := 0
}
if ptr {
if lt(mload(add(ptr, 0x60)), _S_BOUNDARY) {
mstore(ptr, hash)
mstore(0, 0)
pop(staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20))
signer := mload(0)
}
}
}
}
function recoverOrIsValidSignature(
address signer,
bytes32 hash,
bytes calldata signature
) internal view returns (bool success) {
if (signer == address(0)) return false;
if ((signature.length == 64 || signature.length == 65) && recover(hash, signature) == signer) {
return true;
}
return isValidSignature(signer, hash, signature);
}
function recoverOrIsValidSignature(
address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal view returns (bool success) {
if (signer == address(0)) return false;
if (recover(hash, v, r, s) == signer) {
return true;
}
return isValidSignature(signer, hash, v, r, s);
}
function recoverOrIsValidSignature(
address signer,
bytes32 hash,
bytes32 r,
bytes32 vs
) internal view returns (bool success) {
if (signer == address(0)) return false;
if (recover(hash, r, vs) == signer) {
return true;
}
return isValidSignature(signer, hash, r, vs);
}
function recoverOrIsValidSignature65(
address signer,
bytes32 hash,
bytes32 r,
bytes32 vs
) internal view returns (bool success) {
if (signer == address(0)) return false;
if (recover(hash, r, vs) == signer) {
return true;
}
return isValidSignature65(signer, hash, r, vs);
}
function isValidSignature(
address signer,
bytes32 hash,
bytes calldata signature
) internal view returns (bool success) {
bytes4 selector = IERC1271.isValidSignature.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), hash)
mstore(add(ptr, 0x24), 0x40)
mstore(add(ptr, 0x44), signature.length)
calldatacopy(add(ptr, 0x64), signature.offset, signature.length)
if staticcall(gas(), signer, ptr, add(0x64, signature.length), 0, 0x20) {
success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
}
}
}
function isValidSignature(
address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal view returns (bool success) {
bytes4 selector = IERC1271.isValidSignature.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), hash)
mstore(add(ptr, 0x24), 0x40)
mstore(add(ptr, 0x44), 65)
mstore(add(ptr, 0x64), r)
mstore(add(ptr, 0x84), s)
mstore8(add(ptr, 0xa4), v)
if staticcall(gas(), signer, ptr, 0xa5, 0, 0x20) {
success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
}
}
}
function isValidSignature(
address signer,
bytes32 hash,
bytes32 r,
bytes32 vs
) internal view returns (bool success) {
bytes4 selector = IERC1271.isValidSignature.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), hash)
mstore(add(ptr, 0x24), 0x40)
mstore(add(ptr, 0x44), 64)
mstore(add(ptr, 0x64), r)
mstore(add(ptr, 0x84), vs)
if staticcall(gas(), signer, ptr, 0xa4, 0, 0x20) {
success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
}
}
}
function isValidSignature65(
address signer,
bytes32 hash,
bytes32 r,
bytes32 vs
) internal view returns (bool success) {
bytes4 selector = IERC1271.isValidSignature.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), hash)
mstore(add(ptr, 0x24), 0x40)
mstore(add(ptr, 0x44), 65)
mstore(add(ptr, 0x64), r)
mstore(add(ptr, 0x84), and(vs, _COMPACT_S_MASK))
mstore8(add(ptr, 0xa4), add(27, shr(_COMPACT_V_SHIFT, vs)))
if staticcall(gas(), signer, ptr, 0xa5, 0, 0x20) {
success := and(eq(selector, mload(0)), eq(returndatasize(), 0x20))
}
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 res) {
assembly ("memory-safe") {
mstore(0, 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000)
mstore(28, hash)
res := keccak256(0, 60)
}
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 res) {
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, 0x1901000000000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
res := keccak256(ptr, 66)
}
}
}
library OrderLib {
using AddressLib for Address;
using MakerTraitsLib for MakerTraits;
using ExtensionLib for bytes;
error MissingOrderExtension();
error UnexpectedOrderExtension();
error InvalidExtensionHash();
bytes32 constant internal _LIMIT_ORDER_TYPEHASH = keccak256(
"Order("
"uint256 salt,"
"address maker,"
"address receiver,"
"address makerAsset,"
"address takerAsset,"
"uint256 makingAmount,"
"uint256 takingAmount,"
"uint256 makerTraits"
")"
);
uint256 constant internal _ORDER_STRUCT_SIZE = 0x100;
uint256 constant internal _DATA_HASH_SIZE = 0x120;
function hash(IOrderMixin.Order calldata order, bytes32 domainSeparator) internal pure returns(bytes32 result) {
bytes32 typehash = _LIMIT_ORDER_TYPEHASH;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, typehash)
calldatacopy(add(ptr, 0x20), order, _ORDER_STRUCT_SIZE)
result := keccak256(ptr, _DATA_HASH_SIZE)
}
result = ECDSA.toTypedDataHash(domainSeparator, result);
}
function getReceiver(IOrderMixin.Order calldata order) internal pure returns(address ) {
address receiver = order.receiver.get();
return receiver != address(0) ? receiver : order.maker.get();
}
function calculateMakingAmount(
IOrderMixin.Order calldata order,
bytes calldata extension,
uint256 requestedTakingAmount,
uint256 remainingMakingAmount,
bytes32 orderHash
) internal view returns(uint256) {
bytes calldata data = extension.makingAmountData();
if (data.length == 0) {
return AmountCalculatorLib.getMakingAmount(order.makingAmount, order.takingAmount, requestedTakingAmount);
}
return IAmountGetter(address(bytes20(data))).getMakingAmount(
order,
extension,
orderHash,
msg.sender,
requestedTakingAmount,
remainingMakingAmount,
data[20:]
);
}
function calculateTakingAmount(
IOrderMixin.Order calldata order,
bytes calldata extension,
uint256 requestedMakingAmount,
uint256 remainingMakingAmount,
bytes32 orderHash
) internal view returns(uint256) {
bytes calldata data = extension.takingAmountData();
if (data.length == 0) {
return AmountCalculatorLib.getTakingAmount(order.makingAmount, order.takingAmount, requestedMakingAmount);
}
return IAmountGetter(address(bytes20(data))).getTakingAmount(
order,
extension,
orderHash,
msg.sender,
requestedMakingAmount,
remainingMakingAmount,
data[20:]
);
}
function isValidExtension(IOrderMixin.Order calldata order, bytes calldata extension) internal pure returns(bool, bytes4) {
if (order.makerTraits.hasExtension()) {
if (extension.length == 0) return (false, MissingOrderExtension.selector);
if (uint256(keccak256(extension)) & type(uint160).max != order.salt & type(uint160).max) return (false, InvalidExtensionHash.selector);
} else {
if (extension.length > 0) return (false, UnexpectedOrderExtension.selector);
}
return (true, 0x00000000);
}
}
contract PredicateHelper {
error ArbitraryStaticCallFailed();
function or(uint256 offsets, bytes calldata data) public view returns(bool) {
uint256 previous;
for (uint256 current; (current = uint32(offsets)) != 0; offsets >>= 32) {
(bool success, uint256 res) = _staticcallForUint(address(this), data[previous:current]);
if (success && res == 1) {
return true;
}
previous = current;
}
return false;
}
function and(uint256 offsets, bytes calldata data) public view returns(bool) {
uint256 previous;
for (uint256 current; (current = uint32(offsets)) != 0; offsets >>= 32) {
(bool success, uint256 res) = _staticcallForUint(address(this), data[previous:current]);
if (!success || res != 1) {
return false;
}
previous = current;
}
return true;
}
function not(bytes calldata data) public view returns(bool) {
(bool success, uint256 res) = _staticcallForUint(address(this), data);
return success && res == 0;
}
function eq(uint256 value, bytes calldata data) public view returns(bool) {
(bool success, uint256 res) = _staticcallForUint(address(this), data);
return success && res == value;
}
function lt(uint256 value, bytes calldata data) public view returns(bool) {
(bool success, uint256 res) = _staticcallForUint(address(this), data);
return success && res < value;
}
function gt(uint256 value, bytes calldata data) public view returns(bool) {
(bool success, uint256 res) = _staticcallForUint(address(this), data);
return success && res > value;
}
function arbitraryStaticCall(address target, bytes calldata data) public view returns(uint256) {
(bool success, uint256 res) = _staticcallForUint(target, data);
if (!success) revert ArbitraryStaticCallFailed();
return res;
}
function _staticcallForUint(address target, bytes calldata data) internal view returns(bool success, uint256 res) {
assembly ("memory-safe") {
let ptr := mload(0x40)
calldatacopy(ptr, data.offset, data.length)
success := staticcall(gas(), target, ptr, data.length, 0x0, 0x20)
success := and(success, eq(returndatasize(), 32))
if success {
res := mload(0)
}
}
}
}
contract SeriesEpochManager {
error AdvanceEpochFailed();
event EpochIncreased(address indexed maker, uint256 series, uint256 newEpoch);
mapping(uint256 seriesId => uint256 epoch) private _epochs;
function epoch(address maker, uint96 series) public view returns(uint256) {
return _epochs[uint160(maker) | (uint256(series) << 160)];
}
function increaseEpoch(uint96 series) external {
advanceEpoch(series, 1);
}
function advanceEpoch(uint96 series, uint256 amount) public {
if (amount == 0 || amount > 255) revert AdvanceEpochFailed();
unchecked {
uint256 key = uint160(msg.sender) | (uint256(series) << 160);
uint256 newEpoch = _epochs[key] + amount;
_epochs[key] = newEpoch;
emit EpochIncreased(msg.sender, series, newEpoch);
}
}
function epochEquals(address maker, uint256 series, uint256 makerEpoch) public view returns(bool) {
return _epochs[uint160(maker) | (uint256(series) << 160)] == makerEpoch;
}
}
library BitInvalidatorLib {
error BitInvalidatedOrder();
struct Data {
mapping(uint256 slotIndex => uint256 slotData) _raw;
}
function checkSlot(Data storage self, uint256 nonce) internal view returns(uint256) {
uint256 invalidatorSlot = nonce >> 8;
return self._raw[invalidatorSlot];
}
function checkAndInvalidate(Data storage self, uint256 nonce) internal {
uint256 invalidatorSlot = nonce >> 8;
uint256 invalidatorBit = 1 << (nonce & 0xff);
uint256 invalidator = self._raw[invalidatorSlot];
if (invalidator & invalidatorBit == invalidatorBit) revert BitInvalidatedOrder();
self._raw[invalidatorSlot] = invalidator | invalidatorBit;
}
function massInvalidate(Data storage self, uint256 nonce, uint256 additionalMask) internal returns(uint256 result) {
uint256 invalidatorSlot = nonce >> 8;
uint256 invalidatorBits = (1 << (nonce & 0xff)) | additionalMask;
result = self._raw[invalidatorSlot] | invalidatorBits;
self._raw[invalidatorSlot] = result;
}
}
library Errors {
error InvalidMsgValue();
error ETHTransferFailed();
}
type RemainingInvalidator is uint256;
library RemainingInvalidatorLib {
error RemainingInvalidatedOrder();
function isNewOrder(RemainingInvalidator invalidator) internal pure returns(bool) {
return RemainingInvalidator.unwrap(invalidator) == 0;
}
function remaining(RemainingInvalidator invalidator) internal pure returns(uint256) {
uint256 value = RemainingInvalidator.unwrap(invalidator);
if (value == 0) {
revert RemainingInvalidatedOrder();
}
unchecked {
return ~value;
}
}
function remaining(RemainingInvalidator invalidator, uint256 orderMakerAmount) internal pure returns(uint256) {
uint256 value = RemainingInvalidator.unwrap(invalidator);
if (value == 0) {
return orderMakerAmount;
}
unchecked {
return ~value;
}
}
function remains(uint256 remainingMakingAmount, uint256 makingAmount) internal pure returns(RemainingInvalidator) {
unchecked {
return RemainingInvalidator.wrap(~(remainingMakingAmount - makingAmount));
}
}
function fullyFilled() internal pure returns(RemainingInvalidator) {
return RemainingInvalidator.wrap(type(uint256).max);
}
}
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 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
interface IWETH is IERC20 {
event Deposit(address indexed dst, uint256 wad);
event Withdrawal(address indexed src, uint256 wad);
function deposit() external payable;
function withdraw(uint256 amount) external;
}
interface IDaiLikePermit {
function permit(
address holder,
address spender,
uint256 nonce,
uint256 expiry,
bool allowed,
uint8 v,
bytes32 r,
bytes32 s
) external;
}
interface IPermit2 {
struct PermitDetails {
address token;
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct PermitSingle {
PermitDetails details;
address spender;
uint256 sigDeadline;
}
struct PackedAllowance {
uint160 amount;
uint48 expiration;
uint48 nonce;
}
function transferFrom(address user, address spender, uint160 amount, address token) external;
function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external;
function allowance(address user, address token, address spender) external view returns (PackedAllowance memory);
}
library RevertReasonForwarder {
function reRevert() internal pure {
assembly ("memory-safe") {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
function reReason() internal pure returns (bytes memory reason) {
assembly ("memory-safe") {
reason := mload(0x40)
let length := returndatasize()
mstore(reason, length)
returndatacopy(add(reason, 0x20), 0, length)
mstore(0x40, add(reason, add(0x20, length)))
}
}
}
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);
}
library SafeERC20 {
error SafeTransferFailed();
error SafeTransferFromFailed();
error ForceApproveFailed();
error SafeIncreaseAllowanceFailed();
error SafeDecreaseAllowanceFailed();
error SafePermitBadLength();
error Permit2TransferAmountTooHigh();
address private constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
bytes4 private constant _PERMIT_LENGTH_ERROR = 0x68275857;
uint256 private constant _RAW_CALL_GAS_LIMIT = 5000;
function safeBalanceOf(
IERC20 token,
address account
) internal view returns(uint256 tokenBalance) {
bytes4 selector = IERC20.balanceOf.selector;
assembly ("memory-safe") {
mstore(0x00, selector)
mstore(0x04, account)
let success := staticcall(gas(), token, 0x00, 0x24, 0x00, 0x20)
tokenBalance := mload(0)
if or(iszero(success), lt(returndatasize(), 0x20)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
function safeTransferFromUniversal(
IERC20 token,
address from,
address to,
uint256 amount,
bool permit2
) internal {
if (permit2) {
safeTransferFromPermit2(token, from, to, amount);
} else {
safeTransferFrom(token, from, to, amount);
}
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
bytes4 selector = token.transferFrom.selector;
bool success;
assembly ("memory-safe") {
let data := mload(0x40)
mstore(data, selector)
mstore(add(data, 0x04), from)
mstore(add(data, 0x24), to)
mstore(add(data, 0x44), amount)
success := call(gas(), token, 0, data, 100, 0x0, 0x20)
if success {
switch returndatasize()
case 0 {
success := gt(extcodesize(token), 0)
}
default {
success := and(gt(returndatasize(), 31), eq(mload(0), 1))
}
}
}
if (!success) revert SafeTransferFromFailed();
}
function safeTransferFromPermit2(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
if (amount > type(uint160).max) revert Permit2TransferAmountTooHigh();
bytes4 selector = IPermit2.transferFrom.selector;
bool success;
assembly ("memory-safe") {
let data := mload(0x40)
mstore(data, selector)
mstore(add(data, 0x04), from)
mstore(add(data, 0x24), to)
mstore(add(data, 0x44), amount)
mstore(add(data, 0x64), token)
success := call(gas(), _PERMIT2, 0, data, 0x84, 0x0, 0x0)
if success {
success := gt(extcodesize(_PERMIT2), 0)
}
}
if (!success) revert SafeTransferFromFailed();
}
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
if (!_makeCall(token, token.transfer.selector, to, value)) {
revert SafeTransferFailed();
}
}
function forceApprove(
IERC20 token,
address spender,
uint256 value
) internal {
if (!_makeCall(token, token.approve.selector, spender, value)) {
if (
!_makeCall(token, token.approve.selector, spender, 0) ||
!_makeCall(token, token.approve.selector, spender, value)
) {
revert ForceApproveFailed();
}
}
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 allowance = token.allowance(address(this), spender);
if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();
forceApprove(token, spender, allowance + value);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 allowance = token.allowance(address(this), spender);
if (value > allowance) revert SafeDecreaseAllowanceFailed();
forceApprove(token, spender, allowance - value);
}
function safePermit(IERC20 token, bytes calldata permit) internal {
if (!tryPermit(token, msg.sender, address(this), permit)) RevertReasonForwarder.reRevert();
}
function safePermit(IERC20 token, address owner, address spender, bytes calldata permit) internal {
if (!tryPermit(token, owner, spender, permit)) RevertReasonForwarder.reRevert();
}
function tryPermit(IERC20 token, bytes calldata permit) internal returns(bool success) {
return tryPermit(token, msg.sender, address(this), permit);
}
function tryPermit(IERC20 token, address owner, address spender, bytes calldata permit) internal returns(bool success) {
bytes4 permitSelector = IERC20Permit.permit.selector;
bytes4 daiPermitSelector = IDaiLikePermit.permit.selector;
bytes4 permit2Selector = IPermit2.permit.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
switch permit.length
case 100 {
mstore(ptr, permitSelector)
mstore(add(ptr, 0x04), owner)
mstore(add(ptr, 0x24), spender)
{
let deadline := shr(224, calldataload(add(permit.offset, 0x20)))
let vs := calldataload(add(permit.offset, 0x44))
calldatacopy(add(ptr, 0x44), permit.offset, 0x20)
mstore(add(ptr, 0x64), sub(deadline, 1))
mstore(add(ptr, 0x84), add(27, shr(255, vs)))
calldatacopy(add(ptr, 0xa4), add(permit.offset, 0x24), 0x20)
mstore(add(ptr, 0xc4), shr(1, shl(1, vs)))
}
success := call(gas(), token, 0, ptr, 0xe4, 0, 0)
}
case 72 {
mstore(ptr, daiPermitSelector)
mstore(add(ptr, 0x04), owner)
mstore(add(ptr, 0x24), spender)
{
let expiry := shr(224, calldataload(add(permit.offset, 0x04)))
let vs := calldataload(add(permit.offset, 0x28))
mstore(add(ptr, 0x44), shr(224, calldataload(permit.offset)))
mstore(add(ptr, 0x64), sub(expiry, 1))
mstore(add(ptr, 0x84), true)
mstore(add(ptr, 0xa4), add(27, shr(255, vs)))
calldatacopy(add(ptr, 0xc4), add(permit.offset, 0x08), 0x20)
mstore(add(ptr, 0xe4), shr(1, shl(1, vs)))
}
success := call(gas(), token, 0, ptr, 0x104, 0, 0)
}
case 224 {
mstore(ptr, permitSelector)
calldatacopy(add(ptr, 0x04), permit.offset, permit.length)
success := call(gas(), token, 0, ptr, 0xe4, 0, 0)
}
case 256 {
mstore(ptr, daiPermitSelector)
calldatacopy(add(ptr, 0x04), permit.offset, permit.length)
success := call(gas(), token, 0, ptr, 0x104, 0, 0)
}
case 96 {
mstore(ptr, permit2Selector)
mstore(add(ptr, 0x04), owner)
mstore(add(ptr, 0x24), token)
calldatacopy(add(ptr, 0x50), permit.offset, 0x14)
mstore(add(ptr, 0x64), and(0xffffffffffff, sub(shr(224, calldataload(add(permit.offset, 0x14))), 1)))
mstore(add(ptr, 0x84), shr(224, calldataload(add(permit.offset, 0x18))))
mstore(add(ptr, 0xa4), spender)
mstore(add(ptr, 0xc4), and(0xffffffffffff, sub(shr(224, calldataload(add(permit.offset, 0x1c))), 1)))
mstore(add(ptr, 0xe4), 0x100)
mstore(add(ptr, 0x104), 0x40)
calldatacopy(add(ptr, 0x124), add(permit.offset, 0x20), 0x20)
calldatacopy(add(ptr, 0x144), add(permit.offset, 0x40), 0x20)
success := call(gas(), _PERMIT2, 0, ptr, 0x164, 0, 0)
}
case 352 {
mstore(ptr, permit2Selector)
calldatacopy(add(ptr, 0x04), permit.offset, permit.length)
success := call(gas(), _PERMIT2, 0, ptr, 0x164, 0, 0)
}
default {
mstore(ptr, _PERMIT_LENGTH_ERROR)
revert(ptr, 4)
}
}
}
function _makeCall(
IERC20 token,
bytes4 selector,
address to,
uint256 amount
) private returns (bool success) {
assembly ("memory-safe") {
let data := mload(0x40)
mstore(data, selector)
mstore(add(data, 0x04), to)
mstore(add(data, 0x24), amount)
success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)
if success {
switch returndatasize()
case 0 {
success := gt(extcodesize(token), 0)
}
default {
success := and(gt(returndatasize(), 31), eq(mload(0), 1))
}
}
}
}
function safeDeposit(IWETH weth, uint256 amount) internal {
if (amount > 0) {
bytes4 selector = IWETH.deposit.selector;
assembly ("memory-safe") {
mstore(0, selector)
if iszero(call(gas(), weth, amount, 0, 4, 0, 0)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
}
function safeWithdraw(IWETH weth, uint256 amount) internal {
bytes4 selector = IWETH.withdraw.selector;
assembly ("memory-safe") {
mstore(0, selector)
mstore(4, amount)
if iszero(call(gas(), weth, 0, 0, 0x24, 0, 0)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
function safeWithdrawTo(IWETH weth, uint256 amount, address to) internal {
safeWithdraw(weth, amount);
if (to != address(this)) {
assembly ("memory-safe") {
if iszero(call(_RAW_CALL_GAS_LIMIT, to, amount, 0, 0, 0, 0)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
}
}
abstract contract EthReceiver {
error EthDepositRejected();
receive() external payable {
_receive();
}
function _receive() internal virtual {
if (msg.sender == tx.origin) revert EthDepositRejected();
}
}
abstract contract OnlyWethReceiver is EthReceiver {
address private immutable _WETH;
constructor(address weth) {
_WETH = address(weth);
}
function _receive() internal virtual override {
if (msg.sender != _WETH) revert EthDepositRejected();
}
}
abstract contract PermitAndCall {
using SafeERC20 for IERC20;
function permitAndCall(bytes calldata permit, bytes calldata action) external payable {
IERC20(address(bytes20(permit))).tryPermit(permit[20:]);
assembly ("memory-safe") {
let ptr := mload(0x40)
calldatacopy(ptr, action.offset, action.length)
let success := delegatecall(gas(), address(), ptr, action.length, 0, 0)
returndatacopy(ptr, 0, returndatasize())
switch success
case 0 {
revert(ptr, returndatasize())
}
default {
return(ptr, returndatasize())
}
}
}
}
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
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 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) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
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 (unsignedRoundsUp(rounding) && 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 + (unsignedRoundsUp(rounding) && 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 + (unsignedRoundsUp(rounding) && 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 + (unsignedRoundsUp(rounding) && 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
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);
}
}
}
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
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), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(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) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
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 bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
library MessageHashUtils {
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
abstract contract Pausable is Context {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract OrderMixin is IOrderMixin, EIP712, PredicateHelper, SeriesEpochManager, Pausable, OnlyWethReceiver, PermitAndCall {
using SafeERC20 for IERC20;
using SafeERC20 for IWETH;
using OrderLib for IOrderMixin.Order;
using ExtensionLib for bytes;
using AddressLib for Address;
using MakerTraitsLib for MakerTraits;
using TakerTraitsLib for TakerTraits;
using BitInvalidatorLib for BitInvalidatorLib.Data;
using RemainingInvalidatorLib for RemainingInvalidator;
IWETH private immutable _WETH;
mapping(address maker => BitInvalidatorLib.Data data) private _bitInvalidator;
mapping(address maker => mapping(bytes32 orderHash => RemainingInvalidator remaining)) private _remainingInvalidator;
constructor(IWETH weth) OnlyWethReceiver(address(weth)) {
_WETH = weth;
}
function bitInvalidatorForOrder(address maker, uint256 slot) external view returns(uint256 ) {
return _bitInvalidator[maker].checkSlot(slot);
}
function remainingInvalidatorForOrder(address maker, bytes32 orderHash) external view returns(uint256 ) {
return _remainingInvalidator[maker][orderHash].remaining();
}
function rawRemainingInvalidatorForOrder(address maker, bytes32 orderHash) external view returns(uint256 ) {
return RemainingInvalidator.unwrap(_remainingInvalidator[maker][orderHash]);
}
function simulate(address target, bytes calldata data) external {
(bool success, bytes memory result) = target.delegatecall(data);
revert SimulationResults(success, result);
}
function cancelOrder(MakerTraits makerTraits, bytes32 orderHash) public {
if (makerTraits.useBitInvalidator()) {
uint256 invalidator = _bitInvalidator[msg.sender].massInvalidate(makerTraits.nonceOrEpoch(), 0);
emit BitInvalidatorUpdated(msg.sender, makerTraits.nonceOrEpoch() >> 8, invalidator);
} else {
_remainingInvalidator[msg.sender][orderHash] = RemainingInvalidatorLib.fullyFilled();
emit OrderCancelled(orderHash);
}
}
function cancelOrders(MakerTraits[] calldata makerTraits, bytes32[] calldata orderHashes) external {
if (makerTraits.length != orderHashes.length) revert MismatchArraysLengths();
unchecked {
for (uint256 i = 0; i < makerTraits.length; i++) {
cancelOrder(makerTraits[i], orderHashes[i]);
}
}
}
function bitsInvalidateForOrder(MakerTraits makerTraits, uint256 additionalMask) external {
if (!makerTraits.useBitInvalidator()) revert OrderIsNotSuitableForMassInvalidation();
uint256 invalidator = _bitInvalidator[msg.sender].massInvalidate(makerTraits.nonceOrEpoch(), additionalMask);
emit BitInvalidatorUpdated(msg.sender, makerTraits.nonceOrEpoch() >> 8, invalidator);
}
function hashOrder(IOrderMixin.Order calldata order) external view returns(bytes32) {
return order.hash(_domainSeparatorV4());
}
function checkPredicate(bytes calldata predicate) public view returns(bool) {
(bool success, uint256 res) = _staticcallForUint(address(this), predicate);
return success && res == 1;
}
function fillOrder(
IOrderMixin.Order calldata order,
bytes32 r,
bytes32 vs,
uint256 amount,
TakerTraits takerTraits
) external payable returns(uint256 , uint256 , bytes32 ) {
return _fillOrder(order, r, vs, amount, takerTraits, msg.sender, msg.data[:0], msg.data[:0]);
}
function fillOrderArgs(
IOrderMixin.Order calldata order,
bytes32 r,
bytes32 vs,
uint256 amount,
TakerTraits takerTraits,
bytes calldata args
) external payable returns(uint256 , uint256 , bytes32 ) {
(
address target,
bytes calldata extension,
bytes calldata interaction
) = _parseArgs(takerTraits, args);
return _fillOrder(order, r, vs, amount, takerTraits, target, extension, interaction);
}
function _fillOrder(
IOrderMixin.Order calldata order,
bytes32 r,
bytes32 vs,
uint256 amount,
TakerTraits takerTraits,
address target,
bytes calldata extension,
bytes calldata interaction
) private returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash) {
orderHash = order.hash(_domainSeparatorV4());
uint256 remainingMakingAmount = _checkRemainingMakingAmount(order, orderHash);
if (remainingMakingAmount == order.makingAmount) {
address maker = order.maker.get();
if (maker == address(0) || maker != ECDSA.recover(orderHash, r, vs)) revert BadSignature();
if (!takerTraits.skipMakerPermit()) {
bytes calldata makerPermit = extension.makerPermit();
if (makerPermit.length >= 20) {
IERC20(address(bytes20(makerPermit))).tryPermit(maker, address(this), makerPermit[20:]);
if (!order.makerTraits.useBitInvalidator()) {
if (!_remainingInvalidator[order.maker.get()][orderHash].isNewOrder()) revert ReentrancyDetected();
}
}
}
}
(makingAmount, takingAmount) = _fill(order, orderHash, remainingMakingAmount, amount, takerTraits, target, extension, interaction);
}
function fillContractOrder(
IOrderMixin.Order calldata order,
bytes calldata signature,
uint256 amount,
TakerTraits takerTraits
) external returns(uint256 , uint256 , bytes32 ) {
return _fillContractOrder(order, signature, amount, takerTraits, msg.sender, msg.data[:0], msg.data[:0]);
}
function fillContractOrderArgs(
IOrderMixin.Order calldata order,
bytes calldata signature,
uint256 amount,
TakerTraits takerTraits,
bytes calldata args
) external returns(uint256 , uint256 , bytes32 ) {
(
address target,
bytes calldata extension,
bytes calldata interaction
) = _parseArgs(takerTraits, args);
return _fillContractOrder(order, signature, amount, takerTraits, target, extension, interaction);
}
function _fillContractOrder(
IOrderMixin.Order calldata order,
bytes calldata signature,
uint256 amount,
TakerTraits takerTraits,
address target,
bytes calldata extension,
bytes calldata interaction
) private returns(uint256 makingAmount, uint256 takingAmount, bytes32 orderHash) {
orderHash = order.hash(_domainSeparatorV4());
uint256 remainingMakingAmount = _checkRemainingMakingAmount(order, orderHash);
if (remainingMakingAmount == order.makingAmount) {
if (!ECDSA.isValidSignature(order.maker.get(), orderHash, signature)) revert BadSignature();
}
(makingAmount, takingAmount) = _fill(order, orderHash, remainingMakingAmount, amount, takerTraits, target, extension, interaction);
}
function _fill(
IOrderMixin.Order calldata order,
bytes32 orderHash,
uint256 remainingMakingAmount,
uint256 amount,
TakerTraits takerTraits,
address target,
bytes calldata extension,
bytes calldata interaction
) private whenNotPaused() returns(uint256 makingAmount, uint256 takingAmount) {
{
(bool valid, bytes4 validationResult) = order.isValidExtension(extension);
if (!valid) {
assembly ("memory-safe") {
mstore(0, validationResult)
revert(0, 4)
}
}
}
if (!order.makerTraits.isAllowedSender(msg.sender)) revert PrivateOrder();
if (order.makerTraits.isExpired()) revert OrderExpired();
if (order.makerTraits.needCheckEpochManager()) {
if (order.makerTraits.useBitInvalidator()) revert EpochManagerAndBitInvalidatorsAreIncompatible();
if (!epochEquals(order.maker.get(), order.makerTraits.series(), order.makerTraits.nonceOrEpoch())) revert WrongSeriesNonce();
}
if (extension.length > 0) {
bytes calldata predicate = extension.predicate();
if (predicate.length > 0) {
if (!checkPredicate(predicate)) revert PredicateIsNotTrue();
}
}
if (takerTraits.isMakingAmount()) {
makingAmount = Math.min(amount, remainingMakingAmount);
takingAmount = order.calculateTakingAmount(extension, makingAmount, remainingMakingAmount, orderHash);
uint256 threshold = takerTraits.threshold();
if (threshold > 0) {
if (amount == makingAmount) {
if (takingAmount > threshold) revert TakingAmountTooHigh();
} else {
if (takingAmount * amount > threshold * makingAmount) revert TakingAmountTooHigh();
}
}
}
else {
takingAmount = amount;
makingAmount = order.calculateMakingAmount(extension, takingAmount, remainingMakingAmount, orderHash);
if (makingAmount > remainingMakingAmount) {
makingAmount = remainingMakingAmount;
takingAmount = order.calculateTakingAmount(extension, makingAmount, remainingMakingAmount, orderHash);
if (takingAmount > amount) revert TakingAmountExceeded();
}
uint256 threshold = takerTraits.threshold();
if (threshold > 0) {
if (amount == takingAmount) {
if (makingAmount < threshold) revert MakingAmountTooLow();
} else {
if (makingAmount * amount < threshold * takingAmount) revert MakingAmountTooLow();
}
}
}
if (!order.makerTraits.allowPartialFills() && makingAmount != order.makingAmount) revert PartialFillNotAllowed();
unchecked { if (makingAmount * takingAmount == 0) revert SwapWithZeroAmount(); }
if (order.makerTraits.useBitInvalidator()) {
_bitInvalidator[order.maker.get()].checkAndInvalidate(order.makerTraits.nonceOrEpoch());
} else {
_remainingInvalidator[order.maker.get()][orderHash] = RemainingInvalidatorLib.remains(remainingMakingAmount, makingAmount);
}
if (order.makerTraits.needPreInteractionCall()) {
bytes calldata data = extension.preInteractionTargetAndData();
address listener = order.maker.get();
if (data.length > 19) {
listener = address(bytes20(data));
data = data[20:];
}
IPreInteraction(listener).preInteraction(
order, extension, orderHash, msg.sender, makingAmount, takingAmount, remainingMakingAmount, data
);
}
{
bool needUnwrap = order.makerAsset.get() == address(_WETH) && takerTraits.unwrapWeth();
address receiver = needUnwrap ? address(this) : target;
if (order.makerTraits.usePermit2()) {
if (extension.makerAssetSuffix().length > 0) revert InvalidPermit2Transfer();
IERC20(order.makerAsset.get()).safeTransferFromPermit2(order.maker.get(), receiver, makingAmount);
} else {
if (!_callTransferFromWithSuffix(
order.makerAsset.get(),
order.maker.get(),
receiver,
makingAmount,
extension.makerAssetSuffix()
)) revert TransferFromMakerToTakerFailed();
}
if (needUnwrap) {
_WETH.safeWithdrawTo(makingAmount, target);
}
}
if (interaction.length > 19) {
ITakerInteraction(address(bytes20(interaction))).takerInteraction(
order, extension, orderHash, msg.sender, makingAmount, takingAmount, remainingMakingAmount, interaction[20:]
);
}
if (order.takerAsset.get() == address(_WETH) && msg.value > 0) {
if (msg.value < takingAmount) revert Errors.InvalidMsgValue();
if (msg.value > takingAmount) {
unchecked {
(bool success, ) = msg.sender.call{value: msg.value - takingAmount}("");
if (!success) revert Errors.ETHTransferFailed();
}
}
if (order.makerTraits.unwrapWeth()) {
(bool success, ) = order.getReceiver().call{value: takingAmount}("");
if (!success) revert Errors.ETHTransferFailed();
} else {
_WETH.safeDeposit(takingAmount);
_WETH.safeTransfer(order.getReceiver(), takingAmount);
}
} else {
if (msg.value != 0) revert Errors.InvalidMsgValue();
bool needUnwrap = order.takerAsset.get() == address(_WETH) && order.makerTraits.unwrapWeth();
address receiver = needUnwrap ? address(this) : order.getReceiver();
if (takerTraits.usePermit2()) {
if (extension.takerAssetSuffix().length > 0) revert InvalidPermit2Transfer();
IERC20(order.takerAsset.get()).safeTransferFromPermit2(msg.sender, receiver, takingAmount);
} else {
if (!_callTransferFromWithSuffix(
order.takerAsset.get(),
msg.sender,
receiver,
takingAmount,
extension.takerAssetSuffix()
)) revert TransferFromTakerToMakerFailed();
}
if (needUnwrap) {
_WETH.safeWithdrawTo(takingAmount, order.getReceiver());
}
}
if (order.makerTraits.needPostInteractionCall()) {
bytes calldata data = extension.postInteractionTargetAndData();
address listener = order.maker.get();
if (data.length > 19) {
listener = address(bytes20(data));
data = data[20:];
}
IPostInteraction(listener).postInteraction(
order, extension, orderHash, msg.sender, makingAmount, takingAmount, remainingMakingAmount, data
);
}
emit OrderFilled(orderHash, remainingMakingAmount - makingAmount);
}
function _parseArgs(TakerTraits takerTraits, bytes calldata args)
private
view
returns(
address target,
bytes calldata extension,
bytes calldata interaction
)
{
if (takerTraits.argsHasTarget()) {
target = address(bytes20(args));
args = args[20:];
} else {
target = msg.sender;
}
uint256 extensionLength = takerTraits.argsExtensionLength();
if (extensionLength > 0) {
extension = args[:extensionLength];
args = args[extensionLength:];
} else {
extension = msg.data[:0];
}
uint256 interactionLength = takerTraits.argsInteractionLength();
if (interactionLength > 0) {
interaction = args[:interactionLength];
} else {
interaction = msg.data[:0];
}
}
function _checkRemainingMakingAmount(IOrderMixin.Order calldata order, bytes32 orderHash) private view returns(uint256 remainingMakingAmount) {
if (order.makerTraits.useBitInvalidator()) {
remainingMakingAmount = order.makingAmount;
} else {
remainingMakingAmount = _remainingInvalidator[order.maker.get()][orderHash].remaining(order.makingAmount);
}
if (remainingMakingAmount == 0) revert InvalidatedOrder();
}
function _callTransferFromWithSuffix(address asset, address from, address to, uint256 amount, bytes calldata suffix) private returns(bool success) {
bytes4 selector = IERC20.transferFrom.selector;
assembly ("memory-safe") {
let data := mload(0x40)
mstore(data, selector)
mstore(add(data, 0x04), from)
mstore(add(data, 0x24), to)
mstore(add(data, 0x44), amount)
if suffix.length {
calldatacopy(add(data, 0x64), suffix.offset, suffix.length)
}
let status := call(gas(), asset, 0, data, add(0x64, suffix.length), 0x0, 0x20)
success := and(status, or(iszero(returndatasize()), and(gt(returndatasize(), 31), eq(mload(0), 1))))
}
}
}
interface IERC20MetadataUppercase {
function NAME() external view returns (string memory);
function SYMBOL() external view returns (string memory);
}
library StringUtil {
function toHex(uint256 value) internal pure returns (string memory) {
return toHex(abi.encodePacked(value));
}
function toHex(address value) internal pure returns (string memory) {
return toHex(abi.encodePacked(value));
}
function toHex(bytes memory data) internal pure returns (string memory result) {
assembly ("memory-safe") {
function _toHex16(input) -> output {
output := or(
and(input, 0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000),
shr(64, and(input, 0x0000000000000000FFFFFFFFFFFFFFFF00000000000000000000000000000000))
)
output := or(
and(output, 0xFFFFFFFF000000000000000000000000FFFFFFFF000000000000000000000000),
shr(32, and(output, 0x00000000FFFFFFFF000000000000000000000000FFFFFFFF0000000000000000))
)
output := or(
and(output, 0xFFFF000000000000FFFF000000000000FFFF000000000000FFFF000000000000),
shr(16, and(output, 0x0000FFFF000000000000FFFF000000000000FFFF000000000000FFFF00000000))
)
output := or(
and(output, 0xFF000000FF000000FF000000FF000000FF000000FF000000FF000000FF000000),
shr(8, and(output, 0x00FF000000FF000000FF000000FF000000FF000000FF000000FF000000FF0000))
)
output := or(
shr(4, and(output, 0xF000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000)),
shr(8, and(output, 0x0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00))
)
output := add(
add(0x3030303030303030303030303030303030303030303030303030303030303030, output),
mul(
and(
shr(4, add(output, 0x0606060606060606060606060606060606060606060606060606060606060606)),
0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F
),
7
)
)
}
result := mload(0x40)
let length := mload(data)
let resultLength := shl(1, length)
let toPtr := add(result, 0x22)
mstore(0x40, add(toPtr, resultLength))
mstore(add(result, 2), 0x3078)
mstore(result, add(resultLength, 2))
for {
let fromPtr := add(data, 0x20)
let endPtr := add(fromPtr, length)
} lt(fromPtr, endPtr) {
fromPtr := add(fromPtr, 0x20)
} {
let rawData := mload(fromPtr)
let hexData := _toHex16(rawData)
mstore(toPtr, hexData)
toPtr := add(toPtr, 0x20)
hexData := _toHex16(shl(128, rawData))
mstore(toPtr, hexData)
toPtr := add(toPtr, 0x20)
}
}
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library UniERC20 {
using SafeERC20 for IERC20;
error InsufficientBalance();
error ApproveCalledOnETH();
error NotEnoughValue();
error FromIsNotSender();
error ToIsNotThis();
error ETHTransferFailed();
uint256 private constant _RAW_CALL_GAS_LIMIT = 5000;
IERC20 private constant _ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
IERC20 private constant _ZERO_ADDRESS = IERC20(address(0));
function isETH(IERC20 token) internal pure returns (bool) {
return (token == _ZERO_ADDRESS || token == _ETH_ADDRESS);
}
function uniBalanceOf(IERC20 token, address account) internal view returns (uint256) {
if (isETH(token)) {
return account.balance;
} else {
return token.balanceOf(account);
}
}
function uniTransfer(
IERC20 token,
address payable to,
uint256 amount
) internal {
if (amount > 0) {
if (isETH(token)) {
if (address(this).balance < amount) revert InsufficientBalance();
(bool success, ) = to.call{value: amount, gas: _RAW_CALL_GAS_LIMIT}("");
if (!success) revert ETHTransferFailed();
} else {
token.safeTransfer(to, amount);
}
}
}
function uniTransferFrom(
IERC20 token,
address payable from,
address to,
uint256 amount
) internal {
if (amount > 0) {
if (isETH(token)) {
if (msg.value < amount) revert NotEnoughValue();
if (from != msg.sender) revert FromIsNotSender();
if (to != address(this)) revert ToIsNotThis();
if (msg.value > amount) {
unchecked {
(bool success, ) = from.call{value: msg.value - amount, gas: _RAW_CALL_GAS_LIMIT}("");
if (!success) revert ETHTransferFailed();
}
}
} else {
token.safeTransferFrom(from, to, amount);
}
}
}
function uniSymbol(IERC20 token) internal view returns (string memory) {
return _uniDecode(token, IERC20Metadata.symbol.selector, IERC20MetadataUppercase.SYMBOL.selector);
}
function uniName(IERC20 token) internal view returns (string memory) {
return _uniDecode(token, IERC20Metadata.name.selector, IERC20MetadataUppercase.NAME.selector);
}
function uniApprove(
IERC20 token,
address to,
uint256 amount
) internal {
if (isETH(token)) revert ApproveCalledOnETH();
token.forceApprove(to, amount);
}
function _uniDecode(
IERC20 token,
bytes4 lowerCaseSelector,
bytes4 upperCaseSelector
) private view returns (string memory result) {
if (isETH(token)) {
return "ETH";
}
(bool success, bytes memory data) = address(token).staticcall{gas: 20000}(
abi.encodeWithSelector(lowerCaseSelector)
);
if (!success) {
(success, data) = address(token).staticcall{gas: 20000}(abi.encodeWithSelector(upperCaseSelector));
}
if (success && data.length >= 0x40) {
(uint256 offset, uint256 len) = abi.decode(data, (uint256, uint256));
if (offset == 0x20 && data.length >= 0x40 + len) {
assembly ("memory-safe") {
result := add(data, 0x40)
}
return result;
}
}
if (success && data.length == 32) {
uint256 len = 0;
while (len < data.length && data[len] >= 0x20 && data[len] <= 0x7E) {
unchecked {
len++;
}
}
if (len > 0) {
assembly ("memory-safe") {
mstore(data, len)
}
return string(data);
}
}
return StringUtil.toHex(address(token));
}
}
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library RouterErrors {
error ReturnAmountIsNotEnough(uint256 result, uint256 minReturn);
error InvalidMsgValue();
error ERC20TransferFailed();
error Permit2TransferFromFailed();
error ApproveFailed();
}
interface IClipperExchange {
struct Signature {
uint8 v;
bytes32 r;
bytes32 s;
}
function sellEthForToken(address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external payable;
function sellTokenForEth(address inputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external;
function swap(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external;
}
contract ClipperRouter is Pausable, EthReceiver {
using SafeERC20 for IERC20;
using SafeERC20 for IWETH;
using AddressLib for Address;
uint256 private constant _PERMIT2_FLAG = 1 << 255;
uint256 private constant _SIGNATURE_S_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 private constant _SIGNATURE_V_SHIFT = 255;
bytes5 private constant _INCH_TAG = "1INCH";
uint256 private constant _INCH_TAG_LENGTH = 5;
IERC20 private constant _ETH = IERC20(address(0));
IWETH private immutable _WETH;
constructor(IWETH weth) {
_WETH = weth;
}
function clipperSwap(
IClipperExchange clipperExchange,
Address srcToken,
IERC20 dstToken,
uint256 inputAmount,
uint256 outputAmount,
uint256 goodUntil,
bytes32 r,
bytes32 vs
) external payable returns(uint256 returnAmount) {
return clipperSwapTo(clipperExchange, payable(msg.sender), srcToken, dstToken, inputAmount, outputAmount, goodUntil, r, vs);
}
function clipperSwapTo(
IClipperExchange clipperExchange,
address payable recipient,
Address srcToken,
IERC20 dstToken,
uint256 inputAmount,
uint256 outputAmount,
uint256 goodUntil,
bytes32 r,
bytes32 vs
) public payable whenNotPaused() returns(uint256 returnAmount) {
IERC20 srcToken_ = IERC20(srcToken.get());
if (srcToken_ == _ETH) {
if (msg.value != inputAmount) revert RouterErrors.InvalidMsgValue();
} else {
if (msg.value != 0) revert RouterErrors.InvalidMsgValue();
srcToken_.safeTransferFromUniversal(msg.sender, address(clipperExchange), inputAmount, srcToken.getFlag(_PERMIT2_FLAG));
}
if (srcToken_ == _ETH) {
address clipper = address(clipperExchange);
bytes4 selector = clipperExchange.sellEthForToken.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), dstToken)
mstore(add(ptr, 0x24), inputAmount)
mstore(add(ptr, 0x44), outputAmount)
mstore(add(ptr, 0x64), goodUntil)
mstore(add(ptr, 0x84), recipient)
mstore(add(ptr, 0xa4), add(27, shr(_SIGNATURE_V_SHIFT, vs)))
mstore(add(ptr, 0xc4), r)
mstore(add(ptr, 0xe4), and(vs, _SIGNATURE_S_MASK))
mstore(add(ptr, 0x104), 0x120)
mstore(add(ptr, 0x124), _INCH_TAG_LENGTH)
mstore(add(ptr, 0x144), _INCH_TAG)
if iszero(call(gas(), clipper, inputAmount, ptr, 0x149, 0, 0)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
} else if (dstToken == _ETH) {
address clipper = address(clipperExchange);
bytes4 selector = clipperExchange.sellTokenForEth.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), srcToken_)
mstore(add(ptr, 0x24), inputAmount)
mstore(add(ptr, 0x44), outputAmount)
mstore(add(ptr, 0x64), goodUntil)
switch iszero(dstToken)
case 1 {
mstore(add(ptr, 0x84), recipient)
}
default {
mstore(add(ptr, 0x84), address())
}
mstore(add(ptr, 0xa4), add(27, shr(_SIGNATURE_V_SHIFT, vs)))
mstore(add(ptr, 0xc4), r)
mstore(add(ptr, 0xe4), and(vs, _SIGNATURE_S_MASK))
mstore(add(ptr, 0x104), 0x120)
mstore(add(ptr, 0x124), _INCH_TAG_LENGTH)
mstore(add(ptr, 0x144), _INCH_TAG)
if iszero(call(gas(), clipper, 0, ptr, 0x149, 0, 0)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
} else {
address clipper = address(clipperExchange);
bytes4 selector = clipperExchange.swap.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, selector)
mstore(add(ptr, 0x04), srcToken_)
mstore(add(ptr, 0x24), dstToken)
mstore(add(ptr, 0x44), inputAmount)
mstore(add(ptr, 0x64), outputAmount)
mstore(add(ptr, 0x84), goodUntil)
mstore(add(ptr, 0xa4), recipient)
mstore(add(ptr, 0xc4), add(27, shr(_SIGNATURE_V_SHIFT, vs)))
mstore(add(ptr, 0xe4), r)
mstore(add(ptr, 0x104), and(vs, _SIGNATURE_S_MASK))
mstore(add(ptr, 0x124), 0x140)
mstore(add(ptr, 0x144), _INCH_TAG_LENGTH)
mstore(add(ptr, 0x164), _INCH_TAG)
if iszero(call(gas(), clipper, 0, ptr, 0x169, 0, 0)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
return outputAmount;
}
}
interface IAggregationExecutor {
function execute(address msgSender) external payable returns(uint256);
}
contract GenericRouter is Pausable, EthReceiver {
using UniERC20 for IERC20;
using SafeERC20 for IERC20;
error ZeroMinReturn();
uint256 private constant _PARTIAL_FILL = 1 << 0;
uint256 private constant _REQUIRES_EXTRA_ETH = 1 << 1;
uint256 private constant _USE_PERMIT2 = 1 << 2;
struct SwapDescription {
IERC20 srcToken;
IERC20 dstToken;
address payable srcReceiver;
address payable dstReceiver;
uint256 amount;
uint256 minReturnAmount;
uint256 flags;
}
function swap(
IAggregationExecutor executor,
SwapDescription calldata desc,
bytes calldata data
)
external
payable
whenNotPaused()
returns (
uint256 returnAmount,
uint256 spentAmount
)
{
if (desc.minReturnAmount == 0) revert ZeroMinReturn();
IERC20 srcToken = desc.srcToken;
IERC20 dstToken = desc.dstToken;
bool srcETH = srcToken.isETH();
if (desc.flags & _REQUIRES_EXTRA_ETH != 0) {
if (msg.value <= (srcETH ? desc.amount : 0)) revert RouterErrors.InvalidMsgValue();
} else {
if (msg.value != (srcETH ? desc.amount : 0)) revert RouterErrors.InvalidMsgValue();
}
if (!srcETH) {
srcToken.safeTransferFromUniversal(msg.sender, desc.srcReceiver, desc.amount, desc.flags & _USE_PERMIT2 != 0);
}
returnAmount = _execute(executor, msg.sender, desc.amount, data);
spentAmount = desc.amount;
if (desc.flags & _PARTIAL_FILL != 0) {
uint256 unspentAmount = srcToken.uniBalanceOf(address(this));
if (unspentAmount > 1) {
unchecked { unspentAmount--; }
spentAmount -= unspentAmount;
srcToken.uniTransfer(payable(msg.sender), unspentAmount);
}
if (returnAmount * desc.amount < desc.minReturnAmount * spentAmount) revert RouterErrors.ReturnAmountIsNotEnough(returnAmount, desc.minReturnAmount * spentAmount / desc.amount);
} else {
if (returnAmount < desc.minReturnAmount) revert RouterErrors.ReturnAmountIsNotEnough(returnAmount, desc.minReturnAmount);
}
address payable dstReceiver = (desc.dstReceiver == address(0)) ? payable(msg.sender) : desc.dstReceiver;
dstToken.uniTransfer(dstReceiver, returnAmount);
}
function _execute(
IAggregationExecutor executor,
address srcTokenOwner,
uint256 inputAmount,
bytes calldata data
) private returns(uint256 result) {
bytes4 executeSelector = executor.execute.selector;
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, executeSelector)
mstore(add(ptr, 0x04), srcTokenOwner)
calldatacopy(add(ptr, 0x24), data.offset, data.length)
mstore(add(add(ptr, 0x24), data.length), inputAmount)
if iszero(call(gas(), executor, callvalue(), ptr, add(0x44, data.length), 0, 0x20)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
result := mload(0)
}
}
}
interface IUniswapV3Pool {
event Swap(
address indexed sender,
address indexed recipient,
int256 amount0,
int256 amount1,
uint160 sqrtPriceX96,
uint128 liquidity,
int24 tick
);
function swap(
address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int256 amount0, int256 amount1);
function token0() external view returns (address);
function token1() external view returns (address);
function fee() external view returns (uint24);
}
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
library ProtocolLib {
using AddressLib for Address;
enum Protocol {
UniswapV2,
UniswapV3,
Curve
}
uint256 private constant _PROTOCOL_OFFSET = 253;
uint256 private constant _WETH_UNWRAP_FLAG = 1 << 252;
uint256 private constant _WETH_NOT_WRAP_FLAG = 1 << 251;
uint256 private constant _USE_PERMIT2_FLAG = 1 << 250;
function protocol(Address self) internal pure returns(Protocol) {
return Protocol((Address.unwrap(self) >> _PROTOCOL_OFFSET));
}
function shouldUnwrapWeth(Address self) internal pure returns(bool) {
return self.getFlag(_WETH_UNWRAP_FLAG);
}
function shouldWrapWeth(Address self) internal pure returns(bool) {
return !self.getFlag(_WETH_NOT_WRAP_FLAG);
}
function usePermit2(Address self) internal pure returns(bool) {
return self.getFlag(_USE_PERMIT2_FLAG);
}
function addressForPreTransfer(Address self) internal view returns(address) {
if (protocol(self) == Protocol.UniswapV2) {
return self.get();
}
return address(this);
}
}
contract UnoswapRouter is Pausable, EthReceiver, IUniswapV3SwapCallback {
using SafeERC20 for IERC20;
using SafeERC20 for IWETH;
using AddressLib for Address;
using ProtocolLib for Address;
error BadPool();
error BadCurveSwapSelector();
address private constant _WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant _ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address private constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
bytes4 private constant _WETH_DEPOSIT_CALL_SELECTOR = 0xd0e30db0;
bytes4 private constant _WETH_WITHDRAW_CALL_SELECTOR = 0x2e1a7d4d;
uint256 private constant _ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
uint256 private constant _SELECTORS = (
(uint256(uint32(IUniswapV3Pool.token0.selector)) << 224) |
(uint256(uint32(IUniswapV3Pool.token1.selector)) << 192) |
(uint256(uint32(IUniswapV3Pool.fee.selector)) << 160) |
(uint256(uint32(IERC20.transfer.selector)) << 128) |
(uint256(uint32(IERC20.transferFrom.selector)) << 96) |
(uint256(uint32(IPermit2.transferFrom.selector)) << 64)
);
uint256 private constant _TOKEN0_SELECTOR_OFFSET = 0;
uint256 private constant _TOKEN1_SELECTOR_OFFSET = 4;
uint256 private constant _FEE_SELECTOR_OFFSET = 8;
uint256 private constant _TRANSFER_SELECTOR_OFFSET = 12;
uint256 private constant _TRANSFER_FROM_SELECTOR_OFFSET = 16;
uint256 private constant _PERMIT2_TRANSFER_FROM_SELECTOR_OFFSET = 20;
bytes32 private constant _POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
bytes32 private constant _FF_FACTORY = 0xff1F98431c8aD98523631AE4a59f267346ea31F9840000000000000000000000;
function unoswap(Address token, uint256 amount, uint256 minReturn, Address dex) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo(msg.sender, msg.sender, token, amount, minReturn, dex);
}
function unoswapTo(Address to, Address token, uint256 amount, uint256 minReturn, Address dex) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo(msg.sender, to.get(), token, amount, minReturn, dex);
}
function ethUnoswap(uint256 minReturn, Address dex) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo(address(this), msg.sender, Address.wrap(uint160(_WETH)), msg.value, minReturn, dex);
}
function ethUnoswapTo(Address to, uint256 minReturn, Address dex) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo(address(this), to.get(), Address.wrap(uint160(_WETH)), msg.value, minReturn, dex);
}
function _unoswapTo(address from, address to, Address token, uint256 amount, uint256 minReturn, Address dex) private whenNotPaused() returns(uint256 returnAmount) {
if (dex.shouldUnwrapWeth()) {
returnAmount = _unoswap(from, address(this), token, amount, minReturn, dex);
IWETH(_WETH).safeWithdrawTo(returnAmount, to);
} else {
returnAmount = _unoswap(from, to, token, amount, minReturn, dex);
}
}
function unoswap2(Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo2(msg.sender, msg.sender, token, amount, minReturn, dex, dex2);
}
function unoswapTo2(Address to, Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo2(msg.sender, to.get(), token, amount, minReturn, dex, dex2);
}
function ethUnoswap2(uint256 minReturn, Address dex, Address dex2) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo2(address(this), msg.sender, Address.wrap(uint160(_WETH)), msg.value, minReturn, dex, dex2);
}
function ethUnoswapTo2(Address to, uint256 minReturn, Address dex, Address dex2) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo2(address(this), to.get(), Address.wrap(uint160(_WETH)), msg.value, minReturn, dex, dex2);
}
function _unoswapTo2(address from, address to, Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2) private whenNotPaused() returns(uint256 returnAmount) {
address pool2 = dex2.addressForPreTransfer();
address target = dex2.shouldUnwrapWeth() ? address(this) : to;
returnAmount = _unoswap(from, pool2, token, amount, 0, dex);
returnAmount = _unoswap(pool2, target, Address.wrap(0), returnAmount, minReturn, dex2);
if (dex2.shouldUnwrapWeth()) {
IWETH(_WETH).safeWithdrawTo(returnAmount, to);
}
}
function unoswap3(Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2, Address dex3) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo3(msg.sender, msg.sender, token, amount, minReturn, dex, dex2, dex3);
}
function unoswapTo3(Address to, Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2, Address dex3) external returns(uint256 returnAmount) {
returnAmount = _unoswapTo3(msg.sender, to.get(), token, amount, minReturn, dex, dex2, dex3);
}
function ethUnoswap3(uint256 minReturn, Address dex, Address dex2, Address dex3) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo3(address(this), msg.sender, Address.wrap(uint160(_WETH)), msg.value, minReturn, dex, dex2, dex3);
}
function ethUnoswapTo3(Address to, uint256 minReturn, Address dex, Address dex2, Address dex3) external payable returns(uint256 returnAmount) {
if (dex.shouldWrapWeth()) {
IWETH(_WETH).safeDeposit(msg.value);
}
returnAmount = _unoswapTo3(address(this), to.get(), Address.wrap(uint160(_WETH)), msg.value, minReturn, dex, dex2, dex3);
}
function _unoswapTo3(address from, address to, Address token, uint256 amount, uint256 minReturn, Address dex, Address dex2, Address dex3) private whenNotPaused() returns(uint256 returnAmount) {
address pool2 = dex2.addressForPreTransfer();
address pool3 = dex3.addressForPreTransfer();
address target = dex3.shouldUnwrapWeth() ? address(this) : to;
returnAmount = _unoswap(from, pool2, token, amount, 0, dex);
returnAmount = _unoswap(pool2, pool3, Address.wrap(0), returnAmount, 0, dex2);
returnAmount = _unoswap(pool3, target, Address.wrap(0), returnAmount, minReturn, dex3);
if (dex3.shouldUnwrapWeth()) {
IWETH(_WETH).safeWithdrawTo(returnAmount, to);
}
}
function _unoswap(
address spender,
address recipient,
Address token,
uint256 amount,
uint256 minReturn,
Address dex
) private returns(uint256 returnAmount) {
ProtocolLib.Protocol protocol = dex.protocol();
if (protocol == ProtocolLib.Protocol.UniswapV3) {
returnAmount = _unoswapV3(spender, recipient, amount, minReturn, dex);
} else if (protocol == ProtocolLib.Protocol.UniswapV2) {
if (spender == address(this)) {
IERC20(token.get()).safeTransfer(dex.get(), amount);
} else if (spender == msg.sender) {
IERC20(token.get()).safeTransferFromUniversal(msg.sender, dex.get(), amount, dex.usePermit2());
}
returnAmount = _unoswapV2(recipient, amount, minReturn, dex);
} else if (protocol == ProtocolLib.Protocol.Curve) {
if (spender == msg.sender && msg.value == 0) {
IERC20(token.get()).safeTransferFromUniversal(msg.sender, address(this), amount, dex.usePermit2());
}
returnAmount = _curfe(recipient, amount, minReturn, dex);
}
}
uint256 private constant _UNISWAP_V2_ZERO_FOR_ONE_OFFSET = 247;
uint256 private constant _UNISWAP_V2_ZERO_FOR_ONE_MASK = 0x01;
uint256 private constant _UNISWAP_V2_NUMERATOR_OFFSET = 160;
uint256 private constant _UNISWAP_V2_NUMERATOR_MASK = 0xffffffff;
bytes4 private constant _UNISWAP_V2_PAIR_RESERVES_CALL_SELECTOR = 0x0902f1ac;
bytes4 private constant _UNISWAP_V2_PAIR_SWAP_CALL_SELECTOR = 0x022c0d9f;
uint256 private constant _UNISWAP_V2_DENOMINATOR = 1e9;
uint256 private constant _UNISWAP_V2_DEFAULT_NUMERATOR = 997_000_000;
error ReservesCallFailed();
function _unoswapV2(
address recipient,
uint256 amount,
uint256 minReturn,
Address dex
) private returns(uint256 ret) {
bytes4 returnAmountNotEnoughException = RouterErrors.ReturnAmountIsNotEnough.selector;
bytes4 reservesCallFailedException = ReservesCallFailed.selector;
assembly ("memory-safe") {
let pool := and(dex, _ADDRESS_MASK)
let zeroForOne := and(shr(_UNISWAP_V2_ZERO_FOR_ONE_OFFSET, dex), _UNISWAP_V2_ZERO_FOR_ONE_MASK)
let numerator := and(shr(_UNISWAP_V2_NUMERATOR_OFFSET, dex), _UNISWAP_V2_NUMERATOR_MASK)
if iszero(numerator) {
numerator := _UNISWAP_V2_DEFAULT_NUMERATOR
}
let ptr := mload(0x40)
mstore(0, _UNISWAP_V2_PAIR_RESERVES_CALL_SELECTOR)
if iszero(staticcall(gas(), pool, 0, 4, 0, 0x40)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
if sub(returndatasize(), 0x60) {
mstore(0, reservesCallFailedException)
revert(0, 4)
}
let reserve0 := mload(mul(0x20, iszero(zeroForOne)))
let reserve1 := mload(mul(0x20, zeroForOne))
ret := mul(amount, numerator)
ret := div(mul(ret, reserve1), add(ret, mul(reserve0, _UNISWAP_V2_DENOMINATOR)))
if lt(ret, minReturn) {
mstore(ptr, returnAmountNotEnoughException)
mstore(add(ptr, 0x04), ret)
mstore(add(ptr, 0x24), minReturn)
revert(ptr, 0x44)
}
mstore(ptr, _UNISWAP_V2_PAIR_SWAP_CALL_SELECTOR)
mstore(add(ptr, 0x04), mul(ret, iszero(zeroForOne)))
mstore(add(ptr, 0x24), mul(ret, zeroForOne))
mstore(add(ptr, 0x44), recipient)
mstore(add(ptr, 0x64), 0x80)
mstore(add(ptr, 0x84), 0)
if iszero(call(gas(), pool, 0, ptr, 0xa4, 0, 0)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
}
}
uint160 private constant _UNISWAP_V3_MIN_SQRT_RATIO = 4295128739 + 1;
uint160 private constant _UNISWAP_V3_MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342 - 1;
uint256 private constant _UNISWAP_V3_ZERO_FOR_ONE_OFFSET = 247;
uint256 private constant _UNISWAP_V3_ZERO_FOR_ONE_MASK = 0x01;
function _unoswapV3(
address spender,
address recipient,
uint256 amount,
uint256 minReturn,
Address dex
) private returns(uint256 ret) {
bytes4 swapSelector = IUniswapV3Pool.swap.selector;
bool usePermit2 = dex.usePermit2();
assembly ("memory-safe") {
let pool := and(dex, _ADDRESS_MASK)
let zeroForOne := and(shr(_UNISWAP_V3_ZERO_FOR_ONE_OFFSET, dex), _UNISWAP_V3_ZERO_FOR_ONE_MASK)
let ptr := mload(0x40)
mstore(ptr, swapSelector)
mstore(add(ptr, 0x04), recipient)
mstore(add(ptr, 0x24), zeroForOne)
mstore(add(ptr, 0x44), amount)
switch zeroForOne
case 1 {
mstore(add(ptr, 0x64), _UNISWAP_V3_MIN_SQRT_RATIO)
}
case 0 {
mstore(add(ptr, 0x64), _UNISWAP_V3_MAX_SQRT_RATIO)
}
mstore(add(ptr, 0x84), 0xa0)
mstore(add(ptr, 0xa4), 0x40)
mstore(add(ptr, 0xc4), spender)
mstore(add(ptr, 0xe4), usePermit2)
if iszero(call(gas(), pool, 0, ptr, 0x0104, 0, 0x40)) {
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
ret := sub(0, mload(mul(0x20, zeroForOne)))
}
if (ret < minReturn) revert RouterErrors.ReturnAmountIsNotEnough(ret, minReturn);
}
uint256 private constant _CURVE_SWAP_SELECTOR_IDX_OFFSET = 184;
uint256 private constant _CURVE_SWAP_SELECTOR_IDX_MASK = 0xff;
uint256 private constant _CURVE_FROM_COINS_SELECTOR_OFFSET = 192;
uint256 private constant _CURVE_FROM_COINS_SELECTOR_MASK = 0xff;
uint256 private constant _CURVE_FROM_COINS_ARG_OFFSET = 200;
uint256 private constant _CURVE_FROM_COINS_ARG_MASK = 0xff;
uint256 private constant _CURVE_TO_COINS_SELECTOR_OFFSET = 208;
uint256 private constant _CURVE_TO_COINS_SELECTOR_MASK = 0xff;
uint256 private constant _CURVE_TO_COINS_ARG_OFFSET = 216;
uint256 private constant _CURVE_TO_COINS_ARG_MASK = 0xff;
uint256 private constant _CURVE_FROM_TOKEN_OFFSET = 224;
uint256 private constant _CURVE_FROM_TOKEN_MASK = 0xff;
uint256 private constant _CURVE_TO_TOKEN_OFFSET = 232;
uint256 private constant _CURVE_TO_TOKEN_MASK = 0xff;
uint256 private constant _CURVE_INPUT_WETH_DEPOSIT_OFFSET = 240;
uint256 private constant _CURVE_INPUT_WETH_WITHDRAW_OFFSET = 241;
uint256 private constant _CURVE_SWAP_USE_ETH_OFFSET = 242;
uint256 private constant _CURVE_SWAP_HAS_ARG_USE_ETH_OFFSET = 243;
uint256 private constant _CURVE_SWAP_HAS_ARG_DESTINATION_OFFSET = 244;
uint256 private constant _CURVE_OUTPUT_WETH_DEPOSIT_OFFSET = 245;
uint256 private constant _CURVE_OUTPUT_WETH_WITHDRAW_OFFSET = 246;
uint256 private constant _CURVE_SWAP_USE_SECOND_OUTPUT_OFFSET = 247;
uint256 private constant _CURVE_SWAP_HAS_ARG_CALLBACK_OFFSET = 249;
bytes32 private constant _CURVE_COINS_SELECTORS = 0x87cb4f5723746eb8c6610657b739953eb9947eb0000000000000000000000000;
bytes32 private constant _CURVE_SWAP_SELECTORS_1 = 0x3df02124a6417ed6ddc1f59d44ee1986ed4ae2b8bf5ed0562f7865a837cab679;
bytes32 private constant _CURVE_SWAP_SELECTORS_2 = 0x2a064e3c5b41b90865b2489ba64833a0e2ad025a394747c5cb7558f1ce7d6503;
bytes32 private constant _CURVE_SWAP_SELECTORS_3 = 0xd2e2833add96994f000000000000000000000000000000000000000000000000;
uint256 private constant _CURVE_MAX_SELECTOR_INDEX = 17;
function _curfe(
address recipient,
uint256 amount,
uint256 minReturn,
Address dex
) private returns(uint256 ret) {
bytes4 callbackSelector = this.curveSwapCallback.selector;
assembly ("memory-safe") {
function reRevert() {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
function callReturnSize(status) -> rds {
if iszero(status) {
reRevert()
}
rds := returndatasize()
}
function tokenBalanceOf(tokenAddress, accountAddress) -> tokenBalance {
mstore(0, 0x70a0823100000000000000000000000000000000000000000000000000000000)
mstore(4, accountAddress)
if iszero(callReturnSize(staticcall(gas(), tokenAddress, 0, 0x24, 0, 0x20))) {
revert(0, 0)
}
tokenBalance := mload(0)
}
function asmApprove(token, to, value, mem) {
let selector := 0x095ea7b300000000000000000000000000000000000000000000000000000000
let exception := 0x3e3f8f7300000000000000000000000000000000000000000000000000000000
if iszero(_asmCall(token, selector, to, value, mem)) {
if iszero(_asmCall(token, selector, to, 0, mem)) {
mstore(mem, exception)
revert(mem, 4)
}
if iszero(_asmCall(token, selector, to, value, mem)) {
mstore(mem, exception)
revert(mem, 4)
}
}
}
function _asmCall(token, selector, to, value, mem) -> done {
mstore(mem, selector)
mstore(add(mem, 0x04), to)
mstore(add(mem, 0x24), value)
let success := call(gas(), token, 0, mem, 0x44, 0x0, 0x20)
done := and(
success,
or(
iszero(returndatasize()),
and(gt(returndatasize(), 31), eq(mload(0), 1))
)
)
}
function curveCoins(pool, selectorOffset, index) -> coin {
mstore(0, _CURVE_COINS_SELECTORS)
mstore(add(selectorOffset, 4), index)
if iszero(staticcall(gas(), pool, selectorOffset, 0x24, 0, 0x20)) {
reRevert()
}
coin := mload(0)
}
let pool := and(dex, _ADDRESS_MASK)
let useEth := and(shr(_CURVE_SWAP_USE_ETH_OFFSET, dex), 0x01)
let hasCallback := and(shr(_CURVE_SWAP_HAS_ARG_CALLBACK_OFFSET, dex), 0x01)
if and(shr(_CURVE_INPUT_WETH_DEPOSIT_OFFSET, dex), 0x01) {
mstore(0, _WETH_DEPOSIT_CALL_SELECTOR)
if iszero(call(gas(), _WETH, amount, 0, 4, 0, 0)) {
reRevert()
}
}
if and(shr(_CURVE_INPUT_WETH_WITHDRAW_OFFSET, dex), 0x01) {
mstore(0, _WETH_WITHDRAW_CALL_SELECTOR)
mstore(4, amount)
if iszero(call(gas(), _WETH, 0, 0, 0x24, 0, 0)) {
reRevert()
}
}
let toToken
{
let toSelectorOffset := and(shr(_CURVE_TO_COINS_SELECTOR_OFFSET, dex), _CURVE_TO_COINS_SELECTOR_MASK)
let toTokenIndex := and(shr(_CURVE_TO_COINS_ARG_OFFSET, dex), _CURVE_TO_COINS_ARG_MASK)
toToken := curveCoins(pool, toSelectorOffset, toTokenIndex)
}
let toTokenIsEth := or(eq(toToken, _ETH), eq(toToken, _WETH))
if and(iszero(hasCallback), or(iszero(useEth), toTokenIsEth)) {
let fromSelectorOffset := and(shr(_CURVE_FROM_COINS_SELECTOR_OFFSET, dex), _CURVE_FROM_COINS_SELECTOR_MASK)
let fromTokenIndex := and(shr(_CURVE_FROM_COINS_ARG_OFFSET, dex), _CURVE_FROM_COINS_ARG_MASK)
let fromToken := curveCoins(pool, fromSelectorOffset, fromTokenIndex)
if eq(fromToken, _ETH) {
fromToken := _WETH
}
asmApprove(fromToken, pool, amount, mload(0x40))
}
let ptr := mload(0x40)
{
let selectorIndex := and(shr(_CURVE_SWAP_SELECTOR_IDX_OFFSET, dex), _CURVE_SWAP_SELECTOR_IDX_MASK)
if gt(selectorIndex, _CURVE_MAX_SELECTOR_INDEX) {
mstore(0, 0xa231cb8200000000000000000000000000000000000000000000000000000000)
revert(0, 4)
}
mstore(ptr, _CURVE_SWAP_SELECTORS_1)
mstore(add(ptr, 0x20), _CURVE_SWAP_SELECTORS_2)
mstore(add(ptr, 0x40), _CURVE_SWAP_SELECTORS_3)
ptr := add(ptr, mul(selectorIndex, 4))
}
mstore(add(ptr, 0x04), and(shr(_CURVE_FROM_TOKEN_OFFSET, dex), _CURVE_FROM_TOKEN_MASK))
mstore(add(ptr, 0x24), and(shr(_CURVE_TO_TOKEN_OFFSET, dex), _CURVE_TO_TOKEN_MASK))
mstore(add(ptr, 0x44), amount)
mstore(add(ptr, 0x64), minReturn)
let offset := 0x84
if and(shr(_CURVE_SWAP_HAS_ARG_USE_ETH_OFFSET, dex), 0x01) {
mstore(add(ptr, offset), useEth)
offset := add(offset, 0x20)
}
switch hasCallback
case 1 {
mstore(add(ptr, offset), address())
mstore(add(ptr, add(offset, 0x20)), recipient)
mstore(add(ptr, add(offset, 0x40)), callbackSelector)
offset := add(offset, 0x60)
}
default {
if and(shr(_CURVE_SWAP_HAS_ARG_DESTINATION_OFFSET, dex), 0x01) {
mstore(add(ptr, offset), recipient)
offset := add(offset, 0x20)
}
}
switch callReturnSize(call(gas(), pool, mul(mul(amount, useEth), iszero(toTokenIsEth)), ptr, offset, 0, 0x40))
case 0 {
switch and(useEth, toTokenIsEth)
case 1 {
ret := balance(address())
}
default {
ret := tokenBalanceOf(toToken, address())
}
ret := sub(ret, 1)
}
default {
ret := mload(mul(0x20, and(shr(_CURVE_SWAP_USE_SECOND_OUTPUT_OFFSET, dex), 0x01)))
}
if iszero(and(shr(_CURVE_SWAP_HAS_ARG_DESTINATION_OFFSET, dex), 0x01)) {
if and(shr(_CURVE_OUTPUT_WETH_DEPOSIT_OFFSET, dex), 0x01) {
mstore(0, _WETH_DEPOSIT_CALL_SELECTOR)
if iszero(call(gas(), _WETH, ret, 0, 4, 0, 0)) {
reRevert()
}
}
if and(shr(_CURVE_OUTPUT_WETH_WITHDRAW_OFFSET, dex), 0x01) {
mstore(0, _WETH_WITHDRAW_CALL_SELECTOR)
mstore(4, ret)
if iszero(call(gas(), _WETH, 0, 0, 0x24, 0, 0)) {
reRevert()
}
}
if xor(recipient, address()) {
switch and(useEth, toTokenIsEth)
case 1 {
if iszero(call(gas(), recipient, ret, 0, 0, 0, 0)) {
reRevert()
}
}
default {
if eq(toToken, _ETH) {
toToken := _WETH
}
if iszero(_asmCall(toToken, 0xa9059cbb00000000000000000000000000000000000000000000000000000000, recipient, ret, ptr)) {
mstore(ptr, 0xf27f64e400000000000000000000000000000000000000000000000000000000)
revert(ptr, 4)
}
}
}
}
}
if (ret < minReturn) revert RouterErrors.ReturnAmountIsNotEnough(ret, minReturn);
}
function curveSwapCallback(
address ,
address ,
address inCoin,
uint256 dx,
uint256
) external {
IERC20(inCoin).safeTransfer(msg.sender, dx);
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata
) external override {
uint256 selectors = _SELECTORS;
assembly ("memory-safe") {
function reRevert() {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
function safeERC20(target, value, mem, memLength, outLen) {
let status := call(gas(), target, value, mem, memLength, 0, outLen)
if iszero(status) {
reRevert()
}
let success := or(
iszero(returndatasize()),
and(gt(returndatasize(), 31), eq(mload(0), 1))
)
if iszero(success) {
mstore(0, 0xf27f64e400000000000000000000000000000000000000000000000000000000)
revert(0, 4)
}
}
let emptyPtr := mload(0x40)
let resultPtr := add(emptyPtr, 0x15)
mstore(emptyPtr, selectors)
let amount
let token
switch sgt(amount0Delta, 0)
case 1 {
if iszero(staticcall(gas(), caller(), add(emptyPtr, _TOKEN0_SELECTOR_OFFSET), 0x4, resultPtr, 0x20)) {
reRevert()
}
token := mload(resultPtr)
amount := amount0Delta
}
default {
if iszero(staticcall(gas(), caller(), add(emptyPtr, _TOKEN1_SELECTOR_OFFSET), 0x4, add(resultPtr, 0x20), 0x20)) {
reRevert()
}
token := mload(add(resultPtr, 0x20))
amount := amount1Delta
}
let payer := calldataload(0x84)
let usePermit2 := calldataload(0xa4)
switch eq(payer, address())
case 1 {
mstore(add(emptyPtr, add(_TRANSFER_SELECTOR_OFFSET, 0x04)), caller())
mstore(add(emptyPtr, add(_TRANSFER_SELECTOR_OFFSET, 0x24)), amount)
safeERC20(token, 0, add(emptyPtr, _TRANSFER_SELECTOR_OFFSET), 0x44, 0x20)
}
default {
switch sgt(amount0Delta, 0)
case 1 {
if iszero(staticcall(gas(), caller(), add(emptyPtr, _TOKEN1_SELECTOR_OFFSET), 0x4, add(resultPtr, 0x20), 0x20)) {
reRevert()
}
}
default {
if iszero(staticcall(gas(), caller(), add(emptyPtr, _TOKEN0_SELECTOR_OFFSET), 0x4, resultPtr, 0x20)) {
reRevert()
}
}
if iszero(staticcall(gas(), caller(), add(emptyPtr, _FEE_SELECTOR_OFFSET), 0x4, add(resultPtr, 0x40), 0x20)) {
reRevert()
}
mstore(emptyPtr, _FF_FACTORY)
mstore(resultPtr, keccak256(resultPtr, 0x60))
mstore(add(resultPtr, 0x20), _POOL_INIT_CODE_HASH)
let pool := and(keccak256(emptyPtr, 0x55), _ADDRESS_MASK)
if xor(pool, caller()) {
mstore(0, 0xb2c0272200000000000000000000000000000000000000000000000000000000)
revert(0, 4)
}
switch usePermit2
case 1 {
mstore(emptyPtr, selectors)
emptyPtr := add(emptyPtr, _PERMIT2_TRANSFER_FROM_SELECTOR_OFFSET)
mstore(add(emptyPtr, 0x04), payer)
mstore(add(emptyPtr, 0x24), caller())
mstore(add(emptyPtr, 0x44), amount)
mstore(add(emptyPtr, 0x64), token)
let success := call(gas(), _PERMIT2, 0, emptyPtr, 0x84, 0, 0)
if success {
success := gt(extcodesize(_PERMIT2), 0)
}
if iszero(success) {
mstore(0, 0xc3f9d33200000000000000000000000000000000000000000000000000000000)
revert(0, 4)
}
}
case 0 {
mstore(emptyPtr, selectors)
emptyPtr := add(emptyPtr, _TRANSFER_FROM_SELECTOR_OFFSET)
mstore(add(emptyPtr, 0x04), payer)
mstore(add(emptyPtr, 0x24), caller())
mstore(add(emptyPtr, 0x44), amount)
safeERC20(token, 0, emptyPtr, 0x64, 0x20)
}
}
}
}
}
contract AggregationRouterV6 is EIP712("1inch Aggregation Router", "6"), Ownable, Pausable,
ClipperRouter, GenericRouter, UnoswapRouter, PermitAndCall, OrderMixin
{
using UniERC20 for IERC20;
error ZeroAddress();
constructor(IWETH weth)
ClipperRouter(weth)
OrderMixin(weth)
Ownable(msg.sender)
{
if (address(weth) == address(0)) revert ZeroAddress();
}
function rescueFunds(IERC20 token, uint256 amount) external onlyOwner {
token.uniTransfer(payable(msg.sender), amount);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function _receive() internal override(EthReceiver, OnlyWethReceiver) {
EthReceiver._receive();
}
}
