Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 76,151 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Execute Batch | 21462493 | 3 hrs ago | IN | 0 ETH | 0.0004694 | ||||
Execute Batch | 21462260 | 4 hrs ago | IN | 0 ETH | 0.00022982 | ||||
Execute Batch | 21462107 | 4 hrs ago | IN | 0 ETH | 0.00023508 | ||||
Execute Batch | 21462105 | 4 hrs ago | IN | 0 ETH | 0.00021933 | ||||
Execute Batch | 21462095 | 4 hrs ago | IN | 0 ETH | 0.00017869 | ||||
Execute Batch | 21461733 | 5 hrs ago | IN | 0 ETH | 0.00021758 | ||||
Execute Batch | 21461592 | 6 hrs ago | IN | 0 ETH | 0.00020534 | ||||
Execute Batch | 21461590 | 6 hrs ago | IN | 0 ETH | 0.00021095 | ||||
Execute Batch | 21460880 | 8 hrs ago | IN | 0 ETH | 0.00028637 | ||||
Execute Batch | 21460217 | 11 hrs ago | IN | 0 ETH | 0.00031023 | ||||
Execute Batch | 21460191 | 11 hrs ago | IN | 0 ETH | 0.00033976 | ||||
Execute Batch | 21459327 | 14 hrs ago | IN | 0 ETH | 0.00029935 | ||||
Execute Batch | 21458640 | 16 hrs ago | IN | 0 ETH | 0.00045541 | ||||
Execute Batch | 21458398 | 17 hrs ago | IN | 0 ETH | 0.00029505 | ||||
Execute Batch | 21458397 | 17 hrs ago | IN | 0 ETH | 0.00029645 | ||||
Execute Batch | 21457909 | 18 hrs ago | IN | 0 ETH | 0.00059326 | ||||
Execute Batch | 21457885 | 18 hrs ago | IN | 0 ETH | 0.00030606 | ||||
Execute Batch | 21457300 | 20 hrs ago | IN | 0 ETH | 0.00033922 | ||||
Execute Batch | 21457287 | 20 hrs ago | IN | 0 ETH | 0.00026563 | ||||
Execute Batch | 21457276 | 20 hrs ago | IN | 0 ETH | 0.00033807 | ||||
Execute Batch | 21456871 | 22 hrs ago | IN | 0 ETH | 0.00027648 | ||||
Execute Batch | 21455969 | 25 hrs ago | IN | 0 ETH | 0.00027809 | ||||
Execute Batch | 21455593 | 26 hrs ago | IN | 0 ETH | 0.00021417 | ||||
Execute Batch | 21455389 | 27 hrs ago | IN | 0 ETH | 0.00026577 | ||||
Execute Batch | 21455131 | 28 hrs ago | IN | 0 ETH | 0.00031722 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
21463187 | 1 hr ago | 0.00026349 ETH | ||||
21463187 | 1 hr ago | 0.09543649 ETH | ||||
21463187 | 1 hr ago | 0.09569999 ETH | ||||
21463187 | 1 hr ago | 0.00000206 ETH | ||||
21463187 | 1 hr ago | 0.13309793 ETH | ||||
21463187 | 1 hr ago | 0.13309999 ETH | ||||
21463176 | 1 hr ago | 1.98819 ETH | ||||
21463176 | 1 hr ago | 1.98819 ETH | ||||
21463094 | 1 hr ago | 0.5854 ETH | ||||
21463094 | 1 hr ago | 0.5854 ETH | ||||
21462893 | 2 hrs ago | 2.25831291 ETH | ||||
21462893 | 2 hrs ago | 2.25831291 ETH | ||||
21462838 | 2 hrs ago | 4.49757275 ETH | ||||
21462838 | 2 hrs ago | 4.49757275 ETH | ||||
21462733 | 2 hrs ago | 0.00043199 ETH | ||||
21462733 | 2 hrs ago | 0.00043199 ETH | ||||
21462683 | 2 hrs ago | 224 wei | ||||
21462683 | 2 hrs ago | 0.22130419 ETH | ||||
21462683 | 2 hrs ago | 0.22130419 ETH | ||||
21462280 | 4 hrs ago | 0.00000864 ETH | ||||
21462280 | 4 hrs ago | 0.19259134 ETH | ||||
21462280 | 4 hrs ago | 0.19259999 ETH | ||||
21462145 | 4 hrs ago | 0.00006807 ETH | ||||
21462145 | 4 hrs ago | 0.00193192 ETH | ||||
21462145 | 4 hrs ago | 0.00199999 ETH |
Loading...
Loading
Contract Name:
ExclusiveDutchOrderReactor
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 1000000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {BaseReactor} from "./BaseReactor.sol"; import {IPermit2} from "permit2/src/interfaces/IPermit2.sol"; import {ExclusivityOverrideLib} from "../lib/ExclusivityOverrideLib.sol"; import {Permit2Lib} from "../lib/Permit2Lib.sol"; import {DutchDecayLib} from "../lib/DutchDecayLib.sol"; import {ExclusiveDutchOrderLib, ExclusiveDutchOrder, DutchOutput, DutchInput} from "../lib/ExclusiveDutchOrderLib.sol"; import {SignedOrder, ResolvedOrder, OrderInfo} from "../base/ReactorStructs.sol"; /// @notice Reactor for exclusive dutch orders contract ExclusiveDutchOrderReactor is BaseReactor { using Permit2Lib for ResolvedOrder; using ExclusiveDutchOrderLib for ExclusiveDutchOrder; using DutchDecayLib for DutchOutput[]; using DutchDecayLib for DutchInput; using ExclusivityOverrideLib for ResolvedOrder; /// @notice thrown when an order's deadline is before its end time error DeadlineBeforeEndTime(); /// @notice thrown when an order's end time is before its start time error OrderEndTimeBeforeStartTime(); /// @notice thrown when an order's inputs and outputs both decay error InputAndOutputDecay(); constructor(IPermit2 _permit2, address _protocolFeeOwner) BaseReactor(_permit2, _protocolFeeOwner) {} /// @inheritdoc BaseReactor function resolve(SignedOrder calldata signedOrder) internal view virtual override returns (ResolvedOrder memory resolvedOrder) { ExclusiveDutchOrder memory order = abi.decode(signedOrder.order, (ExclusiveDutchOrder)); _validateOrder(order); resolvedOrder = ResolvedOrder({ info: order.info, input: order.input.decay(order.decayStartTime, order.decayEndTime), outputs: order.outputs.decay(order.decayStartTime, order.decayEndTime), sig: signedOrder.sig, hash: order.hash() }); resolvedOrder.handleOverride(order.exclusiveFiller, order.decayStartTime, order.exclusivityOverrideBps); } /// @inheritdoc BaseReactor function transferInputTokens(ResolvedOrder memory order, address to) internal override { permit2.permitWitnessTransferFrom( order.toPermit(), order.transferDetails(to), order.info.swapper, order.hash, ExclusiveDutchOrderLib.PERMIT2_ORDER_TYPE, order.sig ); } /// @notice validate the dutch order fields /// - deadline must be greater than or equal than decayEndTime /// - decayEndTime must be greater than or equal to decayStartTime /// - if there's input decay, outputs must not decay /// - for input decay, startAmount must < endAmount /// @dev Throws if the order is invalid function _validateOrder(ExclusiveDutchOrder memory order) internal pure { if (order.info.deadline < order.decayEndTime) { revert DeadlineBeforeEndTime(); } if (order.decayEndTime < order.decayStartTime) { revert OrderEndTimeBeforeStartTime(); } if (order.input.startAmount != order.input.endAmount) { unchecked { for (uint256 i = 0; i < order.outputs.length; i++) { if (order.outputs[i].startAmount != order.outputs[i].endAmount) { revert InputAndOutputDecay(); } } } } } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {SafeTransferLib} from "solmate/src/utils/SafeTransferLib.sol"; import {ReentrancyGuard} from "openzeppelin-contracts/security/ReentrancyGuard.sol"; import {IPermit2} from "permit2/src/interfaces/IPermit2.sol"; import {ERC20} from "solmate/src/tokens/ERC20.sol"; import {ReactorEvents} from "../base/ReactorEvents.sol"; import {ResolvedOrderLib} from "../lib/ResolvedOrderLib.sol"; import {CurrencyLibrary, NATIVE} from "../lib/CurrencyLibrary.sol"; import {IReactorCallback} from "../interfaces/IReactorCallback.sol"; import {IReactor} from "../interfaces/IReactor.sol"; import {ProtocolFees} from "../base/ProtocolFees.sol"; import {SignedOrder, ResolvedOrder, OutputToken} from "../base/ReactorStructs.sol"; /// @notice Generic reactor logic for settling off-chain signed orders /// using arbitrary fill methods specified by a filler abstract contract BaseReactor is IReactor, ReactorEvents, ProtocolFees, ReentrancyGuard { using SafeTransferLib for ERC20; using ResolvedOrderLib for ResolvedOrder; using CurrencyLibrary for address; // Occurs when an output = ETH and the reactor does contain enough ETH but // the direct filler did not include enough ETH in their call to execute/executeBatch error InsufficientEth(); /// @notice permit2 address used for token transfers and signature verification IPermit2 public immutable permit2; constructor(IPermit2 _permit2, address _protocolFeeOwner) ProtocolFees(_protocolFeeOwner) { permit2 = _permit2; } /// @inheritdoc IReactor function execute(SignedOrder calldata order) external payable override nonReentrant { ResolvedOrder[] memory resolvedOrders = new ResolvedOrder[](1); resolvedOrders[0] = resolve(order); _prepare(resolvedOrders); _fill(resolvedOrders); } /// @inheritdoc IReactor function executeWithCallback(SignedOrder calldata order, bytes calldata callbackData) external payable override nonReentrant { ResolvedOrder[] memory resolvedOrders = new ResolvedOrder[](1); resolvedOrders[0] = resolve(order); _prepare(resolvedOrders); IReactorCallback(msg.sender).reactorCallback(resolvedOrders, callbackData); _fill(resolvedOrders); } /// @inheritdoc IReactor function executeBatch(SignedOrder[] calldata orders) external payable override nonReentrant { uint256 ordersLength = orders.length; ResolvedOrder[] memory resolvedOrders = new ResolvedOrder[](ordersLength); unchecked { for (uint256 i = 0; i < ordersLength; i++) { resolvedOrders[i] = resolve(orders[i]); } } _prepare(resolvedOrders); _fill(resolvedOrders); } /// @inheritdoc IReactor function executeBatchWithCallback(SignedOrder[] calldata orders, bytes calldata callbackData) external payable override nonReentrant { uint256 ordersLength = orders.length; ResolvedOrder[] memory resolvedOrders = new ResolvedOrder[](ordersLength); unchecked { for (uint256 i = 0; i < ordersLength; i++) { resolvedOrders[i] = resolve(orders[i]); } } _prepare(resolvedOrders); IReactorCallback(msg.sender).reactorCallback(resolvedOrders, callbackData); _fill(resolvedOrders); } /// @notice validates, injects fees, and transfers input tokens in preparation for order fill /// @param orders The orders to prepare function _prepare(ResolvedOrder[] memory orders) internal { uint256 ordersLength = orders.length; unchecked { for (uint256 i = 0; i < ordersLength; i++) { ResolvedOrder memory order = orders[i]; _injectFees(order); order.validate(msg.sender); transferInputTokens(order, msg.sender); } } } /// @notice fills a list of orders, ensuring all outputs are satisfied /// @param orders The orders to fill function _fill(ResolvedOrder[] memory orders) internal { uint256 ordersLength = orders.length; // attempt to transfer all currencies to all recipients unchecked { // transfer output tokens to their respective recipients for (uint256 i = 0; i < ordersLength; i++) { ResolvedOrder memory resolvedOrder = orders[i]; uint256 outputsLength = resolvedOrder.outputs.length; for (uint256 j = 0; j < outputsLength; j++) { OutputToken memory output = resolvedOrder.outputs[j]; output.token.transferFill(output.recipient, output.amount); } emit Fill(orders[i].hash, msg.sender, resolvedOrder.info.swapper, resolvedOrder.info.nonce); } } // refund any remaining ETH to the filler. Only occurs when filler sends more ETH than required to // `execute()` or `executeBatch()`, or when there is excess contract balance remaining from others // incorrectly calling execute/executeBatch without direct filler method but with a msg.value if (address(this).balance > 0) { CurrencyLibrary.transferNative(msg.sender, address(this).balance); } } receive() external payable { // receive native asset to support native output } /// @notice Resolve order-type specific requirements into a generic order with the final inputs and outputs. /// @param order The encoded order to resolve /// @return resolvedOrder generic resolved order of inputs and outputs /// @dev should revert on any order-type-specific validation errors function resolve(SignedOrder calldata order) internal view virtual returns (ResolvedOrder memory resolvedOrder); /// @notice Transfers tokens to the fillContract /// @param order The encoded order to transfer tokens for /// @param to The address to transfer tokens to function transferInputTokens(ResolvedOrder memory order, address to) internal virtual; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {ISignatureTransfer} from "./ISignatureTransfer.sol"; import {IAllowanceTransfer} from "./IAllowanceTransfer.sol"; /// @notice Permit2 handles signature-based transfers in SignatureTransfer and allowance-based transfers in AllowanceTransfer. /// @dev Users must approve Permit2 before calling any of the transfer functions. interface IPermit2 is ISignatureTransfer, IAllowanceTransfer { // IPermit2 unifies the two interfaces so users have maximal flexibility with their approval. }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {FixedPointMathLib} from "solmate/src/utils/FixedPointMathLib.sol"; import {ResolvedOrder, OutputToken} from "../base/ReactorStructs.sol"; /// @title ExclusiveOverride /// @dev This library handles order exclusivity /// giving the configured filler exclusive rights to fill the order before exclusivityEndTime /// or enforcing an override price improvement by non-exclusive fillers library ExclusivityOverrideLib { using FixedPointMathLib for uint256; /// @notice thrown when an order has strict exclusivity and the filler does not have it error NoExclusiveOverride(); uint256 private constant STRICT_EXCLUSIVITY = 0; uint256 private constant BPS = 10_000; /// @notice Applies exclusivity override to the resolved order if necessary /// @param order The order to apply exclusivity override to /// @param exclusive The exclusive address /// @param exclusivityEndTime The exclusivity end time /// @param exclusivityOverrideBps The exclusivity override BPS function handleOverride( ResolvedOrder memory order, address exclusive, uint256 exclusivityEndTime, uint256 exclusivityOverrideBps ) internal view { // if the filler has fill right, we proceed with the order as-is if (checkExclusivity(exclusive, exclusivityEndTime)) { return; } // if override is 0, then assume strict exclusivity so the order cannot be filled if (exclusivityOverrideBps == STRICT_EXCLUSIVITY) { revert NoExclusiveOverride(); } // scale outputs by override amount OutputToken[] memory outputs = order.outputs; for (uint256 i = 0; i < outputs.length;) { OutputToken memory output = outputs[i]; output.amount = output.amount.mulDivDown(BPS + exclusivityOverrideBps, BPS); unchecked { i++; } } } /// @notice checks if the order currently passes the exclusivity check /// @dev if the order has no exclusivity, always returns true /// @dev if the order has exclusivity and the current filler is the exclusive address, returns true /// @dev if the order has exclusivity and the current filler is not the exclusive address, returns false function checkExclusivity(address exclusive, uint256 exclusivityEndTime) internal view returns (bool pass) { return exclusive == address(0) || block.timestamp > exclusivityEndTime || exclusive == msg.sender; } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ERC20} from "solmate/src/tokens/ERC20.sol"; import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {ResolvedOrder} from "../base/ReactorStructs.sol"; /// @notice handling some permit2-specific encoding library Permit2Lib { /// @notice returns a ResolvedOrder into a permit object function toPermit(ResolvedOrder memory order) internal pure returns (ISignatureTransfer.PermitTransferFrom memory) { return ISignatureTransfer.PermitTransferFrom({ permitted: ISignatureTransfer.TokenPermissions({ token: address(order.input.token), amount: order.input.maxAmount }), nonce: order.info.nonce, deadline: order.info.deadline }); } /// @notice returns a ResolvedOrder into a permit object function transferDetails(ResolvedOrder memory order, address to) internal pure returns (ISignatureTransfer.SignatureTransferDetails memory) { return ISignatureTransfer.SignatureTransferDetails({to: to, requestedAmount: order.input.amount}); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {OutputToken, InputToken} from "../base/ReactorStructs.sol"; import {DutchOutput, DutchInput} from "../lib/DutchOrderLib.sol"; import {FixedPointMathLib} from "solmate/src/utils/FixedPointMathLib.sol"; /// @notice helpers for handling dutch order objects library DutchDecayLib { using FixedPointMathLib for uint256; /// @notice thrown if the decay direction is incorrect /// - for DutchInput, startAmount must be less than or equal toendAmount /// - for DutchOutput, startAmount must be greater than or equal to endAmount error IncorrectAmounts(); /// @notice thrown if the endTime of an order is before startTime error EndTimeBeforeStartTime(); /// @notice calculates an amount using linear decay over time from decayStartTime to decayEndTime /// @dev handles both positive and negative decay depending on startAmount and endAmount /// @param startAmount The amount of tokens at decayStartTime /// @param endAmount The amount of tokens at decayEndTime /// @param decayStartTime The time to start decaying linearly /// @param decayEndTime The time to stop decaying linearly function decay(uint256 startAmount, uint256 endAmount, uint256 decayStartTime, uint256 decayEndTime) internal view returns (uint256 decayedAmount) { if (decayEndTime < decayStartTime) { revert EndTimeBeforeStartTime(); } else if (decayEndTime <= block.timestamp) { decayedAmount = endAmount; } else if (decayStartTime >= block.timestamp) { decayedAmount = startAmount; } else { unchecked { uint256 elapsed = block.timestamp - decayStartTime; uint256 duration = decayEndTime - decayStartTime; if (endAmount < startAmount) { decayedAmount = startAmount - (startAmount - endAmount).mulDivDown(elapsed, duration); } else { decayedAmount = startAmount + (endAmount - startAmount).mulDivDown(elapsed, duration); } } } } /// @notice returns a decayed output using the given dutch spec and times /// @param output The output to decay /// @param decayStartTime The time to start decaying /// @param decayEndTime The time to end decaying /// @return result a decayed output function decay(DutchOutput memory output, uint256 decayStartTime, uint256 decayEndTime) internal view returns (OutputToken memory result) { if (output.startAmount < output.endAmount) { revert IncorrectAmounts(); } uint256 decayedOutput = DutchDecayLib.decay(output.startAmount, output.endAmount, decayStartTime, decayEndTime); result = OutputToken(output.token, decayedOutput, output.recipient); } /// @notice returns a decayed output array using the given dutch spec and times /// @param outputs The output array to decay /// @param decayStartTime The time to start decaying /// @param decayEndTime The time to end decaying /// @return result a decayed output array function decay(DutchOutput[] memory outputs, uint256 decayStartTime, uint256 decayEndTime) internal view returns (OutputToken[] memory result) { uint256 outputLength = outputs.length; result = new OutputToken[](outputLength); unchecked { for (uint256 i = 0; i < outputLength; i++) { result[i] = decay(outputs[i], decayStartTime, decayEndTime); } } } /// @notice returns a decayed input using the given dutch spec and times /// @param input The input to decay /// @param decayStartTime The time to start decaying /// @param decayEndTime The time to end decaying /// @return result a decayed input function decay(DutchInput memory input, uint256 decayStartTime, uint256 decayEndTime) internal view returns (InputToken memory result) { if (input.startAmount > input.endAmount) { revert IncorrectAmounts(); } uint256 decayedInput = DutchDecayLib.decay(input.startAmount, input.endAmount, decayStartTime, decayEndTime); result = InputToken(input.token, decayedInput, input.endAmount); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {OrderInfo} from "../base/ReactorStructs.sol"; import {DutchOutput, DutchInput, DutchOrderLib} from "./DutchOrderLib.sol"; import {OrderInfoLib} from "./OrderInfoLib.sol"; struct ExclusiveDutchOrder { // generic order information OrderInfo info; // The time at which the DutchOutputs start decaying uint256 decayStartTime; // The time at which price becomes static uint256 decayEndTime; // The address who has exclusive rights to the order until decayStartTime address exclusiveFiller; // The amount in bps that a non-exclusive filler needs to improve the outputs by to be able to fill the order uint256 exclusivityOverrideBps; // The tokens that the swapper will provide when settling the order DutchInput input; // The tokens that must be received to satisfy the order DutchOutput[] outputs; } /// @notice helpers for handling dutch order objects library ExclusiveDutchOrderLib { using DutchOrderLib for DutchOutput[]; using OrderInfoLib for OrderInfo; bytes internal constant EXCLUSIVE_DUTCH_LIMIT_ORDER_TYPE = abi.encodePacked( "ExclusiveDutchOrder(", "OrderInfo info,", "uint256 decayStartTime,", "uint256 decayEndTime,", "address exclusiveFiller,", "uint256 exclusivityOverrideBps,", "address inputToken,", "uint256 inputStartAmount,", "uint256 inputEndAmount,", "DutchOutput[] outputs)" ); bytes internal constant ORDER_TYPE = abi.encodePacked( EXCLUSIVE_DUTCH_LIMIT_ORDER_TYPE, DutchOrderLib.DUTCH_OUTPUT_TYPE, OrderInfoLib.ORDER_INFO_TYPE ); bytes32 internal constant ORDER_TYPE_HASH = keccak256(ORDER_TYPE); /// @dev Note that sub-structs have to be defined in alphabetical order in the EIP-712 spec string internal constant PERMIT2_ORDER_TYPE = string( abi.encodePacked( "ExclusiveDutchOrder witness)", DutchOrderLib.DUTCH_OUTPUT_TYPE, EXCLUSIVE_DUTCH_LIMIT_ORDER_TYPE, OrderInfoLib.ORDER_INFO_TYPE, DutchOrderLib.TOKEN_PERMISSIONS_TYPE ) ); /// @notice hash the given order /// @param order the order to hash /// @return the eip-712 order hash function hash(ExclusiveDutchOrder memory order) internal pure returns (bytes32) { return keccak256( abi.encode( ORDER_TYPE_HASH, order.info.hash(), order.decayStartTime, order.decayEndTime, order.exclusiveFiller, order.exclusivityOverrideBps, order.input.token, order.input.startAmount, order.input.endAmount, order.outputs.hash() ) ); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {IReactor} from "../interfaces/IReactor.sol"; import {IValidationCallback} from "../interfaces/IValidationCallback.sol"; import {ERC20} from "solmate/src/tokens/ERC20.sol"; /// @dev generic order information /// should be included as the first field in any concrete order types struct OrderInfo { // The address of the reactor that this order is targeting // Note that this must be included in every order so the swapper // signature commits to the specific reactor that they trust to fill their order properly IReactor reactor; // The address of the user which created the order // Note that this must be included so that order hashes are unique by swapper address swapper; // The nonce of the order, allowing for signature replay protection and cancellation uint256 nonce; // The timestamp after which this order is no longer valid uint256 deadline; // Custom validation contract IValidationCallback additionalValidationContract; // Encoded validation params for additionalValidationContract bytes additionalValidationData; } /// @dev tokens that need to be sent from the swapper in order to satisfy an order struct InputToken { ERC20 token; uint256 amount; // Needed for dutch decaying inputs uint256 maxAmount; } /// @dev tokens that need to be received by the recipient in order to satisfy an order struct OutputToken { address token; uint256 amount; address recipient; } /// @dev generic concrete order that specifies exact tokens which need to be sent and received struct ResolvedOrder { OrderInfo info; InputToken input; OutputToken[] outputs; bytes sig; bytes32 hash; } /// @dev external struct including a generic encoded order and swapper signature /// The order bytes will be parsed and mapped to a ResolvedOrder in the concrete reactor contract struct SignedOrder { bytes order; bytes sig; }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "../tokens/ERC20.sol"; /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol) /// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer. /// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller. library SafeTransferLib { /*////////////////////////////////////////////////////////////// ETH OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferETH(address to, uint256 amount) internal { bool success; /// @solidity memory-safe-assembly assembly { // Transfer the ETH and store if it succeeded or not. success := call(gas(), to, amount, 0, 0, 0, 0) } require(success, "ETH_TRANSFER_FAILED"); } /*////////////////////////////////////////////////////////////// ERC20 OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferFrom( ERC20 token, address from, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "from" argument. mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 100, 0, 32) ) } require(success, "TRANSFER_FROM_FAILED"); } function safeTransfer( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "TRANSFER_FAILED"); } function safeApprove( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "APPROVE_FAILED"); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == _ENTERED; } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it. abstract contract ERC20 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); /*////////////////////////////////////////////////////////////// METADATA STORAGE //////////////////////////////////////////////////////////////*/ string public name; string public symbol; uint8 public immutable decimals; /*////////////////////////////////////////////////////////////// ERC20 STORAGE //////////////////////////////////////////////////////////////*/ uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; /*////////////////////////////////////////////////////////////// EIP-2612 STORAGE //////////////////////////////////////////////////////////////*/ uint256 internal immutable INITIAL_CHAIN_ID; bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR; mapping(address => uint256) public nonces; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor( string memory _name, string memory _symbol, uint8 _decimals ) { name = _name; symbol = _symbol; decimals = _decimals; INITIAL_CHAIN_ID = block.chainid; INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); } /*////////////////////////////////////////////////////////////// ERC20 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 amount) public virtual returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) public virtual returns (bool) { balanceOf[msg.sender] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(msg.sender, to, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual returns (bool) { uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount; balanceOf[from] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } /*////////////////////////////////////////////////////////////// EIP-2612 LOGIC //////////////////////////////////////////////////////////////*/ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED"); // Unchecked because the only math done is incrementing // the owner's nonce which cannot realistically overflow. unchecked { address recoveredAddress = ecrecover( keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( keccak256( "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" ), owner, spender, value, nonces[owner]++, deadline ) ) ) ), v, r, s ); require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER"); allowance[recoveredAddress][spender] = value; } emit Approval(owner, spender, value); } function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator(); } function computeDomainSeparator() internal view virtual returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256("1"), block.chainid, address(this) ) ); } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; // Cannot underflow because a user's balance // will never be larger than the total supply. unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; /// @notice standardized events that should be emitted by all reactors /// @dev collated into one library to help with forge expectEmit integration /// @dev and for reactors which dont use base interface ReactorEvents { /// @notice emitted when an order is filled /// @param orderHash The hash of the order that was filled /// @param filler The address which executed the fill /// @param nonce The nonce of the filled order /// @param swapper The swapper of the filled order event Fill(bytes32 indexed orderHash, address indexed filler, address indexed swapper, uint256 nonce); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ResolvedOrder} from "../base/ReactorStructs.sol"; import {IValidationCallback} from "../interfaces/IValidationCallback.sol"; library ResolvedOrderLib { /// @notice thrown when the order targets a different reactor error InvalidReactor(); /// @notice thrown if the order has expired error DeadlinePassed(); /// @notice Validates a resolved order, reverting if invalid /// @param filler The filler of the order function validate(ResolvedOrder memory resolvedOrder, address filler) internal view { if (address(this) != address(resolvedOrder.info.reactor)) { revert InvalidReactor(); } if (block.timestamp > resolvedOrder.info.deadline) { revert DeadlinePassed(); } if (address(resolvedOrder.info.additionalValidationContract) != address(0)) { resolvedOrder.info.additionalValidationContract.validate(filler, resolvedOrder); } } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ERC20} from "solmate/src/tokens/ERC20.sol"; import {IPermit2} from "permit2/src/interfaces/IPermit2.sol"; import {SafeCast} from "openzeppelin-contracts/utils/math/SafeCast.sol"; import {SafeTransferLib} from "solmate/src/utils/SafeTransferLib.sol"; address constant NATIVE = 0x0000000000000000000000000000000000000000; uint256 constant TRANSFER_NATIVE_GAS_LIMIT = 6900; /// @title CurrencyLibrary /// @dev This library allows for transferring native ETH and ERC20s via direct filler OR fill contract. library CurrencyLibrary { using SafeTransferLib for ERC20; /// @notice Thrown when a native transfer fails error NativeTransferFailed(); /// @notice Get the balance of a currency for addr /// @param currency The currency to get the balance of /// @param addr The address to get the balance of /// @return balance The balance of the currency for addr function balanceOf(address currency, address addr) internal view returns (uint256 balance) { if (isNative(currency)) { balance = addr.balance; } else { balance = ERC20(currency).balanceOf(addr); } } /// @notice Transfer currency from the caller to recipient /// @dev for native outputs we will already have the currency in local balance /// @param currency The currency to transfer /// @param recipient The recipient of the currency /// @param amount The amount of currency to transfer function transferFill(address currency, address recipient, uint256 amount) internal { if (isNative(currency)) { // we will have received native assets directly so can directly transfer transferNative(recipient, amount); } else { // else the caller must have approved the token for the fill ERC20(currency).safeTransferFrom(msg.sender, recipient, amount); } } /// @notice Transfer native currency to recipient /// @param recipient The recipient of the currency /// @param amount The amount of currency to transfer function transferNative(address recipient, uint256 amount) internal { (bool success,) = recipient.call{value: amount, gas: TRANSFER_NATIVE_GAS_LIMIT}(""); if (!success) revert NativeTransferFailed(); } /// @notice returns true if currency is native /// @param currency The currency to check /// @return true if currency is native function isNative(address currency) internal pure returns (bool) { return currency == NATIVE; } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ResolvedOrder} from "../base/ReactorStructs.sol"; /// @notice Callback for executing orders through a reactor. interface IReactorCallback { /// @notice Called by the reactor during the execution of an order /// @param resolvedOrders Has inputs and outputs /// @param callbackData The callbackData specified for an order execution /// @dev Must have approved each token and amount in outputs to the msg.sender function reactorCallback(ResolvedOrder[] memory resolvedOrders, bytes memory callbackData) external; }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ResolvedOrder, SignedOrder} from "../base/ReactorStructs.sol"; import {IReactorCallback} from "./IReactorCallback.sol"; /// @notice Interface for order execution reactors interface IReactor { /// @notice Execute a single order /// @param order The order definition and valid signature to execute function execute(SignedOrder calldata order) external payable; /// @notice Execute a single order using the given callback data /// @param order The order definition and valid signature to execute function executeWithCallback(SignedOrder calldata order, bytes calldata callbackData) external payable; /// @notice Execute the given orders at once /// @param orders The order definitions and valid signatures to execute function executeBatch(SignedOrder[] calldata orders) external payable; /// @notice Execute the given orders at once using a callback with the given callback data /// @param orders The order definitions and valid signatures to execute /// @param callbackData The callbackData to pass to the callback function executeBatchWithCallback(SignedOrder[] calldata orders, bytes calldata callbackData) external payable; }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {Owned} from "solmate/src/auth/Owned.sol"; import {SafeTransferLib} from "solmate/src/utils/SafeTransferLib.sol"; import {FixedPointMathLib} from "solmate/src/utils/FixedPointMathLib.sol"; import {ERC20} from "solmate/src/tokens/ERC20.sol"; import {IProtocolFeeController} from "../interfaces/IProtocolFeeController.sol"; import {CurrencyLibrary} from "../lib/CurrencyLibrary.sol"; import {ResolvedOrder, OutputToken} from "../base/ReactorStructs.sol"; /// @notice Handling for protocol fees abstract contract ProtocolFees is Owned { using SafeTransferLib for ERC20; using FixedPointMathLib for uint256; using CurrencyLibrary for address; /// @notice thrown if two fee outputs have the same token error DuplicateFeeOutput(address duplicateToken); /// @notice thrown if a given fee output is greater than MAX_FEE_BPS of the order outputs error FeeTooLarge(address token, uint256 amount, address recipient); /// @notice thrown if a fee output token does not have a corresponding non-fee output error InvalidFeeToken(address feeToken); event ProtocolFeeControllerSet(address oldFeeController, address newFeeController); uint256 private constant BPS = 10_000; uint256 private constant MAX_FEE_BPS = 5; /// @dev The address of the fee controller IProtocolFeeController public feeController; // @notice Required to customize owner from constructor of BaseReactor.sol constructor(address _owner) Owned(_owner) {} /// @notice Injects fees into an order /// @dev modifies the orders to include protocol fee outputs /// @param order The encoded order to inject fees into function _injectFees(ResolvedOrder memory order) internal view { if (address(feeController) == address(0)) { return; } OutputToken[] memory feeOutputs = feeController.getFeeOutputs(order); uint256 outputsLength = order.outputs.length; uint256 feeOutputsLength = feeOutputs.length; // apply fee outputs // fill new outputs with old outputs OutputToken[] memory newOutputs = new OutputToken[]( outputsLength + feeOutputsLength ); unchecked { for (uint256 i = 0; i < outputsLength; i++) { newOutputs[i] = order.outputs[i]; } } for (uint256 i = 0; i < feeOutputsLength;) { OutputToken memory feeOutput = feeOutputs[i]; // assert no duplicates unchecked { for (uint256 j = 0; j < i; j++) { if (feeOutput.token == feeOutputs[j].token) { revert DuplicateFeeOutput(feeOutput.token); } } } // assert not greater than MAX_FEE_BPS uint256 tokenValue; for (uint256 j = 0; j < outputsLength;) { OutputToken memory output = order.outputs[j]; if (output.token == feeOutput.token) { tokenValue += output.amount; } unchecked { j++; } } // allow fee on input token as well if (address(order.input.token) == feeOutput.token) { tokenValue += order.input.amount; } if (tokenValue == 0) revert InvalidFeeToken(feeOutput.token); if (feeOutput.amount > tokenValue.mulDivDown(MAX_FEE_BPS, BPS)) { revert FeeTooLarge(feeOutput.token, feeOutput.amount, feeOutput.recipient); } newOutputs[outputsLength + i] = feeOutput; unchecked { i++; } } order.outputs = newOutputs; } /// @notice sets the protocol fee controller /// @dev only callable by the owner /// @param _newFeeController the new fee controller function setProtocolFeeController(address _newFeeController) external onlyOwner { address oldFeeController = address(feeController); feeController = IProtocolFeeController(_newFeeController); emit ProtocolFeeControllerSet(oldFeeController, _newFeeController); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; import {IEIP712} from "./IEIP712.sol"; /// @title SignatureTransfer /// @notice Handles ERC20 token transfers through signature based actions /// @dev Requires user's token approval on the Permit2 contract interface ISignatureTransfer is IEIP712 { /// @notice Thrown when the requested amount for a transfer is larger than the permissioned amount /// @param maxAmount The maximum amount a spender can request to transfer error InvalidAmount(uint256 maxAmount); /// @notice Thrown when the number of tokens permissioned to a spender does not match the number of tokens being transferred /// @dev If the spender does not need to transfer the number of tokens permitted, the spender can request amount 0 to be transferred error LengthMismatch(); /// @notice Emits an event when the owner successfully invalidates an unordered nonce. event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask); /// @notice The token and amount details for a transfer signed in the permit transfer signature struct TokenPermissions { // ERC20 token address address token; // the maximum amount that can be spent uint256 amount; } /// @notice The signed permit message for a single token transfer struct PermitTransferFrom { TokenPermissions permitted; // a unique value for every token owner's signature to prevent signature replays uint256 nonce; // deadline on the permit signature uint256 deadline; } /// @notice Specifies the recipient address and amount for batched transfers. /// @dev Recipients and amounts correspond to the index of the signed token permissions array. /// @dev Reverts if the requested amount is greater than the permitted signed amount. struct SignatureTransferDetails { // recipient address address to; // spender requested amount uint256 requestedAmount; } /// @notice Used to reconstruct the signed permit message for multiple token transfers /// @dev Do not need to pass in spender address as it is required that it is msg.sender /// @dev Note that a user still signs over a spender address struct PermitBatchTransferFrom { // the tokens and corresponding amounts permitted for a transfer TokenPermissions[] permitted; // a unique value for every token owner's signature to prevent signature replays uint256 nonce; // deadline on the permit signature uint256 deadline; } /// @notice A map from token owner address and a caller specified word index to a bitmap. Used to set bits in the bitmap to prevent against signature replay protection /// @dev Uses unordered nonces so that permit messages do not need to be spent in a certain order /// @dev The mapping is indexed first by the token owner, then by an index specified in the nonce /// @dev It returns a uint256 bitmap /// @dev The index, or wordPosition is capped at type(uint248).max function nonceBitmap(address, uint256) external view returns (uint256); /// @notice Transfers a token using a signed permit message /// @dev Reverts if the requested amount is greater than the permitted signed amount /// @param permit The permit data signed over by the owner /// @param owner The owner of the tokens to transfer /// @param transferDetails The spender's requested transfer details for the permitted token /// @param signature The signature to verify function permitTransferFrom( PermitTransferFrom memory permit, SignatureTransferDetails calldata transferDetails, address owner, bytes calldata signature ) external; /// @notice Transfers a token using a signed permit message /// @notice Includes extra data provided by the caller to verify signature over /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition /// @dev Reverts if the requested amount is greater than the permitted signed amount /// @param permit The permit data signed over by the owner /// @param owner The owner of the tokens to transfer /// @param transferDetails The spender's requested transfer details for the permitted token /// @param witness Extra data to include when checking the user signature /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash /// @param signature The signature to verify function permitWitnessTransferFrom( PermitTransferFrom memory permit, SignatureTransferDetails calldata transferDetails, address owner, bytes32 witness, string calldata witnessTypeString, bytes calldata signature ) external; /// @notice Transfers multiple tokens using a signed permit message /// @param permit The permit data signed over by the owner /// @param owner The owner of the tokens to transfer /// @param transferDetails Specifies the recipient and requested amount for the token transfer /// @param signature The signature to verify function permitTransferFrom( PermitBatchTransferFrom memory permit, SignatureTransferDetails[] calldata transferDetails, address owner, bytes calldata signature ) external; /// @notice Transfers multiple tokens using a signed permit message /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition /// @notice Includes extra data provided by the caller to verify signature over /// @param permit The permit data signed over by the owner /// @param owner The owner of the tokens to transfer /// @param transferDetails Specifies the recipient and requested amount for the token transfer /// @param witness Extra data to include when checking the user signature /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash /// @param signature The signature to verify function permitWitnessTransferFrom( PermitBatchTransferFrom memory permit, SignatureTransferDetails[] calldata transferDetails, address owner, bytes32 witness, string calldata witnessTypeString, bytes calldata signature ) external; /// @notice Invalidates the bits specified in mask for the bitmap at the word position /// @dev The wordPos is maxed at type(uint248).max /// @param wordPos A number to index the nonceBitmap at /// @param mask A bitmap masked against msg.sender's current bitmap at the word position function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; import {IEIP712} from "./IEIP712.sol"; /// @title AllowanceTransfer /// @notice Handles ERC20 token permissions through signature based allowance setting and ERC20 token transfers by checking allowed amounts /// @dev Requires user's token approval on the Permit2 contract interface IAllowanceTransfer is IEIP712 { /// @notice Thrown when an allowance on a token has expired. /// @param deadline The timestamp at which the allowed amount is no longer valid error AllowanceExpired(uint256 deadline); /// @notice Thrown when an allowance on a token has been depleted. /// @param amount The maximum amount allowed error InsufficientAllowance(uint256 amount); /// @notice Thrown when too many nonces are invalidated. error ExcessiveInvalidation(); /// @notice Emits an event when the owner successfully invalidates an ordered nonce. event NonceInvalidation( address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce ); /// @notice Emits an event when the owner successfully sets permissions on a token for the spender. event Approval( address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration ); /// @notice Emits an event when the owner successfully sets permissions using a permit signature on a token for the spender. event Permit( address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce ); /// @notice Emits an event when the owner sets the allowance back to 0 with the lockdown function. event Lockdown(address indexed owner, address token, address spender); /// @notice The permit data for a token struct PermitDetails { // ERC20 token address address token; // the maximum amount allowed to spend uint160 amount; // timestamp at which a spender's token allowances become invalid uint48 expiration; // an incrementing value indexed per owner,token,and spender for each signature uint48 nonce; } /// @notice The permit message signed for a single token allownce struct PermitSingle { // the permit data for a single token alownce PermitDetails details; // address permissioned on the allowed tokens address spender; // deadline on the permit signature uint256 sigDeadline; } /// @notice The permit message signed for multiple token allowances struct PermitBatch { // the permit data for multiple token allowances PermitDetails[] details; // address permissioned on the allowed tokens address spender; // deadline on the permit signature uint256 sigDeadline; } /// @notice The saved permissions /// @dev This info is saved per owner, per token, per spender and all signed over in the permit message /// @dev Setting amount to type(uint160).max sets an unlimited approval struct PackedAllowance { // amount allowed uint160 amount; // permission expiry uint48 expiration; // an incrementing value indexed per owner,token,and spender for each signature uint48 nonce; } /// @notice A token spender pair. struct TokenSpenderPair { // the token the spender is approved address token; // the spender address address spender; } /// @notice Details for a token transfer. struct AllowanceTransferDetails { // the owner of the token address from; // the recipient of the token address to; // the amount of the token uint160 amount; // the token to be transferred address token; } /// @notice A mapping from owner address to token address to spender address to PackedAllowance struct, which contains details and conditions of the approval. /// @notice The mapping is indexed in the above order see: allowance[ownerAddress][tokenAddress][spenderAddress] /// @dev The packed slot holds the allowed amount, expiration at which the allowed amount is no longer valid, and current nonce thats updated on any signature based approvals. function allowance(address user, address token, address spender) external view returns (uint160 amount, uint48 expiration, uint48 nonce); /// @notice Approves the spender to use up to amount of the specified token up until the expiration /// @param token The token to approve /// @param spender The spender address to approve /// @param amount The approved amount of the token /// @param expiration The timestamp at which the approval is no longer valid /// @dev The packed allowance also holds a nonce, which will stay unchanged in approve /// @dev Setting amount to type(uint160).max sets an unlimited approval function approve(address token, address spender, uint160 amount, uint48 expiration) external; /// @notice Permit a spender to a given amount of the owners token via the owner's EIP-712 signature /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce /// @param owner The owner of the tokens being approved /// @param permitSingle Data signed over by the owner specifying the terms of approval /// @param signature The owner's signature over the permit data function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external; /// @notice Permit a spender to the signed amounts of the owners tokens via the owner's EIP-712 signature /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce /// @param owner The owner of the tokens being approved /// @param permitBatch Data signed over by the owner specifying the terms of approval /// @param signature The owner's signature over the permit data function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external; /// @notice Transfer approved tokens from one address to another /// @param from The address to transfer from /// @param to The address of the recipient /// @param amount The amount of the token to transfer /// @param token The token address to transfer /// @dev Requires the from address to have approved at least the desired amount /// of tokens to msg.sender. function transferFrom(address from, address to, uint160 amount, address token) external; /// @notice Transfer approved tokens in a batch /// @param transferDetails Array of owners, recipients, amounts, and tokens for the transfers /// @dev Requires the from addresses to have approved at least the desired amount /// of tokens to msg.sender. function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external; /// @notice Enables performing a "lockdown" of the sender's Permit2 identity /// by batch revoking approvals /// @param approvals Array of approvals to revoke. function lockdown(TokenSpenderPair[] calldata approvals) external; /// @notice Invalidate nonces for a given (token, spender) pair /// @param token The token to invalidate nonces for /// @param spender The spender to invalidate nonces for /// @param newNonce The new nonce to set. Invalidates all nonces less than it. /// @dev Can't invalidate more than 2**16 nonces per transaction. function invalidateNonces(address token, address spender, uint48 newNonce) external; }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Arithmetic library with operations for fixed-point numbers. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol) /// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol) library FixedPointMathLib { /*////////////////////////////////////////////////////////////// SIMPLIFIED FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ uint256 internal constant MAX_UINT256 = 2**256 - 1; uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s. function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down. } function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up. } function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down. } function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up. } /*////////////////////////////////////////////////////////////// LOW LEVEL FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ function mulDivDown( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // Divide x * y by the denominator. z := div(mul(x, y), denominator) } } function mulDivUp( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // If x * y modulo the denominator is strictly greater than 0, // 1 is added to round up the division of x * y by the denominator. z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator)) } } function rpow( uint256 x, uint256 n, uint256 scalar ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { switch x case 0 { switch n case 0 { // 0 ** 0 = 1 z := scalar } default { // 0 ** n = 0 z := 0 } } default { switch mod(n, 2) case 0 { // If n is even, store scalar in z for now. z := scalar } default { // If n is odd, store x in z for now. z := x } // Shifting right by 1 is like dividing by 2. let half := shr(1, scalar) for { // Shift n right by 1 before looping to halve it. n := shr(1, n) } n { // Shift n right by 1 each iteration to halve it. n := shr(1, n) } { // Revert immediately if x ** 2 would overflow. // Equivalent to iszero(eq(div(xx, x), x)) here. if shr(128, x) { revert(0, 0) } // Store x squared. let xx := mul(x, x) // Round to the nearest number. let xxRound := add(xx, half) // Revert if xx + half overflowed. if lt(xxRound, xx) { revert(0, 0) } // Set x to scaled xxRound. x := div(xxRound, scalar) // If n is even: if mod(n, 2) { // Compute z * x. let zx := mul(z, x) // If z * x overflowed: if iszero(eq(div(zx, x), z)) { // Revert if x is non-zero. if iszero(iszero(x)) { revert(0, 0) } } // Round to the nearest number. let zxRound := add(zx, half) // Revert if zx + half overflowed. if lt(zxRound, zx) { revert(0, 0) } // Return properly scaled zxRound. z := div(zxRound, scalar) } } } } } /*////////////////////////////////////////////////////////////// GENERAL NUMBER UTILITIES //////////////////////////////////////////////////////////////*/ function sqrt(uint256 x) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { let y := x // We start y at x, which will help us make our initial estimate. z := 181 // The "correct" value is 1, but this saves a multiplication later. // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically. // We check y >= 2^(k + 8) but shift right by k bits // each branch to ensure that if x >= 256, then y >= 256. if iszero(lt(y, 0x10000000000000000000000000000000000)) { y := shr(128, y) z := shl(64, z) } if iszero(lt(y, 0x1000000000000000000)) { y := shr(64, y) z := shl(32, z) } if iszero(lt(y, 0x10000000000)) { y := shr(32, y) z := shl(16, z) } if iszero(lt(y, 0x1000000)) { y := shr(16, y) z := shl(8, z) } // Goal was to get z*z*y within a small factor of x. More iterations could // get y in a tighter range. Currently, we will have y in [256, 256*2^16). // We ensured y >= 256 so that the relative difference between y and y+1 is small. // That's not possible if x < 256 but we can just verify those cases exhaustively. // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256. // Correctness can be checked exhaustively for x < 256, so we assume y >= 256. // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps. // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256. // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18. // There is no overflow risk here since y < 2^136 after the first branch above. z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181. // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough. z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) // If x+1 is a perfect square, the Babylonian method cycles between // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor. // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case. // If you don't care whether the floor or ceil square root is returned, you can remove this statement. z := sub(z, lt(div(x, z), z)) } } function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Mod x by y. Note this will return // 0 instead of reverting if y is zero. z := mod(x, y) } } function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) { /// @solidity memory-safe-assembly assembly { // Divide x by y. Note this will return // 0 instead of reverting if y is zero. r := div(x, y) } } function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Add 1 to x * y if x % y > 0. Note this will // return 0 instead of reverting if y is zero. z := add(gt(mod(x, y), 0), div(x, y)) } } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {OrderInfo} from "../base/ReactorStructs.sol"; import {OrderInfoLib} from "./OrderInfoLib.sol"; import {ERC20} from "solmate/src/tokens/ERC20.sol"; /// @dev An amount of output tokens that decreases linearly over time struct DutchOutput { // The ERC20 token address (or native ETH address) address token; // The amount of tokens at the start of the time period uint256 startAmount; // The amount of tokens at the end of the time period uint256 endAmount; // The address who must receive the tokens to satisfy the order address recipient; } /// @dev An amount of input tokens that increases linearly over time struct DutchInput { // The ERC20 token address ERC20 token; // The amount of tokens at the start of the time period uint256 startAmount; // The amount of tokens at the end of the time period uint256 endAmount; } struct DutchOrder { // generic order information OrderInfo info; // The time at which the DutchOutputs start decaying uint256 decayStartTime; // The time at which price becomes static uint256 decayEndTime; // The tokens that the swapper will provide when settling the order DutchInput input; // The tokens that must be received to satisfy the order DutchOutput[] outputs; } /// @notice helpers for handling dutch order objects library DutchOrderLib { using OrderInfoLib for OrderInfo; bytes internal constant DUTCH_OUTPUT_TYPE = "DutchOutput(address token,uint256 startAmount,uint256 endAmount,address recipient)"; bytes32 internal constant DUTCH_OUTPUT_TYPE_HASH = keccak256(DUTCH_OUTPUT_TYPE); bytes internal constant DUTCH_LIMIT_ORDER_TYPE = abi.encodePacked( "DutchOrder(", "OrderInfo info,", "uint256 decayStartTime,", "uint256 decayEndTime,", "address inputToken,", "uint256 inputStartAmount,", "uint256 inputEndAmount,", "DutchOutput[] outputs)" ); /// @dev Note that sub-structs have to be defined in alphabetical order in the EIP-712 spec bytes internal constant ORDER_TYPE = abi.encodePacked(DUTCH_LIMIT_ORDER_TYPE, DUTCH_OUTPUT_TYPE, OrderInfoLib.ORDER_INFO_TYPE); bytes32 internal constant ORDER_TYPE_HASH = keccak256(ORDER_TYPE); string internal constant TOKEN_PERMISSIONS_TYPE = "TokenPermissions(address token,uint256 amount)"; string internal constant PERMIT2_ORDER_TYPE = string(abi.encodePacked("DutchOrder witness)", ORDER_TYPE, TOKEN_PERMISSIONS_TYPE)); /// @notice hash the given output /// @param output the output to hash /// @return the eip-712 output hash function hash(DutchOutput memory output) internal pure returns (bytes32) { return keccak256( abi.encode(DUTCH_OUTPUT_TYPE_HASH, output.token, output.startAmount, output.endAmount, output.recipient) ); } /// @notice hash the given outputs /// @param outputs the outputs to hash /// @return the eip-712 outputs hash function hash(DutchOutput[] memory outputs) internal pure returns (bytes32) { unchecked { bytes memory packedHashes = new bytes(32 * outputs.length); for (uint256 i = 0; i < outputs.length; i++) { bytes32 outputHash = hash(outputs[i]); assembly { mstore(add(add(packedHashes, 0x20), mul(i, 0x20)), outputHash) } } return keccak256(packedHashes); } } /// @notice hash the given order /// @param order the order to hash /// @return the eip-712 order hash function hash(DutchOrder memory order) internal pure returns (bytes32) { return keccak256( abi.encode( ORDER_TYPE_HASH, order.info.hash(), order.decayStartTime, order.decayEndTime, order.input.token, order.input.startAmount, order.input.endAmount, hash(order.outputs) ) ); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {OrderInfo} from "../base/ReactorStructs.sol"; /// @notice helpers for handling OrderInfo objects library OrderInfoLib { bytes internal constant ORDER_INFO_TYPE = "OrderInfo(address reactor,address swapper,uint256 nonce,uint256 deadline,address additionalValidationContract,bytes additionalValidationData)"; bytes32 internal constant ORDER_INFO_TYPE_HASH = keccak256(ORDER_INFO_TYPE); /// @notice hash an OrderInfo object /// @param info The OrderInfo object to hash function hash(OrderInfo memory info) internal pure returns (bytes32) { return keccak256( abi.encode( ORDER_INFO_TYPE_HASH, info.reactor, info.swapper, info.nonce, info.deadline, info.additionalValidationContract, keccak256(info.additionalValidationData) ) ); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {OrderInfo, ResolvedOrder} from "../base/ReactorStructs.sol"; /// @notice Callback to validate an order interface IValidationCallback { /// @notice Called by the reactor for custom validation of an order. Will revert if validation fails /// @param filler The filler of the order /// @param resolvedOrder The resolved order to fill function validate(address filler, ResolvedOrder calldata resolvedOrder) external view; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Simple single owner authorization mixin. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol) abstract contract Owned { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event OwnershipTransferred(address indexed user, address indexed newOwner); /*////////////////////////////////////////////////////////////// OWNERSHIP STORAGE //////////////////////////////////////////////////////////////*/ address public owner; modifier onlyOwner() virtual { require(msg.sender == owner, "UNAUTHORIZED"); _; } /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor(address _owner) { owner = _owner; emit OwnershipTransferred(address(0), _owner); } /*////////////////////////////////////////////////////////////// OWNERSHIP LOGIC //////////////////////////////////////////////////////////////*/ function transferOwnership(address newOwner) public virtual onlyOwner { owner = newOwner; emit OwnershipTransferred(msg.sender, newOwner); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import {ResolvedOrder, OutputToken} from "../base/ReactorStructs.sol"; /// @notice Interface for getting fee outputs interface IProtocolFeeController { /// @notice Get fee outputs for the given orders /// @param order The orders to get fee outputs for /// @return List of fee outputs to append for each provided order function getFeeOutputs(ResolvedOrder memory order) external view returns (OutputToken[] memory); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; interface IEIP712 { function DOMAIN_SEPARATOR() external view returns (bytes32); }
{ "remappings": [ "ds-test/=lib/forge-std/lib/ds-test/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-gas-snapshot/=lib/forge-gas-snapshot/src/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/", "openzeppelin/=lib/openzeppelin-contracts/contracts/", "permit2/=lib/permit2/", "solmate/=lib/solmate/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "metadata": { "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IPermit2","name":"_permit2","type":"address"},{"internalType":"address","name":"_protocolFeeOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DeadlineBeforeEndTime","type":"error"},{"inputs":[],"name":"DeadlinePassed","type":"error"},{"inputs":[{"internalType":"address","name":"duplicateToken","type":"address"}],"name":"DuplicateFeeOutput","type":"error"},{"inputs":[],"name":"EndTimeBeforeStartTime","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"FeeTooLarge","type":"error"},{"inputs":[],"name":"IncorrectAmounts","type":"error"},{"inputs":[],"name":"InputAndOutputDecay","type":"error"},{"inputs":[],"name":"InsufficientEth","type":"error"},{"inputs":[{"internalType":"address","name":"feeToken","type":"address"}],"name":"InvalidFeeToken","type":"error"},{"inputs":[],"name":"InvalidReactor","type":"error"},{"inputs":[],"name":"NativeTransferFailed","type":"error"},{"inputs":[],"name":"NoExclusiveOverride","type":"error"},{"inputs":[],"name":"OrderEndTimeBeforeStartTime","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"filler","type":"address"},{"indexed":true,"internalType":"address","name":"swapper","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"Fill","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldFeeController","type":"address"},{"indexed":false,"internalType":"address","name":"newFeeController","type":"address"}],"name":"ProtocolFeeControllerSet","type":"event"},{"inputs":[{"components":[{"internalType":"bytes","name":"order","type":"bytes"},{"internalType":"bytes","name":"sig","type":"bytes"}],"internalType":"struct SignedOrder","name":"order","type":"tuple"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"order","type":"bytes"},{"internalType":"bytes","name":"sig","type":"bytes"}],"internalType":"struct SignedOrder[]","name":"orders","type":"tuple[]"}],"name":"executeBatch","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"order","type":"bytes"},{"internalType":"bytes","name":"sig","type":"bytes"}],"internalType":"struct SignedOrder[]","name":"orders","type":"tuple[]"},{"internalType":"bytes","name":"callbackData","type":"bytes"}],"name":"executeBatchWithCallback","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"order","type":"bytes"},{"internalType":"bytes","name":"sig","type":"bytes"}],"internalType":"struct SignedOrder","name":"order","type":"tuple"},{"internalType":"bytes","name":"callbackData","type":"bytes"}],"name":"executeWithCallback","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"feeController","outputs":[{"internalType":"contract IProtocolFeeController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permit2","outputs":[{"internalType":"contract IPermit2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newFeeController","type":"address"}],"name":"setProtocolFeeController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
60a06040523480156200001157600080fd5b5060405162003136380380620031368339810160408190526200003491620000b8565b600080546001600160a01b0319166001600160a01b03831690811782556040518492849283928392907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350506001600255506001600160a01b031660805250620000f79050565b6001600160a01b0381168114620000b557600080fd5b50565b60008060408385031215620000cc57600080fd5b8251620000d9816200009f565b6020840151909250620000ec816200009f565b809150509250929050565b60805161301d620001196000396000818160e0015261191b015261301d6000f3fe60806040526004361061009a5760003560e01c80632d771389116100695780636999b3771161004e5780636999b377146101715780638da5cb5b1461019e578063f2fde38b146101cb57600080fd5b80632d7713891461013e5780633f62192e1461015e57600080fd5b80630d335884146100a65780630d7a16c3146100bb57806312261ee7146100ce57806313fb72c71461012b57600080fd5b366100a157005b600080fd5b6100b96100b4366004612281565b6101eb565b005b6100b96100c936600461232f565b610364565b3480156100da57600080fd5b506101027f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b9610139366004612371565b6104c5565b34801561014a57600080fd5b506100b961015936600461240f565b610683565b6100b961016c366004612433565b61078f565b34801561017d57600080fd5b506001546101029073ffffffffffffffffffffffffffffffffffffffff1681565b3480156101aa57600080fd5b506000546101029073ffffffffffffffffffffffffffffffffffffffff1681565b3480156101d757600080fd5b506100b96101e636600461240f565b610894565b6101f3610985565b604080516001808252818301909252600091816020015b6040805161016081018252600060a0820181815260c0830182905260e0830182905261010083018290526101208301829052606061014084018190529083528351808201855282815260208082018490528186018490528085019190915293830181905280830152608082015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90920191018161020a5790505090506102b2846109f6565b816000815181106102c5576102c5612497565b60200260200101819052506102d981610b62565b6040517f585da628000000000000000000000000000000000000000000000000000000008152339063585da6289061031990849087908790600401612699565b600060405180830381600087803b15801561033357600080fd5b505af1158015610347573d6000803e3d6000fd5b5050505061035481610bb3565b5061035f6001600255565b505050565b61036c610985565b8060008167ffffffffffffffff81111561038857610388612468565b60405190808252806020026020018201604052801561044357816020015b6040805161016081018252600060a0820181815260c0830182905260e0830182905261010083018290526101208301829052606061014084018190529083528351808201855282815260208082018490528186018490528085019190915293830181905280830152608082015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9092019101816103a65790505b50905060005b828110156104a25761047d85858381811061046657610466612497565b9050602002810190610478919061275f565b6109f6565b82828151811061048f5761048f612497565b6020908102919091010152600101610449565b506104ac81610b62565b6104b581610bb3565b50506104c16001600255565b5050565b6104cd610985565b8260008167ffffffffffffffff8111156104e9576104e9612468565b6040519080825280602002602001820160405280156105a457816020015b6040805161016081018252600060a0820181815260c0830182905260e0830182905261010083018290526101208301829052606061014084018190529083528351808201855282815260208082018490528186018490528085019190915293830181905280830152608082015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9092019101816105075790505b50905060005b828110156105ec576105c787878381811061046657610466612497565b8282815181106105d9576105d9612497565b60209081029190910101526001016105aa565b506105f681610b62565b6040517f585da628000000000000000000000000000000000000000000000000000000008152339063585da6289061063690849088908890600401612699565b600060405180830381600087803b15801561065057600080fd5b505af1158015610664573d6000803e3d6000fd5b5050505061067181610bb3565b505061067d6001600255565b50505050565b60005473ffffffffffffffffffffffffffffffffffffffff163314610709576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600c60248201527f554e415554484f52495a4544000000000000000000000000000000000000000060448201526064015b60405180910390fd5b6001805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604080519190921680825260208201939093527fb904ae9529e373e48bc82df4326cceaf1b4c472babf37f5b7dec46fecc6b53e0910160405180910390a15050565b610797610985565b604080516001808252818301909252600091816020015b6040805161016081018252600060a0820181815260c0830182905260e0830182905261010083018290526101208301829052606061014084018190529083528351808201855282815260208082018490528186018490528085019190915293830181905280830152608082015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9092019101816107ae579050509050610856826109f6565b8160008151811061086957610869612497565b602002602001018190525061087d81610b62565b61088681610bb3565b506108916001600255565b50565b60005473ffffffffffffffffffffffffffffffffffffffff163314610915576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600c60248201527f554e415554484f52495a454400000000000000000000000000000000000000006044820152606401610700565b600080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081178255604051909133917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a350565b60028054036109f0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610700565b60028055565b6040805161016081018252600060a0820181815260c0830182905260e083018290526101008301829052610120830182905260606101408401819052908352835180820185528281526020808201849052818601849052840152928201839052828201929092526080810182905290610a6f838061279d565b810190610a7c9190612b26565b9050610a8781610d06565b6040518060a0016040528082600001518152602001610abd836020015184604001518560a00151610e339092919063ffffffff16565b8152602001610ae3836020015184604001518560c00151610f059092919063ffffffff16565b8152602001848060200190610af8919061279d565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250505090825250602001610b3b83610fec565b9052606082015160208301516080840151929450610b5c92859291906112be565b50919050565b805160005b8181101561035f576000838281518110610b8357610b83612497565b60200260200101519050610b9681611367565b610ba081336117e1565b610baa8133611919565b50600101610b67565b805160005b81811015610cf5576000838281518110610bd457610bd4612497565b602002602001015190506000816040015151905060005b81811015610c5557600083604001518281518110610c0b57610c0b612497565b60200260200101519050610c4c81604001518260200151836000015173ffffffffffffffffffffffffffffffffffffffff16611cac9092919063ffffffff16565b50600101610beb565b5081600001516020015173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16868581518110610c9e57610c9e612497565b6020026020010151608001517f78ad7ec0e9f89e74012afa58738b6b661c024cb0fd185ee2f616c0a28924bd66856000015160400151604051610ce391815260200190565b60405180910390a45050600101610bb8565b5047156104c1576104c13347611cf3565b60408101518151606001511015610d49576040517f773a618700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806020015181604001511015610d8b576040517f48fee69c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60a08101516040810151602090910151146108915760005b8160c00151518110156104c1578160c001518181518110610dc657610dc6612497565b6020026020010151604001518260c001518281518110610de857610de8612497565b60200260200101516020015114610e2b576040517fd303758b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600101610da3565b610e6d6040518060600160405280600073ffffffffffffffffffffffffffffffffffffffff16815260200160008152602001600081525090565b836040015184602001511115610eaf576040517f7c1f811300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610ec5856020015186604001518686611d92565b60408051606081018252875173ffffffffffffffffffffffffffffffffffffffff1681526020810192909252958601519581019590955250929392505050565b82516060908067ffffffffffffffff811115610f2357610f23612468565b604051908082528060200260200182016040528015610f8c57816020015b60408051606081018252600080825260208083018290529282015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff909201910181610f415790505b50915060005b81811015610fe357610fbe868281518110610faf57610faf612497565b60200260200101518686611e2c565b838281518110610fd057610fd0612497565b6020908102919091010152600101610f92565b50509392505050565b6040517f4578636c757369766544757463684f726465722800000000000000000000000060208201527f4f72646572496e666f20696e666f2c000000000000000000000000000000000060348201527f75696e74323536206465636179537461727454696d652c00000000000000000060438201527f75696e74323536206465636179456e6454696d652c0000000000000000000000605a8201527f61646472657373206578636c757369766546696c6c65722c0000000000000000606f8201527f75696e74323536206578636c757369766974794f766572726964654270732c0060878201527f6164647265737320696e707574546f6b656e2c0000000000000000000000000060a68201527f75696e7432353620696e7075745374617274416d6f756e742c0000000000000060b98201527f75696e7432353620696e707574456e64416d6f756e742c00000000000000000060d28201527f44757463684f75747075745b5d206f757470757473290000000000000000000060e982015260009060ff01604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152608083019091526052808352909190612edb60208301396040518060c00160405280608d8152602001612f5b608d91396040516020016111de93929190612bfa565b604051602081830303815290604052805190602001206112018360000151611efc565b83602001518460400151856060015186608001518760a00151600001518860a00151602001518960a001516040015161123d8b60c00151611f96565b60408051602081019b909b528a01989098526060890196909652608088019490945273ffffffffffffffffffffffffffffffffffffffff92831660a088015260c08701919091521660e0850152610100840152610120830152610140820152610160015b604051602081830303815290604052805190602001209050919050565b6112c88383612034565b61067d5780611303576040517fb9ec1e9600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604084015160005b815181101561135f57600082828151811061132857611328612497565b60200260200101519050611351846127106113439190612c3d565b602083015190612710612081565b60209091015260010161130b565b505050505050565b60015473ffffffffffffffffffffffffffffffffffffffff166113875750565b6001546040517f8aa6cf0300000000000000000000000000000000000000000000000000000000815260009173ffffffffffffffffffffffffffffffffffffffff1690638aa6cf03906113de908590600401612c77565b600060405180830381865afa1580156113fb573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526114419190810190612c8a565b60408301515181519192509060006114598284612c3d565b67ffffffffffffffff81111561147157611471612468565b6040519080825280602002602001820160405280156114da57816020015b60408051606081018252600080825260208083018290529282015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90920191018161148f5790505b50905060005b8381101561152b57856040015181815181106114fe576114fe612497565b602002602001015182828151811061151857611518612497565b60209081029190910101526001016114e0565b5060005b828110156117d257600085828151811061154b5761154b612497565b6020026020010151905060005b828110156116095786818151811061157257611572612497565b60200260200101516000015173ffffffffffffffffffffffffffffffffffffffff16826000015173ffffffffffffffffffffffffffffffffffffffff16036116015781516040517ffff0830300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff9091166004820152602401610700565b600101611558565b506000805b8681101561168e5760008960400151828151811061162e5761162e612497565b60200260200101519050836000015173ffffffffffffffffffffffffffffffffffffffff16816000015173ffffffffffffffffffffffffffffffffffffffff16036116855760208101516116829084612c3d565b92505b5060010161160e565b50815160208901515173ffffffffffffffffffffffffffffffffffffffff9182169116036116cb5760208089015101516116c89082612c3d565b90505b806000036117205781516040517feddf07f500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff9091166004820152602401610700565b61172e816005612710612081565b826020015111156117a1578151602083015160408085015190517f82e7565600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff93841660048201526024810192909252919091166044820152606401610700565b81846117ad8589612c3d565b815181106117bd576117bd612497565b6020908102919091010152505060010161152f565b50604090940193909352505050565b81515173ffffffffffffffffffffffffffffffffffffffff163014611832576040517f4ddf4a6400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b815160600151421115611871576040517f70f65caa00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81516080015173ffffffffffffffffffffffffffffffffffffffff16156104c1578151608001516040517f6e84ba2b00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff90911690636e84ba2b906118ed9084908690600401612d5a565b60006040518083038186803b15801561190557600080fd5b505afa15801561135f573d6000803e3d6000fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663137c29fe6119d9846040805160a0810182526000606082018181526080830182905282526020820181905291810191909152506040805160a081018252602080840180515173ffffffffffffffffffffffffffffffffffffffff1660608085019182529151850151608085015283528451840151918301919091529251909201519082015290565b6040805180820182526000808252602091820152815180830190925273ffffffffffffffffffffffffffffffffffffffff8616825280870151810151908201528560000151602001518660800151604051806080016040528060528152602001612edb60529139604080517f4578636c757369766544757463684f726465722800000000000000000000000060208201527f4f72646572496e666f20696e666f2c000000000000000000000000000000000060348201527f75696e74323536206465636179537461727454696d652c00000000000000000060438201527f75696e74323536206465636179456e6454696d652c0000000000000000000000605a8201527f61646472657373206578636c757369766546696c6c65722c0000000000000000606f8201527f75696e74323536206578636c757369766974794f766572726964654270732c0060878201527f6164647265737320696e707574546f6b656e2c0000000000000000000000000060a68201527f75696e7432353620696e7075745374617274416d6f756e742c0000000000000060b98201527f75696e7432353620696e707574456e64416d6f756e742c00000000000000000060d28201527f44757463684f75747075745b5d206f757470757473290000000000000000000060e9820152815160df8183030181526101bf8201909252608d60ff820181815291612f5b9061011f01396040518060600160405280602e8152602001612f2d602e9139604051602001611c119493929190612d89565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529082905260608a01517fffffffff0000000000000000000000000000000000000000000000000000000060e089901b168352611c7e9695949392600401612e12565b600060405180830381600087803b158015611c9857600080fd5b505af115801561135f573d6000803e3d6000fd5b73ffffffffffffffffffffffffffffffffffffffff8316611cd15761035f8282611cf3565b61035f73ffffffffffffffffffffffffffffffffffffffff84163384846120bd565b60008273ffffffffffffffffffffffffffffffffffffffff1682611af490604051600060405180830381858888f193505050503d8060008114611d52576040519150601f19603f3d011682016040523d82523d6000602084013e611d57565b606091505b505090508061035f576040517ff4b3b1bc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600082821015611dce576040517f4313345300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b428211611ddc575082611e24565b428310611dea575083611e24565b4283900383830386861015611e0f57611e068688038383612081565b87039250611e21565b611e1c8787038383612081565b870192505b50505b949350505050565b6040805160608101825260008082526020820181905291810191909152836040015184602001511015611e8b576040517f7c1f811300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000611ea1856020015186604001518686611d92565b90506040518060600160405280866000015173ffffffffffffffffffffffffffffffffffffffff168152602001828152602001866060015173ffffffffffffffffffffffffffffffffffffffff168152509150509392505050565b60006040518060c00160405280608d8152602001612f5b608d913980516020918201208351848301516040808701516060880151608089015160a08a015180519089012093516112a198939492939192910196875273ffffffffffffffffffffffffffffffffffffffff958616602088015293851660408701526060860192909252608085015290911660a083015260c082015260e00190565b600080825160200267ffffffffffffffff811115611fb657611fb6612468565b6040519080825280601f01601f191660200182016040528015611fe0576020820181803683370190505b50905060005b835181101561202557600061201385838151811061200657612006612497565b60200260200101516121af565b60208381028501015250600101611fe6565b50805160209091012092915050565b600073ffffffffffffffffffffffffffffffffffffffff8316158061205857508142115b80612078575073ffffffffffffffffffffffffffffffffffffffff831633145b90505b92915050565b6000827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04841183021582026120b657600080fd5b5091020490565b60006040517f23b872dd00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8516600482015273ffffffffffffffffffffffffffffffffffffffff841660248201528260448201526020600060648360008a5af13d15601f3d11600160005114161716915050806121a8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f5452414e534645525f46524f4d5f4641494c45440000000000000000000000006044820152606401610700565b5050505050565b6000604051806080016040528060528152602001612edb605291398051602091820120835184830151604080870151606088015191516112a1969192910194855273ffffffffffffffffffffffffffffffffffffffff93841660208601526040850192909252606084015216608082015260a00190565b600060408284031215610b5c57600080fd5b60008083601f84011261224a57600080fd5b50813567ffffffffffffffff81111561226257600080fd5b60208301915083602082850101111561227a57600080fd5b9250929050565b60008060006040848603121561229657600080fd5b833567ffffffffffffffff808211156122ae57600080fd5b6122ba87838801612226565b945060208601359150808211156122d057600080fd5b506122dd86828701612238565b9497909650939450505050565b60008083601f8401126122fc57600080fd5b50813567ffffffffffffffff81111561231457600080fd5b6020830191508360208260051b850101111561227a57600080fd5b6000806020838503121561234257600080fd5b823567ffffffffffffffff81111561235957600080fd5b612365858286016122ea565b90969095509350505050565b6000806000806040858703121561238757600080fd5b843567ffffffffffffffff8082111561239f57600080fd5b6123ab888389016122ea565b909650945060208701359150808211156123c457600080fd5b506123d187828801612238565b95989497509550505050565b73ffffffffffffffffffffffffffffffffffffffff8116811461089157600080fd5b803561240a816123dd565b919050565b60006020828403121561242157600080fd5b813561242c816123dd565b9392505050565b60006020828403121561244557600080fd5b813567ffffffffffffffff81111561245c57600080fd5b611e2484828501612226565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60005b838110156124e15781810151838201526020016124c9565b50506000910152565b600081518084526125028160208601602086016124c6565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600081518084526020808501945080840160005b83811015612593578151805173ffffffffffffffffffffffffffffffffffffffff908116895284820151858a0152604091820151169088015260609096019590820190600101612548565b509495945050505050565b6000815160e0845273ffffffffffffffffffffffffffffffffffffffff8082511660e08601528060208301511661010086015260408201516101208601526060820151610140860152806080830151166101608601525060a0810151905060c06101808501526126126101a08501826124ea565b905060208301516126506020860182805173ffffffffffffffffffffffffffffffffffffffff16825260208082015190830152604090810151910152565b50604083015184820360808601526126688282612534565b915050606083015184820360a086015261268282826124ea565b915050608083015160c08501528091505092915050565b6000604082016040835280865180835260608501915060608160051b8601019250602080890160005b8381101561270e577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa08887030185526126fc86835161259e565b955093820193908201906001016126c2565b5050858403818701528684528688828601376000848801820152601f9096017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169092019094019695505050505050565b600082357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc183360301811261279357600080fd5b9190910192915050565b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe18436030181126127d257600080fd5b83018035915067ffffffffffffffff8211156127ed57600080fd5b60200191503681900382131561227a57600080fd5b6040516060810167ffffffffffffffff8111828210171561282557612825612468565b60405290565b6040516080810167ffffffffffffffff8111828210171561282557612825612468565b60405160e0810167ffffffffffffffff8111828210171561282557612825612468565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156128b8576128b8612468565b604052919050565b600082601f8301126128d157600080fd5b813567ffffffffffffffff8111156128eb576128eb612468565b61291c60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f84011601612871565b81815284602083860101111561293157600080fd5b816020850160208301376000918101602001919091529392505050565b600060c0828403121561296057600080fd5b60405160c0810167ffffffffffffffff828210818311171561298457612984612468565b8160405282935084359150612998826123dd565b9082526020840135906129aa826123dd565b8160208401526040850135604084015260608501356060840152608085013591506129d4826123dd565b81608084015260a08501359150808211156129ee57600080fd5b506129fb858286016128c0565b60a0830152505092915050565b600060608284031215612a1a57600080fd5b612a22612802565b90508135612a2f816123dd565b80825250602082013560208201526040820135604082015292915050565b600067ffffffffffffffff821115612a6757612a67612468565b5060051b60200190565b600082601f830112612a8257600080fd5b81356020612a97612a9283612a4d565b612871565b82815260079290921b84018101918181019086841115612ab657600080fd5b8286015b84811015612b1b5760808189031215612ad35760008081fd5b612adb61282b565b8135612ae6816123dd565b8152818501358582015260408083013590820152606080830135612b09816123dd565b90820152835291830191608001612aba565b509695505050505050565b600060208284031215612b3857600080fd5b813567ffffffffffffffff80821115612b5057600080fd5b908301906101208286031215612b6557600080fd5b612b6d61284e565b823582811115612b7c57600080fd5b612b888782860161294e565b8252506020830135602082015260408301356040820152612bab606084016123ff565b606082015260808301356080820152612bc78660a08501612a08565b60a082015261010083013582811115612bdf57600080fd5b612beb87828601612a71565b60c08301525095945050505050565b60008451612c0c8184602089016124c6565b845190830190612c208183602089016124c6565b8451910190612c338183602088016124c6565b0195945050505050565b8082018082111561207b577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b602081526000612078602083018461259e565b60006020808385031215612c9d57600080fd5b825167ffffffffffffffff811115612cb457600080fd5b8301601f81018513612cc557600080fd5b8051612cd3612a9282612a4d565b81815260609182028301840191848201919088841115612cf257600080fd5b938501935b83851015612d4e5780858a031215612d0f5760008081fd5b612d17612802565b8551612d22816123dd565b81528587015187820152604080870151612d3b816123dd565b9082015283529384019391850191612cf7565b50979650505050505050565b73ffffffffffffffffffffffffffffffffffffffff83168152604060208201526000611e24604083018461259e565b7f4578636c757369766544757463684f72646572207769746e6573732900000000815260008551612dc181601c850160208a016124c6565b855190830190612dd881601c840160208a016124c6565b8551910190612dee81601c8401602089016124c6565b8451910190612e0481601c8401602088016124c6565b01601c019695505050505050565b6000610140612e42838a51805173ffffffffffffffffffffffffffffffffffffffff168252602090810151910152565b6020890151604084015260408901516060840152612e836080840189805173ffffffffffffffffffffffffffffffffffffffff168252602090810151910152565b73ffffffffffffffffffffffffffffffffffffffff871660c08401528560e084015280610100840152612eb8818401866124ea565b9050828103610120840152612ecd81856124ea565b999850505050505050505056fe44757463684f7574707574286164647265737320746f6b656e2c75696e74323536207374617274416d6f756e742c75696e7432353620656e64416d6f756e742c6164647265737320726563697069656e7429546f6b656e5065726d697373696f6e73286164647265737320746f6b656e2c75696e7432353620616d6f756e74294f72646572496e666f28616464726573732072656163746f722c6164647265737320737761707065722c75696e74323536206e6f6e63652c75696e7432353620646561646c696e652c61646472657373206164646974696f6e616c56616c69646174696f6e436f6e74726163742c6279746573206164646974696f6e616c56616c69646174696f6e4461746129a2646970667358221220895643e805129fd4ed4b9dbb76b8350150a9a20556a76ca1da49adf06223485b64736f6c63430008130033000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba30000000000000000000000001a9c8182c09f50c8318d769245bea52c32be35bc
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba30000000000000000000000001a9c8182c09f50c8318d769245bea52c32be35bc
-----Decoded View---------------
Arg [0] : _permit2 (address): 0x000000000022D473030F116dDEE9F6B43aC78BA3
Arg [1] : _protocolFeeOwner (address): 0x1a9C8182C09F50C8318d769245beA52c32BE35BC
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3
Arg [1] : 0000000000000000000000001a9c8182c09f50c8318d769245bea52c32be35bc
Loading...
Loading
Loading...
Loading
OVERVIEW
Reactor contract to settle Dutch Orders for the UniswapX protocolMultichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.