From 584e4d677d4b5f3f2fffd3e927cce45b34fcf7b4 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 15:52:27 -0400 Subject: [PATCH 1/7] WIP: intent-based settlement Settler --- src/Settler.sol | 6 ++- src/SettlerAbstract.sol | 7 +++ src/SettlerBase.sol | 4 +- src/SettlerIntent.sol | 62 ++++++++++++++++++++++++++ src/SettlerMetaTxn.sol | 22 ++++++--- src/core/Permit2Payment.sol | 22 +++++---- test/unit/core/BasicUnitTest.t.sol | 4 ++ test/unit/core/MakerPSMUnitTest.t.sol | 4 ++ test/unit/core/RfqUnitTest.t.sol | 4 ++ test/unit/core/UniswapV2UnitTest.t.sol | 4 ++ test/unit/core/UniswapV3UnitTest.t.sol | 4 ++ 11 files changed, 127 insertions(+), 16 deletions(-) create mode 100644 src/SettlerIntent.sol diff --git a/src/Settler.sol b/src/Settler.sol index 51196217..58d008ef 100644 --- a/src/Settler.sol +++ b/src/Settler.sol @@ -21,7 +21,11 @@ abstract contract Settler is Permit2PaymentTakerSubmitted, SettlerBase { // When/if you change this, you must make corresponding changes to // `sh/deploy_new_chain.sh` and 'sh/common_deploy_settler.sh' to set // `constructor_args`. - constructor(bytes20 gitCommit) SettlerBase(gitCommit, 2) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} + + function _tokenId() internal pure override returns (uint256) { + return 2; + } function _hasMetaTxn() internal pure override returns (bool) { return false; diff --git a/src/SettlerAbstract.sol b/src/SettlerAbstract.sol index a4514fcd..6e187958 100644 --- a/src/SettlerAbstract.sol +++ b/src/SettlerAbstract.sol @@ -9,13 +9,20 @@ abstract contract SettlerAbstract is Permit2PaymentAbstract { "SlippageAndActions(address recipient,address buyToken,uint256 minAmountOut,bytes[] actions)"; bytes32 internal constant SLIPPAGE_AND_ACTIONS_TYPEHASH = 0x615e8d716cef7295e75dd3f1f10d679914ad6d7759e8e9459f0109ef75241701; + // Permit2 Witness for intents + string internal constant SLIPPAGE_TYPE = "Slippage(address recipient,address buyToken,uint256 minAmountOut)"; + bytes32 internal constant SLIPPAGE_TYPEHASH = 0xdc83993a2ffc65b01b71ed08790b6e39c5c55d76937b62a3b5085b02071f1259; + uint256 internal constant BASIS = 10_000; constructor() { assert(SLIPPAGE_AND_ACTIONS_TYPEHASH == keccak256(bytes(SLIPPAGE_AND_ACTIONS_TYPE))); + assert(SLIPPAGE_TYPEHASH == keccak256(bytes(SLIPPAGE_TYPE))); } function _hasMetaTxn() internal pure virtual returns (bool); + function _tokenId() internal pure virtual returns (uint256); + function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal virtual returns (bool); } diff --git a/src/SettlerBase.sol b/src/SettlerBase.sol index f7847485..9e672481 100644 --- a/src/SettlerBase.sol +++ b/src/SettlerBase.sol @@ -57,10 +57,10 @@ abstract contract SettlerBase is Basic, RfqOrderSettlement, UniswapV3Fork, Unisw event GitCommit(bytes20 indexed); - constructor(bytes20 gitCommit, uint256 tokenId) { + constructor(bytes20 gitCommit) { if (block.chainid != 31337) { emit GitCommit(gitCommit); - assert(IERC721Owner(0x00000000000004533Fe15556B1E086BB1A72cEae).ownerOf(tokenId) == address(this)); + assert(IERC721Owner(0x00000000000004533Fe15556B1E086BB1A72cEae).ownerOf(_tokenId()) == address(this)); } else { assert(gitCommit == bytes20(0)); } diff --git a/src/SettlerIntent.sol b/src/SettlerIntent.sol new file mode 100644 index 00000000..3251549c --- /dev/null +++ b/src/SettlerIntent.sol @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.25; + +import {SettlerAbstract} from "./SettlerAbstract.sol"; +import {SettlerBase} from "./SettlerBase.sol"; +import {SettlerMetaTxn} from "./SettlerMetaTxn.sol"; + +import {Permit2PaymentIntent, Permit2PaymentMetaTxn} from "./core/Permit2Payment.sol"; + +abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { + // 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) SettlerMetaTxn(gitCommit) {} + + function _tokenId() internal pure override(SettlerAbstract, SettlerMetaTxn) returns (uint256) { + return 4; + } + + function _msgSender() + internal + view + virtual + // Solidity inheritance is so stupid + override(Permit2PaymentMetaTxn, SettlerMetaTxn) + returns (address) + { + return super._msgSender(); + } + + // Solidity inheritance is so stupid + function _witnessTypeSuffix() internal pure override(Permit2PaymentMetaTxn, Permit2PaymentIntent) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _hashSlippage(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. + assembly ("memory-safe") { + let ptr := mload(0x40) + mstore(ptr, SLIPPAGE_TYPEHASH) + calldatacopy(add(ptr, 0x20), slippage, 0x60) + result := keccak256(ptr, 0x80) + } + } + + function _executeMetaTxn( + AllowedSlippage calldata slippage, + bytes[] calldata actions, + bytes32, /* zid & affiliate */ + address msgSender, + bytes calldata sig + ) public virtual metaTx(msgSender, _hashSlippage(slippage)) returns (bool) { + return _executeMetaTxn(slippage, actions, sig); + } +} diff --git a/src/SettlerMetaTxn.sol b/src/SettlerMetaTxn.sol index 0b057a0d..a408db17 100644 --- a/src/SettlerMetaTxn.sol +++ b/src/SettlerMetaTxn.sol @@ -19,7 +19,11 @@ abstract contract SettlerMetaTxn is Permit2PaymentMetaTxn, SettlerBase { // 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) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} + + function _tokenId() internal pure virtual override returns (uint256) { + return 3; + } function _hasMetaTxn() internal pure override returns (bool) { return true; @@ -122,13 +126,11 @@ abstract contract SettlerMetaTxn is Permit2PaymentMetaTxn, SettlerBase { return true; } - function executeMetaTxn( + function _executeMetaTxn( AllowedSlippage calldata slippage, bytes[] calldata actions, - bytes32, /* zid & affiliate */ - address msgSender, bytes calldata sig - ) public metaTx(msgSender, _hashActionsAndSlippage(actions, slippage)) returns (bool) { + ) internal returns (bool) { require(actions.length != 0); { (bytes4 action, bytes calldata data) = actions.decodeCall(0); @@ -151,4 +153,14 @@ abstract contract SettlerMetaTxn is Permit2PaymentMetaTxn, SettlerBase { _checkSlippageAndTransfer(slippage); return true; } + + function executeMetaTxn( + AllowedSlippage calldata slippage, + bytes[] calldata actions, + bytes32, /* zid & affiliate */ + address msgSender, + bytes calldata sig + ) public virtual metaTx(msgSender, _hashActionsAndSlippage(actions, slippage)) returns (bool) { + return _executeMetaTxn(slippage, actions, sig); + } } diff --git a/src/core/Permit2Payment.sol b/src/core/Permit2Payment.sol index d4124d9e..6bced489 100644 --- a/src/core/Permit2Payment.sol +++ b/src/core/Permit2Payment.sol @@ -367,13 +367,11 @@ abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { 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 _witnessTypeSuffix() internal pure virtual returns (string memory) { + return string( + abi.encodePacked("SlippageAndActions slippageAndActions)", SLIPPAGE_AND_ACTIONS_TYPE, TOKEN_PERMISSIONS_TYPE) + ); + } function _transferFrom( ISignatureTransfer.PermitTransferFrom memory permit, @@ -386,7 +384,7 @@ abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { revert ConfusedDeputy(); } _transferFromIKnowWhatImDoing( - permit, transferDetails, _msgSender(), witness, _SLIPPAGE_AND_ACTIONS_WITNESS, sig, isForwarded + permit, transferDetails, _msgSender(), witness, _witnessTypeSuffix(), sig, isForwarded ); } @@ -412,3 +410,11 @@ abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { TransientStorage.checkSpentWitness(); } } + +abstract contract Permit2PaymentIntent is Permit2PaymentMetaTxn { + function _witnessTypeSuffix() internal pure virtual override returns (string memory) { + return string( + abi.encodePacked("Slippage slippage)", SLIPPAGE_TYPE, TOKEN_PERMISSIONS_TYPE) + ); + } +} diff --git a/test/unit/core/BasicUnitTest.t.sol b/test/unit/core/BasicUnitTest.t.sol index 0c50391f..ffd97aec 100644 --- a/test/unit/core/BasicUnitTest.t.sol +++ b/test/unit/core/BasicUnitTest.t.sol @@ -15,6 +15,10 @@ contract BasicDummy is Permit2PaymentTakerSubmitted, Basic { super.basicSellToPool(sellToken, bps, pool, offset, data); } + function _tokenId() internal pure override returns (uint256) { + revert("unimplemented"); + } + function _hasMetaTxn() internal pure override returns (bool) { return false; } diff --git a/test/unit/core/MakerPSMUnitTest.t.sol b/test/unit/core/MakerPSMUnitTest.t.sol index dbf06be8..79588ab3 100644 --- a/test/unit/core/MakerPSMUnitTest.t.sol +++ b/test/unit/core/MakerPSMUnitTest.t.sol @@ -23,6 +23,10 @@ contract MakerPSMDummy is MakerPSM { revert("unimplemented"); } + function _tokenId() internal pure override returns (uint256) { + revert("unimplemented"); + } + function _hasMetaTxn() internal pure override returns (bool) { revert("unimplemented"); } diff --git a/test/unit/core/RfqUnitTest.t.sol b/test/unit/core/RfqUnitTest.t.sol index 49d01755..0ef2b08d 100644 --- a/test/unit/core/RfqUnitTest.t.sol +++ b/test/unit/core/RfqUnitTest.t.sol @@ -31,6 +31,10 @@ abstract contract RfqOrderSettlementDummyBase is RfqOrderSettlement, Permit2Paym ) ); } + + function _tokenId() internal pure override returns (uint256) { + revert("unimplemented"); + } } contract RfqOrderSettlementDummy is Permit2PaymentTakerSubmitted, RfqOrderSettlementDummyBase { diff --git a/test/unit/core/UniswapV2UnitTest.t.sol b/test/unit/core/UniswapV2UnitTest.t.sol index 640f06ea..9d4393aa 100644 --- a/test/unit/core/UniswapV2UnitTest.t.sol +++ b/test/unit/core/UniswapV2UnitTest.t.sol @@ -26,6 +26,10 @@ contract UniswapV2Dummy is Permit2PaymentTakerSubmitted, UniswapV2 { return false; } + function _tokenId() internal pure override returns (uint256) { + revert("unimplemented"); + } + function _dispatch(uint256, bytes4, bytes calldata) internal pure override returns (bool) { revert("unimplemented"); } diff --git a/test/unit/core/UniswapV3UnitTest.t.sol b/test/unit/core/UniswapV3UnitTest.t.sol index 76badb1f..51d41a47 100644 --- a/test/unit/core/UniswapV3UnitTest.t.sol +++ b/test/unit/core/UniswapV3UnitTest.t.sol @@ -23,6 +23,10 @@ contract UniswapV3Dummy is Permit2PaymentTakerSubmitted, UniswapV3Fork { uniFactory = _uniFactory; } + function _tokenId() internal pure override returns (uint256) { + revert("unimplemented"); + } + function sellSelf(address recipient, uint256 bps, bytes memory encodedPath, uint256 minBuyAmount) external takerSubmitted From 1f6ebb845c34e2f44b8f3e61684c9cf47f4c4083 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 16:51:00 -0400 Subject: [PATCH 2/7] WIP: specialize `SettlerIntent` on Sepolia --- src/Settler.sol | 5 ----- src/SettlerBase.sol | 3 +++ src/SettlerIntent.sol | 9 ++------- src/SettlerMetaTxn.sol | 5 ----- src/chains/Sepolia.sol | 40 +++++++++++++++++++++++++++++++++++++--- 5 files changed, 42 insertions(+), 20 deletions(-) diff --git a/src/Settler.sol b/src/Settler.sol index 58d008ef..f6387f75 100644 --- a/src/Settler.sol +++ b/src/Settler.sol @@ -18,11 +18,6 @@ abstract contract Settler is Permit2PaymentTakerSubmitted, SettlerBase { using UnsafeMath for uint256; using CalldataDecoder for bytes[]; - // When/if you change this, you must make corresponding changes to - // `sh/deploy_new_chain.sh` and 'sh/common_deploy_settler.sh' to set - // `constructor_args`. - constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} - function _tokenId() internal pure override returns (uint256) { return 2; } diff --git a/src/SettlerBase.sol b/src/SettlerBase.sol index 9e672481..d41638e1 100644 --- a/src/SettlerBase.sol +++ b/src/SettlerBase.sol @@ -57,6 +57,9 @@ abstract contract SettlerBase is Basic, RfqOrderSettlement, UniswapV3Fork, Unisw event GitCommit(bytes20 indexed); + // 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) { if (block.chainid != 31337) { emit GitCommit(gitCommit); diff --git a/src/SettlerIntent.sol b/src/SettlerIntent.sol index 3251549c..b5f78bb7 100644 --- a/src/SettlerIntent.sol +++ b/src/SettlerIntent.sol @@ -8,12 +8,7 @@ import {SettlerMetaTxn} from "./SettlerMetaTxn.sol"; import {Permit2PaymentIntent, Permit2PaymentMetaTxn} from "./core/Permit2Payment.sol"; abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { - // 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) SettlerMetaTxn(gitCommit) {} - - function _tokenId() internal pure override(SettlerAbstract, SettlerMetaTxn) returns (uint256) { + function _tokenId() internal pure virtual override(SettlerAbstract, SettlerMetaTxn) returns (uint256) { return 4; } @@ -29,7 +24,7 @@ abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { } // Solidity inheritance is so stupid - function _witnessTypeSuffix() internal pure override(Permit2PaymentMetaTxn, Permit2PaymentIntent) returns (string memory) { + function _witnessTypeSuffix() internal pure virtual override(Permit2PaymentMetaTxn, Permit2PaymentIntent) returns (string memory) { return super._witnessTypeSuffix(); } diff --git a/src/SettlerMetaTxn.sol b/src/SettlerMetaTxn.sol index a408db17..efdaa794 100644 --- a/src/SettlerMetaTxn.sol +++ b/src/SettlerMetaTxn.sol @@ -16,11 +16,6 @@ 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) {} - function _tokenId() internal pure virtual override returns (uint256) { return 3; } diff --git a/src/chains/Sepolia.sol b/src/chains/Sepolia.sol index da15fc6f..8556776e 100644 --- a/src/chains/Sepolia.sol +++ b/src/chains/Sepolia.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {MaverickV2, IMaverickV2Pool} from "../core/MaverickV2.sol"; @@ -24,6 +25,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract SepoliaMixin is FreeMemory, SettlerBase, MaverickV2 { constructor() { @@ -74,7 +76,7 @@ abstract contract SepoliaMixin is FreeMemory, SettlerBase, MaverickV2 { /// @custom:security-contact security@0x.org contract SepoliaSettler is Settler, SepoliaMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { @@ -121,10 +123,11 @@ contract SepoliaSettler is Settler, SepoliaMixin { /// @custom:security-contact security@0x.org contract SepoliaSettlerMetaTxn is SettlerMetaTxn, SepoliaMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -150,13 +153,44 @@ contract SepoliaSettlerMetaTxn is SettlerMetaTxn, SepoliaMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, SepoliaMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { + return super._msgSender(); + } +} + +/// @custom:security-contact security@0x.org +contract SepoliaSettlerIntent is SettlerIntent, SepoliaSettlerMetaTxn { + constructor(bytes20 gitCommit) SepoliaSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(SepoliaSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, SepoliaSettlerMetaTxn) returns (address) { return super._msgSender(); } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(SepoliaSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } } From f89f3998754c45732380d9ee544cf4ea7dc5ac02 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 17:10:32 -0400 Subject: [PATCH 3/7] WIP: specialize `SettlerIntent` on all other chains --- src/chains/Arbitrum.sol | 43 ++++++++++++++++++++++++++++++---- src/chains/Avalanche.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Base.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Blast.sol | 50 +++++++++++++++++++++++++++++++++++++--- src/chains/Bnb.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Linea.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Mainnet.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Mantle.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Optimism.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Polygon.sol | 40 +++++++++++++++++++++++++++++--- src/chains/Scroll.sol | 40 +++++++++++++++++++++++++++++--- 11 files changed, 419 insertions(+), 34 deletions(-) diff --git a/src/chains/Arbitrum.sol b/src/chains/Arbitrum.sol index 8b62ff54..38b75e7f 100644 --- a/src/chains/Arbitrum.sol +++ b/src/chains/Arbitrum.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {MaverickV2, IMaverickV2Pool} from "../core/MaverickV2.sol"; @@ -39,6 +40,7 @@ import {dackieSwapV3ArbitrumFactory, dackieSwapV3ForkId} from "../core/univ3fork import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract ArbitrumMixin is FreeMemory, SettlerBase, MaverickV2, CurveTricrypto, DodoV2 { constructor() { @@ -124,9 +126,9 @@ abstract contract ArbitrumMixin is FreeMemory, SettlerBase, MaverickV2, CurveTri /// @custom:security-contact security@0x.org contract ArbitrumSettler is Settler, ArbitrumMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} - function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data) internal virtual override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { return true; } else if (action == ISettlerActions.MAVERICKV2_VIP.selector) { @@ -168,6 +170,7 @@ contract ArbitrumSettler is Settler, ArbitrumMixin { function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, ArbitrumMixin) returns (bool) { @@ -181,10 +184,11 @@ contract ArbitrumSettler is Settler, ArbitrumMixin { /// @custom:security-contact security@0x.org contract ArbitrumSettlerMetaTxn is SettlerMetaTxn, ArbitrumMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -219,13 +223,44 @@ contract ArbitrumSettlerMetaTxn is SettlerMetaTxn, ArbitrumMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, ArbitrumMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract ArbitrumSettlerIntent is SettlerIntent, ArbitrumSettlerMetaTxn { + constructor(bytes20 gitCommit) ArbitrumSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(ArbitrumSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, ArbitrumSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(ArbitrumSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Avalanche.sol b/src/chains/Avalanche.sol index 595f83ac..ce1a478c 100644 --- a/src/chains/Avalanche.sol +++ b/src/chains/Avalanche.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {DodoV2, IDodoV2} from "../core/DodoV2.sol"; @@ -24,6 +25,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract AvalancheMixin is FreeMemory, SettlerBase, DodoV2 { constructor() { @@ -72,7 +74,7 @@ abstract contract AvalancheMixin is FreeMemory, SettlerBase, DodoV2 { /// @custom:security-contact security@0x.org contract AvalancheSettler is Settler, AvalancheMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -103,10 +105,11 @@ contract AvalancheSettler is Settler, AvalancheMixin { /// @custom:security-contact security@0x.org contract AvalancheSettlerMetaTxn is SettlerMetaTxn, AvalancheMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -117,13 +120,44 @@ contract AvalancheSettlerMetaTxn is SettlerMetaTxn, AvalancheMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, AvalancheMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract AvalancheSettlerIntent is SettlerIntent, AvalancheSettlerMetaTxn { + constructor(bytes20 gitCommit) AvalancheSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(AvalancheSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, AvalancheSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(AvalancheSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Base.sol b/src/chains/Base.sol index 5f54033d..0c6c3085 100644 --- a/src/chains/Base.sol +++ b/src/chains/Base.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {DodoV2, IDodoV2} from "../core/DodoV2.sol"; @@ -42,6 +43,7 @@ import {kinetixV3BaseFactory, kinetixV3ForkId} from "../core/univ3forks/KinetixV import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract BaseMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -155,7 +157,7 @@ abstract contract BaseMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { /// @custom:security-contact security@0x.org contract BaseSettler is Settler, BaseMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { @@ -202,10 +204,11 @@ contract BaseSettler is Settler, BaseMixin { /// @custom:security-contact security@0x.org contract BaseSettlerMetaTxn is SettlerMetaTxn, BaseMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -231,13 +234,44 @@ contract BaseSettlerMetaTxn is SettlerMetaTxn, BaseMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, BaseMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { + return super._msgSender(); + } +} + +/// @custom:security-contact security@0x.org +contract BaseSettlerIntent is SettlerIntent, BaseSettlerMetaTxn { + constructor(bytes20 gitCommit) BaseSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(BaseSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, BaseSettlerMetaTxn) returns (address) { return super._msgSender(); } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BaseSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } } diff --git a/src/chains/Blast.sol b/src/chains/Blast.sol index b9c1d045..240549dd 100644 --- a/src/chains/Blast.sol +++ b/src/chains/Blast.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; @@ -36,6 +37,7 @@ import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; import {Permit2PaymentBase} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract BlastMixin is FreeMemory, SettlerBase { constructor() { @@ -109,7 +111,7 @@ abstract contract BlastMixin is FreeMemory, SettlerBase { /// @custom:security-contact security@0x.org contract BlastSettler is Settler, BlastMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -135,10 +137,11 @@ contract BlastSettler is Settler, BlastMixin { /// @custom:security-contact security@0x.org contract BlastSettlerMetaTxn is SettlerMetaTxn, BlastMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -149,6 +152,7 @@ contract BlastSettlerMetaTxn is SettlerMetaTxn, BlastMixin { function _isRestrictedTarget(address target) internal pure + virtual override(Permit2PaymentBase, BlastMixin, Permit2PaymentAbstract) returns (bool) { @@ -158,13 +162,53 @@ contract BlastSettlerMetaTxn is SettlerMetaTxn, BlastMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, BlastMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract BlastSettlerIntent is SettlerIntent, BlastSettlerMetaTxn { + constructor(bytes20 gitCommit) BlastSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _isRestrictedTarget(address target) + internal + pure + override(BlastSettlerMetaTxn, Permit2PaymentBase, Permit2PaymentAbstract) + returns (bool) + { + return super._isRestrictedTarget(target); + } + + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(BlastSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, BlastSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BlastSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Bnb.sol b/src/chains/Bnb.sol index a686fd46..47a9ebeb 100644 --- a/src/chains/Bnb.sol +++ b/src/chains/Bnb.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {MaverickV2, IMaverickV2Pool} from "../core/MaverickV2.sol"; @@ -32,6 +33,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract BnbMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -95,7 +97,7 @@ abstract contract BnbMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { /// @custom:security-contact security@0x.org contract BnbSettler is Settler, BnbMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { @@ -142,10 +144,11 @@ contract BnbSettler is Settler, BnbMixin { /// @custom:security-contact security@0x.org contract BnbSettlerMetaTxn is SettlerMetaTxn, BnbMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -171,13 +174,44 @@ contract BnbSettlerMetaTxn is SettlerMetaTxn, BnbMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, BnbMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { + return super._msgSender(); + } +} + +/// @custom:security-contact security@0x.org +contract BnbSettlerIntent is SettlerIntent, BnbSettlerMetaTxn { + constructor(bytes20 gitCommit) BnbSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(BnbSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, BnbSettlerMetaTxn) returns (address) { return super._msgSender(); } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BnbSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } } diff --git a/src/chains/Linea.sol b/src/chains/Linea.sol index d0f17ca6..2e542844 100644 --- a/src/chains/Linea.sol +++ b/src/chains/Linea.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; @@ -30,6 +31,7 @@ import {lynexFactory, lynexInitHash, lynexForkId} from "../core/univ3forks/Lynex import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract LineaMixin is FreeMemory, SettlerBase { constructor() { @@ -76,7 +78,7 @@ abstract contract LineaMixin is FreeMemory, SettlerBase { /// @custom:security-contact security@0x.org contract LineaSettler is Settler, LineaMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -107,10 +109,11 @@ contract LineaSettler is Settler, LineaMixin { /// @custom:security-contact security@0x.org contract LineaSettlerMetaTxn is SettlerMetaTxn, LineaMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -121,13 +124,44 @@ contract LineaSettlerMetaTxn is SettlerMetaTxn, LineaMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, LineaMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract LineaSettlerIntent is SettlerIntent, LineaSettlerMetaTxn { + constructor(bytes20 gitCommit) LineaSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(LineaSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, LineaSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(LineaSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Mainnet.sol b/src/chains/Mainnet.sol index 5ca462a8..c61f97c9 100644 --- a/src/chains/Mainnet.sol +++ b/src/chains/Mainnet.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {IPSM, MakerPSM} from "../core/MakerPSM.sol"; @@ -38,6 +39,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract MainnetMixin is FreeMemory, SettlerBase, MakerPSM, MaverickV2, CurveTricrypto, DodoV1, DodoV2 { constructor() { @@ -119,7 +121,7 @@ abstract contract MainnetMixin is FreeMemory, SettlerBase, MakerPSM, MaverickV2, /// @custom:security-contact security@0x.org contract MainnetSettler is Settler, MainnetMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { @@ -176,10 +178,11 @@ contract MainnetSettler is Settler, MainnetMixin { /// @custom:security-contact security@0x.org contract MainnetSettlerMetaTxn is SettlerMetaTxn, MainnetMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -214,13 +217,44 @@ contract MainnetSettlerMetaTxn is SettlerMetaTxn, MainnetMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, MainnetMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { + return super._msgSender(); + } +} + +/// @custom:security-contact security@0x.org +contract MainnetSettlerIntent is SettlerIntent, MainnetSettlerMetaTxn { + constructor(bytes20 gitCommit) MainnetSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(MainnetSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, MainnetSettlerMetaTxn) returns (address) { return super._msgSender(); } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(MainnetSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } } diff --git a/src/chains/Mantle.sol b/src/chains/Mantle.sol index e22366c9..bd29dbfc 100644 --- a/src/chains/Mantle.sol +++ b/src/chains/Mantle.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; @@ -20,6 +21,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract MantleMixin is FreeMemory, SettlerBase { constructor() { @@ -54,7 +56,7 @@ abstract contract MantleMixin is FreeMemory, SettlerBase { /// @custom:security-contact security@0x.org contract MantleSettler is Settler, MantleMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -85,10 +87,11 @@ contract MantleSettler is Settler, MantleMixin { /// @custom:security-contact security@0x.org contract MantleSettlerMetaTxn is SettlerMetaTxn, MantleMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -99,13 +102,44 @@ contract MantleSettlerMetaTxn is SettlerMetaTxn, MantleMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, MantleMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract MantleSettlerIntent is SettlerIntent, MantleSettlerMetaTxn { + constructor(bytes20 gitCommit) MantleSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(MantleSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, MantleSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(MantleSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Optimism.sol b/src/chains/Optimism.sol index 094703ae..90403da7 100644 --- a/src/chains/Optimism.sol +++ b/src/chains/Optimism.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; @@ -28,6 +29,7 @@ import {dackieSwapV3OptimismFactory, dackieSwapV3ForkId} from "../core/univ3fork import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract OptimismMixin is FreeMemory, SettlerBase { constructor() { @@ -78,7 +80,7 @@ abstract contract OptimismMixin is FreeMemory, SettlerBase { /// @custom:security-contact security@0x.org contract OptimismSettler is Settler, OptimismMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -109,10 +111,11 @@ contract OptimismSettler is Settler, OptimismMixin { /// @custom:security-contact security@0x.org contract OptimismSettlerMetaTxn is SettlerMetaTxn, OptimismMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -123,13 +126,44 @@ contract OptimismSettlerMetaTxn is SettlerMetaTxn, OptimismMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, OptimismMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract OptimismSettlerIntent is SettlerIntent, OptimismSettlerMetaTxn { + constructor(bytes20 gitCommit) OptimismSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(OptimismSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, OptimismSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(OptimismSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Polygon.sol b/src/chains/Polygon.sol index 6a49a18a..2efd0f2f 100644 --- a/src/chains/Polygon.sol +++ b/src/chains/Polygon.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {DodoV2, IDodoV2} from "../core/DodoV2.sol"; @@ -26,6 +27,7 @@ import {quickSwapV3Factory, quickSwapV3InitHash, quickSwapV3ForkId} from "../cor import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract PolygonMixin is FreeMemory, SettlerBase, DodoV2 { constructor() { @@ -78,7 +80,7 @@ abstract contract PolygonMixin is FreeMemory, SettlerBase, DodoV2 { /// @custom:security-contact security@0x.org contract PolygonSettler is Settler, PolygonMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { return super._dispatchVIP(action, data); @@ -109,10 +111,11 @@ contract PolygonSettler is Settler, PolygonMixin { /// @custom:security-contact security@0x.org contract PolygonSettlerMetaTxn is SettlerMetaTxn, PolygonMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -123,13 +126,44 @@ contract PolygonSettlerMetaTxn is SettlerMetaTxn, PolygonMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, PolygonMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { return super._msgSender(); } } + +/// @custom:security-contact security@0x.org +contract PolygonSettlerIntent is SettlerIntent, PolygonSettlerMetaTxn { + constructor(bytes20 gitCommit) PolygonSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(PolygonSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, PolygonSettlerMetaTxn) returns (address) { + return super._msgSender(); + } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(PolygonSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } +} diff --git a/src/chains/Scroll.sol b/src/chains/Scroll.sol index bcae5e52..7c37e5bb 100644 --- a/src/chains/Scroll.sol +++ b/src/chains/Scroll.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.25; import {SettlerBase} from "../SettlerBase.sol"; import {Settler} from "../Settler.sol"; import {SettlerMetaTxn} from "../SettlerMetaTxn.sol"; +import {SettlerIntent} from "../SettlerIntent.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {MaverickV2, IMaverickV2Pool} from "../core/MaverickV2.sol"; @@ -28,6 +29,7 @@ import {metavaultV3Factory, metavaultV3ForkId} from "../core/univ3forks/Metavaul import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; abstract contract ScrollMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -95,7 +97,7 @@ abstract contract ScrollMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { /// @custom:security-contact security@0x.org contract ScrollSettler is Settler, ScrollMixin { - constructor(bytes20 gitCommit) Settler(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data) internal override DANGEROUS_freeMemory returns (bool) { if (super._dispatchVIP(action, data)) { @@ -142,10 +144,11 @@ contract ScrollSettler is Settler, ScrollMixin { /// @custom:security-contact security@0x.org contract ScrollSettlerMetaTxn is SettlerMetaTxn, ScrollMixin { - constructor(bytes20 gitCommit) SettlerMetaTxn(gitCommit) {} + constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal + virtual override DANGEROUS_freeMemory returns (bool) @@ -171,13 +174,44 @@ contract ScrollSettlerMetaTxn is SettlerMetaTxn, ScrollMixin { // Solidity inheritance is stupid function _dispatch(uint256 i, bytes4 action, bytes calldata data) internal + virtual override(SettlerAbstract, SettlerBase, ScrollMixin) returns (bool) { return super._dispatch(i, action, data); } - function _msgSender() internal view override(SettlerMetaTxn, AbstractContext) returns (address) { + function _msgSender() internal view virtual override(SettlerMetaTxn, AbstractContext) returns (address) { + return super._msgSender(); + } +} + +/// @custom:security-contact security@0x.org +contract ScrollSettlerIntent is SettlerIntent, ScrollSettlerMetaTxn { + constructor(bytes20 gitCommit) ScrollSettlerMetaTxn(gitCommit) {} + + // Solidity inheritance is stupid + function _dispatch(uint256 i, bytes4 action, bytes calldata data) + internal + override(ScrollSettlerMetaTxn, SettlerBase, SettlerAbstract) + returns (bool) + { + return super._dispatch(i, action, data); + } + + function _msgSender() internal view override(SettlerIntent, ScrollSettlerMetaTxn) returns (address) { return super._msgSender(); } + + function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _tokenId() internal pure override(SettlerIntent, SettlerMetaTxn, SettlerAbstract) returns (uint256) { + return super._tokenId(); + } + + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(ScrollSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + return super._dispatchVIP(action, data, sig); + } } From ac2d52a7d6d35f54ea23fb4332a504427405bd51 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 17:11:36 -0400 Subject: [PATCH 4/7] `forge fmt` --- src/SettlerIntent.sol | 16 +++++++++------- src/SettlerMetaTxn.sol | 9 ++++----- src/chains/Arbitrum.sol | 21 ++++++++++++++++++--- src/chains/Avalanche.sol | 13 +++++++++++-- src/chains/Base.sol | 13 +++++++++++-- src/chains/Blast.sol | 13 +++++++++++-- src/chains/Bnb.sol | 13 +++++++++++-- src/chains/Linea.sol | 13 +++++++++++-- src/chains/Mainnet.sol | 13 +++++++++++-- src/chains/Mantle.sol | 13 +++++++++++-- src/chains/Optimism.sol | 13 +++++++++++-- src/chains/Polygon.sol | 13 +++++++++++-- src/chains/Scroll.sol | 13 +++++++++++-- src/chains/Sepolia.sol | 13 +++++++++++-- src/core/Permit2Payment.sol | 8 ++++---- 15 files changed, 156 insertions(+), 41 deletions(-) diff --git a/src/SettlerIntent.sol b/src/SettlerIntent.sol index b5f78bb7..181447a0 100644 --- a/src/SettlerIntent.sol +++ b/src/SettlerIntent.sol @@ -23,16 +23,18 @@ abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { return super._msgSender(); } - // Solidity inheritance is so stupid - function _witnessTypeSuffix() internal pure virtual override(Permit2PaymentMetaTxn, Permit2PaymentIntent) returns (string memory) { - return super._witnessTypeSuffix(); - } - - function _hashSlippage(AllowedSlippage calldata slippage) + function _witnessTypeSuffix() internal pure - returns (bytes32 result) + virtual + // Solidity inheritance is so stupid + override(Permit2PaymentMetaTxn, Permit2PaymentIntent) + returns (string memory) { + return super._witnessTypeSuffix(); + } + + function _hashSlippage(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 diff --git a/src/SettlerMetaTxn.sol b/src/SettlerMetaTxn.sol index efdaa794..78e7cccb 100644 --- a/src/SettlerMetaTxn.sol +++ b/src/SettlerMetaTxn.sol @@ -121,11 +121,10 @@ abstract contract SettlerMetaTxn is Permit2PaymentMetaTxn, SettlerBase { return true; } - function _executeMetaTxn( - AllowedSlippage calldata slippage, - bytes[] calldata actions, - bytes calldata sig - ) internal returns (bool) { + function _executeMetaTxn(AllowedSlippage calldata slippage, bytes[] calldata actions, bytes calldata sig) + internal + returns (bool) + { require(actions.length != 0); { (bytes4 action, bytes calldata data) = actions.decodeCall(0); diff --git a/src/chains/Arbitrum.sol b/src/chains/Arbitrum.sol index 38b75e7f..2358c3eb 100644 --- a/src/chains/Arbitrum.sol +++ b/src/chains/Arbitrum.sol @@ -128,7 +128,13 @@ abstract contract ArbitrumMixin is FreeMemory, SettlerBase, MaverickV2, CurveTri contract ArbitrumSettler is Settler, ArbitrumMixin { constructor(bytes20 gitCommit) SettlerBase(gitCommit) {} - function _dispatchVIP(bytes4 action, bytes calldata data) internal virtual override DANGEROUS_freeMemory returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data) + internal + virtual + override + DANGEROUS_freeMemory + returns (bool) + { if (super._dispatchVIP(action, data)) { return true; } else if (action == ISettlerActions.MAVERICKV2_VIP.selector) { @@ -252,7 +258,12 @@ contract ArbitrumSettlerIntent is SettlerIntent, ArbitrumSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -260,7 +271,11 @@ contract ArbitrumSettlerIntent is SettlerIntent, ArbitrumSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(ArbitrumSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(ArbitrumSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Avalanche.sol b/src/chains/Avalanche.sol index ce1a478c..93f521cb 100644 --- a/src/chains/Avalanche.sol +++ b/src/chains/Avalanche.sol @@ -149,7 +149,12 @@ contract AvalancheSettlerIntent is SettlerIntent, AvalancheSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -157,7 +162,11 @@ contract AvalancheSettlerIntent is SettlerIntent, AvalancheSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(AvalancheSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(AvalancheSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Base.sol b/src/chains/Base.sol index 0c6c3085..9c7ab3c1 100644 --- a/src/chains/Base.sol +++ b/src/chains/Base.sol @@ -263,7 +263,12 @@ contract BaseSettlerIntent is SettlerIntent, BaseSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -271,7 +276,11 @@ contract BaseSettlerIntent is SettlerIntent, BaseSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BaseSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(BaseSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Blast.sol b/src/chains/Blast.sol index 240549dd..dfcd3127 100644 --- a/src/chains/Blast.sol +++ b/src/chains/Blast.sol @@ -200,7 +200,12 @@ contract BlastSettlerIntent is SettlerIntent, BlastSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -208,7 +213,11 @@ contract BlastSettlerIntent is SettlerIntent, BlastSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BlastSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(BlastSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Bnb.sol b/src/chains/Bnb.sol index 47a9ebeb..0deb59b2 100644 --- a/src/chains/Bnb.sol +++ b/src/chains/Bnb.sol @@ -203,7 +203,12 @@ contract BnbSettlerIntent is SettlerIntent, BnbSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -211,7 +216,11 @@ contract BnbSettlerIntent is SettlerIntent, BnbSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(BnbSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(BnbSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Linea.sol b/src/chains/Linea.sol index 2e542844..26b3ad1d 100644 --- a/src/chains/Linea.sol +++ b/src/chains/Linea.sol @@ -153,7 +153,12 @@ contract LineaSettlerIntent is SettlerIntent, LineaSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -161,7 +166,11 @@ contract LineaSettlerIntent is SettlerIntent, LineaSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(LineaSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(LineaSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Mainnet.sol b/src/chains/Mainnet.sol index c61f97c9..4540fcf9 100644 --- a/src/chains/Mainnet.sol +++ b/src/chains/Mainnet.sol @@ -246,7 +246,12 @@ contract MainnetSettlerIntent is SettlerIntent, MainnetSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -254,7 +259,11 @@ contract MainnetSettlerIntent is SettlerIntent, MainnetSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(MainnetSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(MainnetSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Mantle.sol b/src/chains/Mantle.sol index bd29dbfc..0bb9574e 100644 --- a/src/chains/Mantle.sol +++ b/src/chains/Mantle.sol @@ -131,7 +131,12 @@ contract MantleSettlerIntent is SettlerIntent, MantleSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -139,7 +144,11 @@ contract MantleSettlerIntent is SettlerIntent, MantleSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(MantleSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(MantleSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Optimism.sol b/src/chains/Optimism.sol index 90403da7..b8f80d1a 100644 --- a/src/chains/Optimism.sol +++ b/src/chains/Optimism.sol @@ -155,7 +155,12 @@ contract OptimismSettlerIntent is SettlerIntent, OptimismSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -163,7 +168,11 @@ contract OptimismSettlerIntent is SettlerIntent, OptimismSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(OptimismSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(OptimismSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Polygon.sol b/src/chains/Polygon.sol index 2efd0f2f..5f47418a 100644 --- a/src/chains/Polygon.sol +++ b/src/chains/Polygon.sol @@ -155,7 +155,12 @@ contract PolygonSettlerIntent is SettlerIntent, PolygonSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -163,7 +168,11 @@ contract PolygonSettlerIntent is SettlerIntent, PolygonSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(PolygonSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(PolygonSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Scroll.sol b/src/chains/Scroll.sol index 7c37e5bb..ad021628 100644 --- a/src/chains/Scroll.sol +++ b/src/chains/Scroll.sol @@ -203,7 +203,12 @@ contract ScrollSettlerIntent is SettlerIntent, ScrollSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -211,7 +216,11 @@ contract ScrollSettlerIntent is SettlerIntent, ScrollSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(ScrollSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(ScrollSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/chains/Sepolia.sol b/src/chains/Sepolia.sol index 8556776e..234d367f 100644 --- a/src/chains/Sepolia.sol +++ b/src/chains/Sepolia.sol @@ -182,7 +182,12 @@ contract SepoliaSettlerIntent is SettlerIntent, SepoliaSettlerMetaTxn { return super._msgSender(); } - function _witnessTypeSuffix() internal pure override(SettlerIntent, Permit2PaymentMetaTxn) returns (string memory) { + function _witnessTypeSuffix() + internal + pure + override(SettlerIntent, Permit2PaymentMetaTxn) + returns (string memory) + { return super._witnessTypeSuffix(); } @@ -190,7 +195,11 @@ contract SepoliaSettlerIntent is SettlerIntent, SepoliaSettlerMetaTxn { return super._tokenId(); } - function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) internal override(SepoliaSettlerMetaTxn, SettlerMetaTxn) returns (bool) { + function _dispatchVIP(bytes4 action, bytes calldata data, bytes calldata sig) + internal + override(SepoliaSettlerMetaTxn, SettlerMetaTxn) + returns (bool) + { return super._dispatchVIP(action, data, sig); } } diff --git a/src/core/Permit2Payment.sol b/src/core/Permit2Payment.sol index 6bced489..503fbf67 100644 --- a/src/core/Permit2Payment.sol +++ b/src/core/Permit2Payment.sol @@ -369,7 +369,9 @@ abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { function _witnessTypeSuffix() internal pure virtual returns (string memory) { return string( - abi.encodePacked("SlippageAndActions slippageAndActions)", SLIPPAGE_AND_ACTIONS_TYPE, TOKEN_PERMISSIONS_TYPE) + abi.encodePacked( + "SlippageAndActions slippageAndActions)", SLIPPAGE_AND_ACTIONS_TYPE, TOKEN_PERMISSIONS_TYPE + ) ); } @@ -413,8 +415,6 @@ abstract contract Permit2PaymentMetaTxn is Context, Permit2Payment { abstract contract Permit2PaymentIntent is Permit2PaymentMetaTxn { function _witnessTypeSuffix() internal pure virtual override returns (string memory) { - return string( - abi.encodePacked("Slippage slippage)", SLIPPAGE_TYPE, TOKEN_PERMISSIONS_TYPE) - ); + return string(abi.encodePacked("Slippage slippage)", SLIPPAGE_TYPE, TOKEN_PERMISSIONS_TYPE)); } } From fe85e8f6aa2bef33914a3e31280850e98ff40781 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 20:32:29 -0400 Subject: [PATCH 5/7] Forbid proportional-sell behavior for Intent Settlers --- src/SettlerIntent.sol | 15 ++++++++++++++- src/chains/Arbitrum.sol | 11 ++++++++++- src/chains/Avalanche.sol | 12 +++++++++++- src/chains/Base.sol | 11 ++++++++++- src/chains/Blast.sol | 12 +++++++++++- src/chains/Bnb.sol | 11 ++++++++++- src/chains/Linea.sol | 12 +++++++++++- src/chains/Mainnet.sol | 11 ++++++++++- src/chains/Mantle.sol | 12 +++++++++++- src/chains/Optimism.sol | 12 +++++++++++- src/chains/Polygon.sol | 12 +++++++++++- src/chains/Scroll.sol | 11 ++++++++++- src/chains/Sepolia.sol | 11 ++++++++++- src/core/Permit2Payment.sol | 1 + 14 files changed, 141 insertions(+), 13 deletions(-) diff --git a/src/SettlerIntent.sol b/src/SettlerIntent.sol index 181447a0..c1a20879 100644 --- a/src/SettlerIntent.sol +++ b/src/SettlerIntent.sol @@ -5,7 +5,10 @@ import {SettlerAbstract} from "./SettlerAbstract.sol"; import {SettlerBase} from "./SettlerBase.sol"; import {SettlerMetaTxn} from "./SettlerMetaTxn.sol"; -import {Permit2PaymentIntent, Permit2PaymentMetaTxn} from "./core/Permit2Payment.sol"; +import {Permit2PaymentAbstract} from "./core/Permit2PaymentAbstract.sol"; +import {Permit2PaymentIntent, Permit2PaymentMetaTxn, Permit2Payment} from "./core/Permit2Payment.sol"; + +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { function _tokenId() internal pure virtual override(SettlerAbstract, SettlerMetaTxn) returns (uint256) { @@ -56,4 +59,14 @@ abstract contract SettlerIntent is Permit2PaymentIntent, SettlerMetaTxn { ) public virtual metaTx(msgSender, _hashSlippage(slippage)) returns (bool) { return _executeMetaTxn(slippage, actions, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + virtual + override(Permit2Payment, Permit2PaymentAbstract) + returns (uint256 sellAmount) + { + sellAmount = permit.permitted.amount; + } } diff --git a/src/chains/Arbitrum.sol b/src/chains/Arbitrum.sol index 2358c3eb..a299f27c 100644 --- a/src/chains/Arbitrum.sol +++ b/src/chains/Arbitrum.sol @@ -40,7 +40,7 @@ import {dackieSwapV3ArbitrumFactory, dackieSwapV3ForkId} from "../core/univ3fork import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract ArbitrumMixin is FreeMemory, SettlerBase, MaverickV2, CurveTricrypto, DodoV2 { constructor() { @@ -278,4 +278,13 @@ contract ArbitrumSettlerIntent is SettlerIntent, ArbitrumSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Avalanche.sol b/src/chains/Avalanche.sol index 93f521cb..a986d251 100644 --- a/src/chains/Avalanche.sol +++ b/src/chains/Avalanche.sol @@ -11,6 +11,7 @@ import {DodoV2, IDodoV2} from "../core/DodoV2.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; import {ISettlerActions} from "../ISettlerActions.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -25,7 +26,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract AvalancheMixin is FreeMemory, SettlerBase, DodoV2 { constructor() { @@ -169,4 +170,13 @@ contract AvalancheSettlerIntent is SettlerIntent, AvalancheSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Base.sol b/src/chains/Base.sol index 9c7ab3c1..4a81b641 100644 --- a/src/chains/Base.sol +++ b/src/chains/Base.sol @@ -43,7 +43,7 @@ import {kinetixV3BaseFactory, kinetixV3ForkId} from "../core/univ3forks/KinetixV import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract BaseMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -283,4 +283,13 @@ contract BaseSettlerIntent is SettlerIntent, BaseSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Blast.sol b/src/chains/Blast.sol index dfcd3127..42af482a 100644 --- a/src/chains/Blast.sol +++ b/src/chains/Blast.sol @@ -9,6 +9,7 @@ import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; import {ISettlerActions} from "../ISettlerActions.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -37,7 +38,7 @@ import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; import {Permit2PaymentBase} from "../core/Permit2Payment.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract BlastMixin is FreeMemory, SettlerBase { constructor() { @@ -220,4 +221,13 @@ contract BlastSettlerIntent is SettlerIntent, BlastSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Bnb.sol b/src/chains/Bnb.sol index 0deb59b2..a47eebc8 100644 --- a/src/chains/Bnb.sol +++ b/src/chains/Bnb.sol @@ -33,7 +33,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract BnbMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -223,4 +223,13 @@ contract BnbSettlerIntent is SettlerIntent, BnbSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Linea.sol b/src/chains/Linea.sol index 26b3ad1d..ff729df4 100644 --- a/src/chains/Linea.sol +++ b/src/chains/Linea.sol @@ -9,6 +9,7 @@ import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; import {ISettlerActions} from "../ISettlerActions.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -31,7 +32,7 @@ import {lynexFactory, lynexInitHash, lynexForkId} from "../core/univ3forks/Lynex import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract LineaMixin is FreeMemory, SettlerBase { constructor() { @@ -173,4 +174,13 @@ contract LineaSettlerIntent is SettlerIntent, LineaSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Mainnet.sol b/src/chains/Mainnet.sol index 4540fcf9..ba65634e 100644 --- a/src/chains/Mainnet.sol +++ b/src/chains/Mainnet.sol @@ -39,7 +39,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract MainnetMixin is FreeMemory, SettlerBase, MakerPSM, MaverickV2, CurveTricrypto, DodoV1, DodoV2 { constructor() { @@ -266,4 +266,13 @@ contract MainnetSettlerIntent is SettlerIntent, MainnetSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Mantle.sol b/src/chains/Mantle.sol index 0bb9574e..aef3c04c 100644 --- a/src/chains/Mantle.sol +++ b/src/chains/Mantle.sol @@ -8,6 +8,7 @@ import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -21,7 +22,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract MantleMixin is FreeMemory, SettlerBase { constructor() { @@ -151,4 +152,13 @@ contract MantleSettlerIntent is SettlerIntent, MantleSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Optimism.sol b/src/chains/Optimism.sol index b8f80d1a..b71bafd1 100644 --- a/src/chains/Optimism.sol +++ b/src/chains/Optimism.sol @@ -9,6 +9,7 @@ import {SettlerIntent} from "../SettlerIntent.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; import {ISettlerActions} from "../ISettlerActions.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -29,7 +30,7 @@ import {dackieSwapV3OptimismFactory, dackieSwapV3ForkId} from "../core/univ3fork import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract OptimismMixin is FreeMemory, SettlerBase { constructor() { @@ -175,4 +176,13 @@ contract OptimismSettlerIntent is SettlerIntent, OptimismSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Polygon.sol b/src/chains/Polygon.sol index 5f47418a..65c9518b 100644 --- a/src/chains/Polygon.sol +++ b/src/chains/Polygon.sol @@ -11,6 +11,7 @@ import {DodoV2, IDodoV2} from "../core/DodoV2.sol"; import {FreeMemory} from "../utils/FreeMemory.sol"; import {ISettlerActions} from "../ISettlerActions.sol"; +import {ISignatureTransfer} from "permit2/src/interfaces/ISignatureTransfer.sol"; import {UnknownForkId} from "../core/SettlerErrors.sol"; import { @@ -27,7 +28,7 @@ import {quickSwapV3Factory, quickSwapV3InitHash, quickSwapV3ForkId} from "../cor import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract PolygonMixin is FreeMemory, SettlerBase, DodoV2 { constructor() { @@ -175,4 +176,13 @@ contract PolygonSettlerIntent is SettlerIntent, PolygonSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Scroll.sol b/src/chains/Scroll.sol index ad021628..8f15b0c4 100644 --- a/src/chains/Scroll.sol +++ b/src/chains/Scroll.sol @@ -29,7 +29,7 @@ import {metavaultV3Factory, metavaultV3ForkId} from "../core/univ3forks/Metavaul import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract ScrollMixin is FreeMemory, SettlerBase, MaverickV2, DodoV2 { constructor() { @@ -223,4 +223,13 @@ contract ScrollSettlerIntent is SettlerIntent, ScrollSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/chains/Sepolia.sol b/src/chains/Sepolia.sol index 234d367f..63047441 100644 --- a/src/chains/Sepolia.sol +++ b/src/chains/Sepolia.sol @@ -25,7 +25,7 @@ import { import {SettlerAbstract} from "../SettlerAbstract.sol"; import {AbstractContext} from "../Context.sol"; import {Permit2PaymentAbstract} from "../core/Permit2PaymentAbstract.sol"; -import {Permit2PaymentMetaTxn} from "../core/Permit2Payment.sol"; +import {Permit2PaymentMetaTxn, Permit2Payment} from "../core/Permit2Payment.sol"; abstract contract SepoliaMixin is FreeMemory, SettlerBase, MaverickV2 { constructor() { @@ -202,4 +202,13 @@ contract SepoliaSettlerIntent is SettlerIntent, SepoliaSettlerMetaTxn { { return super._dispatchVIP(action, data, sig); } + + function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) + internal + view + override(SettlerIntent, Permit2Payment, Permit2PaymentAbstract) + returns (uint256) + { + return super._permitToSellAmount(permit); + } } diff --git a/src/core/Permit2Payment.sol b/src/core/Permit2Payment.sol index 503fbf67..dbf71bf7 100644 --- a/src/core/Permit2Payment.sol +++ b/src/core/Permit2Payment.sol @@ -232,6 +232,7 @@ abstract contract Permit2Payment is Permit2PaymentBase { function _permitToSellAmount(ISignatureTransfer.PermitTransferFrom memory permit) internal view + virtual override returns (uint256 sellAmount) { From 50d37fc19dc48e43ffc014006a2ea41c68bdb7aa Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Wed, 28 Aug 2024 20:33:42 -0400 Subject: [PATCH 6/7] `CHANGELOG.md` --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 258efad5..b163f028 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,10 @@ Master list of UniV3 forks: --- +* Create new Settler version for intent-based settlement -- the taker only signs + the slippage, not the actions + * This is now `tokenId` 4 + ## 2024-08-26 ### Breaking changes From 238c20b2ccc7f2edef55f6edbc8609c9e8b95de4 Mon Sep 17 00:00:00 2001 From: Duncan Townsend Date: Thu, 29 Aug 2024 08:33:45 -0400 Subject: [PATCH 7/7] Add intents Settler info to `README.md` --- README.md | 31 ++++++++++++++++++++----------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 13cfad5b..499835c5 100644 --- a/README.md +++ b/README.md @@ -13,12 +13,13 @@ ERC721-compatible NFT. To find the address of the most recent `Settler` deployment, call `function ownerOf(uint256 tokenId) external view returns (address)` with the `tokenId` set to the number of the feature that you wish to query. For taker-submitted flows, the feature number is probably 2 unless something major -changed and nobody updated this document. Likewise, for gasless/metatransaction -flows, the feature number is probably 3. A reverting response indicates that -`Settler` is paused and you should not interact. Do not hardcode any `Settler` -address in your integration. _**ALWAYS**_ query the deployer/registry for the -address of the most recent `Settler` contract before building or signing a -transaction, metatransaction, or order. +changed and nobody updated this document. For gasless/metatransaction flows, the +feature number is probably 3. For intents, the feature number is probably 4. A +reverting response indicates that `Settler` is paused and you should not +interact. Do not hardcode any `Settler` address in your +integration. _**ALWAYS**_ query the deployer/registry for the address of the +most recent `Settler` contract before building or signing a transaction, +metatransaction, or order. ### 0x API dwell time @@ -153,6 +154,7 @@ import { createPublicClient, http, parseAbi } from 'viem'; const tokenDescriptions = { 2: "taker submitted", 3: "metatransaction", + 4: "intents", }; const deployerAbi = parseAbi([ @@ -211,6 +213,7 @@ const {ethers} = require("ethers"); const tokenDescriptions = { 2: "taker submitted", 3: "metatransaction", + 4: "intents", }; const deployerAbi = [ @@ -300,8 +303,12 @@ async fn main() -> Result<()> { let provider = ProviderBuilder::new().on_http(env::var("RPC_URL")?.parse()?); let block_id = BlockId::number(provider.get_block_number().await?); - let token_ids = vec![2, 3]; - let token_descriptions = HashMap::from([(2, "taker submitted"), (3, "metatransaction")]); + let token_ids = vec![2, 3, 4]; + let token_descriptions = HashMap::from([ + (2, "taker submitted"), + (3, "metatransaction"), + (4, "intents") + ]); for token_id in token_ids.iter() { { @@ -384,6 +391,7 @@ deployer_address = "0x00000000000004533Fe15556B1E086BB1A72cEae" token_descriptions = { 2: "taker submitted", 3: "metatransaction", + 4: "intents", } deployer_abi = [ @@ -461,6 +469,7 @@ declare -r deployer='0x00000000000004533Fe15556B1E086BB1A72cEae' declare -A token_descriptions token_descriptions[2]='taker submitted' token_descriptions[3]='metatransaction' +token_descriptions[4]='intents' declare -r -A token_descriptions declare -r -a function_signatures=('prev(uint128)(address)' 'ownerOf(uint256)(address)' 'next(uint128)(address)') @@ -1250,10 +1259,10 @@ from this document. ![Click on "Connect to Web3"](img/pause6.png?raw=true) 9. Enter the "feature" number in the text box. This is probably 2 for - taker-submitted for 3 for gasless/metatransaction, unless something major has - changed and nobody bothered to update this document. + taker-submitted, 3 for gasless/metatransaction, or 4 for intents, unless + something major has changed and nobody bothered to update this document. -![Enter the "feature" number (2 or 3) in the text box](img/pause7.png?raw=true) +![Enter the "feature" number (2, 3, or 4) in the text box](img/pause7.png?raw=true) 10. Click "Write" and confirm the transaction in your wallet. You have _really_ ruined everybody's day :+1: