Contract Name:
SonicSettlerMetaTxn
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity =0.8.25 >=0.6.2 >=0.8.25 ^0.8.0 ^0.8.25;
// 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/core/univ3forks/SpookySwap.sol
address constant spookySwapFactory = 0x3D91B700252e0E3eE7805d12e048a988Ab69C8ad;
uint8 constant spookySwapForkId = 27;
// 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;
address constant uniswapV3TaikoFactory = 0x75FC67473A91335B5b8F8821277262a13B38c9b3;
address constant uniswapV3WorldChainFactory = 0x7a5028BDa40e7B173C278C5342087826455ea25a;
address constant uniswapV3GnosisFactory = 0xe32F7dD7e3f098D518ff19A22d5f028e076489B1;
address constant uniswapV3SonicFactory = 0xcb2436774C3e191c85056d248EF4260ce5f27A9D;
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 unsafeDec(uint256 x) internal pure returns (uint256) {
unchecked {
return x - 1;
}
}
function unsafeDec(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();
error DeltaNotPositive(IERC20 token);
error DeltaNotNegative(IERC20 token);
error ZeroSellAmount(IERC20 token);
error ZeroBuyAmount(IERC20 buyToken);
error BoughtSellToken(IERC20 sellToken);
error TokenHashCollision(IERC20 token0, IERC20 token1);
error ZeroToken();
// src/vendor/SafeTransferLib.sol
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Modified from Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address payable to, uint256 amount) internal {
assembly ("memory-safe") {
// Transfer the ETH and revert if it fails.
if iszero(call(gas(), to, amount, 0x00, 0x00, 0x00, 0x00)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0x00, returndatasize())
revert(ptr, returndatasize())
}
}
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function fastBalanceOf(IERC20 token, address acct) internal view returns (uint256 r) {
assembly ("memory-safe") {
mstore(0x14, acct) // Store the `acct` argument.
mstore(0x00, 0x70a08231000000000000000000000000) // Selector for `balanceOf(address)`, with `acct`'s padding.
// Call and check for revert. Storing the selector with padding in
// memory at 0 results in a start of calldata at offset 16. Calldata
// is 36 bytes long (4 bytes selector, 32 bytes argument)
if iszero(staticcall(gas(), token, 0x10, 0x24, 0x00, 0x20)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0x00, returndatasize())
revert(ptr, returndatasize())
}
// Check for short calldata and missing code
if iszero(gt(returndatasize(), 0x1f)) { revert(0x00, 0x00) }
r := mload(0x00)
}
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
assembly ("memory-safe") {
let ptr := mload(0x40) // Cache the free memory pointer.
mstore(0x60, amount) // Store the `amount` argument.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(0x60, from)) // Store the `from` argument. (Clears `to`'s padding.)
mstore(0x0c, 0x23b872dd000000000000000000000000) // Selector for `transferFrom(address,address,uint256)`, with `from`'s padding.
// Calldata starts at offset 28 and is 100 bytes long (3 * 32 + 4).
// If there is returndata (optional) we copy the first 32 bytes into the first slot of memory.
if iszero(call(gas(), token, 0x00, 0x1c, 0x64, 0x00, 0x20)) {
returndatacopy(ptr, 0x00, returndatasize())
revert(ptr, returndatasize())
}
// We check that the call either returned exactly 1 [true] (can't just be non-zero
// data), or had no return data.
if iszero(or(and(eq(mload(0x00), 0x01), gt(returndatasize(), 0x1f)), iszero(returndatasize()))) {
mstore(0x00, 0x7939f424) // Selector for `TransferFromFailed()`
revert(0x1c, 0x04)
}
mstore(0x60, 0x00) // Restore the zero slot to zero.
mstore(0x40, ptr) // Restore the free memory pointer.
}
}
function safeTransfer(IERC20 token, address to, uint256 amount) internal {
assembly ("memory-safe") {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
// Storing `amount` clobbers the upper bits of the free memory pointer, but those bits
// can never be set without running into an OOG, so it's safe. We'll restore them to
// zero at the end.
mstore(0x00, 0xa9059cbb000000000000000000000000) // Selector for `transfer(address,uint256)`, with `to`'s padding.
// Calldata starts at offset 16 and is 68 bytes long (2 * 32 + 4).
// If there is returndata (optional) we copy the first 32 bytes into the first slot of memory.
if iszero(call(gas(), token, 0x00, 0x10, 0x44, 0x00, 0x20)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0x00, returndatasize())
revert(ptr, returndatasize())
}
// We check that the call either returned exactly 1 [true] (can't just be non-zero
// data), or had no return data.
if iszero(or(and(eq(mload(0x00), 0x01), gt(returndatasize(), 0x1f)), iszero(returndatasize()))) {
mstore(0x00, 0x90b8ec18) // Selector for `TransferFailed()`
revert(0x1c, 0x04)
}
mstore(0x34, 0x00) // Restore the part of the free memory pointer that was overwritten.
}
}
function safeApprove(IERC20 token, address to, uint256 amount) internal {
assembly ("memory-safe") {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
// Storing `amount` clobbers the upper bits of the free memory pointer, but those bits
// can never be set without running into an OOG, so it's safe. We'll restore them to
// zero at the end.
mstore(0x00, 0x095ea7b3000000000000000000000000) // Selector for `approve(address,uint256)`, with `to`'s padding.
// Calldata starts at offset 16 and is 68 bytes long (2 * 32 + 4).
// If there is returndata (optional) we copy the first 32 bytes into the first slot of memory.
if iszero(call(gas(), token, 0x00, 0x10, 0x44, 0x00, 0x20)) {
let ptr := mload(0x40)
returndatacopy(ptr, 0x00, returndatasize())
revert(ptr, returndatasize())
}
// We check that the call either returned exactly 1 [true] (can't just be non-zero
// data), or had no return data.
if iszero(or(and(eq(mload(0x00), 0x01), gt(returndatasize(), 0x1f)), iszero(returndatasize()))) {
mstore(0x00, 0x3e3f8f73) // Selector for `ApproveFailed()`
revert(0x1c, 0x04)
}
mstore(0x34, 0x00) // Restore the part of the free memory pointer that was overwritten.
}
}
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;
function UNISWAPV4(
address recipient,
address sellToken,
uint256 bps,
bool feeOnTransfer,
uint256 hashMul,
uint256 hashMod,
bytes memory fills,
uint256 amountOutMin
) external;
function UNISWAPV4_VIP(
address recipient,
bool feeOnTransfer,
uint256 hashMul,
uint256 hashMod,
bytes memory fills,
ISignatureTransfer.PermitTransferFrom memory permit,
bytes memory sig,
uint256 amountOutMin
) external;
function METATXN_UNISWAPV4_VIP(
address recipient,
bool feeOnTransfer,
uint256 hashMul,
uint256 hashMod,
bytes memory fills,
ISignatureTransfer.PermitTransferFrom memory permit,
uint256 amountOutMin
) 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;
/// @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;
function MAKERPSM(address recipient, uint256 bps, 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 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/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);
}
/// @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
/// @dev This is the branchless, straight line version of `unsafeMulDiv`. If we know that `prod1 != 0` this may be faster. Also this gives Solc a better chance to optimize.
/// @return The 256-bit result
function unsafeMulDivAlt(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256) {
(uint256 prod0, uint256 prod1, uint256 remainder) = _mulDivSetup(a, b, 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 _permitToSellAmountCalldata(ISignatureTransfer.PermitTransferFrom calldata permit)
internal
view
virtual
returns (uint256 sellAmount);
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;
IERC20 internal constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
constructor() {
assert(SLIPPAGE_AND_ACTIONS_TYPEHASH == keccak256(bytes(SLIPPAGE_AND_ACTIONS_TYPE)));
}
function _hasMetaTxn() internal pure virtual returns (bool);
function _dispatch(uint256 i, uint256 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 SafeTransferLib for IERC20;
// 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).fastBalanceOf(address(this)) * bps / 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/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 {
if (!_hasMetaTxn()) {
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 {
if (!_hasMetaTxn()) {
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.fastBalanceOf(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 UnsafeMath for int256;
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))).fastBalanceOf(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).unsafeNeg();
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;
assembly ("memory-safe") {
payer := shr(0x60, calldataload(data.offset))
data.length := sub(data.length, 0x14)
data.offset := add(0x14, data.offset)
// We don't check for underflow/array-out-of-bounds here because the trusted inithash
// ensures that `data` was passed unmodified from `_updateSwapCallbackData`. Therefore,
// it is at least 40 bytes long.
}
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 token;
assembly ("memory-safe") {
token := shr(0x60, calldataload(permit2Data.offset))
}
token.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/Velodrome.sol
//import {Panic} from "../utils/Panic.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 FullMath for uint256;
using SafeTransferLib for IERC20;
// This is the basis used for token balances. The original token may have fewer decimals, in
// which case we scale up by the appropriate factor to give this basis.
uint256 internal constant _VELODROME_TOKEN_BASIS = 1 ether;
// When computing `k`, to minimize rounding error, we use a significantly larger basis. This
// also allows us to save work in the Newton-Raphson step because dividing a quantity with this
// basis by a quantity with `_VELODROME_TOKEN_BASIS` basis gives that same
// `_VELODROME_TOKEN_BASIS` basis. Convenient *and* accurate.
uint256 private constant _VELODROME_INTERNAL_BASIS = _VELODROME_TOKEN_BASIS * _VELODROME_TOKEN_BASIS;
uint256 private constant _VELODROME_INTERNAL_TO_TOKEN_RATIO = _VELODROME_INTERNAL_BASIS / _VELODROME_TOKEN_BASIS;
// When computing `d` we need to compute the cube of a token quantity and format the result with
// `_VELODROME_TOKEN_BASIS`. In order to avoid overflow, we must divide the squared token
// quantity by this before multiplying again by the token quantity. Setting this value as small
// as possible preserves precision. This gives a result in an awkward basis, but we'll correct
// that with `_VELODROME_CUBE_STEP_BASIS` after the cubing
uint256 private constant _VELODROME_SQUARE_STEP_BASIS = 54210109;
// After squaring a token quantity (in `_VELODROME_TOKEN_BASIS`), we need to multiply again by a
// token quantity and then divide out the awkward basis to get back to
// `_VELODROME_TOKEN_BASIS`. This constant is what gets us back to the original token quantity
// basis. `_VELODROME_TOKEN_BASIS * _VELODROME_TOKEN_BASIS / _VELODROME_SQUARE_STEP_BASIS *
// _VELODROME_TOKEN_BASIS / _VELODROME_CUBE_STEP_BASIS == _VELODROME_TOKEN_BASIS`
uint256 private constant _VELODROME_CUBE_STEP_BASIS = 18446743945857035631490798146;
// The maximum balance in the AMM's implementation of `k` is `b` such that `b * b / 1 ether * b
// / 1 ether * b` does not overflow. This that quantity, `b`.
uint256 internal constant _VELODROME_MAX_BALANCE = 18446744073709551616000000000;
// This is the `k = x^3 * y + y^3 * x` constant function. Unlike the original formulation, the
// result has a basis of `_VELODROME_INTERNAL_BASIS` instead of `_VELODROME_TOKEN_BASIS`
function _k(uint256 x, uint256 y) private pure returns (uint256) {
unchecked {
return _k(x, y, x * x);
}
}
function _k(uint256 x, uint256 y, uint256 x_squared) private pure returns (uint256) {
unchecked {
return _k(x, y, x_squared, y * y);
}
}
function _k(uint256 x, uint256 y, uint256 x_squared, uint256 y_squared) private pure returns (uint256) {
unchecked {
return (x * y).unsafeMulDivAlt(x_squared + y_squared, _VELODROME_INTERNAL_BASIS);
}
}
function _k_compat(uint256 x, uint256 y) internal pure returns (uint256) {
unchecked {
return (x * y).unsafeMulDivAlt(x * x + y * y, _VELODROME_INTERNAL_BASIS * _VELODROME_TOKEN_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`. The result has a basis of
// `_VELODROME_TOKEN_BASIS`.
function _d(uint256 y, uint256 x) private pure returns (uint256) {
unchecked {
return _d(y, 3 * x, x * x / _VELODROME_SQUARE_STEP_BASIS * x / _VELODROME_CUBE_STEP_BASIS);
}
}
function _d(uint256 y, uint256 three_x, uint256 x_cubed) private pure returns (uint256) {
unchecked {
return _d(y, three_x, x_cubed, y * y / _VELODROME_SQUARE_STEP_BASIS);
}
}
function _d(uint256, uint256 three_x, uint256 x_cubed, uint256 y_squared) private pure returns (uint256) {
unchecked {
return y_squared * three_x / _VELODROME_CUBE_STEP_BASIS + x_cubed;
}
}
error NotConverged();
// Using Newton-Raphson iterations, compute the smallest `new_y` such that `_k(x + dx, new_y) >=
// _k(x, y)`. As a function of `new_y`, we find the root of `_k(x + dx, new_y) - _k(x, y)`.
function _get_y(uint256 x, uint256 dx, uint256 y) internal pure returns (uint256) {
unchecked {
uint256 k_orig = _k(x, y);
// `k_orig` has a basis much greater than is actually required for correctness. To
// achieve wei-level accuracy, we perform our final comparisons agains `k_target`
// instead, which has the same precision as the AMM itself.
uint256 k_target = k_orig / _VELODROME_INTERNAL_TO_TOKEN_RATIO;
// Now that we have `k` computed, we offset `x` to account for the sell amount and use
// the constant-product formula to compute an initial estimate for `y`.
x += dx;
y -= (dx * y).unsafeDiv(x);
// These intermediate values do not change throughout the Newton-Raphson iterations, so
// precomputing and caching them saves us gas.
uint256 three_x = 3 * x;
uint256 x_squared_raw = x * x;
uint256 x_cubed = x_squared_raw / _VELODROME_SQUARE_STEP_BASIS * x / _VELODROME_CUBE_STEP_BASIS;
for (uint256 i; i < 255; i++) {
uint256 y_squared_raw = y * y;
uint256 k = _k(x, y, x_squared_raw, y_squared_raw);
uint256 d = _d(y, three_x, x_cubed, y_squared_raw / _VELODROME_SQUARE_STEP_BASIS);
if (k < k_orig) {
uint256 dy = (k_orig - k).unsafeDiv(d);
// there are two cases where `dy == 0`
// case 1: The `y` is converged and we find the correct answer
// case 2: `_d(y, x)` is too large compare to `(k_orig - k)` and the rounding
// error screwed us.
// In this case, we need to increase `y` by 1
if (dy == 0) {
uint256 k_next = _k(x, y + 1, x_squared_raw) / _VELODROME_INTERNAL_TO_TOKEN_RATIO;
if (k_next >= k_target) {
// If `_k(x, y + 1) >= k_orig`, then we are close to the correct answer.
// There's no closer answer than `y + 1`
return y + 1;
}
// `y + 1` does not give us the condition `k >= k_orig`, so we have to do at
// least 1 more iteration to find a satisfactory `y` value
dy = 2;
}
y += dy;
if (y > _VELODROME_MAX_BALANCE) {
y = _VELODROME_MAX_BALANCE;
}
} else {
uint256 dy = (k - k_orig).unsafeDiv(d);
if (dy == 0) {
if (k / _VELODROME_INTERNAL_TO_TOKEN_RATIO == k_target) {
// Likewise, if `k == k_orig`, we found the correct answer.
return y;
}
uint256 k_next = _k(x, y - 1, x_squared_raw) / _VELODROME_INTERNAL_TO_TOKEN_RATIO;
if (k_next < k_target) {
// If `_k(x, y - 1) < k_orig`, 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(x, y) >=
// k_orig`
// As a result, we can't return `y - 1` even it's closer to the correct
// answer
return y;
}
if (k_next == k_target) {
return y - 1;
}
// It's possible that `y - 1` is the correct answer. To know that, we must
// check that `y - 2` gives `k < k_orig`. We must do at least 1 more
// iteration to determine this.
dy = 2;
}
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.fastBalanceOf(address(this)) * bps).unsafeDiv(BASIS);
}
if (sellAmount != 0) {
sellToken.safeTransfer(address(pair), sellAmount);
}
if (sellAmount == 0 || sellTokenHasFee) {
sellAmount = sellToken.fastBalanceOf(address(pair)) - sellReserve;
}
// Convert reserves from native units to `_VELODROME_TOKEN_BASIS`
sellReserve = (sellReserve * _VELODROME_TOKEN_BASIS).unsafeDiv(sellBasis);
buyReserve = (buyReserve * _VELODROME_TOKEN_BASIS).unsafeDiv(buyBasis);
// This check is commented because values that are too large will
// result in reverts inside the pool anyways. We don't need to
// bother.
/*
// Check for overflow
if (buyReserve > _VELODROME_MAX_BALANCE) {
Panic.panic(Panic.ARITHMETIC_OVERFLOW);
}
if (sellReserve + (sellAmount * _VELODROME_TOKEN_BASIS).unsafeDiv(sellBasis) > _VELODROME_MAX_BALANCE) {
Panic.panic(Panic.ARITHMETIC_OVERFLOW);
}
*/
// Apply the fee in native units
sellAmount -= sellAmount * feeBps / 10_000; // can't overflow
// Convert sell amount from native units to `_VELODROME_TOKEN_BASIS`
sellAmount = (sellAmount * _VELODROME_TOKEN_BASIS).unsafeDiv(sellBasis);
// Solve the constant function numerically to get `buyAmount` from `sellAmount`
buyAmount = buyReserve - _get_y(sellReserve, sellAmount, buyReserve);
// Convert `buyAmount` from `_VELODROME_TOKEN_BASIS` to native units
buyAmount = buyAmount * buyBasis / _VELODROME_TOKEN_BASIS;
}
buyAmount--;
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/Basic.sol
abstract contract Basic is SettlerAbstract {
using SafeTransferLib for IERC20;
using FullMath for uint256;
using Revert for bool;
/// @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 == 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.fastBalanceOf(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 {
fallback(bytes calldata) external virtual returns (bytes memory) {
return _invokeCallback(_msgData());
}
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 {
using FullMath for uint256;
using SafeTransferLib for IERC20;
constructor() {
assert(!_hasMetaTxn());
}
function _permitToSellAmountCalldata(ISignatureTransfer.PermitTransferFrom calldata 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).fastBalanceOf(_msgSender()).mulDiv(sellAmount, BASIS);
}
}
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).fastBalanceOf(_msgSender()).mulDiv(sellAmount, BASIS);
}
}
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 _permitToSellAmountCalldata(ISignatureTransfer.PermitTransferFrom calldata permit)
internal
pure
override
returns (uint256)
{
return permit.permitted.amount;
}
function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit)
internal
pure
override
returns (uint256)
{
return permit.permitted.amount;
}
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 (uint256 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 := shr(0xe0, calldataload(args.offset))
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.fastBalanceOf(address(this));
if (amountOut < minAmountOut) {
revert TooMuchSlippage(buyToken, minAmountOut, amountOut);
}
buyToken.safeTransfer(recipient, amountOut);
}
}
}
function _dispatch(uint256, uint256 action, bytes calldata data) internal virtual override returns (bool) {
if (action == uint32(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 == uint32(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 == uint32(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 == uint32(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 == uint32(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 == uint32(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 == uint32(ISettlerActions.POSITIVE_SLIPPAGE.selector)) {
(address recipient, IERC20 token, uint256 expectedAmount) = abi.decode(data, (address, IERC20, uint256));
if (token == ETH_ADDRESS) {
uint256 balance = address(this).balance;
if (balance > expectedAmount) {
unchecked {
payable(recipient).safeTransferETH(balance - expectedAmount);
}
}
} else {
uint256 balance = token.fastBalanceOf(address(this));
if (balance > expectedAmount) {
unchecked {
token.safeTransfer(recipient, balance - expectedAmount);
}
}
}
} else {
return false;
}
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(uint256 action, bytes calldata data, bytes calldata sig) internal virtual returns (bool) {
if (action == uint32(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 == uint32(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 == uint32(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);
{
(uint256 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, bytes4(uint32(action)), data);
}
}
for (uint256 i = 1; i < actions.length; i = i.unsafeInc()) {
(uint256 action, bytes calldata data) = actions.decodeCall(i);
if (!_dispatch(i, action, data)) {
revert ActionInvalid(i, bytes4(uint32(action)), data);
}
}
_checkSlippageAndTransfer(slippage);
return true;
}
}
// src/chains/Sonic/Common.sol
// Solidity inheritance is stupid
abstract contract SonicMixin is FreeMemory, SettlerBase {
constructor() {
assert(block.chainid == 146 || block.chainid == 31337);
}
function _dispatch(uint256 i, uint256 action, bytes calldata data)
internal
virtual
override(/* SettlerAbstract, */ SettlerBase)
DANGEROUS_freeMemory
returns (bool)
{
if (super._dispatch(i, action, data)) {
return true;
} else {
return false;
}
return true;
}
function _uniV3ForkInfo(uint8 forkId)
internal
pure
override
returns (address factory, bytes32 initHash, uint32 callbackSelector)
{
if (forkId == uniswapV3ForkId) {
factory = uniswapV3SonicFactory;
initHash = uniswapV3InitHash;
callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector);
} else if (forkId == spookySwapForkId) {
factory = spookySwapFactory;
initHash = uniswapV3InitHash;
callbackSelector = uint32(IUniswapV3Callback.uniswapV3SwapCallback.selector);
} else {
revert UnknownForkId(forkId);
}
}
}
// src/chains/Sonic/MetaTxn.sol
// Solidity inheritance is stupid
/// @custom:security-contact [email protected]
contract SonicSettlerMetaTxn is SettlerMetaTxn, SonicMixin {
constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {}
function _dispatchVIP(uint256 action, bytes calldata data, bytes calldata sig)
internal
override
DANGEROUS_freeMemory
returns (bool)
{
if (super._dispatchVIP(action, data, sig)) {
return true;
} else {
return false;
}
return true;
}
// Solidity inheritance is stupid
function _dispatch(uint256 i, uint256 action, bytes calldata data)
internal
override(SettlerAbstract, SettlerBase, SonicMixin)
returns (bool)
{
return super._dispatch(i, action, data);
}
function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) {
return super._msgSender();
}
}