More Info
Private Name Tags
ContractCreator
Sponsored
Latest 14 from a total of 14 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Execute | 9797792 | 13 hrs ago | IN | 0 ETH | 0.00000063 | ||||
Execute | 9738022 | 46 hrs ago | IN | 0 ETH | 0.00000034 | ||||
Execute | 9607907 | 4 days ago | IN | 0 ETH | 0.00000052 | ||||
Execute | 9607693 | 4 days ago | IN | 0 ETH | 0.00000089 | ||||
Execute | 9607504 | 4 days ago | IN | 0 ETH | 0.00000048 | ||||
Execute | 9606916 | 4 days ago | IN | 0 ETH | 0.00000045 | ||||
Execute | 9606889 | 4 days ago | IN | 0 ETH | 0.00000046 | ||||
Execute | 9606851 | 4 days ago | IN | 0 ETH | 0.00000045 | ||||
Execute | 9606836 | 4 days ago | IN | 0 ETH | 0.00000045 | ||||
Execute | 9606444 | 5 days ago | IN | 0 ETH | 0.00000045 | ||||
Execute | 9606421 | 5 days ago | IN | 0 ETH | 0.00000164 | ||||
Execute | 9605730 | 5 days ago | IN | 0 ETH | 0.00000051 | ||||
Execute | 9356000 | 10 days ago | IN | 0.0005 ETH | 0.00000126 | ||||
Execute | 9285870 | 12 days ago | IN | 0 ETH | 0.0000023 |
Latest 10 internal transactions
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
9797792 | 13 hrs ago | 0.1260821 ETH | ||||
9797792 | 13 hrs ago | 0.1260821 ETH | ||||
9738022 | 46 hrs ago | 0.00110224 ETH | ||||
9738022 | 46 hrs ago | 0.00110224 ETH | ||||
9605730 | 5 days ago | 0.00151739 ETH | ||||
9605730 | 5 days ago | 0.00151739 ETH | ||||
9356000 | 10 days ago | 0.0005 ETH | ||||
9285870 | 12 days ago | 0.0007235 ETH | ||||
9285870 | 12 days ago | 0.0007235 ETH | ||||
8542114 | 29 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
BlastSettler
Compiler Version
v0.8.25+commit.b61c2a91
Optimization Enabled:
Yes with 10000 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 >=0.8.25 ^0.8.17 ^0.8.25; // lib/forge-std/src/interfaces/IERC165.sol interface IERC165 { /// @notice Query if a contract implements an interface /// @param interfaceID The interface identifier, as specified in ERC-165 /// @dev Interface identification is specified in ERC-165. This function /// uses less than 30,000 gas. /// @return `true` if the contract implements `interfaceID` and /// `interfaceID` is not 0xffffffff, `false` otherwise function supportsInterface(bytes4 interfaceID) external view returns (bool); } // lib/forge-std/src/interfaces/IERC20.sol /// @dev Interface of the ERC20 standard as defined in the EIP. /// @dev This includes the optional name, symbol, and decimals metadata. interface IERC20 { /// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`). event Transfer(address indexed from, address indexed to, uint256 value); /// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value` /// is the new allowance. event Approval(address indexed owner, address indexed spender, uint256 value); /// @notice Returns the amount of tokens in existence. function totalSupply() external view returns (uint256); /// @notice Returns the amount of tokens owned by `account`. function balanceOf(address account) external view returns (uint256); /// @notice Moves `amount` tokens from the caller's account to `to`. function transfer(address to, uint256 amount) external returns (bool); /// @notice Returns the remaining number of tokens that `spender` is allowed /// to spend on behalf of `owner` function allowance(address owner, address spender) external view returns (uint256); /// @notice Sets `amount` as the allowance of `spender` over the caller's tokens. /// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 function approve(address spender, uint256 amount) external returns (bool); /// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism. /// `amount` is then deducted from the caller's allowance. function transferFrom(address from, address to, uint256 amount) external returns (bool); /// @notice Returns the name of the token. function name() external view returns (string memory); /// @notice Returns the symbol of the token. function symbol() external view returns (string memory); /// @notice Returns the decimals places of the token. function decimals() external view returns (uint8); } // lib/permit2/src/interfaces/IEIP712.sol interface IEIP712 { function DOMAIN_SEPARATOR() external view returns (bytes32); } // src/Context.sol abstract contract AbstractContext { function _msgSender() internal view virtual returns (address); function _msgData() internal view virtual returns (bytes calldata); function _isForwarded() internal view virtual returns (bool); } abstract contract Context is AbstractContext { function _msgSender() internal view virtual override returns (address) { return msg.sender; } function _msgData() internal view virtual override returns (bytes calldata) { return msg.data; } function _isForwarded() internal view virtual override returns (bool) { return false; } } // src/IERC721Owner.sol interface IERC721Owner { function ownerOf(uint256) external view returns (address); } // src/allowanceholder/IAllowanceHolder.sol interface IAllowanceHolder { /// @notice Executes against `target` with the `data` payload. Prior to execution, token permits /// are temporarily stored for the duration of the transaction. These permits can be /// consumed by the `operator` during the execution /// @notice `operator` consumes the funds during its operations by calling back into /// `AllowanceHolder` with `transferFrom`, consuming a token permit. /// @dev Neither `exec` nor `transferFrom` check that `token` contains code. /// @dev msg.sender is forwarded to target appended to the msg data (similar to ERC-2771) /// @param operator An address which is allowed to consume the token permits /// @param token The ERC20 token the caller has authorised to be consumed /// @param amount The quantity of `token` the caller has authorised to be consumed /// @param target A contract to execute operations with `data` /// @param data The data to forward to `target` /// @return result The returndata from calling `target` with `data` /// @notice If calling `target` with `data` reverts, the revert is propagated function exec(address operator, address token, uint256 amount, address payable target, bytes calldata data) external payable returns (bytes memory result); /// @notice The counterpart to `exec` which allows for the consumption of token permits later /// during execution /// @dev *DOES NOT* check that `token` contains code. This function vacuously succeeds if /// `token` is empty. /// @dev can only be called by the `operator` previously registered in `exec` /// @param token The ERC20 token to transfer /// @param owner The owner of tokens to transfer /// @param recipient The destination/beneficiary of the ERC20 `transferFrom` /// @param amount The quantity of `token` to transfer` /// @return true function transferFrom(address token, address owner, address recipient, uint256 amount) external returns (bool); } // src/chains/IBlast.sol enum BlastYieldMode { AUTOMATIC, VOID, CLAIMABLE } enum BlastGasMode { VOID, CLAIMABLE } interface IBlast { function configure(BlastYieldMode _yield, BlastGasMode gasMode, address governor) external; } interface IBlastYieldERC20 { function configure(BlastYieldMode) external returns (uint256); } IBlast constant BLAST = IBlast(0x4300000000000000000000000000000000000002); IBlastYieldERC20 constant BLAST_USDB = IBlastYieldERC20(0x4300000000000000000000000000000000000003); IBlastYieldERC20 constant BLAST_WETH = IBlastYieldERC20(0x4300000000000000000000000000000000000004); // src/core/univ3forks/Algebra.sol interface IAlgebraCallback { function algebraSwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } // src/core/univ3forks/BladeSwap.sol address constant bladeSwapFactory = 0xfFeEcb1fe0EAaEFeE69d122F6B7a0368637cb593; bytes32 constant bladeSwapInitHash = 0xa9df2657ce5872e94bdc9525588fd983b0aa5db2f3c7a83d7e6b6a99cd2003a1; uint8 constant bladeSwapForkId = 10; // src/core/univ3forks/BlasterV3.sol address constant blasterV3Factory = 0x1A8027625C830aAC43aD82a3f7cD6D5fdCE89d78; bytes32 constant blasterV3InitHash = 0x708ef7fcba73b894862b667ec8c8ea3bef8c3f2a022dc8314152dfb52b4a1b67; uint8 constant blasterV3ForkId = 18; interface IBlasterswapV3SwapCallback { function blasterswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } // src/core/univ3forks/DackieSwapV3.sol address constant dackieSwapV3BaseFactory = 0x4f205D69834f9B101b9289F7AFFAc9B77B3fF9b7; address constant dackieSwapV3OptimismFactory = 0xa466ebCfa58848Feb6D8022081f1C21a884889bB; address constant dackieSwapV3ArbitrumFactory = 0xf79A36F6f440392C63AD61252a64d5d3C43F860D; address constant dackieSwapV3BlastFactory = 0x6510E68561F04C1d111e616750DaC2a063FF5055; bytes32 constant dackieSwapV3BlastInitHash = 0x9173e4373ab542649f2f059b10eaab2181ad82cc2e70cf51cf9d9fa8a144a2af; uint8 constant dackieSwapV3ForkId = 14; // src/core/univ3forks/Fenix.sol address constant fenixFactory = 0x5aCCAc55f692Ae2F065CEdDF5924C8f6B53cDaa8; bytes32 constant fenixInitHash = 0xf45e886a0794c1d80aeae5ab5befecd4f0f2b77c0cf627f7c46ec92dc1fa00e4; uint8 constant fenixForkId = 11; // src/core/univ3forks/MonoSwapV3.sol address constant monoSwapV3Factory = 0x48d0F09710794313f33619c95147F34458BF7C3b; bytes32 constant monoSwapV3InitHash = 0x7ea070216c7d9135010a36147394687bab92df4695e924000eed7c4b33eb922f; uint8 constant monoSwapV3ForkId = 19; // src/core/univ3forks/PancakeSwapV3.sol address constant pancakeSwapV3Factory = 0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9; bytes32 constant pancakeSwapV3InitHash = 0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2; uint8 constant pancakeSwapV3ForkId = 1; interface IPancakeSwapV3Callback { function pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } // src/core/univ3forks/RogueXV1.sol address constant rogueXV1Factory = 0xF22FF8f7f430a2d07efB88015853D52C88BC286d; bytes32 constant rogueXV1InitHash = 0x7eb89ab17cc883d055f470bc0250135af3f951b6403ea74f651bcba0136f210b; uint8 constant rogueXV1ForkId = 20; interface IRoxSpotSwapCallback { function swapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } // src/core/univ3forks/Thruster.sol address constant thrusterFactory = 0xa08ae3d3f4dA51C22d3c041E468bdF4C61405AaB; bytes32 constant thrusterInitHash = 0xd0c3a51b16dbc778f000c620eaabeecd33b33a80bd145e1f7cbc0d4de335193d; uint8 constant thrusterForkId = 9; // src/core/univ3forks/UniswapV3.sol address constant uniswapV3MainnetFactory = 0x1F98431c8aD98523631AE4a59f267346ea31F984; address constant uniswapV3SepoliaFactory = 0x0227628f3F023bb0B980b67D528571c95c6DaC1c; address constant uniswapV3BaseFactory = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD; address constant uniswapV3BnbFactory = 0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7; address constant uniswapV3AvalancheFactory = 0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD; address constant uniswapV3BlastFactory = 0x792edAdE80af5fC680d96a2eD80A44247D2Cf6Fd; address constant uniswapV3ScrollFactory = 0x70C62C8b8e801124A4Aa81ce07b637A3e83cb919; address constant uniswapV3LineaFactory = 0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9; address constant uniswapV3MantleFactory = 0x0d922Fb1Bc191F64970ac40376643808b4B74Df9; bytes32 constant uniswapV3InitHash = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54; uint8 constant uniswapV3ForkId = 0; interface IUniswapV3Callback { function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } // src/utils/FreeMemory.sol abstract contract FreeMemory { modifier DANGEROUS_freeMemory() { uint256 freeMemPtr; assembly ("memory-safe") { freeMemPtr := mload(0x40) } _; assembly ("memory-safe") { mstore(0x40, freeMemPtr) } } } // src/utils/Panic.sol library Panic { function panic(uint256 code) internal pure { assembly ("memory-safe") { mstore(0x00, 0x4e487b71) // selector for `Panic(uint256)` mstore(0x20, code) revert(0x1c, 0x24) } } // https://docs.soliditylang.org/en/latest/control-structures.html#panic-via-assert-and-error-via-require uint8 internal constant GENERIC = 0x00; uint8 internal constant ASSERT_FAIL = 0x01; uint8 internal constant ARITHMETIC_OVERFLOW = 0x11; uint8 internal constant DIVISION_BY_ZERO = 0x12; uint8 internal constant ENUM_CAST = 0x21; uint8 internal constant CORRUPT_STORAGE_ARRAY = 0x22; uint8 internal constant POP_EMPTY_ARRAY = 0x31; uint8 internal constant ARRAY_OUT_OF_BOUNDS = 0x32; uint8 internal constant OUT_OF_MEMORY = 0x41; uint8 internal constant ZERO_FUNCTION_POINTER = 0x51; } // src/utils/Revert.sol library Revert { function _revert(bytes memory reason) internal pure { assembly ("memory-safe") { revert(add(reason, 0x20), mload(reason)) } } function maybeRevert(bool success, bytes memory reason) internal pure { if (!success) { _revert(reason); } } } // src/utils/UnsafeMath.sol library UnsafeMath { function unsafeInc(uint256 x) internal pure returns (uint256) { unchecked { return x + 1; } } function unsafeInc(int256 x) internal pure returns (int256) { unchecked { return x + 1; } } function unsafeNeg(int256 x) internal pure returns (int256) { unchecked { return -x; } } function unsafeDiv(uint256 numerator, uint256 denominator) internal pure returns (uint256 quotient) { assembly ("memory-safe") { quotient := div(numerator, denominator) } } function unsafeDiv(int256 numerator, int256 denominator) internal pure returns (int256 quotient) { assembly ("memory-safe") { quotient := sdiv(numerator, denominator) } } function unsafeMod(uint256 numerator, uint256 denominator) internal pure returns (uint256 remainder) { assembly ("memory-safe") { remainder := mod(numerator, denominator) } } function unsafeMod(int256 numerator, int256 denominator) internal pure returns (int256 remainder) { assembly ("memory-safe") { remainder := smod(numerator, denominator) } } function unsafeMulMod(uint256 a, uint256 b, uint256 m) internal pure returns (uint256 r) { assembly ("memory-safe") { r := mulmod(a, b, m) } } function unsafeAddMod(uint256 a, uint256 b, uint256 m) internal pure returns (uint256 r) { assembly ("memory-safe") { r := addmod(a, b, m) } } } // lib/permit2/src/interfaces/ISignatureTransfer.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; } // src/core/SettlerErrors.sol /// @notice Thrown when an offset is not the expected value error InvalidOffset(); /// @notice Thrown when a validating a target contract to avoid certain types of targets error ConfusedDeputy(); /// @notice Thrown when a target contract is invalid given the context error InvalidTarget(); /// @notice Thrown when validating the caller against the expected caller error InvalidSender(); /// @notice Thrown in cases when using a Trusted Forwarder / AllowanceHolder is not allowed error ForwarderNotAllowed(); /// @notice Thrown when a signature length is not the expected length error InvalidSignatureLen(); /// @notice Thrown when a slippage limit is exceeded error TooMuchSlippage(IERC20 token, uint256 expected, uint256 actual); /// @notice Thrown when a byte array that is supposed to encode a function from ISettlerActions is /// not recognized in context. error ActionInvalid(uint256 i, bytes4 action, bytes data); /// @notice Thrown when the encoded fork ID as part of UniswapV3 fork path is not on the list of /// recognized forks for this chain. error UnknownForkId(uint8 forkId); /// @notice Thrown when an AllowanceHolder transfer's permit is past its deadline error SignatureExpired(uint256 deadline); /// @notice An internal error that should never be thrown. Thrown when a callback reenters the /// entrypoint and attempts to clobber the existing callback. error ReentrantCallback(uint256 callbackInt); /// @notice An internal error that should never be thrown. This error can only be thrown by /// non-metatx-supporting Settler instances. Thrown when a callback-requiring liquidity /// source is called, but Settler never receives the callback. error CallbackNotSpent(uint256 callbackInt); /// @notice Thrown when a metatransaction has reentrancy. error ReentrantMetatransaction(bytes32 oldWitness); /// @notice Thrown when any transaction has reentrancy, not just taker-submitted or metatransaction. error ReentrantPayer(address oldPayer); /// @notice An internal error that should never be thrown. Thrown when a metatransaction fails to /// spend a coupon. error WitnessNotSpent(bytes32 oldWitness); /// @notice An internal error that should never be thrown. Thrown when the payer is unset /// unexpectedly. error PayerSpent(); // src/vendor/SafeTransferLib.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 { uint32 private constant _TRANSFER_FROM_FAILED_SELECTOR = 0x7939f424; // bytes4(keccak256("TransferFromFailed()")) uint32 private constant _TRANSFER_FAILED_SELECTOR = 0x90b8ec18; // bytes4(keccak256("TransferFailed()")) uint32 private constant _APPROVE_FAILED_SELECTOR = 0x3e3f8f73; // bytes4(keccak256("ApproveFailed()")) /*////////////////////////////////////////////////////////////// ETH OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferETH(address payable to, uint256 amount) internal { assembly ("memory-safe") { // Transfer the ETH and store if it succeeded or not. if iszero(call(gas(), to, amount, 0, 0, 0, 0)) { let freeMemoryPointer := mload(0x40) returndatacopy(freeMemoryPointer, 0, returndatasize()) revert(freeMemoryPointer, returndatasize()) } } } /*////////////////////////////////////////////////////////////// ERC20 OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal { assembly ("memory-safe") { // 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. // 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. if iszero(call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)) { returndatacopy(freeMemoryPointer, 0, returndatasize()) revert(freeMemoryPointer, returndatasize()) } // We check that the call either returned exactly 1 (can't just be non-zero data), or had no // return data. if iszero(or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize()))) { mstore(0, _TRANSFER_FROM_FAILED_SELECTOR) revert(0x1c, 0x04) } } } function safeTransfer(IERC20 token, address to, uint256 amount) internal { assembly ("memory-safe") { // 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. // 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. if iszero(call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)) { returndatacopy(freeMemoryPointer, 0, returndatasize()) revert(freeMemoryPointer, returndatasize()) } // We check that the call either returned exactly 1 (can't just be non-zero data), or had no // return data. if iszero(or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize()))) { mstore(0, _TRANSFER_FAILED_SELECTOR) revert(0x1c, 0x04) } } } function safeApprove(IERC20 token, address to, uint256 amount) internal { assembly ("memory-safe") { // 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. // 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. if iszero(call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)) { returndatacopy(freeMemoryPointer, 0, returndatasize()) revert(freeMemoryPointer, returndatasize()) } // We check that the call either returned exactly 1 (can't just be non-zero data), or had no // return data. if iszero(or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize()))) { mstore(0, _APPROVE_FAILED_SELECTOR) revert(0x1c, 0x04) } } } function safeApproveIfBelow(IERC20 token, address spender, uint256 amount) internal { uint256 allowance = token.allowance(address(this), spender); if (allowance < amount) { if (allowance != 0) { safeApprove(token, spender, 0); } safeApprove(token, spender, type(uint256).max); } } } // src/ISettlerActions.sol interface ISettlerActions { /// @dev Transfer funds from msg.sender Permit2. function TRANSFER_FROM(address recipient, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig) external; /// @dev Transfer funds from metatransaction requestor into the Settler contract using Permit2. Only for use in `Settler.executeMetaTxn` where the signature is provided as calldata function METATXN_TRANSFER_FROM(address recipient, ISignatureTransfer.PermitTransferFrom memory permit) external; /// @dev Settle an RfqOrder between maker and taker transfering funds directly between the parties // Post-req: Payout if recipient != taker function RFQ_VIP( address recipient, ISignatureTransfer.PermitTransferFrom memory makerPermit, address maker, bytes memory makerSig, ISignatureTransfer.PermitTransferFrom memory takerPermit, bytes memory takerSig ) external; /// @dev Settle an RfqOrder between maker and taker transfering funds directly between the parties for the entire amount function METATXN_RFQ_VIP( address recipient, ISignatureTransfer.PermitTransferFrom memory makerPermit, address maker, bytes memory makerSig, ISignatureTransfer.PermitTransferFrom memory takerPermit ) external; /// @dev Settle an RfqOrder between Maker and Settler. Transfering funds from the Settler contract to maker. /// Retaining funds in the settler contract. // Pre-req: Funded // Post-req: Payout function RFQ( address recipient, ISignatureTransfer.PermitTransferFrom memory permit, address maker, bytes memory makerSig, address takerToken, uint256 maxTakerAmount ) external; /// @dev Trades against UniswapV3 using the contracts balance for funding // Pre-req: Funded // Post-req: Payout function UNISWAPV3(address recipient, uint256 bps, bytes memory path, uint256 amountOutMin) external; /// @dev Trades against UniswapV3 using user funds via Permit2 for funding function UNISWAPV3_VIP( address recipient, bytes memory path, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, uint256 amountOutMin ) external; function MAKERPSM(address recipient, address gemToken, uint256 bps, address psm, bool buyGem, uint256 amountOutMin) external; function CURVE_TRICRYPTO_VIP( address recipient, uint80 poolInfo, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, uint256 minBuyAmount ) external; function METATXN_CURVE_TRICRYPTO_VIP( address recipient, uint80 poolInfo, ISignatureTransfer.PermitTransferFrom memory permit, uint256 minBuyAmount ) external; function DODOV1(address sellToken, uint256 bps, address pool, bool quoteForBase, uint256 minBuyAmount) external; function DODOV2( address recipient, address sellToken, uint256 bps, address pool, bool quoteForBase, uint256 minBuyAmount ) external; function VELODROME(address recipient, uint256 bps, address pool, uint24 swapInfo, uint256 minBuyAmount) external; /// @dev Trades against UniswapV3 using user funds via Permit2 for funding. Metatransaction variant. Signature is over all actions. function METATXN_UNISWAPV3_VIP( address recipient, bytes memory path, ISignatureTransfer.PermitTransferFrom memory permit, uint256 amountOutMin ) external; /// @dev Trades against MaverickV2 using the contracts balance for funding /// This action does not use the MaverickV2 callback, so it takes an arbitrary pool address to make calls against. /// Passing `tokenAIn` as a parameter actually saves gas relative to introspecting the pool's `tokenA()` accessor. function MAVERICKV2( address recipient, address sellToken, uint256 bps, address pool, bool tokenAIn, uint256 minBuyAmount ) external; /// @dev Trades against MaverickV2, spending the taker's coupon inside the callback /// This action requires the use of the MaverickV2 callback, so we take the MaverickV2 CREATE2 salt as an argument to derive the pool address from the trusted factory and inithash. /// @param salt is formed as `keccak256(abi.encode(feeAIn, feeBIn, tickSpacing, lookback, tokenA, tokenB, kinds, address(0)))` function MAVERICKV2_VIP( address recipient, bytes32 salt, bool tokenAIn, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, uint256 minBuyAmount ) external; /// @dev Trades against MaverickV2, spending the taker's coupon inside the callback; metatransaction variant function METATXN_MAVERICKV2_VIP( address recipient, bytes32 salt, bool tokenAIn, ISignatureTransfer.PermitTransferFrom memory permit, uint256 minBuyAmount ) external; /// @dev Trades against UniswapV2 using the contracts balance for funding /// @param swapInfo is encoded as the upper 16 bits as the fee of the pool in bps, the second /// lowest bit as "sell token has transfer fee", and the lowest bit as the /// "token0 for token1" flag. function UNISWAPV2( address recipient, address sellToken, uint256 bps, address pool, uint24 swapInfo, uint256 amountOutMin ) external; function POSITIVE_SLIPPAGE(address recipient, address token, uint256 expectedAmount) external; /// @dev Trades against a basic AMM which follows the approval, transferFrom(msg.sender) interaction // Pre-req: Funded // Post-req: Payout function BASIC(address sellToken, uint256 bps, address pool, uint256 offset, bytes calldata data) external; } // src/allowanceholder/AllowanceHolderContext.sol abstract contract AllowanceHolderContext is Context { IAllowanceHolder internal constant _ALLOWANCE_HOLDER = IAllowanceHolder(0x0000000000001fF3684f28c67538d4D072C22734); function _isForwarded() internal view virtual override returns (bool) { return super._isForwarded() || super._msgSender() == address(_ALLOWANCE_HOLDER); } function _msgSender() internal view virtual override returns (address sender) { sender = super._msgSender(); if (sender == address(_ALLOWANCE_HOLDER)) { // ERC-2771 like usage where the _trusted_ `AllowanceHolder` has appended the appropriate // msg.sender to the msg data assembly ("memory-safe") { sender := shr(0x60, calldataload(sub(calldatasize(), 0x14))) } } } // this is here to avoid foot-guns and make it very explicit that we intend // to pass the confused deputy check in AllowanceHolder function balanceOf(address) external pure { assembly ("memory-safe") { mstore8(0x00, 0x00) return(0x00, 0x01) } } } // src/deployer/TwoStepOwnable.sol interface IOwnable is IERC165 { event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function owner() external view returns (address); function transferOwnership(address) external returns (bool); error PermissionDenied(); error ZeroAddress(); } abstract contract AbstractOwnable is IOwnable { // This looks stupid (and it is), but this is required due to the glaring // deficiencies in Solidity's inheritance system. function _requireOwner() internal view virtual; /// This function should be overridden exactly once. This provides the base /// implementation. Mixin classes may modify `owner`. function _ownerImpl() internal view virtual returns (address); function owner() public view virtual override returns (address) { return _ownerImpl(); } function _setOwner(address) internal virtual; constructor() { assert(type(IOwnable).interfaceId == 0x7f5828d0); assert(type(IERC165).interfaceId == 0x01ffc9a7); } function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId || interfaceId == type(IOwnable).interfaceId; } /// This modifier is not virtual on purpose; override _requireOwner instead. modifier onlyOwner() { _requireOwner(); _; } } abstract contract AddressSlotStorage { type AddressSlot is bytes32; function _get(AddressSlot s) internal view returns (address r) { assembly ("memory-safe") { r := sload(s) } } function _set(AddressSlot s, address v) internal { assembly ("memory-safe") { sstore(s, v) } } } abstract contract OwnableStorageBase is AddressSlotStorage { function _ownerSlot() internal pure virtual returns (AddressSlot); } abstract contract OwnableStorage is OwnableStorageBase { address private _owner; function _ownerSlot() internal pure override returns (AddressSlot r) { assembly ("memory-safe") { r := _owner.slot } } constructor() { assert(AddressSlot.unwrap(_ownerSlot()) == bytes32(0)); } } abstract contract OwnableBase is AbstractContext, AbstractOwnable { function renounceOwnership() public virtual returns (bool); } abstract contract OwnableImpl is OwnableStorageBase, OwnableBase { function _ownerImpl() internal view override returns (address) { return _get(_ownerSlot()); } function _setOwner(address newOwner) internal virtual override { emit OwnershipTransferred(owner(), newOwner); _set(_ownerSlot(), newOwner); } function _requireOwner() internal view override { if (_msgSender() != owner()) { revert PermissionDenied(); } } function renounceOwnership() public virtual override onlyOwner returns (bool) { _setOwner(address(0)); return true; } function transferOwnership(address newOwner) public virtual override onlyOwner returns (bool) { if (newOwner == address(0)) { revert ZeroAddress(); } _setOwner(newOwner); return true; } } abstract contract Ownable is OwnableStorage, OwnableImpl {} abstract contract AbstractTwoStepOwnable is AbstractOwnable { function _requirePendingOwner() internal view virtual; function pendingOwner() public view virtual returns (address); function _setPendingOwner(address) internal virtual; /// This modifier is not virtual on purpose; override _requirePendingOwner /// instead. modifier onlyPendingOwner() { _requirePendingOwner(); _; } event OwnershipPending(address indexed); } abstract contract TwoStepOwnableStorageBase is AddressSlotStorage { function _pendingOwnerSlot() internal pure virtual returns (AddressSlot); } abstract contract TwoStepOwnableStorage is TwoStepOwnableStorageBase { address private _pendingOwner; function _pendingOwnerSlot() internal pure override returns (AddressSlot r) { assembly ("memory-safe") { r := _pendingOwner.slot } } constructor() { assert(AddressSlot.unwrap(_pendingOwnerSlot()) == bytes32(uint256(1))); } } abstract contract TwoStepOwnableBase is OwnableBase, AbstractTwoStepOwnable {} abstract contract TwoStepOwnableImpl is TwoStepOwnableStorageBase, TwoStepOwnableBase { function pendingOwner() public view override returns (address) { return _get(_pendingOwnerSlot()); } function _setPendingOwner(address newPendingOwner) internal override { emit OwnershipPending(newPendingOwner); _set(_pendingOwnerSlot(), newPendingOwner); } function renounceOwnership() public virtual override onlyOwner returns (bool) { if (pendingOwner() != address(0)) { _setPendingOwner(address(0)); } _setOwner(address(0)); return true; } function transferOwnership(address newOwner) public virtual override onlyOwner returns (bool) { if (newOwner == address(0)) { revert ZeroAddress(); } _setPendingOwner(newOwner); return true; } function _requirePendingOwner() internal view override { if (_msgSender() != pendingOwner()) { revert PermissionDenied(); } } function acceptOwnership() public onlyPendingOwner returns (bool) { _setOwner(_msgSender()); _setPendingOwner(address(0)); return true; } function rejectOwnership() public onlyPendingOwner returns (bool) { _setPendingOwner(address(0)); return true; } } abstract contract TwoStepOwnable is OwnableStorage, OwnableImpl, TwoStepOwnableStorage, TwoStepOwnableImpl { function renounceOwnership() public override(OwnableImpl, TwoStepOwnableImpl) returns (bool) { return TwoStepOwnableImpl.renounceOwnership(); } function transferOwnership(address newOwner) public override(OwnableImpl, TwoStepOwnableImpl) returns (bool) { return TwoStepOwnableImpl.transferOwnership(newOwner); } } // src/utils/AddressDerivation.sol library AddressDerivation { using UnsafeMath for uint256; uint256 internal constant _SECP256K1_P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F; uint256 internal constant _SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141; uint256 internal constant SECP256K1_GX = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798; uint256 internal constant SECP256K1_GY = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8; error InvalidCurve(uint256 x, uint256 y); // keccak256(abi.encodePacked(ECMUL([x, y], k)))[12:] function deriveEOA(uint256 x, uint256 y, uint256 k) internal pure returns (address) { if (k == 0) { Panic.panic(Panic.DIVISION_BY_ZERO); } if (k >= _SECP256K1_N || x >= _SECP256K1_P || y >= _SECP256K1_P) { Panic.panic(Panic.ARITHMETIC_OVERFLOW); } // +/-7 are neither square nor cube mod p, so we only have to check one // coordinate against 0. if it is 0, then the other is too (the point at // infinity) or the point is invalid if ( x == 0 || y.unsafeMulMod(y, _SECP256K1_P) != x.unsafeMulMod(x, _SECP256K1_P).unsafeMulMod(x, _SECP256K1_P).unsafeAddMod(7, _SECP256K1_P) ) { revert InvalidCurve(x, y); } unchecked { // https://ethresear.ch/t/you-can-kinda-abuse-ecrecover-to-do-ecmul-in-secp256k1-today/2384 return ecrecover( bytes32(0), uint8(27 + (y & 1)), bytes32(x), bytes32(UnsafeMath.unsafeMulMod(x, k, _SECP256K1_N)) ); } } // keccak256(RLP([deployer, nonce]))[12:] function deriveContract(address deployer, uint64 nonce) internal pure returns (address result) { if (nonce == 0) { assembly ("memory-safe") { mstore( 0x00, or( 0xd694000000000000000000000000000000000000000080, shl(8, and(0xffffffffffffffffffffffffffffffffffffffff, deployer)) ) ) result := keccak256(0x09, 0x17) } } else if (nonce < 0x80) { assembly ("memory-safe") { // we don't care about dirty bits in `deployer`; they'll be overwritten later mstore(0x14, deployer) mstore(0x00, 0xd694) mstore8(0x34, nonce) result := keccak256(0x1e, 0x17) } } else { // compute ceil(log_256(nonce)) + 1 uint256 nonceLength = 8; unchecked { if ((uint256(nonce) >> 32) != 0) { nonceLength += 32; if (nonce == type(uint64).max) { Panic.panic(Panic.ARITHMETIC_OVERFLOW); } } if ((uint256(nonce) >> 8) >= (1 << nonceLength)) { nonceLength += 16; } if (uint256(nonce) >= (1 << nonceLength)) { nonceLength += 8; } // ceil if ((uint256(nonce) << 8) >= (1 << nonceLength)) { nonceLength += 8; } // bytes, not bits nonceLength >>= 3; } assembly ("memory-safe") { // we don't care about dirty bits in `deployer` or `nonce`. they'll be overwritten later mstore(nonceLength, nonce) mstore8(0x20, add(0x7f, nonceLength)) mstore(0x00, deployer) mstore8(0x0a, add(0xd5, nonceLength)) mstore8(0x0b, 0x94) result := keccak256(0x0a, add(0x16, nonceLength)) } } } // keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, initHash))[12:] function deriveDeterministicContract(address deployer, bytes32 salt, bytes32 initHash) internal pure returns (address result) { assembly ("memory-safe") { let ptr := mload(0x40) // we don't care about dirty bits in `deployer`; they'll be overwritten later mstore(ptr, deployer) mstore8(add(ptr, 0x0b), 0xff) mstore(add(ptr, 0x20), salt) mstore(add(ptr, 0x40), initHash) result := keccak256(add(ptr, 0x0b), 0x55) } } } // src/vendor/FullMath.sol /// @title Contains 512-bit math functions /// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision /// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv library FullMath { using UnsafeMath for uint256; /// @notice 512-bit multiply [prod1 prod0] = a * b /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return prod0 Least significant 256 bits of the product /// @return prod1 Most significant 256 bits of the product /// @return remainder Remainder of full-precision division function _mulDivSetup(uint256 a, uint256 b, uint256 denominator) private pure returns (uint256 prod0, uint256 prod1, uint256 remainder) { // Compute the product mod 2**256 and mod 2**256 - 1 then use the Chinese // Remainder Theorem to reconstruct the 512 bit result. The result is stored // in two 256 variables such that product = prod1 * 2**256 + prod0 assembly ("memory-safe") { // Full-precision multiplication { let mm := mulmod(a, b, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) prod0 := mul(a, b) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } remainder := mulmod(a, b, denominator) } } /// @notice 512-bit by 256-bit division. /// @param prod0 Least significant 256 bits of the product /// @param prod1 Most significant 256 bits of the product /// @param denominator The divisor /// @param remainder Remainder of full-precision division /// @return The 256-bit result /// @dev Overflow and division by zero aren't checked and are GIGO errors function _mulDivInvert(uint256 prod0, uint256 prod1, uint256 denominator, uint256 remainder) private pure returns (uint256) { uint256 inv; assembly ("memory-safe") { // Make division exact by rounding [prod1 prod0] down to a multiple of // denominator // Subtract 256 bit number from 512 bit number prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) // Factor powers of two out of denominator { // Compute largest power of two divisor of denominator. // Always >= 1. let twos := and(sub(0, denominator), denominator) // Divide denominator by power of two denominator := div(denominator, twos) // Divide [prod1 prod0] by the factors of two prod0 := div(prod0, twos) // Shift in bits from prod1 into prod0. For this we need to flip `twos` // such that it is 2**256 / twos. // If twos is zero, then it becomes one twos := add(div(sub(0, twos), twos), 1) prod0 := or(prod0, mul(prod1, twos)) } // Invert denominator mod 2**256 // Now that denominator is an odd number, it has an inverse modulo 2**256 // such that denominator * inv = 1 mod 2**256. // Compute the inverse by starting with a seed that is correct correct for // four bits. That is, denominator * inv = 1 mod 2**4 inv := xor(mul(3, denominator), 2) // Now use Newton-Raphson iteration to improve the precision. // Thanks to Hensel's lifting lemma, this also works in modular // arithmetic, doubling the correct bits in each step. inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**8 inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**16 inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**32 inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**64 inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**128 inv := mul(inv, sub(2, mul(denominator, inv))) // inverse mod 2**256 } // Because the division is now exact we can divide by multiplying with the // modular inverse of denominator. This will give us the correct result // modulo 2**256. Since the precoditions guarantee that the outcome is less // than 2**256, this is the final result. We don't need to compute the high // bits of the result and prod1 is no longer required. unchecked { return prod0 * inv; } } /// @notice Calculates a×b÷denominator with full precision then rounds towards 0. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return The 256-bit result function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256) { (uint256 prod0, uint256 prod1, uint256 remainder) = _mulDivSetup(a, b, denominator); // Make sure the result is less than 2**256. // Also prevents denominator == 0 if (denominator <= prod1) { Panic.panic(denominator == 0 ? Panic.DIVISION_BY_ZERO : Panic.ARITHMETIC_OVERFLOW); } // Handle non-overflow cases, 256 by 256 division if (prod1 == 0) { return prod0.unsafeDiv(denominator); } return _mulDivInvert(prod0, prod1, denominator, remainder); } /// @notice Calculates a×b÷denominator with full precision then rounds towards 0. Overflowing a uint256 or denominator == 0 are GIGO errors /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return The 256-bit result function unsafeMulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256) { (uint256 prod0, uint256 prod1, uint256 remainder) = _mulDivSetup(a, b, denominator); // Overflow and zero-division checks are skipped // Handle non-overflow cases, 256 by 256 division if (prod1 == 0) { return prod0.unsafeDiv(denominator); } return _mulDivInvert(prod0, prod1, denominator, remainder); } } // src/core/Permit2PaymentAbstract.sol abstract contract Permit2PaymentAbstract is AbstractContext { string internal constant TOKEN_PERMISSIONS_TYPE = "TokenPermissions(address token,uint256 amount)"; function _isRestrictedTarget(address) internal view virtual returns (bool); function _operator() internal view virtual returns (address); function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) internal view virtual returns (uint256 sellAmount); function _permitToTransferDetails(ISignatureTransfer.PermitTransferFrom memory permit, address recipient) internal view virtual returns (ISignatureTransfer.SignatureTransferDetails memory transferDetails, uint256 sellAmount); function _transferFromIKnowWhatImDoing( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address from, bytes32 witness, string memory witnessTypeString, bytes memory sig, bool isForwarded ) internal virtual; function _transferFromIKnowWhatImDoing( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address from, bytes32 witness, string memory witnessTypeString, bytes memory sig ) internal virtual; function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, bytes memory sig, bool isForwarded ) internal virtual; function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, bytes memory sig ) internal virtual; function _setOperatorAndCall( address target, bytes memory data, uint32 selector, function (bytes calldata) internal returns (bytes memory) callback ) internal virtual returns (bytes memory); modifier metaTx(address msgSender, bytes32 witness) virtual; modifier takerSubmitted() virtual; function _allowanceHolderTransferFrom(address token, address owner, address recipient, uint256 amount) internal virtual; } // src/SettlerAbstract.sol abstract contract SettlerAbstract is Permit2PaymentAbstract { // Permit2 Witness for meta transactions string internal constant SLIPPAGE_AND_ACTIONS_TYPE = "SlippageAndActions(address recipient,address buyToken,uint256 minAmountOut,bytes[] actions)"; bytes32 internal constant SLIPPAGE_AND_ACTIONS_TYPEHASH = 0x615e8d716cef7295e75dd3f1f10d679914ad6d7759e8e9459f0109ef75241701; uint256 internal constant BASIS = 10_000; constructor() { assert(SLIPPAGE_AND_ACTIONS_TYPEHASH == keccak256(bytes(SLIPPAGE_AND_ACTIONS_TYPE))); } function _hasMetaTxn() internal pure virtual returns (bool); function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal virtual returns (bool); } // src/core/UniswapV2.sol interface IUniV2Pair { function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112, uint112, uint32); function swap(uint256, uint256, address, bytes calldata) external; } abstract contract UniswapV2 is SettlerAbstract { using UnsafeMath for uint256; // bytes4(keccak256("getReserves()")) uint32 private constant UNI_PAIR_RESERVES_SELECTOR = 0x0902f1ac; // bytes4(keccak256("swap(uint256,uint256,address,bytes)")) uint32 private constant UNI_PAIR_SWAP_SELECTOR = 0x022c0d9f; // bytes4(keccak256("transfer(address,uint256)")) uint32 private constant ERC20_TRANSFER_SELECTOR = 0xa9059cbb; // bytes4(keccak256("balanceOf(address)")) uint32 private constant ERC20_BALANCEOF_SELECTOR = 0x70a08231; /// @dev Sell a token for another token using UniswapV2. function sellToUniswapV2( address recipient, address sellToken, uint256 bps, address pool, uint24 swapInfo, uint256 minBuyAmount ) internal { // Preventing calls to Permit2 or AH is not explicitly required as neither of these contracts implement the `swap` nor `transfer` selector // |7|6|5|4|3|2|1|0| - bit positions in swapInfo (uint8) // |0|0|0|0|0|0|F|Z| - Z: zeroForOne flag, F: sellTokenHasFee flag bool zeroForOne = (swapInfo & 1) == 1; // Extract the least significant bit (bit 0) bool sellTokenHasFee = (swapInfo & 2) >> 1 == 1; // Extract the second least significant bit (bit 1) and shift it right uint256 feeBps = swapInfo >> 8; uint256 sellAmount; uint256 buyAmount; // If bps is zero we assume there are no funds within this contract, skip the updating sellAmount. // This case occurs if the pool is being chained, in which the funds have been sent directly to the pool if (bps != 0) { // We don't care about phantom overflow here because reserves are // limited to 112 bits. Any token balance that would overflow here would // also break UniV2. // It is *possible* to set `bps` above the basis and therefore // cause an overflow on this multiplication. However, `bps` is // passed as authenticated calldata, so this is a GIGO error that we // do not attempt to fix. unchecked { sellAmount = (IERC20(sellToken).balanceOf(address(this)) * bps).unsafeDiv(BASIS); } } assembly ("memory-safe") { let ptr := mload(0x40) // transfer sellAmount (a non zero amount) of sellToken to the pool if sellAmount { mstore(ptr, ERC20_TRANSFER_SELECTOR) mstore(add(ptr, 0x20), pool) mstore(add(ptr, 0x40), sellAmount) // ...||ERC20_TRANSFER_SELECTOR|pool|sellAmount| if iszero(call(gas(), sellToken, 0, add(ptr, 0x1c), 0x44, 0x00, 0x20)) { bubbleRevert(ptr) } if iszero(or(iszero(returndatasize()), and(iszero(lt(returndatasize(), 0x20)), eq(mload(0x00), 1)))) { revert(0, 0) } } // get pool reserves let sellReserve let buyReserve mstore(0x00, UNI_PAIR_RESERVES_SELECTOR) // ||UNI_PAIR_RESERVES_SELECTOR| if iszero(staticcall(gas(), pool, 0x1c, 0x04, 0x00, 0x40)) { bubbleRevert(ptr) } if lt(returndatasize(), 0x40) { revert(0, 0) } { let r := shl(5, zeroForOne) buyReserve := mload(r) sellReserve := mload(xor(0x20, r)) } // Update the sell amount in the following cases: // the funds are in the pool already (flagged by sellAmount being 0) // the sell token has a fee (flagged by sellTokenHasFee) if or(iszero(sellAmount), sellTokenHasFee) { // retrieve the sellToken balance of the pool mstore(0x00, ERC20_BALANCEOF_SELECTOR) mstore(0x20, and(0xffffffffffffffffffffffffffffffffffffffff, pool)) // ||ERC20_BALANCEOF_SELECTOR|pool| if iszero(staticcall(gas(), sellToken, 0x1c, 0x24, 0x00, 0x20)) { bubbleRevert(ptr) } if lt(returndatasize(), 0x20) { revert(0, 0) } let bal := mload(0x00) // determine real sellAmount by comparing pool's sellToken balance to reserve amount if lt(bal, sellReserve) { mstore(0x00, 0x4e487b71) // selector for `Panic(uint256)` mstore(0x20, 0x11) // panic code for arithmetic underflow revert(0x1c, 0x24) } sellAmount := sub(bal, sellReserve) } // compute buyAmount based on sellAmount and reserves let sellAmountWithFee := mul(sellAmount, sub(10000, feeBps)) buyAmount := div(mul(sellAmountWithFee, buyReserve), add(sellAmountWithFee, mul(sellReserve, 10000))) let swapCalldata := add(ptr, 0x1c) // set up swap call selector and empty callback data mstore(ptr, UNI_PAIR_SWAP_SELECTOR) mstore(add(ptr, 0x80), 0x80) // offset to length of data mstore(add(ptr, 0xa0), 0) // length of data // set amount0Out and amount1Out { // If `zeroForOne`, offset is 0x24, else 0x04 let offset := add(0x04, shl(5, zeroForOne)) mstore(add(swapCalldata, offset), buyAmount) mstore(add(swapCalldata, xor(0x20, offset)), 0) } mstore(add(swapCalldata, 0x44), and(0xffffffffffffffffffffffffffffffffffffffff, recipient)) // ...||UNI_PAIR_SWAP_SELECTOR|amount0Out|amount1Out|recipient|data| // perform swap at the pool sending bought tokens to the recipient if iszero(call(gas(), pool, 0, swapCalldata, 0xa4, 0, 0)) { bubbleRevert(swapCalldata) } // revert with the return data from the most recent call function bubbleRevert(p) { returndatacopy(p, 0, returndatasize()) revert(p, returndatasize()) } } if (buyAmount < minBuyAmount) { revert TooMuchSlippage( IERC20(zeroForOne ? IUniV2Pair(pool).token1() : IUniV2Pair(pool).token0()), minBuyAmount, buyAmount ); } } } // src/core/Velodrome.sol interface IVelodromePair { function metadata() external view returns ( uint256 basis0, uint256 basis1, uint256 reserve0, uint256 reserve1, bool stable, IERC20 token0, IERC20 token1 ); function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external; } abstract contract Velodrome is SettlerAbstract { using UnsafeMath for uint256; using SafeTransferLib for IERC20; uint256 private constant _BASIS = 1 ether; // This is the `k = x^3 * y + y^3 * x` constant function function _k(uint256 x, uint256 y) private pure returns (uint256) { unchecked { return _k(x, y, x * x / _BASIS); } } function _k(uint256 x, uint256 y, uint256 x_squared) private pure returns (uint256) { unchecked { return _k(x, y, x_squared, y * y / _BASIS); } } function _k(uint256 x, uint256 y, uint256 x_squared, uint256 y_squared) private pure returns (uint256) { unchecked { return x * y / _BASIS * (x_squared + y_squared) / _BASIS; } } // For numerically approximating a solution to the `k = x^3 * y + y^3 * x` constant function // using Newton-Raphson, this is `∂k/∂y = 3 * x * y^2 + x^3`. function _d(uint256 y, uint256 three_x0, uint256 x0_cubed) private pure returns (uint256) { unchecked { return _d(y, three_x0, x0_cubed, y * y / _BASIS); } } function _d(uint256, uint256 three_x0, uint256 x0_cubed, uint256 y_squared) private pure returns (uint256) { unchecked { return y_squared * three_x0 / _BASIS + x0_cubed; } } error NotConverged(); // Using Newton-Raphson iterations, compute the smallest `new_y` such that `_k(x0, new_y) >= // xy`. As a function of `y`, we find the root of `_k(x0, y) - xy`. function _get_y(uint256 x0, uint256 xy, uint256 y) private pure returns (uint256) { unchecked { uint256 three_x0 = 3 * x0; uint256 x0_squared = x0 * x0 / _BASIS; uint256 x0_cubed = x0_squared * x0 / _BASIS; for (uint256 i; i < 255; i++) { uint256 y_squared = y * y / _BASIS; uint256 k = _k(x0, y, x0_squared, y_squared); if (k < xy) { // there are two cases where dy == 0 // case 1: The y is converged and we find the correct answer // case 2: _d(x0, y) is too large compare to (xy - k) and the rounding error // screwed us. // In this case, we need to increase y by 1 uint256 dy = ((xy - k) * _BASIS).unsafeDiv(_d(y, three_x0, x0_cubed, y_squared)); if (dy == 0) { if (k == xy) { // We found the correct answer. Return y return y; } if (_k(x0, y + 1, x0_squared) > xy) { // If _k(x0, y + 1) > xy, then we are close to the correct answer. // There's no closer answer than y + 1 return y + 1; } dy = 1; } y += dy; } else { uint256 dy = ((k - xy) * _BASIS).unsafeDiv(_d(y, three_x0, x0_cubed, y_squared)); if (dy == 0) { if (k == xy || _k(x0, y - 1, x0_squared) < xy) { // Likewise, if k == xy, we found the correct answer. // If _k(x0, y - 1) < xy, then we are close to the correct answer. // There's no closer answer than "y" // It's worth mentioning that we need to find y where _k(x0, y) >= xy // As a result, we can't return y - 1 even it's closer to the correct answer return y; } dy = 1; } y -= dy; } } revert NotConverged(); } } function sellToVelodrome(address recipient, uint256 bps, IVelodromePair pair, uint24 swapInfo, uint256 minAmountOut) internal { // Preventing calls to Permit2 or AH is not explicitly required as neither of these contracts implement the `swap` nor `transfer` selector // |7|6|5|4|3|2|1|0| - bit positions in swapInfo (uint8) // |0|0|0|0|0|0|F|Z| - Z: zeroForOne flag, F: sellTokenHasFee flag bool zeroForOne = (swapInfo & 1) == 1; // Extract the least significant bit (bit 0) bool sellTokenHasFee = (swapInfo & 2) >> 1 == 1; // Extract the second least significant bit (bit 1) and shift it right uint256 feeBps = swapInfo >> 8; ( uint256 sellBasis, uint256 buyBasis, uint256 sellReserve, uint256 buyReserve, bool stable, IERC20 sellToken, IERC20 buyToken ) = pair.metadata(); assert(stable); if (!zeroForOne) { (sellBasis, buyBasis, sellReserve, buyReserve, sellToken, buyToken) = (buyBasis, sellBasis, buyReserve, sellReserve, buyToken, sellToken); } uint256 buyAmount; unchecked { // Compute sell amount in native units uint256 sellAmount; if (bps != 0) { // It must be possible to square the sell token balance of the pool, otherwise it // will revert with an overflow. Therefore, it can't be so large that multiplying by // a "reasonable" `bps` value could overflow. We don't care to protect against // unreasonable `bps` values because that just means the taker is griefing themself. sellAmount = (sellToken.balanceOf(address(this)) * bps).unsafeDiv(BASIS); } if (sellAmount != 0) { sellToken.safeTransfer(address(pair), sellAmount); } if (sellAmount == 0 || sellTokenHasFee) { sellAmount = sellToken.balanceOf(address(pair)) - sellReserve; } // Apply the fee sellAmount -= sellAmount * feeBps / 10_000; // can't overflow // Convert everything from native units to `_BASIS` sellReserve = (sellReserve * _BASIS).unsafeDiv(sellBasis); buyReserve = (buyReserve * _BASIS).unsafeDiv(buyBasis); sellAmount = (sellAmount * _BASIS).unsafeDiv(sellBasis); // Solve the constant function numerically to get `buyAmount` from `sellAmount` buyAmount = buyReserve - _get_y(sellAmount + sellReserve, _k(sellReserve, buyReserve), buyReserve); // Convert `buyAmount` from `_BASIS` to native units buyAmount = buyAmount * buyBasis / _BASIS; } if (buyAmount < minAmountOut) { revert TooMuchSlippage(sellToken, minAmountOut, buyAmount); } { (uint256 buyAmount0, uint256 buyAmount1) = zeroForOne ? (uint256(0), buyAmount) : (buyAmount, uint256(0)); pair.swap(buyAmount0, buyAmount1, recipient, new bytes(0)); } } } // src/core/RfqOrderSettlement.sol abstract contract RfqOrderSettlement is SettlerAbstract { using SafeTransferLib for IERC20; using FullMath for uint256; struct Consideration { IERC20 token; uint256 amount; address counterparty; bool partialFillAllowed; } string internal constant CONSIDERATION_TYPE = "Consideration(address token,uint256 amount,address counterparty,bool partialFillAllowed)"; // `string.concat` isn't recognized by solc as compile-time constant, but `abi.encodePacked` is string internal constant CONSIDERATION_WITNESS = string(abi.encodePacked("Consideration consideration)", CONSIDERATION_TYPE, TOKEN_PERMISSIONS_TYPE)); bytes32 internal constant CONSIDERATION_TYPEHASH = 0x7d806873084f389a66fd0315dead7adaad8ae6e8b6cf9fb0d3db61e5a91c3ffa; string internal constant RFQ_ORDER_TYPE = "RfqOrder(Consideration makerConsideration,Consideration takerConsideration)"; string internal constant RFQ_ORDER_TYPE_RECURSIVE = string(abi.encodePacked(RFQ_ORDER_TYPE, CONSIDERATION_TYPE)); bytes32 internal constant RFQ_ORDER_TYPEHASH = 0x49fa719b76f0f6b7e76be94b56c26671a548e1c712d5b13dc2874f70a7598276; function _hashConsideration(Consideration memory consideration) internal pure returns (bytes32 result) { assembly ("memory-safe") { let ptr := sub(consideration, 0x20) let oldValue := mload(ptr) mstore(ptr, CONSIDERATION_TYPEHASH) result := keccak256(ptr, 0xa0) mstore(ptr, oldValue) } } function _logRfqOrder(bytes32 makerConsiderationHash, bytes32 takerConsiderationHash, uint128 makerFilledAmount) private { assembly ("memory-safe") { mstore(0x00, RFQ_ORDER_TYPEHASH) mstore(0x20, makerConsiderationHash) let ptr := mload(0x40) mstore(0x40, takerConsiderationHash) let orderHash := keccak256(0x00, 0x60) mstore(0x40, ptr) mstore(0x10, makerFilledAmount) mstore(0x00, orderHash) log0(0x00, 0x30) } } constructor() { assert(CONSIDERATION_TYPEHASH == keccak256(bytes(CONSIDERATION_TYPE))); assert(RFQ_ORDER_TYPEHASH == keccak256(bytes(RFQ_ORDER_TYPE_RECURSIVE))); } /// @dev Settle an RfqOrder between maker and taker transfering funds directly between the counterparties. Either /// two Permit2 signatures are consumed, with the maker Permit2 containing a witness of the RfqOrder, or /// AllowanceHolder is supported for the taker payment. The Maker has signed the same order as the /// Taker. Submission may be directly by the taker or via a third party with the Taker signing a witness. /// @dev if used, the taker's witness is not calculated nor verified here as calling function is trusted function fillRfqOrderVIP( address recipient, ISignatureTransfer.PermitTransferFrom memory makerPermit, address maker, bytes memory makerSig, ISignatureTransfer.PermitTransferFrom memory takerPermit, bytes memory takerSig ) internal { assert(makerPermit.permitted.amount <= type(uint256).max - BASIS); (ISignatureTransfer.SignatureTransferDetails memory makerTransferDetails, uint256 makerAmount) = _permitToTransferDetails(makerPermit, recipient); // In theory, the taker permit could invoke the balance-proportional sell amount logic. However, // because we hash the sell amount computed here into the maker's consideration (witness) only a // balance-proportional sell amount that corresponds exactly to the signed order would avoid a // revert. In other words, no unexpected behavior is possible. It's pointless to prohibit the // use of that logic. (ISignatureTransfer.SignatureTransferDetails memory takerTransferDetails, uint256 takerAmount) = _permitToTransferDetails(takerPermit, maker); bytes32 witness = _hashConsideration( Consideration({ token: IERC20(takerPermit.permitted.token), amount: takerAmount, counterparty: _msgSender(), partialFillAllowed: false }) ); _transferFrom(takerPermit, takerTransferDetails, takerSig); _transferFromIKnowWhatImDoing( makerPermit, makerTransferDetails, maker, witness, CONSIDERATION_WITNESS, makerSig, false ); _logRfqOrder( witness, _hashConsideration( Consideration({ token: IERC20(makerPermit.permitted.token), amount: makerAmount, counterparty: maker, partialFillAllowed: false }) ), uint128(makerAmount) ); } /// @dev Settle an RfqOrder between maker and Settler retaining funds in this contract. /// @dev pre-condition: msgSender has been authenticated against the requestor /// One Permit2 signature is consumed, with the maker Permit2 containing a witness of the RfqOrder. // In this variant, Maker pays recipient and Settler pays Maker function fillRfqOrderSelfFunded( address recipient, ISignatureTransfer.PermitTransferFrom memory permit, address maker, bytes memory makerSig, IERC20 takerToken, uint256 maxTakerAmount ) internal { assert(permit.permitted.amount <= type(uint256).max - BASIS); // Compute witnesses. These are based on the quoted maximum amounts. We will modify them // later to adjust for the actual settled amount, which may be modified by encountered // slippage. (ISignatureTransfer.SignatureTransferDetails memory transferDetails, uint256 makerAmount) = _permitToTransferDetails(permit, recipient); bytes32 takerWitness = _hashConsideration( Consideration({ token: IERC20(permit.permitted.token), amount: makerAmount, counterparty: maker, partialFillAllowed: true }) ); bytes32 makerWitness = _hashConsideration( Consideration({ token: takerToken, amount: maxTakerAmount, counterparty: _msgSender(), partialFillAllowed: true }) ); // Now we adjust the transfer amounts to compensate for encountered slippage. Rounding is // performed in the maker's favor. uint256 takerAmount = takerToken.balanceOf(address(this)); if (takerAmount > maxTakerAmount) { takerAmount = maxTakerAmount; } transferDetails.requestedAmount = makerAmount = makerAmount.unsafeMulDiv(takerAmount, maxTakerAmount); // Now that we have all the relevant information, make the transfers and log the order. takerToken.safeTransfer(maker, takerAmount); _transferFromIKnowWhatImDoing( permit, transferDetails, maker, makerWitness, CONSIDERATION_WITNESS, makerSig, false ); _logRfqOrder(makerWitness, takerWitness, uint128(makerAmount)); } } // src/core/UniswapV3Fork.sol interface IUniswapV3Pool { /// @notice Swap token0 for token1, or token1 for token0 /// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback /// @param recipient The address to receive the output of the swap /// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0 /// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), /// or exact output (negative) /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this /// value after the swap. If one for zero, the price cannot be greater than this value after the swap /// @param data Any data to be passed through to the callback /// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive /// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive function swap( address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data ) external returns (int256 amount0, int256 amount1); } abstract contract UniswapV3Fork is SettlerAbstract { using UnsafeMath for uint256; using SafeTransferLib for IERC20; /// @dev Minimum size of an encoded swap path: /// sizeof(address(inputToken) | uint8(forkId) | uint24(poolId) | address(outputToken)) uint256 private constant SINGLE_HOP_PATH_SIZE = 0x2c; /// @dev How many bytes to skip ahead in an encoded path to start at the next hop: /// sizeof(address(inputToken) | uint8(forkId) | uint24(poolId)) uint256 private constant PATH_SKIP_HOP_SIZE = 0x18; /// @dev The size of the swap callback prefix data before the Permit2 data. uint256 private constant SWAP_CALLBACK_PREFIX_DATA_SIZE = 0x28; /// @dev The offset from the pointer to the length of the swap callback prefix data to the start of the Permit2 data. uint256 private constant SWAP_CALLBACK_PERMIT2DATA_OFFSET = 0x48; uint256 private constant PERMIT_DATA_SIZE = 0x60; uint256 private constant ISFORWARDED_DATA_SIZE = 0x01; /// @dev Minimum tick price sqrt ratio. uint160 private constant MIN_PRICE_SQRT_RATIO = 4295128739; /// @dev Minimum tick price sqrt ratio. uint160 private constant MAX_PRICE_SQRT_RATIO = 1461446703485210103287273052203988822378723970342; /// @dev Mask of lower 20 bytes. uint256 private constant ADDRESS_MASK = 0x00ffffffffffffffffffffffffffffffffffffffff; /// @dev Mask of lower 3 bytes. uint256 private constant UINT24_MASK = 0xffffff; /// @dev Sell a token for another token directly against uniswap v3. /// @param encodedPath Uniswap-encoded path. /// @param bps proportion of current balance of the first token in the path to sell. /// @param minBuyAmount Minimum amount of the last token in the path to buy. /// @param recipient The recipient of the bought tokens. /// @return buyAmount Amount of the last token in the path bought. function sellToUniswapV3(address recipient, uint256 bps, bytes memory encodedPath, uint256 minBuyAmount) internal returns (uint256 buyAmount) { buyAmount = _uniV3ForkSwap( recipient, encodedPath, // We don't care about phantom overflow here because reserves are // limited to 128 bits. Any token balance that would overflow here // would also break UniV3. (IERC20(address(bytes20(encodedPath))).balanceOf(address(this)) * bps).unsafeDiv(BASIS), minBuyAmount, address(this), // payer new bytes(SWAP_CALLBACK_PREFIX_DATA_SIZE) ); } /// @dev Sell a token for another token directly against uniswap v3. Payment is using a Permit2 signature (or AllowanceHolder). /// @param encodedPath Uniswap-encoded path. /// @param minBuyAmount Minimum amount of the last token in the path to buy. /// @param recipient The recipient of the bought tokens. /// @param permit The PermitTransferFrom allowing this contract to spend the taker's tokens /// @param sig The taker's signature for Permit2 /// @return buyAmount Amount of the last token in the path bought. function sellToUniswapV3VIP( address recipient, bytes memory encodedPath, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, uint256 minBuyAmount ) internal returns (uint256 buyAmount) { bytes memory swapCallbackData = new bytes(SWAP_CALLBACK_PREFIX_DATA_SIZE + PERMIT_DATA_SIZE + ISFORWARDED_DATA_SIZE + sig.length); _encodePermit2Data(swapCallbackData, permit, sig, _isForwarded()); buyAmount = _uniV3ForkSwap( recipient, encodedPath, _permitToSellAmount(permit), minBuyAmount, address(0), // payer swapCallbackData ); } // Executes successive swaps along an encoded uniswap path. function _uniV3ForkSwap( address recipient, bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address payer, bytes memory swapCallbackData ) internal returns (uint256 buyAmount) { if (sellAmount > uint256(type(int256).max)) { Panic.panic(Panic.ARITHMETIC_OVERFLOW); } IERC20 outputToken; while (true) { bool isPathMultiHop = _isPathMultiHop(encodedPath); bool zeroForOne; IUniswapV3Pool pool; uint32 callbackSelector; { (IERC20 token0, uint8 forkId, uint24 poolId, IERC20 token1) = _decodeFirstPoolInfoFromPath(encodedPath); IERC20 sellToken = token0; outputToken = token1; if (!(zeroForOne = token0 < token1)) { (token0, token1) = (token1, token0); } address factory; bytes32 initHash; (factory, initHash, callbackSelector) = _uniV3ForkInfo(forkId); pool = _toPool(factory, initHash, token0, token1, poolId); _updateSwapCallbackData(swapCallbackData, sellToken, payer); } int256 amount0; int256 amount1; if (isPathMultiHop) { uint256 freeMemPtr; assembly ("memory-safe") { freeMemPtr := mload(0x40) } (amount0, amount1) = abi.decode( _setOperatorAndCall( address(pool), abi.encodeCall( pool.swap, ( // Intermediate tokens go to this contract. address(this), zeroForOne, int256(sellAmount), zeroForOne ? MIN_PRICE_SQRT_RATIO + 1 : MAX_PRICE_SQRT_RATIO - 1, swapCallbackData ) ), callbackSelector, _uniV3ForkCallback ), (int256, int256) ); assembly ("memory-safe") { mstore(0x40, freeMemPtr) } } else { (amount0, amount1) = abi.decode( _setOperatorAndCall( address(pool), abi.encodeCall( pool.swap, ( recipient, zeroForOne, int256(sellAmount), zeroForOne ? MIN_PRICE_SQRT_RATIO + 1 : MAX_PRICE_SQRT_RATIO - 1, swapCallbackData ) ), callbackSelector, _uniV3ForkCallback ), (int256, int256) ); } { int256 _buyAmount = -(zeroForOne ? amount1 : amount0); if (_buyAmount < 0) { Panic.panic(Panic.ARITHMETIC_OVERFLOW); } buyAmount = uint256(_buyAmount); } if (!isPathMultiHop) { // Done. break; } // Continue with next hop. payer = address(this); // Subsequent hops are paid for by us. sellAmount = buyAmount; // Skip to next hop along path. encodedPath = _shiftHopFromPathInPlace(encodedPath); assembly ("memory-safe") { mstore(swapCallbackData, SWAP_CALLBACK_PREFIX_DATA_SIZE) } } if (buyAmount < minBuyAmount) { revert TooMuchSlippage(outputToken, minBuyAmount, buyAmount); } } // Return whether or not an encoded uniswap path contains more than one hop. function _isPathMultiHop(bytes memory encodedPath) private pure returns (bool) { return encodedPath.length > SINGLE_HOP_PATH_SIZE; } function _decodeFirstPoolInfoFromPath(bytes memory encodedPath) private pure returns (IERC20 inputToken, uint8 forkId, uint24 poolId, IERC20 outputToken) { if (encodedPath.length < SINGLE_HOP_PATH_SIZE) { Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS); } assembly ("memory-safe") { // Solidity cleans dirty bits automatically inputToken := mload(add(encodedPath, 0x14)) forkId := mload(add(encodedPath, 0x15)) poolId := mload(add(encodedPath, 0x18)) outputToken := mload(add(encodedPath, SINGLE_HOP_PATH_SIZE)) } } // Skip past the first hop of an encoded uniswap path in-place. function _shiftHopFromPathInPlace(bytes memory encodedPath) private pure returns (bytes memory) { if (encodedPath.length < PATH_SKIP_HOP_SIZE) { Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS); } assembly ("memory-safe") { let length := sub(mload(encodedPath), PATH_SKIP_HOP_SIZE) encodedPath := add(encodedPath, PATH_SKIP_HOP_SIZE) mstore(encodedPath, length) } return encodedPath; } function _encodePermit2Data( bytes memory swapCallbackData, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, bool isForwarded ) private pure { assembly ("memory-safe") { mstore(add(SWAP_CALLBACK_PERMIT2DATA_OFFSET, swapCallbackData), mload(add(0x20, mload(permit)))) mcopy(add(add(SWAP_CALLBACK_PERMIT2DATA_OFFSET, 0x20), swapCallbackData), add(0x20, permit), 0x40) mstore8(add(add(SWAP_CALLBACK_PERMIT2DATA_OFFSET, PERMIT_DATA_SIZE), swapCallbackData), isForwarded) mcopy( add( add(add(SWAP_CALLBACK_PERMIT2DATA_OFFSET, PERMIT_DATA_SIZE), ISFORWARDED_DATA_SIZE), swapCallbackData ), add(0x20, sig), mload(sig) ) } } // Update `swapCallbackData` in place with new values. function _updateSwapCallbackData(bytes memory swapCallbackData, IERC20 sellToken, address payer) private pure { assembly ("memory-safe") { let length := mload(swapCallbackData) mstore(add(0x28, swapCallbackData), sellToken) mstore(add(0x14, swapCallbackData), payer) mstore(swapCallbackData, length) } } // Compute the pool address given two tokens and a poolId. function _toPool(address factory, bytes32 initHash, IERC20 token0, IERC20 token1, uint24 poolId) private pure returns (IUniswapV3Pool) { // address(keccak256(abi.encodePacked( // hex"ff", // factory, // keccak256(abi.encode(token0, token1, poolId)), // initHash // ))) bytes32 salt; assembly ("memory-safe") { token0 := and(ADDRESS_MASK, token0) token1 := and(ADDRESS_MASK, token1) poolId := and(UINT24_MASK, poolId) let ptr := mload(0x40) mstore(0x00, token0) mstore(0x20, token1) mstore(0x40, poolId) salt := keccak256(0x00, sub(0x60, shl(0x05, iszero(poolId)))) mstore(0x40, ptr) } return IUniswapV3Pool(AddressDerivation.deriveDeterministicContract(factory, salt, initHash)); } function _uniV3ForkInfo(uint8 forkId) internal view virtual returns (address, bytes32, uint32); function _uniV3ForkCallback(bytes calldata data) private returns (bytes memory) { require(data.length >= 0x80); int256 amount0Delta; int256 amount1Delta; assembly ("memory-safe") { amount0Delta := calldataload(data.offset) amount1Delta := calldataload(add(0x20, data.offset)) data.offset := add(data.offset, calldataload(add(0x40, data.offset))) data.length := calldataload(data.offset) data.offset := add(0x20, data.offset) } uniswapV3SwapCallback(amount0Delta, amount1Delta, data); return new bytes(0); } /// @dev The UniswapV3 pool swap callback which pays the funds requested /// by the caller/pool to the pool. Can only be called by a valid /// UniswapV3 pool. /// @param amount0Delta Token0 amount owed. /// @param amount1Delta Token1 amount owed. /// @param data Arbitrary data forwarded from swap() caller. A packed encoding of: payer, sellToken, (optionally: permit[0x20:], isForwarded, sig) function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) private { address payer = address(uint160(bytes20(data))); data = data[0x14:]; uint256 sellAmount = amount0Delta > 0 ? uint256(amount0Delta) : uint256(amount1Delta); _pay(payer, sellAmount, data); } function _pay(address payer, uint256 amount, bytes calldata permit2Data) private { if (payer == address(this)) { IERC20(address(uint160(bytes20(permit2Data)))).safeTransfer(msg.sender, amount); } else { assert(payer == address(0)); ISignatureTransfer.PermitTransferFrom calldata permit; bool isForwarded; bytes calldata sig; assembly ("memory-safe") { // this is super dirty, but it works because although `permit` is aliasing in the // middle of `payer`, because `payer` is all zeroes, it's treated as padding for the // first word of `permit`, which is the sell token permit := sub(permit2Data.offset, 0x0c) isForwarded := and(0x01, calldataload(add(0x55, permit2Data.offset))) sig.offset := add(0x75, permit2Data.offset) sig.length := sub(permit2Data.length, 0x75) } ISignatureTransfer.SignatureTransferDetails memory transferDetails = ISignatureTransfer.SignatureTransferDetails({to: msg.sender, requestedAmount: amount}); _transferFrom(permit, transferDetails, sig, isForwarded); } } } // src/core/Basic.sol abstract contract Basic is SettlerAbstract { using SafeTransferLib for IERC20; using FullMath for uint256; using Revert for bool; IERC20 internal constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); /// @dev Sell to a pool with a generic approval, transferFrom interaction. /// offset in the calldata is used to update the sellAmount given a proportion of the sellToken balance function basicSellToPool(IERC20 sellToken, uint256 bps, address pool, uint256 offset, bytes memory data) internal { if (_isRestrictedTarget(pool)) { revert ConfusedDeputy(); } bool success; bytes memory returnData; uint256 value; if (sellToken == IERC20(ETH_ADDRESS)) { value = address(this).balance.mulDiv(bps, BASIS); if (data.length == 0) { if (offset != 0) revert InvalidOffset(); (success, returnData) = payable(pool).call{value: value}(""); success.maybeRevert(returnData); return; } else { if ((offset += 32) > data.length) { Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS); } assembly ("memory-safe") { mstore(add(data, offset), value) } } } else if (address(sellToken) == address(0)) { // TODO: check for zero `bps` if (offset != 0) revert InvalidOffset(); } else { uint256 amount = sellToken.balanceOf(address(this)).mulDiv(bps, BASIS); if ((offset += 32) > data.length) { Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS); } assembly ("memory-safe") { mstore(add(data, offset), amount) } if (address(sellToken) != pool) { sellToken.safeApproveIfBelow(pool, amount); } } (success, returnData) = payable(pool).call{value: value}(data); success.maybeRevert(returnData); // forbid sending data to EOAs if (returnData.length == 0 && pool.code.length == 0) revert InvalidTarget(); } } // src/core/Permit2Payment.sol library TransientStorage { // bytes32(uint256(keccak256("operator slot")) - 1) bytes32 private constant _OPERATOR_SLOT = 0x009355806b743562f351db2e3726091207f49fa1cdccd5c65a7d4860ce3abbe9; // bytes32(uint256(keccak256("witness slot")) - 1) bytes32 private constant _WITNESS_SLOT = 0x1643bf8e9fdaef48c4abf5a998de359be44a235ac7aebfbc05485e093720deaa; // bytes32(uint256(keccak256("payer slot")) - 1) bytes32 private constant _PAYER_SLOT = 0x46bacb9b87ba1d2910347e4a3e052d06c824a45acd1e9517bb0cb8d0d5cde893; // We assume (and our CI enforces) that internal function pointers cannot be // greater than 2 bytes. On chains not supporting the ViaIR pipeline, not // supporting EOF, and where the Spurious Dragon size limit is not enforced, // it might be possible to violate this assumption. However, our // `foundry.toml` enforces the use of the IR pipeline, so the point is moot. // // `operator` must not be `address(0)`. This is not checked. // `callback` must not be zero. This is checked in `_invokeCallback`. function setOperatorAndCallback( address operator, uint32 selector, function (bytes calldata) internal returns (bytes memory) callback ) internal { address currentSigner; assembly ("memory-safe") { currentSigner := tload(_PAYER_SLOT) } if (operator == currentSigner) { revert ConfusedDeputy(); } uint256 callbackInt; assembly ("memory-safe") { callbackInt := tload(_OPERATOR_SLOT) } if (callbackInt != 0) { // It should be impossible to reach this error because the first thing the fallback does // is clear the operator. It's also not possible to reenter the entrypoint function // because `_PAYER_SLOT` is an implicit reentrancy guard. revert ReentrantCallback(callbackInt); } assembly ("memory-safe") { tstore( _OPERATOR_SLOT, or( shl(0xe0, selector), or(shl(0xa0, and(0xffff, callback)), and(0xffffffffffffffffffffffffffffffffffffffff, operator)) ) ) } } function checkSpentOperatorAndCallback() internal view { uint256 callbackInt; assembly ("memory-safe") { callbackInt := tload(_OPERATOR_SLOT) } if (callbackInt != 0) { revert CallbackNotSpent(callbackInt); } } function getAndClearOperatorAndCallback() internal returns (bytes4 selector, function (bytes calldata) internal returns (bytes memory) callback, address operator) { assembly ("memory-safe") { selector := tload(_OPERATOR_SLOT) callback := and(0xffff, shr(0xa0, selector)) operator := selector tstore(_OPERATOR_SLOT, 0x00) } } // `newWitness` must not be `bytes32(0)`. This is not checked. function setWitness(bytes32 newWitness) internal { bytes32 currentWitness; assembly ("memory-safe") { currentWitness := tload(_WITNESS_SLOT) } if (currentWitness != bytes32(0)) { // It should be impossible to reach this error because the first thing a metatransaction // does on entry is to spend the `witness` (either directly or via a callback) revert ReentrantMetatransaction(currentWitness); } assembly ("memory-safe") { tstore(_WITNESS_SLOT, newWitness) } } function checkSpentWitness() internal view { bytes32 currentWitness; assembly ("memory-safe") { currentWitness := tload(_WITNESS_SLOT) } if (currentWitness != bytes32(0)) { revert WitnessNotSpent(currentWitness); } } function getAndClearWitness() internal returns (bytes32 witness) { assembly ("memory-safe") { witness := tload(_WITNESS_SLOT) tstore(_WITNESS_SLOT, 0x00) } } function setPayer(address payer) internal { if (payer == address(0)) { revert ConfusedDeputy(); } address oldPayer; assembly ("memory-safe") { oldPayer := tload(_PAYER_SLOT) } if (oldPayer != address(0)) { revert ReentrantPayer(oldPayer); } assembly ("memory-safe") { tstore(_PAYER_SLOT, and(0xffffffffffffffffffffffffffffffffffffffff, payer)) } } function getPayer() internal view returns (address payer) { assembly ("memory-safe") { payer := tload(_PAYER_SLOT) } } function clearPayer(address expectedOldPayer) internal { address oldPayer; assembly ("memory-safe") { oldPayer := tload(_PAYER_SLOT) } if (oldPayer != expectedOldPayer) { revert PayerSpent(); } assembly ("memory-safe") { tstore(_PAYER_SLOT, 0x00) } } } abstract contract Permit2PaymentBase is SettlerAbstract { using Revert for bool; /// @dev Permit2 address ISignatureTransfer internal constant _PERMIT2 = ISignatureTransfer(0x000000000022D473030F116dDEE9F6B43aC78BA3); function _isRestrictedTarget(address target) internal pure virtual override returns (bool) { return target == address(_PERMIT2); } function _msgSender() internal view virtual override returns (address) { return TransientStorage.getPayer(); } /// @dev You must ensure that `target` is derived by hashing trusted initcode or another /// equivalent mechanism that guarantees "reasonable"ness. `target` must not be /// user-supplied or attacker-controlled. This is required for security and is not checked /// here. For example, it must not do something weird like modifying the spender (possibly /// setting it to itself). If the callback is expected to relay a /// `ISignatureTransfer.PermitTransferFrom` struct, then the computation of `target` using /// the trusted initcode (or equivalent) must ensure that that calldata is relayed /// unmodified. The library function `AddressDerivation.deriveDeterministicContract` is /// recommended. function _setOperatorAndCall( address payable target, uint256 value, bytes memory data, uint32 selector, function (bytes calldata) internal returns (bytes memory) callback ) internal returns (bytes memory) { TransientStorage.setOperatorAndCallback(target, selector, callback); (bool success, bytes memory returndata) = target.call{value: value}(data); success.maybeRevert(returndata); TransientStorage.checkSpentOperatorAndCallback(); return returndata; } function _setOperatorAndCall( address target, bytes memory data, uint32 selector, function (bytes calldata) internal returns (bytes memory) callback ) internal override returns (bytes memory) { return _setOperatorAndCall(payable(target), 0, data, selector, callback); } function _invokeCallback(bytes calldata data) internal returns (bytes memory) { // Retrieve callback and perform call with untrusted calldata (bytes4 selector, function (bytes calldata) internal returns (bytes memory) callback, address operator) = TransientStorage.getAndClearOperatorAndCallback(); require(bytes4(data) == selector); require(msg.sender == operator); return callback(data[4:]); } } abstract contract Permit2Payment is Permit2PaymentBase { using FullMath for uint256; fallback(bytes calldata data) external virtual returns (bytes memory) { return _invokeCallback(data); } function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) internal view override returns (uint256 sellAmount) { sellAmount = permit.permitted.amount; if (sellAmount > type(uint256).max - BASIS) { unchecked { sellAmount -= type(uint256).max - BASIS; } sellAmount = IERC20(permit.permitted.token).balanceOf(_msgSender()).mulDiv(sellAmount, BASIS); } } function _permitToTransferDetails(ISignatureTransfer.PermitTransferFrom memory permit, address recipient) internal view override returns (ISignatureTransfer.SignatureTransferDetails memory transferDetails, uint256 sellAmount) { transferDetails.to = recipient; transferDetails.requestedAmount = sellAmount = _permitToSellAmount(permit); } // This function is provided *EXCLUSIVELY* for use here and in RfqOrderSettlement. Any other use // of this function is forbidden. You must use the version that does *NOT* take a `from` or // `witness` argument. function _transferFromIKnowWhatImDoing( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address from, bytes32 witness, string memory witnessTypeString, bytes memory sig, bool isForwarded ) internal override { if (isForwarded) revert ForwarderNotAllowed(); _PERMIT2.permitWitnessTransferFrom(permit, transferDetails, from, witness, witnessTypeString, sig); } // See comment in above overload; don't use this function function _transferFromIKnowWhatImDoing( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address from, bytes32 witness, string memory witnessTypeString, bytes memory sig ) internal override { _transferFromIKnowWhatImDoing(permit, transferDetails, from, witness, witnessTypeString, sig, _isForwarded()); } function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, bytes memory sig ) internal override { _transferFrom(permit, transferDetails, sig, _isForwarded()); } } abstract contract Permit2PaymentTakerSubmitted is AllowanceHolderContext, Permit2Payment { constructor() { assert(!_hasMetaTxn()); } function _isRestrictedTarget(address target) internal pure virtual override returns (bool) { return target == address(_ALLOWANCE_HOLDER) || super._isRestrictedTarget(target); } function _operator() internal view override returns (address) { return AllowanceHolderContext._msgSender(); } function _msgSender() internal view virtual override(Permit2PaymentBase, AllowanceHolderContext) returns (address) { return Permit2PaymentBase._msgSender(); } function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, bytes memory sig, bool isForwarded ) internal override { if (isForwarded) { if (sig.length != 0) revert InvalidSignatureLen(); if (permit.nonce != 0) Panic.panic(Panic.ARITHMETIC_OVERFLOW); if (block.timestamp > permit.deadline) revert SignatureExpired(permit.deadline); // we don't check `requestedAmount` because it's checked by AllowanceHolder itself _allowanceHolderTransferFrom( permit.permitted.token, _msgSender(), transferDetails.to, transferDetails.requestedAmount ); } else { _PERMIT2.permitTransferFrom(permit, transferDetails, _msgSender(), sig); } } function _allowanceHolderTransferFrom(address token, address owner, address recipient, uint256 amount) internal override { // `owner` is always `_msgSender()` _ALLOWANCE_HOLDER.transferFrom(token, owner, recipient, amount); } modifier takerSubmitted() override { address msgSender = _operator(); TransientStorage.setPayer(msgSender); _; TransientStorage.clearPayer(msgSender); } modifier metaTx(address, bytes32) override { revert(); _; } } abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { constructor() { assert(_hasMetaTxn()); } function _operator() internal view override returns (address) { return Context._msgSender(); } function _msgSender() internal view virtual override(Permit2PaymentBase, Context) returns (address) { return Permit2PaymentBase._msgSender(); } // `string.concat` isn't recognized by solc as compile-time constant, but `abi.encodePacked` is // This is defined here as `private` and not in `SettlerAbstract` as `internal` because no other // contract/file should reference it. The *ONLY* approved way to make a transfer using this // witness string is by setting the witness with modifier `metaTx` string private constant _SLIPPAGE_AND_ACTIONS_WITNESS = string( abi.encodePacked("SlippageAndActions slippageAndActions)", SLIPPAGE_AND_ACTIONS_TYPE, TOKEN_PERMISSIONS_TYPE) ); function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, bytes memory sig, bool isForwarded // must be false ) internal override { bytes32 witness = TransientStorage.getAndClearWitness(); if (witness == bytes32(0)) { revert ConfusedDeputy(); } _transferFromIKnowWhatImDoing( permit, transferDetails, _msgSender(), witness, _SLIPPAGE_AND_ACTIONS_WITNESS, sig, isForwarded ); } function _allowanceHolderTransferFrom(address, address, address, uint256) internal pure override { revert ConfusedDeputy(); } modifier takerSubmitted() override { revert(); _; } modifier metaTx(address msgSender, bytes32 witness) override { if (_isForwarded()) { revert ForwarderNotAllowed(); } TransientStorage.setWitness(witness); TransientStorage.setPayer(msgSender); _; TransientStorage.clearPayer(msgSender); // It should not be possible for this check to revert because the very first thing that a // metatransaction does is spend the witness. TransientStorage.checkSpentWitness(); } } // src/SettlerBase.sol /// @dev This library's ABIDeocding is more lax than the Solidity ABIDecoder. This library omits index bounds/overflow /// checking when accessing calldata arrays for gas efficiency. It also omits checks against `calldatasize()`. This /// means that it is possible that `args` will run off the end of calldata and be implicitly padded with zeroes. That we /// don't check for overflow means that offsets can be negative. This can also result in `args` that alias other parts /// of calldata, or even the `actions` array itself. library CalldataDecoder { function decodeCall(bytes[] calldata data, uint256 i) internal pure returns (bytes4 selector, bytes calldata args) { assembly ("memory-safe") { // initially, we set `args.offset` to the pointer to the length. this is 32 bytes before the actual start of data args.offset := add( data.offset, // We allow the indirection/offset to `calls[i]` to be negative calldataload( add(shl(5, i), data.offset) // can't overflow; we assume `i` is in-bounds ) ) // now we load `args.length` and set `args.offset` to the start of data args.length := calldataload(args.offset) args.offset := add(args.offset, 0x20) // slice off the first 4 bytes of `args` as the selector selector := calldataload(args.offset) // solidity cleans dirty bits automatically args.length := sub(args.length, 0x04) args.offset := add(args.offset, 0x04) } } } abstract contract SettlerBase is Basic, RfqOrderSettlement, UniswapV3Fork, UniswapV2, Velodrome { using SafeTransferLib for IERC20; using SafeTransferLib for address payable; receive() external payable {} event GitCommit(bytes20 indexed); constructor(bytes20 gitCommit, uint256 tokenId) { if (block.chainid != 31337) { emit GitCommit(gitCommit); assert(IERC721Owner(0x00000000000004533Fe15556B1E086BB1A72cEae).ownerOf(tokenId) == address(this)); } else { assert(gitCommit == bytes20(0)); } } struct AllowedSlippage { address recipient; IERC20 buyToken; uint256 minAmountOut; } function _checkSlippageAndTransfer(AllowedSlippage calldata slippage) internal { // This final slippage check effectively prohibits custody optimization on the // final hop of every swap. This is gas-inefficient. This is on purpose. Because // ISettlerActions.BASIC could interact with an intents-based settlement // mechanism, we must ensure that the user's want token increase is coming // directly from us instead of from some other form of exchange of value. (address recipient, IERC20 buyToken, uint256 minAmountOut) = (slippage.recipient, slippage.buyToken, slippage.minAmountOut); if (minAmountOut != 0 || address(buyToken) != address(0)) { if (buyToken == ETH_ADDRESS) { uint256 amountOut = address(this).balance; if (amountOut < minAmountOut) { revert TooMuchSlippage(buyToken, minAmountOut, amountOut); } payable(recipient).safeTransferETH(amountOut); } else { uint256 amountOut = buyToken.balanceOf(address(this)); if (amountOut < minAmountOut) { revert TooMuchSlippage(buyToken, minAmountOut, amountOut); } buyToken.safeTransfer(recipient, amountOut); } } } function _dispatch(uint256, bytes4 action, bytes calldata data) internal virtual override returns (bool) { if (action == ISettlerActions.TRANSFER_FROM.selector) { (address recipient, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig) = abi.decode(data, (address, ISignatureTransfer.PermitTransferFrom, bytes)); (ISignatureTransfer.SignatureTransferDetails memory transferDetails,) = _permitToTransferDetails(permit, recipient); _transferFrom(permit, transferDetails, sig); } else if (action == ISettlerActions.RFQ.selector) { ( address recipient, ISignatureTransfer.PermitTransferFrom memory permit, address maker, bytes memory makerSig, IERC20 takerToken, uint256 maxTakerAmount ) = abi.decode(data, (address, ISignatureTransfer.PermitTransferFrom, address, bytes, IERC20, uint256)); fillRfqOrderSelfFunded(recipient, permit, maker, makerSig, takerToken, maxTakerAmount); } else if (action == ISettlerActions.UNISWAPV3.selector) { (address recipient, uint256 bps, bytes memory path, uint256 amountOutMin) = abi.decode(data, (address, uint256, bytes, uint256)); sellToUniswapV3(recipient, bps, path, amountOutMin); } else if (action == ISettlerActions.UNISWAPV2.selector) { (address recipient, address sellToken, uint256 bps, address pool, uint24 swapInfo, uint256 amountOutMin) = abi.decode(data, (address, address, uint256, address, uint24, uint256)); sellToUniswapV2(recipient, sellToken, bps, pool, swapInfo, amountOutMin); } else if (action == ISettlerActions.BASIC.selector) { (IERC20 sellToken, uint256 bps, address pool, uint256 offset, bytes memory _data) = abi.decode(data, (IERC20, uint256, address, uint256, bytes)); basicSellToPool(sellToken, bps, pool, offset, _data); } else if (action == ISettlerActions.VELODROME.selector) { (address recipient, uint256 bps, IVelodromePair pool, uint24 swapInfo, uint256 minAmountOut) = abi.decode(data, (address, uint256, IVelodromePair, uint24, uint256)); sellToVelodrome(recipient, bps, pool, swapInfo, minAmountOut); } else if (action == ISettlerActions.POSITIVE_SLIPPAGE.selector) { (address recipient, IERC20 token, uint256 expectedAmount) = abi.decode(data, (address, IERC20, uint256)); if (token == IERC20(ETH_ADDRESS)) { uint256 balance = address(this).balance; if (balance > expectedAmount) { unchecked { payable(recipient).safeTransferETH(balance - expectedAmount); } } } else { uint256 balance = token.balanceOf(address(this)); if (balance > expectedAmount) { unchecked { token.safeTransfer(recipient, balance - expectedAmount); } } } } else { return false; } return true; } } // src/Settler.sol abstract contract Settler is Permit2PaymentTakerSubmitted, SettlerBase { using UnsafeMath for uint256; using CalldataDecoder for bytes[]; // When/if you change this, you must make corresponding changes to // `sh/deploy_new_chain.sh` and 'sh/common_deploy_settler.sh' to set // `constructor_args`. constructor(bytes20 gitCommit) SettlerBase(gitCommit, 2) {} function _hasMetaTxn() internal pure override returns (bool) { return false; } function _msgSender() internal view virtual // Solidity inheritance is so stupid override(Permit2PaymentTakerSubmitted, AbstractContext) returns (address) { return super._msgSender(); } function _isRestrictedTarget(address target) internal pure virtual // Solidity inheritance is so stupid override(Permit2PaymentTakerSubmitted, Permit2PaymentAbstract) returns (bool) { return super._isRestrictedTarget(target); } function _dispatchVIP(bytes4 action, bytes calldata data) internal virtual returns (bool) { if (action == ISettlerActions.RFQ_VIP.selector) { ( address recipient, ISignatureTransfer.PermitTransferFrom memory makerPermit, address maker, bytes memory makerSig, ISignatureTransfer.PermitTransferFrom memory takerPermit, bytes memory takerSig ) = abi.decode( data, ( address, ISignatureTransfer.PermitTransferFrom, address, bytes, ISignatureTransfer.PermitTransferFrom, bytes ) ); fillRfqOrderVIP(recipient, makerPermit, maker, makerSig, takerPermit, takerSig); } else if (action == ISettlerActions.UNISWAPV3_VIP.selector) { ( address recipient, bytes memory path, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig, uint256 amountOutMin ) = abi.decode(data, (address, bytes, ISignatureTransfer.PermitTransferFrom, bytes, uint256)); sellToUniswapV3VIP(recipient, path, permit, sig, amountOutMin); } else { return false; } return true; } function execute(AllowedSlippage calldata slippage, bytes[] calldata actions, bytes32 /* zid & affiliate */ ) public payable takerSubmitted returns (bool) { if (actions.length != 0) { (bytes4 action, bytes calldata data) = actions.decodeCall(0); if (!_dispatchVIP(action, data)) { if (!_dispatch(0, action, data)) { revert ActionInvalid(0, action, data); } } } for (uint256 i = 1; i < actions.length; i = i.unsafeInc()) { (bytes4 action, bytes calldata data) = actions.decodeCall(i); if (!_dispatch(i, action, data)) { revert ActionInvalid(i, action, data); } } _checkSlippageAndTransfer(slippage); return true; } } // src/SettlerMetaTxn.sol abstract contract SettlerMetaTxn is Permit2PaymentMetaTxn, SettlerBase { using UnsafeMath for uint256; using CalldataDecoder for bytes[]; // When/if you change this, you must make corresponding changes to // `sh/deploy_new_chain.sh` and 'sh/common_deploy_settler.sh' to set // `constructor_args`. constructor(bytes20 gitCommit) SettlerBase(gitCommit, 3) {} function _hasMetaTxn() internal pure override returns (bool) { return true; } function _msgSender() internal view virtual // Solidity inheritance is so stupid override(Permit2PaymentMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } function _hashArrayOfBytes(bytes[] calldata actions) internal pure returns (bytes32 result) { // This function deliberately does no bounds checking on `actions` for // gas efficiency. We assume that `actions` will get used elsewhere in // this context and any OOB or other malformed calldata will result in a // revert later. assembly ("memory-safe") { let ptr := mload(0x40) let hashesLength := shl(5, actions.length) for { let i := actions.offset let dst := ptr let end := add(i, hashesLength) } lt(i, end) { i := add(i, 0x20) dst := add(dst, 0x20) } { let src := add(actions.offset, calldataload(i)) let length := calldataload(src) calldatacopy(dst, add(src, 0x20), length) mstore(dst, keccak256(dst, length)) } result := keccak256(ptr, hashesLength) } } function _hashActionsAndSlippage(bytes[] calldata actions, AllowedSlippage calldata slippage) internal pure returns (bytes32 result) { // This function does not check for or clean any dirty bits that might // exist in `slippage`. We assume that `slippage` will be used elsewhere // in this context and that if there are dirty bits it will result in a // revert later. bytes32 arrayOfBytesHash = _hashArrayOfBytes(actions); assembly ("memory-safe") { let ptr := mload(0x40) mstore(ptr, SLIPPAGE_AND_ACTIONS_TYPEHASH) calldatacopy(add(ptr, 0x20), slippage, 0x60) mstore(add(ptr, 0x80), arrayOfBytesHash) result := keccak256(ptr, 0xa0) } } function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal virtual returns (bool) { if (action == ISettlerActions.METATXN_RFQ_VIP.selector) { // An optimized path involving a maker/taker in a single trade // The RFQ order is signed by both maker and taker, validation is // performed inside the RfqOrderSettlement so there is no need to // validate `sig` against `actions` here ( address recipient, ISignatureTransfer.PermitTransferFrom memory makerPermit, address maker, bytes memory makerSig, ISignatureTransfer.PermitTransferFrom memory takerPermit ) = abi.decode( data, (address, ISignatureTransfer.PermitTransferFrom, address, bytes, ISignatureTransfer.PermitTransferFrom) ); fillRfqOrderVIP(recipient, makerPermit, maker, makerSig, takerPermit, sig); } else if (action == ISettlerActions.METATXN_TRANSFER_FROM.selector) { (address recipient, ISignatureTransfer.PermitTransferFrom memory permit) = abi.decode(data, (address, ISignatureTransfer.PermitTransferFrom)); (ISignatureTransfer.SignatureTransferDetails memory transferDetails,) = _permitToTransferDetails(permit, recipient); // We simultaneously transfer-in the taker's tokens and authenticate the // metatransaction. _transferFrom(permit, transferDetails, sig); } else if (action == ISettlerActions.METATXN_UNISWAPV3_VIP.selector) { ( address recipient, bytes memory path, ISignatureTransfer.PermitTransferFrom memory permit, uint256 amountOutMin ) = abi.decode(data, (address, bytes, ISignatureTransfer.PermitTransferFrom, uint256)); sellToUniswapV3VIP(recipient, path, permit, sig, amountOutMin); } else { return false; } return true; } function executeMetaTxn( AllowedSlippage calldata slippage, bytes[] calldata actions, bytes32, /* zid & affiliate */ address msgSender, bytes calldata sig ) public metaTx(msgSender, _hashActionsAndSlippage(actions, slippage)) returns (bool) { require(actions.length != 0); { (bytes4 action, bytes calldata data) = actions.decodeCall(0); // By forcing the first action to be one of the witness-aware // actions, we ensure that the entire sequence of actions is // authorized. `msgSender` is the signer of the metatransaction. if (!_dispatchVIP(action, data, sig)) { revert ActionInvalid(0, action, data); } } for (uint256 i = 1; i < actions.length; i = i.unsafeInc()) { (bytes4 action, bytes calldata data) = actions.decodeCall(i); if (!_dispatch(i, action, data)) { revert ActionInvalid(i, action, data); } } _checkSlippageAndTransfer(slippage); return true; } } // src/chains/Blast.sol //import {sushiswapV3BlastFactory, sushiswapV3BlastInitHash, sushiswapV3ForkId} from "../core/univ3forks/SushiswapV3.sol"; // Solidity inheritance is stupid abstract contract BlastMixin is FreeMemory, SettlerBase { constructor() { if (block.chainid != 31337) { assert(block.chainid == 81457); BLAST.configure( BlastYieldMode.AUTOMATIC, BlastGasMode.CLAIMABLE, IOwnable(0x00000000000004533Fe15556B1E086BB1A72cEae).owner() ); BLAST_USDB.configure(BlastYieldMode.VOID); BLAST_WETH.configure(BlastYieldMode.VOID); } } function _isRestrictedTarget(address target) internal pure virtual override(Permit2PaymentAbstract) returns (bool) { return target == address(BLAST); } function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal virtual override DANGEROUS_freeMemory returns (bool) { return super._dispatch(i, action, data); } function _uniV3ForkInfo(uint8 forkId) internal pure override returns (address factory, bytes32 initHash, uint32 callbackSelector) { if (forkId < dackieSwapV3ForkId) { if (forkId == uniswapV3ForkId) { factory = uniswapV3BlastFactory; initHash = uniswapV3InitHash; callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector); //} else if (forkId == sushiswapV3ForkId) { // factory = sushiswapV3BlastFactory; // initHash = sushiswapV3BlastInitHash; // callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector); } else if (forkId == thrusterForkId) { factory = thrusterFactory; initHash = thrusterInitHash; callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector); } else if (forkId == bladeSwapForkId) { factory = bladeSwapFactory; initHash = bladeSwapInitHash; callbackSelector = uint32(IAlgebraCallback.algebraSwapCallback.selector); } else if (forkId == fenixForkId) { factory = fenixFactory; initHash = fenixInitHash; callbackSelector = uint32(IAlgebraCallback.algebraSwapCallback.selector); } else { revert UnknownForkId(forkId); } } else { if (forkId == dackieSwapV3ForkId) { factory = dackieSwapV3BlastFactory; initHash = dackieSwapV3BlastInitHash; callbackSelector = uint32(IPancakeSwapV3Callback.pancakeV3SwapCallback.selector); } else if (forkId == blasterV3ForkId) { factory = blasterV3Factory; initHash = blasterV3InitHash; callbackSelector = uint32(IBlasterswapV3SwapCallback.blasterswapV3SwapCallback.selector); } else if (forkId == monoSwapV3ForkId) { factory = monoSwapV3Factory; initHash = monoSwapV3InitHash; callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector); } else if (forkId == rogueXV1ForkId) { factory = rogueXV1Factory; initHash = rogueXV1InitHash; callbackSelector = uint32(IRoxSpotSwapCallback.swapCallback.selector); } else { revert UnknownForkId(forkId); } } } } /// @custom:security-contact [email protected] contract BlastSettler is Settler, BlastMixin { constructor(bytes20 gitCommit) Settler(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); } function _isRestrictedTarget(address target) internal pure override(Settler, BlastMixin) returns (bool) { return BlastMixin._isRestrictedTarget(target) || Settler._isRestrictedTarget(target); } // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal override(SettlerAbstract, SettlerBase, BlastMixin) returns (bool) { return super._dispatch(i, action, data); } function _msgSender() internal view override(Settler, AbstractContext) returns (address) { return super._msgSender(); } } /// @custom:security-contact [email protected] contract BlastSettlerMetaTxn is SettlerMetaTxn, BlastMixin { constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data, sig); } function _isRestrictedTarget(address target) internal pure override(Permit2PaymentBase, BlastMixin, Permit2PaymentAbstract) returns (bool) { return BlastMixin._isRestrictedTarget(target) || Permit2PaymentBase._isRestrictedTarget(target); } // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal override(SettlerAbstract, SettlerBase, BlastMixin) returns (bool) { return super._dispatch(i, action, data); } function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } }
{ "remappings": [ "solmate/=lib/solmate/", "permit2/=lib/permit2/", "forge-std/=lib/forge-std/src/", "forge-gas-snapshot/=lib/forge-gas-snapshot/src/", "ds-test/=lib/forge-std/lib/ds-test/src/" ], "optimizer": { "enabled": true, "runs": 10000, "details": { "constantOptimizer": true, "yul": true } }, "metadata": { "useLiteralContent": false, "bytecodeHash": "none", "appendCBOR": false }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "cancun", "viaIR": true, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"bytes20","name":"gitCommit","type":"bytes20"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"},{"internalType":"bytes4","name":"action","type":"bytes4"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"ActionInvalid","type":"error"},{"inputs":[{"internalType":"uint256","name":"callbackInt","type":"uint256"}],"name":"CallbackNotSpent","type":"error"},{"inputs":[],"name":"ConfusedDeputy","type":"error"},{"inputs":[],"name":"ForwarderNotAllowed","type":"error"},{"inputs":[],"name":"InvalidOffset","type":"error"},{"inputs":[],"name":"InvalidSignatureLen","type":"error"},{"inputs":[],"name":"InvalidTarget","type":"error"},{"inputs":[],"name":"NotConverged","type":"error"},{"inputs":[],"name":"PayerSpent","type":"error"},{"inputs":[{"internalType":"uint256","name":"callbackInt","type":"uint256"}],"name":"ReentrantCallback","type":"error"},{"inputs":[{"internalType":"address","name":"oldPayer","type":"address"}],"name":"ReentrantPayer","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"SignatureExpired","type":"error"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"expected","type":"uint256"},{"internalType":"uint256","name":"actual","type":"uint256"}],"name":"TooMuchSlippage","type":"error"},{"inputs":[{"internalType":"uint8","name":"forkId","type":"uint8"}],"name":"UnknownForkId","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes20","name":"","type":"bytes20"}],"name":"GitCommit","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"contract IERC20","name":"buyToken","type":"address"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"}],"internalType":"struct SettlerBase.AllowedSlippage","name":"slippage","type":"tuple"},{"internalType":"bytes[]","name":"actions","type":"bytes[]"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"execute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
d86391e90c849c1e925e111e2db3e3a46f063011000000000000000000000000
-----Decoded View---------------
Arg [0] : gitCommit (bytes20): 0xd86391e90c849c1e925e111e2db3e3a46f063011
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : d86391e90c849c1e925e111e2db3e3a46f063011000000000000000000000000
Loading...
Loading
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.