// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; import "./interface/IBebopSettlement.sol"; import "./interface/IWETH.sol"; import "./interface/IPermit2.sol"; import "./base/BebopSigning.sol"; import "./base/BebopTransfer.sol"; import "./libs/Order.sol"; import "./libs/Signature.sol"; import "./libs/Transfer.sol"; import "./libs/Commands.sol"; import "./libs/common/BytesLib.sol"; import "./libs/common/SafeCast160.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; contract BebopSettlement is IBebopSettlement, BebopSigning, BebopTransfer, ReentrancyGuard { using SafeERC20 for IERC20; constructor(address _wrapped_native_token_address, address _permit, address _dai_address) BebopTransfer(_wrapped_native_token_address, _permit, _dai_address){ } receive() external payable {} function SettleAggregateOrder( Order.Aggregate memory order, Signature.TypedSignature memory takerSig, Signature.MakerSignatures[] memory makerSigs ) external nonReentrant payable override returns (bool) { bytes32 h = assertAndInvalidateAggregateOrder(order, takerSig, makerSigs); uint numMakerSigs = makerSigs.length; Transfer.NativeTokens memory nativeTokens = Transfer.NativeTokens({toTaker: 0, toMakers: 0}); Transfer.Pending[] memory pendingNativeTokensToMakers = new Transfer.Pending[](numMakerSigs); uint commandsInd; for (uint i; i < numMakerSigs; ++i) { // Batch transfer from maker to taker and accumulate maker's number of native tokens nativeTokens.toTaker += makerTransferFunds( order.maker_addresses[i], order.receiver, order.maker_tokens[i], order.maker_amounts[i], makerSigs[i].usingPermit2, BytesLib.slice(order.commands, commandsInd, order.maker_tokens[i].length) ); commandsInd += order.maker_tokens[i].length; for (uint k; k < order.taker_tokens[i].length; ++k) { bytes1 curCommand = order.commands[commandsInd + k]; if (curCommand == Commands.SIMPLE_TRANSFER) { // Transfer taker's token with standard approval IERC20(order.taker_tokens[i][k]).safeTransferFrom( order.taker_address, order.maker_addresses[i], order.taker_amounts[i][k] ); } else if (curCommand == Commands.NATIVE_TRANSFER) { require(order.taker_tokens[i][k] == WRAPPED_NATIVE_TOKEN, "Taker's token is not native token"); // Accumulating taker's number of native tokens nativeTokens.toMakers += order.taker_amounts[i][k]; pendingNativeTokensToMakers[i] = Transfer.Pending( order.taker_tokens[i][k], order.maker_addresses[i], order.taker_amounts[i][k] ); } else if (curCommand == Commands.TRANSFER_FROM_CONTRACT) { // If using contract as an intermediate recipient for tokens transferring IERC20(order.taker_tokens[i][k]).safeTransfer(order.maker_addresses[i], order.taker_amounts[i][k]); } else { revert("Unknown command"); } } commandsInd += order.taker_tokens[i].length; } // Wrap taker's native token and transfer to Makers if (nativeTokens.toMakers != 0) { require(msg.value == nativeTokens.toMakers, "Taker doesn't have enough native tokens"); IWETH(WRAPPED_NATIVE_TOKEN).deposit{value: nativeTokens.toMakers}(); for (uint i; i < numMakerSigs; ++i) { if (pendingNativeTokensToMakers[i].amount != 0) { IERC20(pendingNativeTokensToMakers[i].token).safeTransfer( pendingNativeTokensToMakers[i].maker_address, pendingNativeTokensToMakers[i].amount ); } } } // Unwrap and transfer native token to receiver if (nativeTokens.toTaker != 0) { IWETH(WRAPPED_NATIVE_TOKEN).withdraw(nativeTokens.toTaker); (bool sent,) = order.receiver.call{value: nativeTokens.toTaker}(""); require(sent, "Failed to send Ether to taker"); } emit AggregateOrderExecuted(h); return true; } function SettleAggregateOrderWithTakerPermits( Order.Aggregate memory order, Signature.TypedSignature memory takerSig, Signature.MakerSignatures[] memory makerSigs, Signature.TakerPermitsInfo memory takerPermitsInfo ) external nonReentrant payable override returns (bool) { bytes32 h = assertAndInvalidateAggregateOrder(order, takerSig, makerSigs); uint totalTakersTransfers; for (uint i; i < order.taker_tokens.length; ++i) { totalTakersTransfers += order.taker_tokens[i].length; } IPermit2.AllowanceTransferDetails[] memory batchTransferDetails = new IPermit2.AllowanceTransferDetails[](totalTakersTransfers); IPermit2.PermitDetails[] memory batchToApprove = new IPermit2.PermitDetails[](takerPermitsInfo.noncesPermit2.length); Transfer.Pending[] memory pendingTransfersToMakers = new Transfer.Pending[](totalTakersTransfers); Transfer.NativeTokens memory nativeTokens = Transfer.NativeTokens({toTaker: 0, toMakers: 0}); Transfer.Indices memory indices = Transfer.Indices(0, 0, 0, 0, 0); for (uint i; i < makerSigs.length; ++i) { // Batch transfer from maker to taker and accumulate maker's number of native tokens nativeTokens.toTaker += makerTransferFunds( order.maker_addresses[i], order.receiver, order.maker_tokens[i], order.maker_amounts[i], makerSigs[i].usingPermit2, BytesLib.slice(order.commands, indices.commandsInd, order.maker_tokens[i].length) ); indices.commandsInd += order.maker_tokens[i].length; for (uint k; k < order.taker_tokens[i].length; ++k) { bytes1 curCommand = order.commands[indices.commandsInd + k]; if (curCommand == Commands.SIMPLE_TRANSFER) { batchTransferDetails[indices.batchLen++] = IPermit2.AllowanceTransferDetails({ from: order.taker_address, to: order.maker_addresses[i], amount: SafeCast160.toUint160(order.taker_amounts[i][k]), token: order.taker_tokens[i][k] }); } else if (curCommand == Commands.TRANSFER_WITH_PERMIT) { // Transfer taker's token with Permit signature IERC20(order.taker_tokens[i][k]).safeTransferFrom( order.taker_address, order.maker_addresses[i], order.taker_amounts[i][k] ); assembly {mstore(batchTransferDetails, sub(mload(batchTransferDetails), 1))} } else if (curCommand == Commands.PERMIT_THEN_TRANSFER) { permitToken( order.taker_address, order.taker_tokens[i][k], takerPermitsInfo.deadline, takerPermitsInfo.permitSignatures[indices.permitSignaturesInd++] ); IERC20(order.taker_tokens[i][k]).safeTransferFrom( order.taker_address, order.maker_addresses[i], order.taker_amounts[i][k] ); assembly {mstore(batchTransferDetails, sub(mload(batchTransferDetails), 1))} } else if (curCommand == Commands.PERMIT2_THEN_TRANSFER) { batchToApprove[indices.batchToApproveInd++] = IPermit2.PermitDetails({ token: order.taker_tokens[i][k], amount: type(uint160).max, expiration: takerPermitsInfo.deadline, nonce: takerPermitsInfo.noncesPermit2[indices.batchToApproveInd] }); batchTransferDetails[indices.batchLen++] = IPermit2.AllowanceTransferDetails({ from: order.taker_address, to: order.maker_addresses[i], amount: SafeCast160.toUint160(order.taker_amounts[i][k]), token: order.taker_tokens[i][k] }); } else if (curCommand == Commands.NATIVE_TRANSFER) { require(order.taker_tokens[i][k] == WRAPPED_NATIVE_TOKEN, "Taker's token is not native token"); // Accumulating taker's number of native tokens nativeTokens.toMakers += order.taker_amounts[i][k]; pendingTransfersToMakers[indices.pendingTransfersLen++] = Transfer.Pending( order.taker_tokens[i][k], order.maker_addresses[i], order.taker_amounts[i][k] ); // Shortening Permit2 batch arrays assembly {mstore(batchTransferDetails, sub(mload(batchTransferDetails), 1))} } else if (curCommand == Commands.TRANSFER_FROM_CONTRACT) { // If using contract as an intermediate recipient for tokens transferring pendingTransfersToMakers[indices.pendingTransfersLen++] = Transfer.Pending( order.taker_tokens[i][k], order.maker_addresses[i], order.taker_amounts[i][k] ); assembly {mstore(batchTransferDetails, sub(mload(batchTransferDetails), 1))} } else { revert("Unknown command"); } } indices.commandsInd += order.taker_tokens[i].length; } require(indices.permitSignaturesInd == takerPermitsInfo.permitSignatures.length, "Unexpected number of Permit signatures"); require(indices.batchToApproveInd == batchToApprove.length, "Unexpected number of tokens to approve"); if (batchToApprove.length != 0) { // Update approvals for new taker's tokens PERMIT2.permit({ owner: order.taker_address, permitBatch: IPermit2.PermitBatch({ details: batchToApprove, spender: address(this), sigDeadline: takerPermitsInfo.deadline }), signature: takerPermitsInfo.signatureBytesPermit2 }); } require(indices.batchLen == batchTransferDetails.length, "Unexpected number of tokens"); if (indices.batchLen != 0) { // Transfer taker's tokens with Permit2 batch PERMIT2.transferFrom(batchTransferDetails); } // Wrap taker's native token if (nativeTokens.toMakers != 0) { require(msg.value == nativeTokens.toMakers, "Taker doesn't have enough native tokens"); IWETH(WRAPPED_NATIVE_TOKEN).deposit{value: nativeTokens.toMakers}(); } // Send all pending transfers to makers for (uint i; i < indices.pendingTransfersLen; ++i) { IERC20(pendingTransfersToMakers[i].token).safeTransfer( pendingTransfersToMakers[i].maker_address, pendingTransfersToMakers[i].amount ); } // Unwrap and transfer native token to receiver if (nativeTokens.toTaker != 0) { IWETH(WRAPPED_NATIVE_TOKEN).withdraw(nativeTokens.toTaker); (bool sent,) = order.receiver.call{value: nativeTokens.toTaker}(""); require(sent, "Failed to send Ether to taker"); } emit AggregateOrderExecuted(h); return true; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../libs/Order.sol"; import "../libs/Signature.sol"; import "../libs/common/BytesLib.sol"; import "@openzeppelin/contracts/interfaces/IERC1271.sol"; abstract contract BebopSigning { event OrderSignerRegistered(address maker, address signer, bool allowed); bytes32 private constant DOMAIN_NAME = keccak256("BebopSettlement"); bytes32 private constant DOMAIN_VERSION = keccak256("1"); bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)")); uint256 private constant ETH_SIGN_HASH_PREFIX = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000; bytes32 public constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" )); bytes32 public constant AGGREGATED_ORDER_TYPE_HASH = keccak256(abi.encodePacked( "Aggregate(uint256 expiry,address taker_address,address[] maker_addresses,uint256[] maker_nonces,address[][] taker_tokens,address[][] maker_tokens,uint256[][] taker_amounts,uint256[][] maker_amounts,address receiver,bytes commands)" )); bytes32 public constant PARTIAL_AGGREGATED_ORDER_TYPE_HASH = keccak256(abi.encodePacked( "Partial(uint256 expiry,address taker_address,address maker_address,uint256 maker_nonce,address[] taker_tokens,address[] maker_tokens,uint256[] taker_amounts,uint256[] maker_amounts,address receiver,bytes commands)" )); bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; mapping(address => mapping(uint256 => uint256)) private maker_validator; mapping(address => mapping(address => bool)) private orderSignerRegistry; constructor(){ _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = keccak256( abi.encode(EIP712_DOMAIN_TYPEHASH, DOMAIN_NAME, DOMAIN_VERSION, block.chainid, address(this)) ); } function DOMAIN_SEPARATOR() public view returns (bytes32) { return block.chainid == _CACHED_CHAIN_ID ? _CACHED_DOMAIN_SEPARATOR : keccak256( abi.encode(EIP712_DOMAIN_TYPEHASH, DOMAIN_NAME, DOMAIN_VERSION, block.chainid, address(this)) ); } function hashAggregateOrder(Order.Aggregate memory order) public view returns (bytes32) { return keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( AGGREGATED_ORDER_TYPE_HASH, order.expiry, order.taker_address, keccak256(abi.encodePacked(order.maker_addresses)), keccak256(abi.encodePacked(order.maker_nonces)), keccak256(encodeTightlyPackedNested(order.taker_tokens)), keccak256(encodeTightlyPackedNested(order.maker_tokens)), keccak256(encodeTightlyPackedNestedInt(order.taker_amounts)), keccak256(encodeTightlyPackedNestedInt(order.maker_amounts)), order.receiver, keccak256(order.commands) ) ) ) ); } function hashPartialOrder(Order.Partial memory order) public view returns (bytes32) { return keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( PARTIAL_AGGREGATED_ORDER_TYPE_HASH, order.expiry, order.taker_address, order.maker_address, order.maker_nonce, keccak256(abi.encodePacked(order.taker_tokens)), keccak256(abi.encodePacked(order.maker_tokens)), keccak256(abi.encodePacked(order.taker_amounts)), keccak256(abi.encodePacked(order.maker_amounts)), order.receiver, keccak256(order.commands) ) ) ) ); } function registerAllowedOrderSigner(address signer, bool allowed) external { orderSignerRegistry[msg.sender][signer] = allowed; emit OrderSignerRegistered(msg.sender, signer, allowed); } function validateSignature( address validationAddress, bytes32 hash, Signature.TypedSignature memory signature, bool isMaker ) public view { if (signature.signatureType == Signature.Type.EIP712) { // Signed using EIP712 (bytes32 r, bytes32 s, uint8 v) = Signature.getRsv(signature.signatureBytes); address signer = ecrecover(hash, v, r, s); require(signer != address(0), "Invalid signer"); if (signer != validationAddress && (!isMaker || !orderSignerRegistry[validationAddress][signer])) { revert("Invalid EIP712 order signature"); } } else if (signature.signatureType == Signature.Type.EIP1271) { require( IERC1271(validationAddress).isValidSignature(hash, signature.signatureBytes) == EIP1271_MAGICVALUE, "Invalid EIP1271 order signature" ); } else if (signature.signatureType == Signature.Type.ETHSIGN) { bytes32 ethSignHash; assembly { mstore(0, ETH_SIGN_HASH_PREFIX) // length of 28 bytes mstore(28, hash) // length of 32 bytes ethSignHash := keccak256(0, 60) } (bytes32 r, bytes32 s, uint8 v) = Signature.getRsv(signature.signatureBytes); address signer = ecrecover(ethSignHash, v, r, s); require(signer != address(0), "Invalid signer"); if (signer != validationAddress && (!isMaker || !orderSignerRegistry[validationAddress][signer])) { revert("Invalid ETHSIGH order signature"); } } else { revert("Invalid Signature Type"); } } function encodeTightlyPackedNestedInt(uint256[][] memory _nested_array) private pure returns (bytes memory encoded) { uint nested_array_length = _nested_array.length; for (uint i = 0; i < nested_array_length; i++) { encoded = abi.encodePacked( encoded, keccak256(abi.encodePacked(_nested_array[i])) ); } return encoded; } function encodeTightlyPackedNested(address[][] memory _nested_array) private pure returns (bytes memory encoded) { uint nested_array_length = _nested_array.length; for (uint i = 0; i < nested_array_length; i++) { encoded = abi.encodePacked( encoded, keccak256(abi.encodePacked(_nested_array[i])) ); } return encoded; } function invalidateOrder(address maker, uint256 nonce) private { require(nonce != 0, "Nonce must be non-zero"); uint256 invalidatorSlot = nonce >> 8; uint256 invalidatorBit = 1 << (nonce & 0xff); mapping(uint256 => uint256) storage invalidatorStorage = maker_validator[maker]; uint256 invalidator = invalidatorStorage[invalidatorSlot]; require(invalidator & invalidatorBit != invalidatorBit, "Invalid maker order (nonce)"); invalidatorStorage[invalidatorSlot] = invalidator | invalidatorBit; } function assertAndInvalidateMakerOrders( Order.Aggregate memory order, Signature.MakerSignatures[] memory makerSigs ) private { // number of columns = number of sigs otherwise unwarranted columns can be injected by sender. require(order.taker_tokens.length == makerSigs.length, "Taker tokens length mismatch"); require(order.maker_tokens.length == makerSigs.length, "Maker tokens length mismatch"); require(order.taker_amounts.length == makerSigs.length, "Taker amounts length mismatch"); require(order.maker_amounts.length == makerSigs.length, "Maker amounts length mismatch"); require(order.maker_nonces.length == makerSigs.length, "Maker nonces length mismatch"); require(order.maker_addresses.length == makerSigs.length, "Maker addresses length mismatch"); uint numMakerSigs = makerSigs.length; uint tokenTransfers; for (uint256 i; i < numMakerSigs; ++i) { // validate the partially signed orders. address maker_address = order.maker_addresses[i]; require(order.maker_tokens[i].length == order.maker_amounts[i].length, "Maker tokens and amounts length mismatch"); require(order.taker_tokens[i].length == order.taker_amounts[i].length, "Taker tokens and amounts length mismatch"); Order.Partial memory partial_order = Order.Partial( order.expiry, order.taker_address, maker_address, order.maker_nonces[i], order.taker_tokens[i], order.maker_tokens[i], order.taker_amounts[i], order.maker_amounts[i], order.receiver, BytesLib.slice( order.commands, tokenTransfers, order.maker_tokens[i].length + order.taker_tokens[i].length ) ); validateSignature(maker_address, hashPartialOrder(partial_order), makerSigs[i].signature, true); invalidateOrder(maker_address, order.maker_nonces[i]); tokenTransfers += order.maker_tokens[i].length + order.taker_tokens[i].length; } require(tokenTransfers == order.commands.length, "Token transfers length mismatch"); } function assertAndInvalidateAggregateOrder( Order.Aggregate memory order, Signature.TypedSignature memory takerSig, Signature.MakerSignatures[] memory makerSigs ) internal returns (bytes32) { bytes32 h = hashAggregateOrder(order); if (msg.sender != order.taker_address){ validateSignature(order.taker_address, h, takerSig, false); } // construct and validate maker partial orders assertAndInvalidateMakerOrders(order, makerSigs); require(order.expiry > block.timestamp, "Signature expired"); return h; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../interface/IDaiLikePermit.sol"; import "../interface/IPermit2.sol"; import "../libs/Order.sol"; import "../libs/Signature.sol"; import "../libs/Transfer.sol"; import "../libs/Commands.sol"; import "../libs/common/SafeCast160.sol"; import "./BebopSigning.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; abstract contract BebopTransfer { using SafeERC20 for IERC20; address public immutable WRAPPED_NATIVE_TOKEN; address public immutable DAI_TOKEN; IPermit2 public immutable PERMIT2; uint private immutable _chainId; function getChainId() private view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } constructor(address _wrapped_native_token_address, address _permit, address _dai_address) { WRAPPED_NATIVE_TOKEN = _wrapped_native_token_address; DAI_TOKEN = _dai_address; PERMIT2 = IPermit2(_permit); _chainId = getChainId(); } function makerTransferFunds( address from, address to, address[] memory maker_tokens, uint256[] memory maker_amounts, bool usingPermit2, bytes memory makerCommands ) internal returns (uint256) { uint256 nativeToTaker; uint256 tokensNum = maker_tokens.length; IPermit2.AllowanceTransferDetails[] memory batchTransferDetails = new IPermit2.AllowanceTransferDetails[](tokensNum); for (uint j; j < tokensNum; ++j) { uint256 amount = maker_amounts[j]; address receiver = to; if (makerCommands[j] != Commands.SIMPLE_TRANSFER){ if (makerCommands[j] == Commands.TRANSFER_TO_CONTRACT) { receiver = address(this); } else if (makerCommands[j] == Commands.NATIVE_TRANSFER) { require(maker_tokens[j] == WRAPPED_NATIVE_TOKEN, "Invalid maker's native transfer"); nativeToTaker += amount; receiver = address(this); } else { revert("Unknown maker command"); } } if (usingPermit2) { batchTransferDetails[j] = IPermit2.AllowanceTransferDetails({ from: from, to: receiver, amount: SafeCast160.toUint160(amount), token: maker_tokens[j] }); } else { IERC20(maker_tokens[j]).safeTransferFrom(from, receiver, amount); } } if (usingPermit2){ PERMIT2.transferFrom(batchTransferDetails); } return nativeToTaker; } function permitToken( address takerAddress, address tokenAddress, uint deadline, bytes memory permitSignature ) internal { (bytes32 r, bytes32 s, uint8 v) = Signature.getRsv(permitSignature); if (tokenAddress == DAI_TOKEN){ if (_chainId == 137){ IDaiLikePermit(tokenAddress).permit( takerAddress, address(this), IDaiLikePermit(tokenAddress).getNonce(takerAddress), deadline, true, v, r, s ); } else { IDaiLikePermit(tokenAddress).permit( takerAddress, address(this), IERC20Permit(tokenAddress).nonces(takerAddress), deadline, true, v, r, s ); } } else { IERC20Permit(tokenAddress).permit(takerAddress, address(this), type(uint).max, deadline, v, r, s); } } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library BytesLib { function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) { require(_length + 31 >= _length, "slice_overflow"); require(_bytes.length >= _start + _length, "slice_outOfBounds"); bytes memory tempBytes; // Check length is 0. `iszero` return 1 for `true` and 0 for `false`. assembly { switch iszero(_length) case 0 { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // Calculate length mod 32 to handle slices that are not a multiple of 32 in size. let lengthmod := and(_length, 31) // tempBytes will have the following format in memory: // When copying data we will offset the start forward to avoid allocating additional memory // Therefore part of the length area will be written, but this will be overwritten later anyways. // In case no offset is require, the start is set to the data region (0x20 from the tempBytes) // mc will be used to keep track where to copy the data to. let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod))) let end := add(mc, _length) for { // Same logic as for mc is applied and additionally the start offset specified for the method is added let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start) } lt(mc, end) { // increase `mc` and `cc` to read the next word from memory mc := add(mc, 0x20) cc := add(cc, 0x20) } { // Copy the data from source (cc location) to the slice data (mc location) mstore(mc, mload(cc)) } // Store the length of the slice. This will overwrite any partial data that // was copied when having slices that are not a multiple of 32. mstore(tempBytes, _length) // update free-memory pointer // allocating the array padded to 32 bytes like the compiler does now // To set the used memory as a multiple of 32, add 31 to the actual memory usage (mc) // and remove the modulo 32 (the `and` with `not(31)`) mstore(0x40, and(add(mc, 31), not(31))) } // if we want a zero-length slice let's just return a zero-length array default { tempBytes := mload(0x40) // zero out the 32 bytes slice we are about to return // we need to do it because Solidity does not garbage collect mstore(tempBytes, 0) // update free-memory pointer // tempBytes uses 32 bytes in memory (even when empty) for the length. mstore(0x40, add(tempBytes, 0x20)) } } return tempBytes; } } // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; // Part of IAllowanceTransfer(https://github.com/Uniswap/permit2/blob/main/src/interfaces/IAllowanceTransfer.sol) interface IPermit2 { // ------------------ // IAllowanceTransfer // ------------------ /// @notice Details for a token transfer. struct AllowanceTransferDetails { // the owner of the token address from; // the recipient of the token address to; // the amount of the token uint160 amount; // the token to be transferred address token; } /// @notice The permit data for a token struct PermitDetails { // ERC20 token address address token; // the maximum amount allowed to spend uint160 amount; // timestamp at which a spender's token allowances become invalid uint48 expiration; // an incrementing value indexed per owner,token,and spender for each signature uint48 nonce; } /// @notice The permit message signed for multiple token allowances struct PermitBatch { // the permit data for multiple token allowances PermitDetails[] details; // address permissioned on the allowed tokens address spender; // deadline on the permit signature uint256 sigDeadline; } /// @notice A mapping from owner address to token address to spender address to PackedAllowance struct, which contains details and conditions of the approval. /// @notice The mapping is indexed in the above order see: allowance[ownerAddress][tokenAddress][spenderAddress] /// @dev The packed slot holds the allowed amount, expiration at which the allowed amount is no longer valid, and current nonce thats updated on any signature based approvals. function allowance(address user, address token, address spender) external view returns (uint160 amount, uint48 expiration, uint48 nonce); /// @notice Permit a spender to the signed amounts of the owners tokens via the owner's EIP-712 signature /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce /// @param owner The owner of the tokens being approved /// @param permitBatch Data signed over by the owner specifying the terms of approval /// @param signature The owner's signature over the permit data function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external; /// @notice Transfer approved tokens in a batch /// @param transferDetails Array of owners, recipients, amounts, and tokens for the transfers /// @dev Requires the from addresses to have approved at least the desired amount /// of tokens to msg.sender. function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library Signature { enum Type { EIP712, //0 EIP1271, //1 ETHSIGN //2 } struct TypedSignature { Type signatureType; bytes signatureBytes; } struct MakerSignatures { TypedSignature signature; bool usingPermit2; } struct TakerPermitsInfo { bytes[] permitSignatures; bytes signatureBytesPermit2; uint48[] noncesPermit2; uint48 deadline; } function getRsv(bytes memory sig) internal pure returns (bytes32, bytes32, uint8){ require(sig.length == 65, "Invalid signature length"); bytes32 r; bytes32 s; uint8 v; assembly { r := mload(add(sig, 32)) s := mload(add(sig, 64)) v := and(mload(add(sig, 65)), 255) } if (v < 27) v += 27; require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "Invalid sig value S"); require(v == 27 || v == 28, "Invalid sig value V"); return (r, s, v); } } // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; interface IDaiLikePermit { /// @param holder The address of the token owner. /// @param spender The address of the token spender. /// @param nonce The owner's nonce, increases at each call to permit. /// @param expiry The timestamp at which the permit is no longer valid. /// @param allowed Boolean that sets approval amount, true for type(uint256).max and false for 0. /// @param v Must produce valid secp256k1 signature from the owner along with r and s. /// @param r Must produce valid secp256k1 signature from the owner along with v and s. /// @param s Must produce valid secp256k1 signature from the owner along with r and v. function permit( address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s ) external; // DAI's Polygon getNonce, instead of `nonces(address)` function function getNonce(address user) external view returns (uint256 nonce); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library Transfer { struct Pending { address token; address maker_address; uint256 amount; } struct NativeTokens { uint256 toTaker; // accumulated amount of tokens that will be sent to the taker (receiver) uint256 toMakers; // accumulated amount of tokens that will be sent to the makers } struct Indices { uint commandsInd; // current `order.commands` index uint batchToApproveInd; // current `batchToApprove` index uint permitSignaturesInd; // current `takerPermitsInfo.permitSignatures` index uint pendingTransfersLen; // current length of `pendingTransfers` uint batchLen; // current length of `batchTransferDetails` } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library Order { struct Aggregate { uint256 expiry; address taker_address; address[] maker_addresses; uint256[] maker_nonces; address[][] taker_tokens; address[][] maker_tokens; uint256[][] taker_amounts; uint256[][] maker_amounts; address receiver; bytes commands; } struct Partial { uint256 expiry; address taker_address; address maker_address; uint256 maker_nonce; address[] taker_tokens; address[] maker_tokens; uint256[] taker_amounts; uint256[] maker_amounts; address receiver; bytes commands; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../libs/Order.sol"; import "../libs/Signature.sol"; interface IBebopSettlement { event AggregateOrderExecuted(bytes32 order_hash); function SettleAggregateOrder( Order.Aggregate memory order, Signature.TypedSignature memory takerSig, Signature.MakerSignatures[] memory makerSigs ) external payable returns (bool); function SettleAggregateOrderWithTakerPermits( Order.Aggregate memory order, Signature.TypedSignature memory takerSig, Signature.MakerSignatures[] memory makerSigs, Signature.TakerPermitsInfo memory takerPermitInfo ) external payable returns (bool); } // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; library Commands { bytes1 internal constant SIMPLE_TRANSFER = 0x00; bytes1 internal constant NATIVE_TRANSFER = 0x01; bytes1 internal constant TRANSFER_TO_CONTRACT = 0x02; bytes1 internal constant TRANSFER_FROM_CONTRACT = 0x03; // only for taker commands bytes1 internal constant TRANSFER_WITH_PERMIT = 0x04; // only for taker commands bytes1 internal constant PERMIT_THEN_TRANSFER = 0x05; // only for taker commands bytes1 internal constant PERMIT2_THEN_TRANSFER = 0x06; // only for taker commands } // SPDX-License-Identifier: MIT pragma solidity ^0.8.17; library SafeCast160 { /// @notice Thrown when a valude greater than type(uint160).max is cast to uint160 error UnsafeCast(); /// @notice Safely casts uint256 to uint160 /// @param value The uint256 to be cast function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) revert UnsafeCast(); return uint160(value); } } // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; interface IWETH is IERC20 { function deposit() external payable; function withdraw(uint256 amount) external; }

Visual Contract Explorer

Contract Activity

Build smart contracts visually