| Network |
-Seaport 1.1 |
+Seaport 1.5 |
Seaport 1.4 |
+Seaport 1.1 |
ConduitController |
| Ethereum |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://etherscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -87,12 +93,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://etherscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Goerli |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://goerli.etherscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -100,12 +110,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://goerli.etherscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Sepolia |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://sepolia.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://sepolia.etherscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -113,12 +127,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://sepolia.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://sepolia.etherscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Polygon |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://polygonscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://polygonscan.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -126,12 +144,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://polygonscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://polygonscan.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Mumbai |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://mumbai.polygonscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://mumbai.polygonscan.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -139,51 +161,33 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
-[0x00000000F9490004C11Cef243f5400493c00Ad63](https://mumbai.polygonscan.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
-
- |
-| Klaytn |
-
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://scope.klaytn.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
-
- |
-
-[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://scope.klaytn.com/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://mumbai.polygonscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
|
-[0x00000000F9490004C11Cef243f5400493c00Ad63](https://scope.klaytn.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://mumbai.polygonscan.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
-| Baobab |
+ |
| Optimism |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://baobab.scope.klaytn.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://optimistic.etherscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
-[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://baobab.scope.klaytn.com/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
+[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://optimistic.etherscan.io/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
|
-[0x00000000F9490004C11Cef243f5400493c00Ad63](https://baobab.scope.klaytn.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
-
- |
-| Optimism |
-
[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://optimistic.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
|
-[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://optimistic.etherscan.io/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
-
- |
-
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://optimistic.etherscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Optimistic Goerli |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli-optimism.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://goerli-optimism.etherscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -191,12 +195,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli-optimism.etherscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://goerli-optimism.etherscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Arbitrum |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://arbiscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -204,12 +212,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://arbiscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Arbitrum Goerli |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli.arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://goerli.arbiscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -217,12 +229,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://goerli.arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://goerli.arbiscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Arbitrum Nova |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://nova.arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://nova.arbiscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -230,12 +246,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://nova.arbiscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://nova.arbiscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Avalanche C-Chain |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://snowtrace.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://snowtrace.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -243,12 +263,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://snowtrace.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://snowtrace.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Avalanche Fuji |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://testnet.snowtrace.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://testnet.snowtrace.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -256,12 +280,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://testnet.snowtrace.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://testnet.snowtrace.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| Gnosis Chain |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://gnosisscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://gnosisscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -269,12 +297,33 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://gnosisscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://gnossiscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+ |
+| Chiado |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://blockscout.com/gnosis/chiado/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC/contracts#address-tabs)
+
+ |
+
+Not deployed
+
+ |
+
+Not deployed
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://blockscout.com/gnosis/chiado/address/0x00000000F9490004C11Cef243f5400493c00Ad63/contracts#address-tabs)
+
|
| BSC |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://bscscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://bscscan.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -282,12 +331,16 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://bscscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://bscscan.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
|
| BSC Testnet |
-[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://testnet.bscscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://testnet.bscscan.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
|
@@ -295,8 +348,98 @@ See the [documentation](docs/SeaportDocumentation.md), the [interface](contracts
|
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://testnet.bscscan.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
[0x00000000F9490004C11Cef243f5400493c00Ad63](https://testnet.bscscan.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+ |
+| Klaytn |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://scope.klaytn.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
+
+ |
+
+[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://scope.klaytn.com/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
+
+ |
+
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://scope.klaytn.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://scope.klaytn.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+
+ |
+| Baobab |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://baobab.scope.klaytn.com/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
+
+ |
+
+[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://baobab.scope.klaytn.com/address/0x00000000000001ad428e4906aE43D8F9852d0dD6#code)
+
+ |
+
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://baobab.scope.klaytn.com/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://baobab.scope.klaytn.com/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+
+ |
+| Moonbeam |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://moonscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
+
+ |
+
+Not deployed
+
+ |
+
+Not deployed
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://moonscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+
+ |
+| Moonriver |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://moonriver.moonscan.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
+
+ |
+
+Not deployed
+
+ |
+
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://moonriver.moonscan.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://moonriver.moonscan.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+
+ |
+
+| Canto |
+
+[0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC](https://evm.explorer.canto.io/address/0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC#code)
+
+ |
+
+[0x00000000000001ad428e4906aE43D8F9852d0dD6](https://evm.explorer.canto.io/address/0x00000000000001ad428e4906aE43D8F9852d0dD6)
+
+ |
+
+[0x00000000006c3852cbEf3e08E8dF289169EdE581](https://evm.explorer.canto.io/address/0x00000000006c3852cbEf3e08E8dF289169EdE581#code)
+
+ |
+
+[0x00000000F9490004C11Cef243f5400493c00Ad63](https://evm.explorer.canto.io/address/0x00000000F9490004C11Cef243f5400493c00Ad63#code)
+
|
@@ -345,12 +488,20 @@ graph TD
For a more thorough flowchart see [Seaport diagram](./diagrams/Seaport.drawio.svg).
+## Docs
+
+- [Seaport Deployment](./docs/Deployment.md)
+- [Seaport Documentation](./docs/SeaportDocumentation.md)
+- [Zone Documentation](./docs/ZoneDocumentation.md)
+- [Function Signatures](./docs/FunctionSignatures.md)
+- [Order Validator](./docs/OrderValidator.md)
+
## Install
To install dependencies and compile contracts:
```bash
-git clone https://github.com/ProjectOpenSea/seaport && cd seaport
+git clone --recurse-submodules https://github.com/ProjectOpenSea/seaport && cd seaport
yarn install
yarn build
```
@@ -387,7 +538,15 @@ yarn profile
### Foundry Tests
-Seaport also includes a suite of fuzzing tests written in solidity with Foundry.
+Seaport also includes a suite of fuzzing tests written in Solidity with Foundry.
+
+Before running these tests, you will need to compile an optimized build by running:
+
+```bash
+FOUNDRY_PROFILE=optimized forge build
+```
+
+This should create an `optimized-out/` directory in your project root.
To run tests with full traces and debugging with source, create an `.env` file with the following line:
@@ -397,7 +556,7 @@ FOUNDRY_PROFILE=debug
You may then run tests with `forge test`, optionally specifying a level of verbosity (anywhere from one to five `v`'s, eg, `-vvv`)
-This will compile tests and contracts without `via-ir` enabled, which is must faster, but will not exactly match the deployed bytecode.
+This will compile tests and contracts without `via-ir` enabled, which is much faster, but will not exactly match the deployed bytecode.
To run tests against the actual bytecode intended to be deployed on networks, you will need to pre-compile the contracts, and remove the `FOUNDRY_PROFILE` variable from your `.env` file. **Note** that informative error traces may not be available, and the Forge debugger will not show the accompanying source code.
@@ -410,10 +569,12 @@ To run Forge coverage tests and open the generated coverage report locally:
```bash
brew install lcov
-SEAPORT_COVERAGE=true forge coverage --report summary --report lcov && genhtml lcov.info -o html --branch
-open html/index.htmlg
+SEAPORT_COVERAGE=true forge coverage --report summary --report lcov && lcov -o lcov.info --remove lcov.info --rc lcov_branch_coverage=1 --rc lcov_function_coverage=1 "test/*" "script/*" && genhtml lcov.info -o html --branch
+open html/index.html
```
+When working on the test suite based around `FuzzEngine.sol`, using `FOUNDRY_PROFILE=moat_debug` will cut compile times roughly in half.
+
**Note** that Forge does not yet ignore specific filepaths when running coverage tests.
For information on Foundry, including installation and testing, see the [Foundry Book](https://book.getfoundry.sh/).
diff --git a/config/.solcover-reference.js b/config/.solcover-reference.js
index 84280eeef..df8fd5c01 100644
--- a/config/.solcover-reference.js
+++ b/config/.solcover-reference.js
@@ -14,6 +14,8 @@ module.exports = {
"interfaces/ConsiderationInterface.sol",
"interfaces/ContractOffererInterface.sol",
"interfaces/EIP1271Interface.sol",
+ "interfaces/ERC165.sol",
+ "interfaces/SeaportInterface.sol",
"interfaces/ZoneInterface.sol",
"lib/ConsiderationBase.sol",
"lib/ConsiderationConstants.sol",
@@ -25,6 +27,8 @@ module.exports = {
"lib/TokenTransferrer.sol",
"test/EIP1271Wallet.sol",
"test/ExcessReturnDataRecipient.sol",
+ "test/ERC1155BatchRecipient.sol",
+ "test/InvalidEthRecipient.sol",
"test/Reenterer.sol",
"test/TestERC1155.sol",
"test/TestERC1155Revert.sol",
@@ -37,8 +41,8 @@ module.exports = {
"test/TestInvalidContractOfferer.sol",
"test/TestInvalidContractOffererRatifyOrder.sol",
"test/TestBadContractOfferer.sol",
- "test/TestZone.sol",
"test/TestPostExecution.sol",
+ "test/TestZone.sol",
"test/TestERC20Panic.sol",
"test/TestERC20Revert.sol",
"test/InvalidERC721Recipient.sol",
@@ -50,6 +54,11 @@ module.exports = {
"test/ConduitMockRevertBytes.sol",
"test/ConduitMockRevertNoReason.sol",
"test/TestTransferValidationZoneOfferer.sol",
+ "zones/PausableZone.sol",
+ "zones/PausableZoneController.sol",
+ "zones/interfaces/PausableZoneControllerInterface.sol",
+ "zones/interfaces/PausableZoneEventsAndErrors.sol",
+ "zones/interfaces/PausableZoneInterface.sol",
"../reference/shim/Shim.sol",
],
};
diff --git a/config/.solcover.js b/config/.solcover.js
index 8cac48297..f8091fe4a 100644
--- a/config/.solcover.js
+++ b/config/.solcover.js
@@ -11,6 +11,7 @@ module.exports = {
"interfaces/ConsiderationInterface.sol",
"interfaces/ContractOffererInterface.sol",
"interfaces/EIP1271Interface.sol",
+ "interfaces/ERC165.sol",
"interfaces/SeaportInterface.sol",
"interfaces/ZoneInterface.sol",
"lib/ConsiderationConstants.sol",
diff --git a/contracts/Seaport.sol b/contracts/Seaport.sol
index 057c498af..634dd1d36 100644
--- a/contracts/Seaport.sol
+++ b/contracts/Seaport.sol
@@ -5,7 +5,7 @@ import { Consideration } from "./lib/Consideration.sol";
/**
* @title Seaport
- * @custom:version 1.4
+ * @custom:version 1.5
* @author 0age (0age.eth)
* @custom:coauthor d1ll0n (d1ll0n.eth)
* @custom:coauthor transmissions11 (t11s.eth)
diff --git a/contracts/helpers/ArrayHelpers.sol b/contracts/helpers/ArrayHelpers.sol
new file mode 100644
index 000000000..008eeaa1c
--- /dev/null
+++ b/contracts/helpers/ArrayHelpers.sol
@@ -0,0 +1,705 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./PointerLibraries.sol";
+
+/**
+ * @author d1ll0n
+ * @custom:coauthor Most of the natspec is cribbed from the TypeScript
+ * documentation
+ */
+library ArrayHelpers {
+ // Has to be out of place to silence a linter warning
+ function reduceWithArg(
+ MemoryPointer array,
+ /* function (uint256 currentResult, uint256 element, uint256 arg) */
+ /* returns (uint256 newResult) */
+ function(uint256, uint256, MemoryPointer) internal returns (uint256) fn,
+ uint256 initialValue,
+ MemoryPointer arg
+ ) internal returns (uint256 result) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+
+ result = initialValue;
+ while (srcPosition.lt(srcEnd)) {
+ result = fn(result, srcPosition.readUint256(), arg);
+ srcPosition = srcPosition.next();
+ }
+ }
+ }
+
+ function flatten(
+ MemoryPointer array1,
+ MemoryPointer array2
+ ) internal view returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 arrayLength1 = array1.readUint256();
+ uint256 arrayLength2 = array2.readUint256();
+ uint256 array1HeadSize = arrayLength1 * 32;
+ uint256 array2HeadSize = arrayLength2 * 32;
+
+ newArray = malloc(array1HeadSize + array2HeadSize + 32);
+ newArray.write(arrayLength1 + arrayLength2);
+
+ MemoryPointer dst = newArray.next();
+ if (arrayLength1 > 0) {
+ array1.next().copy(dst, array1HeadSize);
+ }
+ if (arrayLength2 > 0) {
+ array2.next().copy(dst.offset(array1HeadSize), array2HeadSize);
+ }
+ }
+ }
+
+ function flattenThree(
+ MemoryPointer array1,
+ MemoryPointer array2,
+ MemoryPointer array3
+ ) internal view returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 arrayLength1 = array1.readUint256();
+ uint256 arrayLength2 = array2.readUint256();
+ uint256 arrayLength3 = array3.readUint256();
+ uint256 array1HeadSize = arrayLength1 * 32;
+ uint256 array2HeadSize = arrayLength2 * 32;
+ uint256 array3HeadSize = arrayLength3 * 32;
+
+ newArray = malloc(
+ array1HeadSize + array2HeadSize + array3HeadSize + 32
+ );
+ newArray.write(arrayLength1 + arrayLength2 + arrayLength3);
+
+ MemoryPointer dst = newArray.next();
+ if (arrayLength1 > 0) {
+ array1.next().copy(dst, array1HeadSize);
+ }
+ if (arrayLength2 > 0) {
+ array2.next().copy(dst.offset(array1HeadSize), array2HeadSize);
+ }
+ if (arrayLength3 > 0) {
+ array3.next().copy(
+ dst.offset(array1HeadSize + array2HeadSize),
+ array3HeadSize
+ );
+ }
+ }
+ }
+
+ // =====================================================================//
+ // map with (element) => (newElement) callback //
+ // =====================================================================//
+
+ /**
+ * @dev map calls a defined callback function on each element of an array
+ * and returns an array that contains the results
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * returns a new value to put in its place in the new array
+ *
+ * @return newArray the new array created with the results from calling
+ * fn with each element
+ */
+ function map(
+ MemoryPointer array,
+ /* function (uint256 value) returns (uint256 newValue) */
+ function(uint256) internal pure returns (uint256) fn
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+ newArray.write(length);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ while (srcPosition.lt(srcEnd)) {
+ dstPosition.write(fn(srcPosition.readUint256()));
+ srcPosition = srcPosition.next();
+ dstPosition = dstPosition.next();
+ }
+ }
+ }
+
+ // =====================================================================//
+ // filterMap with (element) => (newElement) callback //
+ // =====================================================================//
+
+ /**
+ * @dev filterMap calls a defined callback function on each element of an
+ * array and returns an array that contains only the non-zero results
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * returns a new value to put in its place in the new array
+ * or a zero value to indicate that the element should not
+ * be included in the new array
+ *
+ * @return newArray the new array created with the results from calling
+ * fn with each element
+ */
+ function filterMap(
+ MemoryPointer array,
+ /* function (uint256 value) returns (uint256 newValue) */
+ function(MemoryPointer) internal pure returns (MemoryPointer) fn
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ length = 0;
+
+ while (srcPosition.lt(srcEnd)) {
+ MemoryPointer result = fn(srcPosition.readMemoryPointer());
+ if (!result.isNull()) {
+ dstPosition.write(result);
+ dstPosition = dstPosition.next();
+ length += 1;
+ }
+ srcPosition = srcPosition.next();
+ }
+ newArray.write(length);
+ }
+ }
+
+ // =====================================================================//
+ // filterMap with (element, arg) => (newElement) callback //
+ // =====================================================================//
+
+ /**
+ * @dev filterMap calls a defined callback function on each element of an
+ * array and returns an array that contains only the non-zero results
+ *
+ * filterMapWithArg = (arr, callback, arg) => arr.map(
+ * (element) => callback(element, arg)
+ * ).filter(result => result != 0)
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * returns a new value to put in its place in the new array
+ * or a zero value to indicate that the element should not
+ * be included in the new array
+ * @param arg an arbitrary value provided in each call to fn
+ *
+ * @return newArray the new array created with the results from calling
+ * fn with each element
+ */
+ function filterMapWithArg(
+ MemoryPointer array,
+ /* function (MemoryPointer element, MemoryPointer arg) */
+ /* returns (uint256 newValue) */
+ function(MemoryPointer, MemoryPointer)
+ internal
+ pure
+ returns (MemoryPointer) fn,
+ MemoryPointer arg
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ length = 0;
+
+ while (srcPosition.lt(srcEnd)) {
+ MemoryPointer result = fn(srcPosition.readMemoryPointer(), arg);
+ if (!result.isNull()) {
+ dstPosition.write(result);
+ dstPosition = dstPosition.next();
+ length += 1;
+ }
+ srcPosition = srcPosition.next();
+ }
+ newArray.write(length);
+ }
+ }
+
+ // ====================================================================//
+ // filter with (element, arg) => (bool) predicate //
+ // ====================================================================//
+
+ /**
+ * @dev filter calls a defined callback function on each element of an array
+ * and returns an array that contains only the elements which the
+ * callback returned true for
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * returns a boolean that indicates whether the element
+ * should be included in the new array
+ * @param arg an arbitrary value provided in each call to fn
+ *
+ * @return newArray the new array created with the elements which the
+ * callback returned true for
+ */
+ function filterWithArg(
+ MemoryPointer array,
+ /* function (uint256 value, uint256 arg) returns (bool) */
+ function(MemoryPointer, MemoryPointer) internal pure returns (bool) fn,
+ MemoryPointer arg
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ length = 0;
+
+ while (srcPosition.lt(srcEnd)) {
+ MemoryPointer element = srcPosition.readMemoryPointer();
+ if (fn(element, arg)) {
+ dstPosition.write(element);
+ dstPosition = dstPosition.next();
+ length += 1;
+ }
+ srcPosition = srcPosition.next();
+ }
+ newArray.write(length);
+ }
+ }
+
+ // ====================================================================//
+ // filter with (element) => (bool) predicate //
+ // ====================================================================//
+
+ /**
+ * @dev filter calls a defined callback function on each element of an array
+ * and returns an array that contains only the elements which the
+ * callback returned true for
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * returns a boolean that indicates whether the element
+ * should be included in the new array
+ *
+ * @return newArray the new array created with the elements which the
+ * callback returned true for
+ */
+ function filter(
+ MemoryPointer array,
+ /* function (uint256 value) returns (bool) */
+ function(MemoryPointer) internal pure returns (bool) fn
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ length = 0;
+
+ while (srcPosition.lt(srcEnd)) {
+ MemoryPointer element = srcPosition.readMemoryPointer();
+ if (fn(element)) {
+ dstPosition.write(element);
+ dstPosition = dstPosition.next();
+ length += 1;
+ }
+ srcPosition = srcPosition.next();
+ }
+ newArray.write(length);
+ }
+ }
+
+ /**
+ * @dev mapWithIndex calls a defined callback function with each element of
+ * an array and its index and returns an array that contains the
+ * results
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * its index and returns a new value to put in its place
+ * in the new array
+ *
+ * @return newArray the new array created with the results from calling
+ * fn with each element
+ */
+ function mapWithIndex(
+ MemoryPointer array,
+ /* function (uint256 value, uint256 index) returns (uint256 newValue) */
+ function(uint256, uint256) internal pure returns (uint256) fn
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+ newArray.write(length);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ uint256 index;
+ while (srcPosition.lt(srcEnd)) {
+ dstPosition.write(fn(srcPosition.readUint256(), index++));
+ srcPosition = srcPosition.next();
+ dstPosition = dstPosition.next();
+ }
+ }
+ }
+
+ /**
+ * @dev map calls a defined callback function on each element of an array
+ * and returns an array that contains the results
+ *
+ * @param array the array to map
+ * @param fn a function that accepts each element in the array and
+ * the `arg` value provided in the call to map and returns
+ * a new value to put in its place in the new array
+ * @param arg an arbitrary value provided in each call to fn
+ *
+ * @return newArray the new array created with the results from calling
+ * fn with each element
+ */
+ function mapWithArg(
+ MemoryPointer array,
+ /* function (uint256 value, uint256 arg) returns (uint256 newValue) */
+ function(MemoryPointer, MemoryPointer)
+ internal
+ pure
+ returns (MemoryPointer) fn,
+ MemoryPointer arg
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+ newArray.write(length);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ while (srcPosition.lt(srcEnd)) {
+ dstPosition.write(fn(srcPosition.readMemoryPointer(), arg));
+ srcPosition = srcPosition.next();
+ dstPosition = dstPosition.next();
+ }
+ }
+ }
+
+ function mapWithIndex(
+ MemoryPointer array,
+ /* function (uint256 value, uint256 index, uint256 arg) */
+ /* returns (uint256 newValue) */
+ function(uint256, uint256, uint256) internal pure returns (uint256) fn,
+ uint256 arg
+ ) internal pure returns (MemoryPointer newArray) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ newArray = malloc((length + 1) * 32);
+ newArray.write(length);
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ MemoryPointer dstPosition = newArray.next();
+
+ uint256 index;
+ while (srcPosition.lt(srcEnd)) {
+ dstPosition.write(fn(srcPosition.readUint256(), index++, arg));
+ srcPosition = srcPosition.next();
+ dstPosition = dstPosition.next();
+ }
+ }
+ }
+
+ function reduce(
+ MemoryPointer array,
+ /* function (uint256 currentResult, uint256 element) */
+ /* returns (uint256 newResult) */
+ function(uint256, uint256) internal pure returns (uint256) fn,
+ uint256 initialValue
+ ) internal pure returns (uint256 result) {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+
+ result = initialValue;
+ while (srcPosition.lt(srcEnd)) {
+ result = fn(result, srcPosition.readUint256());
+ srcPosition = srcPosition.next();
+ }
+ }
+ }
+
+ // This was the previous home of `reduceWithArg`. It can now be found near
+ // the top of this file.
+
+ function forEach(
+ MemoryPointer array,
+ /* function (MemoryPointer element, MemoryPointer arg) */
+ function(MemoryPointer, MemoryPointer) internal pure fn,
+ MemoryPointer arg
+ ) internal pure {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+
+ while (srcPosition.lt(srcEnd)) {
+ fn(srcPosition.readMemoryPointer(), arg);
+ srcPosition = srcPosition.next();
+ }
+ }
+ }
+
+ function forEach(
+ MemoryPointer array,
+ /* function (MemoryPointer element) */
+ function(MemoryPointer) internal pure fn
+ ) internal pure {
+ unchecked {
+ uint256 length = array.readUint256();
+
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+
+ while (srcPosition.lt(srcEnd)) {
+ fn(srcPosition.readMemoryPointer());
+ srcPosition = srcPosition.next();
+ }
+ }
+ }
+
+ // =====================================================================//
+ // find with function(uint256 element, uint256 arg) predicate //
+ // =====================================================================//
+
+ /**
+ * @dev calls `predicate` once for each element of the array, in ascending
+ * order, until it finds one where predicate returns true. If such an
+ * element is found, find immediately returns that element value.
+ * Otherwise, find returns 0.
+ *
+ * @param array array to search
+ * @param predicate function that checks whether each element meets the
+ * search filter.
+ * @param arg second input to `predicate`
+ *
+ * @return the value of the first element in the array where
+ * predicate is true and 0 otherwise.
+ */
+ function find(
+ MemoryPointer array,
+ function(uint256, uint256) internal pure returns (bool) predicate,
+ uint256 arg
+ ) internal pure returns (uint256) {
+ unchecked {
+ uint256 length = array.readUint256();
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ while (srcPosition.lt(srcEnd)) {
+ uint256 value = srcPosition.readUint256();
+ if (predicate(value, arg)) return value;
+ srcPosition = srcPosition.next();
+ }
+ return 0;
+ }
+ }
+
+ // =====================================================================//
+ // find with function(uint256 element) predicate //
+ // =====================================================================//
+
+ /**
+ * @dev calls `predicate` once for each element of the array, in ascending
+ * order, until it finds one where predicate returns true. If such an
+ * element is found, find immediately returns that element value.
+ * Otherwise, find returns 0.
+ *
+ * @param array array to search
+ * @param predicate function that checks whether each element meets the
+ * search filter.
+ * @param fromIndex index to start search at
+ *
+ * @custom:return the value of the first element in the array where
+ * predicate is trueand 0 otherwise.
+ */
+ function find(
+ MemoryPointer array,
+ function(uint256) internal pure returns (bool) predicate,
+ uint256 fromIndex
+ ) internal pure returns (uint256) {
+ unchecked {
+ uint256 length = array.readUint256();
+ MemoryPointer srcPosition = array.next().offset(fromIndex * 0x20);
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ while (srcPosition.lt(srcEnd)) {
+ uint256 value = srcPosition.readUint256();
+ if (predicate(value)) return value;
+ srcPosition = srcPosition.next();
+ }
+ return 0;
+ }
+ }
+
+ // =====================================================================//
+ // find with function(uint256 element) predicate //
+ // =====================================================================//
+
+ /**
+ * @dev calls `predicate` once for each element of the array, in ascending
+ * order, until it finds one where predicate returns true. If such an
+ * element is found, find immediately returns that element value.
+ * Otherwise, find returns 0.
+ *
+ * @param array array to search
+ * @param predicate function that checks whether each element meets the
+ * search filter.
+ *
+ * @return the value of the first element in the array where
+ * predicate is true and 0 otherwise.
+ */
+ function find(
+ MemoryPointer array,
+ function(uint256) internal pure returns (bool) predicate
+ ) internal pure returns (uint256) {
+ unchecked {
+ uint256 length = array.readUint256();
+ MemoryPointer srcPosition = array.next();
+ MemoryPointer srcEnd = srcPosition.offset(length * 0x20);
+ while (srcPosition.lt(srcEnd)) {
+ uint256 value = srcPosition.readUint256();
+ if (predicate(value)) return value;
+ srcPosition = srcPosition.next();
+ }
+ return 0;
+ }
+ }
+
+ // =====================================================================//
+ // indexOf //
+ // =====================================================================//
+
+ /**
+ * @dev Returns the index of the first occurrence of a value in an array,
+ * or -1 if it is not present.
+ *
+ * @param array array to search
+ * @param searchElement the value to locate in the array.
+ */
+ function indexOf(
+ MemoryPointer array,
+ uint256 searchElement
+ ) internal pure returns (int256 index) {
+ unchecked {
+ int256 length = array.readInt256();
+ MemoryPointer src = array;
+ int256 reachedEnd;
+ while (
+ ((reachedEnd = toInt(index == length)) |
+ toInt((src = src.next()).readUint256() == searchElement)) ==
+ 0
+ ) {
+ index += 1;
+ }
+ return (reachedEnd * -1) | index;
+ }
+ }
+
+ function toInt(bool a) internal pure returns (int256 b) {
+ assembly {
+ b := a
+ }
+ }
+
+ // =====================================================================//
+ // findIndex with one argument //
+ // =====================================================================//
+
+ function findIndexWithArg(
+ MemoryPointer array,
+ function(uint256, uint256) internal pure returns (bool) predicate,
+ uint256 arg
+ ) internal pure returns (int256 index) {
+ unchecked {
+ int256 length = array.readInt256();
+ MemoryPointer src = array;
+ while (index < length) {
+ if (predicate((src = src.next()).readUint256(), arg)) {
+ return index;
+ }
+ index += 1;
+ }
+ return -1;
+ }
+ }
+
+ // =====================================================================//
+ // findIndex from start index //
+ // =====================================================================//
+
+ function findIndexFrom(
+ MemoryPointer array,
+ function(MemoryPointer) internal pure returns (bool) predicate,
+ uint256 fromIndex
+ ) internal pure returns (int256 index) {
+ unchecked {
+ index = int256(fromIndex);
+ int256 length = array.readInt256();
+ MemoryPointer src = array.offset(fromIndex * 0x20);
+ while (index < length) {
+ if (predicate((src = src.next()).readMemoryPointer())) {
+ return index;
+ }
+ index += 1;
+ }
+ return -1;
+ }
+ }
+
+ function countFrom(
+ MemoryPointer array,
+ function(MemoryPointer) internal pure returns (bool) predicate,
+ uint256 fromIndex
+ ) internal pure returns (int256 count) {
+ unchecked {
+ uint256 index = fromIndex;
+ uint256 length = array.readUint256();
+ MemoryPointer src = array.offset(fromIndex * 0x20);
+ while (index < length) {
+ if (predicate((src = src.next()).readMemoryPointer())) {
+ count += 1;
+ }
+ index += 1;
+ }
+ }
+ }
+
+ // =====================================================================//
+ // includes with one argument //
+ // =====================================================================//
+
+ function includes(
+ MemoryPointer array,
+ uint256 value
+ ) internal pure returns (bool) {
+ return indexOf(array, value) != -1;
+ }
+}
diff --git a/contracts/helpers/PointerLibraries.sol b/contracts/helpers/PointerLibraries.sol
index 7f927b564..298d6c032 100644
--- a/contracts/helpers/PointerLibraries.sol
+++ b/contracts/helpers/PointerLibraries.sol
@@ -74,6 +74,12 @@ library CalldataPointerLib {
}
}
+ function isNull(CalldataPointer a) internal pure returns (bool b) {
+ assembly {
+ b := iszero(a)
+ }
+ }
+
/// @dev Resolves an offset stored at `cdPtr + headOffset` to a calldata.
/// pointer `cdPtr` must point to some parent object with a dynamic
/// type's head stored at `cdPtr + headOffset`.
@@ -155,6 +161,12 @@ library ReturndataPointerLib {
}
}
+ function isNull(ReturndataPointer a) internal pure returns (bool b) {
+ assembly {
+ b := iszero(a)
+ }
+ }
+
/// @dev Resolves an offset stored at `rdPtr + headOffset` to a returndata
/// pointer. `rdPtr` must point to some parent object with a dynamic
/// type's head stored at `rdPtr + headOffset`.
@@ -256,6 +268,21 @@ library MemoryPointerLib {
}
}
+ function isNull(MemoryPointer a) internal pure returns (bool b) {
+ assembly {
+ b := iszero(a)
+ }
+ }
+
+ function hash(
+ MemoryPointer ptr,
+ uint256 length
+ ) internal pure returns (bytes32 _hash) {
+ assembly {
+ _hash := keccak256(ptr, length)
+ }
+ }
+
/// @dev Returns the memory pointer one word after `mPtr`.
function next(
MemoryPointer mPtr
@@ -275,7 +302,7 @@ library MemoryPointerLib {
}
}
- /// @dev Resolves a pointer pointer at `mPtr + headOffset` to a memory
+ /// @dev Resolves a pointer at `mPtr + headOffset` to a memory
/// pointer. `mPtr` must point to some parent object with a dynamic
/// type's pointer stored at `mPtr + headOffset`.
function pptr(
@@ -285,7 +312,7 @@ library MemoryPointerLib {
mPtrChild = mPtr.offset(headOffset).readMemoryPointer();
}
- /// @dev Resolves a pointer pointer stored at `mPtr` to a memory pointer.
+ /// @dev Resolves a pointer stored at `mPtr` to a memory pointer.
/// `mPtr` must point to some parent object with a dynamic type as its
/// first member, e.g. `struct { bytes data; }`
function pptr(
diff --git a/contracts/helpers/SeaportRouter.sol b/contracts/helpers/SeaportRouter.sol
index 43b57c393..c02b0e6f6 100644
--- a/contracts/helpers/SeaportRouter.sol
+++ b/contracts/helpers/SeaportRouter.sol
@@ -10,9 +10,9 @@ import { SeaportInterface } from "../interfaces/SeaportInterface.sol";
import { ReentrancyGuard } from "../lib/ReentrancyGuard.sol";
import {
- Execution,
AdvancedOrder,
CriteriaResolver,
+ Execution,
FulfillmentComponent
} from "../lib/ConsiderationStructs.sol";
@@ -24,20 +24,20 @@ import {
* all consideration items across all listings are native tokens.
*/
contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
- /// @dev The allowed v1.1 contract usable through this router.
- address private immutable _SEAPORT_V1_1;
- /// @dev The allowed v1.2 contract usable through this router.
- address private immutable _SEAPORT_V1_2;
+ /// @dev The allowed v1.4 contract usable through this router.
+ address private immutable _SEAPORT_V1_4;
+ /// @dev The allowed v1.5 contract usable through this router.
+ address private immutable _SEAPORT_V1_5;
/**
* @dev Deploy contract with the supported Seaport contracts.
*
- * @param seaportV1point1 The address of the Seaport v1.1 contract.
- * @param seaportV1point2 The address of the Seaport v1.2 contract.
+ * @param seaportV1point4 The address of the Seaport v1.4 contract.
+ * @param seaportV1point5 The address of the Seaport v1.5 contract.
*/
- constructor(address seaportV1point1, address seaportV1point2) {
- _SEAPORT_V1_1 = seaportV1point1;
- _SEAPORT_V1_2 = seaportV1point2;
+ constructor(address seaportV1point4, address seaportV1point5) {
+ _SEAPORT_V1_4 = seaportV1point4;
+ _SEAPORT_V1_5 = seaportV1point5;
}
/**
@@ -95,6 +95,11 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
maximumFulfilled: fulfillmentsLeft
});
+ // If recipient is not provided assign to msg.sender.
+ if (calldataParams.recipient == address(0)) {
+ calldataParams.recipient = msg.sender;
+ }
+
// Iterate through the provided Seaport contracts.
for (uint256 i = 0; i < params.seaportContracts.length; ) {
// Ensure the provided Seaport contract is allowed.
@@ -114,7 +119,7 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
// Execute the orders, collecting availableOrders and executions.
// This is wrapped in a try/catch in case a single order is
// executed that is no longer available, leading to a revert
- // with `NoSpecifiedOrdersAvailable()`.
+ // with `NoSpecifiedOrdersAvailable()` that can be ignored.
try
SeaportInterface(params.seaportContracts[i])
.fulfillAvailableAdvancedOrders{
@@ -150,7 +155,33 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
if (fulfillmentsLeft == 0) {
break;
}
- } catch {}
+ } catch (bytes memory data) {
+ // Set initial value of first four bytes of revert data
+ // to the mask.
+ bytes4 customErrorSelector = bytes4(0xffffffff);
+
+ // Utilize assembly to read first four bytes
+ // (if present) directly.
+ assembly {
+ // Combine original mask with first four bytes of
+ // revert data.
+ customErrorSelector := and(
+ // Data begins after length offset.
+ mload(add(data, 0x20)),
+ customErrorSelector
+ )
+ }
+
+ // Pass through the custom error if the error is
+ // not NoSpecifiedOrdersAvailable()
+ if (
+ customErrorSelector != NoSpecifiedOrdersAvailable.selector
+ ) {
+ assembly {
+ revert(add(data, 32), mload(data))
+ }
+ }
+ }
// Update fulfillments left.
calldataParams.maximumFulfilled = fulfillmentsLeft;
@@ -160,6 +191,11 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
}
}
+ // Throw an error if no orders were fulfilled.
+ if (fulfillmentsLeft == params.maximumFulfilled) {
+ revert NoSpecifiedOrdersAvailable();
+ }
+
// Return excess ether that may not have been used or was sent back.
if (address(this).balance > 0) {
_returnExcessEther();
@@ -180,8 +216,8 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
returns (address[] memory seaportContracts)
{
seaportContracts = new address[](2);
- seaportContracts[0] = _SEAPORT_V1_1;
- seaportContracts[1] = _SEAPORT_V1_2;
+ seaportContracts[0] = _SEAPORT_V1_4;
+ seaportContracts[1] = _SEAPORT_V1_5;
}
/**
@@ -189,7 +225,7 @@ contract SeaportRouter is SeaportRouterInterface, ReentrancyGuard {
*/
function _assertSeaportAllowed(address seaport) internal view {
if (
- _cast(seaport == _SEAPORT_V1_1) | _cast(seaport == _SEAPORT_V1_2) ==
+ _cast(seaport == _SEAPORT_V1_4) | _cast(seaport == _SEAPORT_V1_5) ==
0
) {
revert SeaportNotAllowed(seaport);
diff --git a/contracts/helpers/order-validator/SeaportValidator.sol b/contracts/helpers/order-validator/SeaportValidator.sol
new file mode 100644
index 000000000..0b6ab3489
--- /dev/null
+++ b/contracts/helpers/order-validator/SeaportValidator.sol
@@ -0,0 +1,1206 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ItemType } from "../../lib/ConsiderationEnums.sol";
+import {
+ Order,
+ OrderParameters,
+ BasicOrderParameters,
+ OfferItem,
+ ConsiderationItem,
+ Schema,
+ ZoneParameters
+} from "../../lib/ConsiderationStructs.sol";
+import { ConsiderationTypeHashes } from "./lib/ConsiderationTypeHashes.sol";
+import {
+ ConsiderationInterface
+} from "../../interfaces/ConsiderationInterface.sol";
+import {
+ ConduitControllerInterface
+} from "../../interfaces/ConduitControllerInterface.sol";
+import {
+ ContractOffererInterface
+} from "../../interfaces/ContractOffererInterface.sol";
+import { ZoneInterface } from "../../interfaces/ZoneInterface.sol";
+import { GettersAndDerivers } from "../../lib/GettersAndDerivers.sol";
+import { SeaportValidatorInterface } from "./lib/SeaportValidatorInterface.sol";
+import { ZoneInterface } from "../../interfaces/ZoneInterface.sol";
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../../interfaces/AbridgedTokenInterfaces.sol";
+import { IERC165 } from "../../interfaces/IERC165.sol";
+import { IERC2981 } from "../../interfaces/IERC2981.sol";
+import {
+ ErrorsAndWarnings,
+ ErrorsAndWarningsLib
+} from "./lib/ErrorsAndWarnings.sol";
+import { SafeStaticCall } from "./lib/SafeStaticCall.sol";
+import {
+ IssueParser,
+ ValidationConfiguration,
+ TimeIssue,
+ StatusIssue,
+ OfferIssue,
+ ContractOffererIssue,
+ ConsiderationIssue,
+ PrimaryFeeIssue,
+ ERC721Issue,
+ ERC1155Issue,
+ ERC20Issue,
+ NativeIssue,
+ ZoneIssue,
+ ConduitIssue,
+ CreatorFeeIssue,
+ SignatureIssue,
+ GenericIssue,
+ ConsiderationItemConfiguration
+} from "./lib/SeaportValidatorTypes.sol";
+import { Verifiers } from "../../lib/Verifiers.sol";
+import { SeaportValidatorHelper } from "./lib/SeaportValidatorHelper.sol";
+
+/**
+ * @title SeaportValidator
+ * @author OpenSea Protocol Team
+ * @notice SeaportValidator provides advanced validation to seaport orders.
+ */
+contract SeaportValidator is
+ SeaportValidatorInterface,
+ ConsiderationTypeHashes
+{
+ using ErrorsAndWarningsLib for ErrorsAndWarnings;
+ using SafeStaticCall for address;
+ using IssueParser for *;
+
+ /// @notice Cross-chain conduit controller Address
+ ConduitControllerInterface private immutable _conduitController;
+
+ SeaportValidatorHelper private immutable _helper;
+
+ bytes4 public constant ERC20_INTERFACE_ID = 0x36372b07;
+
+ bytes4 public constant ERC721_INTERFACE_ID = 0x80ac58cd;
+
+ bytes4 public constant ERC1155_INTERFACE_ID = 0xd9b67a26;
+
+ bytes4 public constant CONTRACT_OFFERER_INTERFACE_ID = 0x1be900b1;
+
+ bytes4 public constant ZONE_INTERFACE_ID = 0x3839be19;
+
+ constructor(
+ address seaportValidatorHelperAddress,
+ address conduitControllerAddress
+ ) {
+ _helper = SeaportValidatorHelper(seaportValidatorHelperAddress);
+ _conduitController = ConduitControllerInterface(
+ conduitControllerAddress
+ );
+ }
+
+ /**
+ * @notice Conduct a comprehensive validation of the given order.
+ * `isValidOrder` validates simple orders that adhere to a set of rules defined below:
+ * - The order is either a listing or an offer order (one NFT to buy or one NFT to sell).
+ * - The first consideration is the primary consideration.
+ * - The order pays up to two fees in the fungible token currency. First fee is primary fee, second is creator fee.
+ * - In private orders, the last consideration specifies a recipient for the offer item.
+ * - Offer items must be owned and properly approved by the offerer.
+ * - There must be one offer item
+ * - Consideration items must exist.
+ * - The signature must be valid, or the order must be already validated on chain
+ * @param order The order to validate.
+ * @return errorsAndWarnings The errors and warnings found in the order.
+ */
+ function isValidOrder(
+ Order calldata order,
+ address seaportAddress
+ ) external returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ isValidOrderWithConfiguration(
+ ValidationConfiguration(
+ seaportAddress,
+ address(0),
+ 0,
+ false,
+ false,
+ 30 minutes,
+ 26 weeks
+ ),
+ order
+ );
+ }
+
+ /**
+ * @notice Same as `isValidOrder` but does not modify state.
+ */
+ function isValidOrderReadOnly(
+ Order calldata order,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ isValidOrderWithConfigurationReadOnly(
+ ValidationConfiguration(
+ seaportAddress,
+ address(0),
+ 0,
+ false,
+ false,
+ 30 minutes,
+ 26 weeks
+ ),
+ order
+ );
+ }
+
+ /**
+ * @notice Same as `isValidOrder` but allows for more configuration related to fee validation.
+ * If `skipStrictValidation` is set order logic validation is not carried out: fees are not
+ * checked and there may be more than one offer item as well as any number of consideration items.
+ */
+ function isValidOrderWithConfiguration(
+ ValidationConfiguration memory validationConfiguration,
+ Order memory order
+ ) public returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Concatenates errorsAndWarnings with the returned errorsAndWarnings
+ errorsAndWarnings.concat(
+ validateTime(
+ order.parameters,
+ validationConfiguration.shortOrderDuration,
+ validationConfiguration.distantOrderExpiration
+ )
+ );
+ errorsAndWarnings.concat(
+ validateOrderStatus(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(
+ validateOfferItems(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(
+ validateConsiderationItems(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(isValidZone(order.parameters));
+ errorsAndWarnings.concat(
+ validateSignature(order, validationConfiguration.seaport)
+ );
+
+ // Skip strict validation if requested
+ if (!validationConfiguration.skipStrictValidation) {
+ errorsAndWarnings.concat(
+ validateStrictLogic(
+ order.parameters,
+ validationConfiguration.primaryFeeRecipient,
+ validationConfiguration.primaryFeeBips,
+ validationConfiguration.checkCreatorFee
+ )
+ );
+ }
+ }
+
+ /**
+ * @notice Same as `isValidOrderWithConfiguration` but doesn't call `validate` on Seaport.
+ * If `skipStrictValidation` is set order logic validation is not carried out: fees are not
+ * checked and there may be more than one offer item as well as any number of consideration items.
+ */
+ function isValidOrderWithConfigurationReadOnly(
+ ValidationConfiguration memory validationConfiguration,
+ Order memory order
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Concatenates errorsAndWarnings with the returned errorsAndWarnings
+ errorsAndWarnings.concat(
+ validateTime(
+ order.parameters,
+ validationConfiguration.shortOrderDuration,
+ validationConfiguration.distantOrderExpiration
+ )
+ );
+ errorsAndWarnings.concat(
+ validateOrderStatus(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(
+ validateOfferItems(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(
+ validateConsiderationItems(
+ order.parameters,
+ validationConfiguration.seaport
+ )
+ );
+ errorsAndWarnings.concat(isValidZone(order.parameters));
+
+ // Skip strict validation if requested
+ if (!validationConfiguration.skipStrictValidation) {
+ errorsAndWarnings.concat(
+ validateStrictLogic(
+ order.parameters,
+ validationConfiguration.primaryFeeRecipient,
+ validationConfiguration.primaryFeeBips,
+ validationConfiguration.checkCreatorFee
+ )
+ );
+ }
+ }
+
+ /**
+ * @notice Strict validation operates under tight assumptions. It validates primary
+ * fee, creator fee, private sale consideration, and overall order format.
+ * @dev Only checks first fee recipient provided by CreatorFeeEngine.
+ * Order of consideration items must be as follows:
+ * 1. Primary consideration
+ * 2. Primary fee
+ * 3. Creator fee
+ * 4. Private sale consideration
+ * @param orderParameters The parameters for the order to validate.
+ * @param primaryFeeRecipient The primary fee recipient. Set to null address for no primary fee.
+ * @param primaryFeeBips The primary fee in BIPs.
+ * @param checkCreatorFee Should check for creator fee. If true, creator fee must be present as
+ * according to creator fee engine. If false, must not have creator fee.
+ * @return errorsAndWarnings The errors and warnings.
+ */
+ function validateStrictLogic(
+ OrderParameters memory orderParameters,
+ address primaryFeeRecipient,
+ uint256 primaryFeeBips,
+ bool checkCreatorFee
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ _helper.validateStrictLogic(
+ orderParameters,
+ primaryFeeRecipient,
+ primaryFeeBips,
+ checkCreatorFee
+ );
+ }
+
+ /**
+ * @notice Checks if a conduit key is valid.
+ * @param conduitKey The conduit key to check.
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function isValidConduit(
+ bytes32 conduitKey,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ (, errorsAndWarnings) = getApprovalAddress(conduitKey, seaportAddress);
+ }
+
+ /**
+ * @notice Checks if the zone of an order is set and implements the EIP165
+ * zone interface
+ * @dev To validate the zone call for an order, see validateOrderWithZone
+ * @param orderParameters The order parameters to check.
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function isValidZone(
+ OrderParameters memory orderParameters
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // If not restricted, zone isn't checked
+ if (
+ uint8(orderParameters.orderType) < 2 ||
+ uint8(orderParameters.orderType) == 4
+ ) {
+ return errorsAndWarnings;
+ }
+
+ if (orderParameters.zone == address(0)) {
+ // Zone is not set
+ errorsAndWarnings.addError(ZoneIssue.NotSet.parseInt());
+ return errorsAndWarnings;
+ }
+
+ // Warn if zone is an EOA
+ if (address(orderParameters.zone).code.length == 0) {
+ errorsAndWarnings.addWarning(ZoneIssue.EOAZone.parseInt());
+ return errorsAndWarnings;
+ }
+
+ // Check the EIP165 zone interface
+ if (!checkInterface(orderParameters.zone, ZONE_INTERFACE_ID)) {
+ errorsAndWarnings.addWarning(ZoneIssue.InvalidZone.parseInt());
+ return errorsAndWarnings;
+ }
+
+ // Check if the zone implements SIP-5
+ try ZoneInterface(orderParameters.zone).getSeaportMetadata() {} catch {
+ errorsAndWarnings.addWarning(ZoneIssue.InvalidZone.parseInt());
+ }
+ }
+
+ /**
+ * @notice Gets the approval address for the given conduit key
+ * @param conduitKey Conduit key to get approval address for
+ * @param seaportAddress The Seaport address
+ * @return approvalAddress The address to use for approvals
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function getApprovalAddress(
+ bytes32 conduitKey,
+ address seaportAddress
+ )
+ public
+ view
+ returns (address, ErrorsAndWarnings memory errorsAndWarnings)
+ {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Zero conduit key corresponds to seaport
+ if (conduitKey == 0) return (seaportAddress, errorsAndWarnings);
+
+ // Pull conduit info from conduitController
+ (address conduitAddress, bool exists) = _conduitController.getConduit(
+ conduitKey
+ );
+
+ // Conduit does not exist
+ if (!exists) {
+ errorsAndWarnings.addError(ConduitIssue.KeyInvalid.parseInt());
+ conduitAddress = address(0); // Don't return invalid conduit
+ }
+
+ // Approval address does not have Seaport added as a channel
+ if (
+ exists &&
+ !_conduitController.getChannelStatus(conduitAddress, seaportAddress)
+ ) {
+ errorsAndWarnings.addError(
+ ConduitIssue.MissingSeaportChannel.parseInt()
+ );
+ }
+
+ return (conduitAddress, errorsAndWarnings);
+ }
+
+ /**
+ * @notice Validates the signature for the order using the offerer's current counter
+ * @dev Will also check if order is validated on chain.
+ */
+ function validateSignature(
+ Order memory order,
+ address seaportAddress
+ ) public returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ // Pull current counter from seaport
+ uint256 currentCounter = ConsiderationInterface(seaportAddress)
+ .getCounter(order.parameters.offerer);
+
+ return
+ validateSignatureWithCounter(order, currentCounter, seaportAddress);
+ }
+
+ /**
+ * @notice Validates the signature for the order using the given counter
+ * @dev Will also check if order is validated on chain.
+ */
+ function validateSignatureWithCounter(
+ Order memory order,
+ uint256 counter,
+ address seaportAddress
+ ) public returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Typecast Seaport address to ConsiderationInterface
+ ConsiderationInterface seaport = ConsiderationInterface(seaportAddress);
+
+ // Contract orders do not have signatures
+ if (uint8(order.parameters.orderType) == 4) {
+ errorsAndWarnings.addWarning(
+ SignatureIssue.ContractOrder.parseInt()
+ );
+ }
+
+ // Get current counter for context
+ uint256 currentCounter = seaport.getCounter(order.parameters.offerer);
+
+ if (currentCounter > counter) {
+ // Counter strictly increases
+ errorsAndWarnings.addError(SignatureIssue.LowCounter.parseInt());
+ return errorsAndWarnings;
+ } else if (currentCounter < counter) {
+ // Counter is incremented by random large number
+ errorsAndWarnings.addError(SignatureIssue.HighCounter.parseInt());
+ return errorsAndWarnings;
+ }
+
+ bytes32 orderHash = _deriveOrderHash(order.parameters, counter);
+
+ // Check if order is validated on chain
+ (bool isValid, , , ) = seaport.getOrderStatus(orderHash);
+
+ if (isValid) {
+ // Shortcut success, valid on chain
+ return errorsAndWarnings;
+ }
+
+ // Create memory array to pass into validate
+ Order[] memory orderArray = new Order[](1);
+
+ // Store order in array
+ orderArray[0] = order;
+
+ try
+ // Call validate on Seaport
+ seaport.validate(orderArray)
+ returns (bool success) {
+ if (!success) {
+ // Call was unsuccessful, so signature is invalid
+ errorsAndWarnings.addError(SignatureIssue.Invalid.parseInt());
+ }
+ } catch {
+ if (
+ order.parameters.consideration.length !=
+ order.parameters.totalOriginalConsiderationItems
+ ) {
+ // May help diagnose signature issues
+ errorsAndWarnings.addWarning(
+ SignatureIssue.OriginalConsiderationItems.parseInt()
+ );
+ }
+ // Call reverted, so signature is invalid
+ errorsAndWarnings.addError(SignatureIssue.Invalid.parseInt());
+ }
+ }
+
+ /**
+ * @notice Check that a contract offerer implements the EIP165
+ * contract offerer interface
+ * @param contractOfferer The address of the contract offerer
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateContractOfferer(
+ address contractOfferer
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Check the EIP165 contract offerer interface
+ if (!checkInterface(contractOfferer, CONTRACT_OFFERER_INTERFACE_ID)) {
+ errorsAndWarnings.addWarning(
+ ContractOffererIssue.InvalidContractOfferer.parseInt()
+ );
+ }
+
+ // Check if the contract offerer implements SIP-5
+ try
+ ContractOffererInterface(contractOfferer).getSeaportMetadata()
+ {} catch {
+ errorsAndWarnings.addWarning(
+ ContractOffererIssue.InvalidContractOfferer.parseInt()
+ );
+ }
+
+ return errorsAndWarnings;
+ }
+
+ /**
+ * @notice Check the time validity of an order
+ * @param orderParameters The parameters for the order to validate
+ * @param shortOrderDuration The duration of which an order is considered short
+ * @param distantOrderExpiration Distant order expiration delta in seconds.
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateTime(
+ OrderParameters memory orderParameters,
+ uint256 shortOrderDuration,
+ uint256 distantOrderExpiration
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ if (orderParameters.endTime <= orderParameters.startTime) {
+ // Order duration is zero
+ errorsAndWarnings.addError(
+ TimeIssue.EndTimeBeforeStartTime.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ if (orderParameters.endTime < block.timestamp) {
+ // Order is expired
+ errorsAndWarnings.addError(TimeIssue.Expired.parseInt());
+ return errorsAndWarnings;
+ } else if (
+ orderParameters.endTime > block.timestamp + distantOrderExpiration
+ ) {
+ // Order expires in a long time
+ errorsAndWarnings.addWarning(
+ TimeIssue.DistantExpiration.parseInt()
+ );
+ }
+
+ if (orderParameters.startTime > block.timestamp) {
+ // Order is not active
+ errorsAndWarnings.addWarning(TimeIssue.NotActive.parseInt());
+ }
+
+ if (
+ orderParameters.endTime -
+ (
+ orderParameters.startTime > block.timestamp
+ ? orderParameters.startTime
+ : block.timestamp
+ ) <
+ shortOrderDuration
+ ) {
+ // Order has a short duration
+ errorsAndWarnings.addWarning(TimeIssue.ShortOrder.parseInt());
+ }
+ }
+
+ /**
+ * @notice Validate the status of an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateOrderStatus(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Typecast Seaport address to ConsiderationInterface
+ ConsiderationInterface seaport = ConsiderationInterface(seaportAddress);
+
+ // Cannot validate status of contract order
+ if (uint8(orderParameters.orderType) == 4) {
+ errorsAndWarnings.addWarning(StatusIssue.ContractOrder.parseInt());
+ }
+
+ // Pull current counter from seaport
+ uint256 currentOffererCounter = seaport.getCounter(
+ orderParameters.offerer
+ );
+ // Derive order hash using orderParameters and currentOffererCounter
+ bytes32 orderHash = _deriveOrderHash(
+ orderParameters,
+ currentOffererCounter
+ );
+ // Get order status from seaport
+ (, bool isCancelled, uint256 totalFilled, uint256 totalSize) = seaport
+ .getOrderStatus(orderHash);
+
+ if (isCancelled) {
+ // Order is cancelled
+ errorsAndWarnings.addError(StatusIssue.Cancelled.parseInt());
+ }
+
+ if (totalSize > 0 && totalFilled == totalSize) {
+ // Order is fully filled
+ errorsAndWarnings.addError(StatusIssue.FullyFilled.parseInt());
+ }
+ }
+
+ /**
+ * @notice Validate all offer items for an order. Ensures that
+ * offerer has sufficient balance and approval for each item.
+ * @dev Amounts are not summed and verified, just the individual amounts.
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateOfferItems(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Iterate over each offer item and validate it
+ for (uint256 i = 0; i < orderParameters.offer.length; i++) {
+ errorsAndWarnings.concat(
+ validateOfferItem(orderParameters, i, seaportAddress)
+ );
+
+ // Check for duplicate offer item
+ OfferItem memory offerItem1 = orderParameters.offer[i];
+
+ for (uint256 j = i + 1; j < orderParameters.offer.length; j++) {
+ // Iterate over each remaining offer item
+ // (previous items already check with this item)
+ OfferItem memory offerItem2 = orderParameters.offer[j];
+
+ // Check if token and id are the same
+ if (
+ offerItem1.token == offerItem2.token &&
+ offerItem1.identifierOrCriteria ==
+ offerItem2.identifierOrCriteria
+ ) {
+ errorsAndWarnings.addError(
+ OfferIssue.DuplicateItem.parseInt()
+ );
+ }
+ }
+ }
+
+ // You must have an offer item
+ if (orderParameters.offer.length == 0) {
+ errorsAndWarnings.addWarning(OfferIssue.ZeroItems.parseInt());
+ }
+
+ // Warning if there is more than one offer item
+ if (orderParameters.offer.length > 1) {
+ errorsAndWarnings.addWarning(OfferIssue.MoreThanOneItem.parseInt());
+ }
+ }
+
+ /**
+ * @notice Validates an offer item
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItem(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ // First validate the parameters (correct amount, contract, etc)
+ errorsAndWarnings = validateOfferItemParameters(
+ orderParameters,
+ offerItemIndex,
+ seaportAddress
+ );
+ if (errorsAndWarnings.hasErrors()) {
+ // Only validate approvals and balances if parameters are valid
+ return errorsAndWarnings;
+ }
+
+ // Validate approvals and balances for the offer item
+ errorsAndWarnings.concat(
+ validateOfferItemApprovalAndBalance(
+ orderParameters,
+ offerItemIndex,
+ seaportAddress
+ )
+ );
+ }
+
+ /**
+ * @notice Validates the OfferItem parameters. This includes token contract validation
+ * @dev OfferItems with criteria are currently not allowed
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItemParameters(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Get the offer item at offerItemIndex
+ OfferItem memory offerItem = orderParameters.offer[offerItemIndex];
+
+ // Check if start amount and end amount are zero
+ if (offerItem.startAmount == 0 && offerItem.endAmount == 0) {
+ errorsAndWarnings.addError(OfferIssue.AmountZero.parseInt());
+ return errorsAndWarnings;
+ }
+
+ // Check that amount velocity is not too high.
+ if (
+ offerItem.startAmount != offerItem.endAmount &&
+ orderParameters.endTime > orderParameters.startTime
+ ) {
+ // Assign larger and smaller amount values
+ (uint256 maxAmount, uint256 minAmount) = offerItem.startAmount >
+ offerItem.endAmount
+ ? (offerItem.startAmount, offerItem.endAmount)
+ : (offerItem.endAmount, offerItem.startAmount);
+
+ uint256 amountDelta = maxAmount - minAmount;
+ // delta of time that order exists for
+ uint256 timeDelta = orderParameters.endTime -
+ orderParameters.startTime;
+
+ // Velocity scaled by 1e10 for precision
+ uint256 velocity = (amountDelta * 1e10) / timeDelta;
+ // gives velocity percentage in hundredth of a basis points per second in terms of larger value
+ uint256 velocityPercentage = velocity / (maxAmount * 1e4);
+
+ // 278 * 60 * 30 ~= 500,000
+ if (velocityPercentage > 278) {
+ // Over 50% change per 30 min
+ errorsAndWarnings.addError(
+ OfferIssue.AmountVelocityHigh.parseInt()
+ );
+ }
+ // Over 50% change per 30 min
+ else if (velocityPercentage > 28) {
+ // Over 5% change per 30 min
+ errorsAndWarnings.addWarning(
+ OfferIssue.AmountVelocityHigh.parseInt()
+ );
+ }
+
+ // Check for large amount steps
+ if (minAmount <= 1e15) {
+ errorsAndWarnings.addWarning(
+ OfferIssue.AmountStepLarge.parseInt()
+ );
+ }
+ }
+
+ if (offerItem.itemType == ItemType.ERC721) {
+ // ERC721 type requires amounts to be 1
+ if (offerItem.startAmount != 1 || offerItem.endAmount != 1) {
+ errorsAndWarnings.addError(ERC721Issue.AmountNotOne.parseInt());
+ }
+
+ // Check the EIP165 token interface
+ if (!checkInterface(offerItem.token, ERC721_INTERFACE_ID)) {
+ errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt());
+ }
+ } else if (offerItem.itemType == ItemType.ERC721_WITH_CRITERIA) {
+ // Check the EIP165 token interface
+ if (!checkInterface(offerItem.token, ERC721_INTERFACE_ID)) {
+ errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt());
+ }
+
+ if (offerItem.startAmount > 1 || offerItem.endAmount > 1) {
+ // Require partial fill enabled. Even orderTypes are full
+ if (uint8(orderParameters.orderType) % 2 == 0) {
+ errorsAndWarnings.addError(
+ ERC721Issue.CriteriaNotPartialFill.parseInt()
+ );
+ }
+ }
+ } else if (
+ offerItem.itemType == ItemType.ERC1155 ||
+ offerItem.itemType == ItemType.ERC1155_WITH_CRITERIA
+ ) {
+ // Check the EIP165 token interface
+ if (!checkInterface(offerItem.token, ERC1155_INTERFACE_ID)) {
+ errorsAndWarnings.addError(
+ ERC1155Issue.InvalidToken.parseInt()
+ );
+ }
+ } else if (offerItem.itemType == ItemType.ERC20) {
+ // ERC20 must have `identifierOrCriteria` be zero
+ if (offerItem.identifierOrCriteria != 0) {
+ errorsAndWarnings.addError(
+ ERC20Issue.IdentifierNonZero.parseInt()
+ );
+ }
+
+ // Validate contract, should return an uint256 if its an ERC20
+ if (
+ !offerItem.token.safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC20Interface.allowance.selector,
+ seaportAddress,
+ seaportAddress
+ ),
+ 0
+ )
+ ) {
+ errorsAndWarnings.addError(ERC20Issue.InvalidToken.parseInt());
+ }
+ } else {
+ // Must be native
+ // NATIVE must have `token` be zero address
+ if (offerItem.token != address(0)) {
+ errorsAndWarnings.addError(NativeIssue.TokenAddress.parseInt());
+ }
+
+ // NATIVE must have `identifierOrCriteria` be zero
+ if (offerItem.identifierOrCriteria != 0) {
+ errorsAndWarnings.addError(
+ NativeIssue.IdentifierNonZero.parseInt()
+ );
+ }
+ }
+ }
+
+ /**
+ * @notice Validates the OfferItem approvals and balances
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItemApprovalAndBalance(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ // Note: If multiple items are of the same token, token amounts are not summed for validation
+
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Get the approval address for the given conduit key
+ (
+ address approvalAddress,
+ ErrorsAndWarnings memory ew
+ ) = getApprovalAddress(orderParameters.conduitKey, seaportAddress);
+ errorsAndWarnings.concat(ew);
+
+ if (ew.hasErrors()) {
+ // Approval address is invalid
+ return errorsAndWarnings;
+ }
+
+ // Get the offer item at offerItemIndex
+ OfferItem memory offerItem = orderParameters.offer[offerItemIndex];
+
+ if (offerItem.itemType == ItemType.ERC721) {
+ ERC721Interface token = ERC721Interface(offerItem.token);
+
+ // Check that offerer owns token
+ if (
+ !address(token).safeStaticCallAddress(
+ abi.encodeWithSelector(
+ ERC721Interface.ownerOf.selector,
+ offerItem.identifierOrCriteria
+ ),
+ orderParameters.offerer
+ )
+ ) {
+ errorsAndWarnings.addError(ERC721Issue.NotOwner.parseInt());
+ }
+
+ // Check for approval via `getApproved`
+ if (
+ !address(token).safeStaticCallAddress(
+ abi.encodeWithSelector(
+ ERC721Interface.getApproved.selector,
+ offerItem.identifierOrCriteria
+ ),
+ approvalAddress
+ )
+ ) {
+ // Fallback to `isApprovalForAll`
+ if (
+ !address(token).safeStaticCallBool(
+ abi.encodeWithSelector(
+ ERC721Interface.isApprovedForAll.selector,
+ orderParameters.offerer,
+ approvalAddress
+ ),
+ true
+ )
+ ) {
+ // Not approved
+ errorsAndWarnings.addError(
+ ERC721Issue.NotApproved.parseInt()
+ );
+ }
+ }
+ } else if (offerItem.itemType == ItemType.ERC721_WITH_CRITERIA) {
+ ERC721Interface token = ERC721Interface(offerItem.token);
+
+ // Check for approval
+ if (
+ !address(token).safeStaticCallBool(
+ abi.encodeWithSelector(
+ ERC721Interface.isApprovedForAll.selector,
+ orderParameters.offerer,
+ approvalAddress
+ ),
+ true
+ )
+ ) {
+ // Not approved
+ errorsAndWarnings.addError(ERC721Issue.NotApproved.parseInt());
+ }
+ } else if (offerItem.itemType == ItemType.ERC1155) {
+ ERC1155Interface token = ERC1155Interface(offerItem.token);
+
+ // Check for approval
+ if (
+ !address(token).safeStaticCallBool(
+ abi.encodeWithSelector(
+ ERC1155Interface.isApprovedForAll.selector,
+ orderParameters.offerer,
+ approvalAddress
+ ),
+ true
+ )
+ ) {
+ errorsAndWarnings.addError(ERC1155Issue.NotApproved.parseInt());
+ }
+
+ // Get min required balance (max(startAmount, endAmount))
+ uint256 minBalance = offerItem.startAmount < offerItem.endAmount
+ ? offerItem.startAmount
+ : offerItem.endAmount;
+
+ // Check for sufficient balance
+ if (
+ !address(token).safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC1155Interface.balanceOf.selector,
+ orderParameters.offerer,
+ offerItem.identifierOrCriteria
+ ),
+ minBalance
+ )
+ ) {
+ // Insufficient balance
+ errorsAndWarnings.addError(
+ ERC1155Issue.InsufficientBalance.parseInt()
+ );
+ }
+ } else if (offerItem.itemType == ItemType.ERC1155_WITH_CRITERIA) {
+ ERC1155Interface token = ERC1155Interface(offerItem.token);
+
+ // Check for approval
+ if (
+ !address(token).safeStaticCallBool(
+ abi.encodeWithSelector(
+ ERC1155Interface.isApprovedForAll.selector,
+ orderParameters.offerer,
+ approvalAddress
+ ),
+ true
+ )
+ ) {
+ errorsAndWarnings.addError(ERC1155Issue.NotApproved.parseInt());
+ }
+ } else if (offerItem.itemType == ItemType.ERC20) {
+ ERC20Interface token = ERC20Interface(offerItem.token);
+
+ // Get min required balance and approval (max(startAmount, endAmount))
+ uint256 minBalanceAndAllowance = offerItem.startAmount <
+ offerItem.endAmount
+ ? offerItem.startAmount
+ : offerItem.endAmount;
+
+ // Check allowance
+ if (
+ !address(token).safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC20Interface.allowance.selector,
+ orderParameters.offerer,
+ approvalAddress
+ ),
+ minBalanceAndAllowance
+ )
+ ) {
+ errorsAndWarnings.addError(
+ ERC20Issue.InsufficientAllowance.parseInt()
+ );
+ }
+
+ // Check balance
+ if (
+ !address(token).safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC20Interface.balanceOf.selector,
+ orderParameters.offerer
+ ),
+ minBalanceAndAllowance
+ )
+ ) {
+ errorsAndWarnings.addError(
+ ERC20Issue.InsufficientBalance.parseInt()
+ );
+ }
+ } else {
+ // Must be native
+ // Get min required balance (max(startAmount, endAmount))
+ uint256 minBalance = offerItem.startAmount < offerItem.endAmount
+ ? offerItem.startAmount
+ : offerItem.endAmount;
+
+ // Check for sufficient balance
+ if (orderParameters.offerer.balance < minBalance) {
+ errorsAndWarnings.addError(
+ NativeIssue.InsufficientBalance.parseInt()
+ );
+ }
+
+ // Native items can not be pulled so warn
+ errorsAndWarnings.addWarning(OfferIssue.NativeItem.parseInt());
+ }
+ }
+
+ /**
+ * @notice Validate all consideration items for an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItems(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ _helper.validateConsiderationItems(orderParameters, seaportAddress);
+ }
+
+ /**
+ * @notice Validate a consideration item
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItem(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ _helper.validateConsiderationItem(
+ orderParameters,
+ considerationItemIndex,
+ seaportAddress
+ );
+ }
+
+ /**
+ * @notice Validates the parameters of a consideration item including contract validation
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItemParameters(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ return
+ _helper.validateConsiderationItemParameters(
+ orderParameters,
+ considerationItemIndex,
+ seaportAddress
+ );
+ }
+
+ /**
+ * @notice Validates the zone call for an order
+ * @param orderParameters The order parameters for the order to validate
+ * @param zoneParameters The zone parameters for the order to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOrderWithZone(
+ OrderParameters memory orderParameters,
+ ZoneParameters memory zoneParameters
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Call isValidZone to check if zone is set and implements EIP165
+ errorsAndWarnings.concat(isValidZone(orderParameters));
+
+ // Call zone function `validateOrder` with the supplied ZoneParameters
+ if (
+ !orderParameters.zone.safeStaticCallBytes4(
+ abi.encodeWithSelector(
+ ZoneInterface.validateOrder.selector,
+ zoneParameters
+ ),
+ ZoneInterface.validateOrder.selector
+ )
+ ) {
+ // Call to validateOrder reverted or returned invalid magic value
+ errorsAndWarnings.addWarning(ZoneIssue.RejectedOrder.parseInt());
+ }
+ }
+
+ /**
+ * @notice Safely check that a contract implements an interface
+ * @param token The token address to check
+ * @param interfaceHash The interface hash to check
+ */
+ function checkInterface(
+ address token,
+ bytes4 interfaceHash
+ ) public view returns (bool) {
+ return
+ token.safeStaticCallBool(
+ abi.encodeWithSelector(
+ IERC165.supportsInterface.selector,
+ interfaceHash
+ ),
+ true
+ );
+ }
+
+ function isPaymentToken(ItemType itemType) public pure returns (bool) {
+ return itemType == ItemType.NATIVE || itemType == ItemType.ERC20;
+ }
+
+ /*//////////////////////////////////////////////////////////////
+ Merkle Helpers
+ //////////////////////////////////////////////////////////////*/
+
+ /**
+ * @notice Sorts an array of token ids by the keccak256 hash of the id. Required ordering of ids
+ * for other merkle operations.
+ * @param includedTokens An array of included token ids.
+ * @return sortedTokens The sorted `includedTokens` array.
+ */
+ function sortMerkleTokens(
+ uint256[] memory includedTokens
+ ) public view returns (uint256[] memory sortedTokens) {
+ // Sort token ids by the keccak256 hash of the id
+ return _helper.sortMerkleTokens(includedTokens);
+ }
+
+ /**
+ * @notice Creates a merkle root for includedTokens.
+ * @dev `includedTokens` must be sorting in strictly ascending order according to the keccak256 hash of the value.
+ * @return merkleRoot The merkle root
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleRoot(
+ uint256[] memory includedTokens
+ )
+ public
+ view
+ returns (bytes32 merkleRoot, ErrorsAndWarnings memory errorsAndWarnings)
+ {
+ return _helper.getMerkleRoot(includedTokens);
+ }
+
+ /**
+ * @notice Creates a merkle proof for the the targetIndex contained in includedTokens.
+ * @dev `targetIndex` is referring to the index of an element in `includedTokens`.
+ * `includedTokens` must be sorting in ascending order according to the keccak256 hash of the value.
+ * @return merkleProof The merkle proof
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleProof(
+ uint256[] memory includedTokens,
+ uint256 targetIndex
+ )
+ public
+ view
+ returns (
+ bytes32[] memory merkleProof,
+ ErrorsAndWarnings memory errorsAndWarnings
+ )
+ {
+ return _helper.getMerkleProof(includedTokens, targetIndex);
+ }
+
+ /**
+ * @notice Verifies a merkle proof for the value to prove and given root and proof.
+ * @dev The `valueToProve` is hashed prior to executing the proof verification.
+ * @param merkleRoot The root of the merkle tree
+ * @param merkleProof The merkle proof
+ * @param valueToProve The value to prove
+ * @return whether proof is valid
+ */
+ function verifyMerkleProof(
+ bytes32 merkleRoot,
+ bytes32[] memory merkleProof,
+ uint256 valueToProve
+ ) public view returns (bool) {
+ return _helper.verifyMerkleProof(merkleRoot, merkleProof, valueToProve);
+ }
+}
diff --git a/contracts/helpers/order-validator/lib/ConsiderationTypeHashes.sol b/contracts/helpers/order-validator/lib/ConsiderationTypeHashes.sol
new file mode 100644
index 000000000..3b987d018
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/ConsiderationTypeHashes.sol
@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import "../../../lib/ConsiderationStructs.sol";
+
+uint256 constant EIP712_Order_size = 0x180;
+uint256 constant EIP712_OfferItem_size = 0xc0;
+uint256 constant EIP712_ConsiderationItem_size = 0xe0;
+uint256 constant EIP712_DomainSeparator_offset = 0x02;
+uint256 constant EIP712_OrderHash_offset = 0x22;
+uint256 constant EIP712_DigestPayload_size = 0x42;
+uint256 constant EIP_712_PREFIX = (
+ 0x1901000000000000000000000000000000000000000000000000000000000000
+);
+
+contract ConsiderationTypeHashes {
+ bytes32 internal immutable _NAME_HASH;
+ bytes32 internal immutable _VERSION_HASH;
+ bytes32 internal immutable _EIP_712_DOMAIN_TYPEHASH;
+ bytes32 internal immutable _OFFER_ITEM_TYPEHASH;
+ bytes32 internal immutable _CONSIDERATION_ITEM_TYPEHASH;
+ bytes32 internal immutable _ORDER_TYPEHASH;
+ bytes32 internal immutable _DOMAIN_SEPARATOR;
+ address internal constant seaportAddress =
+ address(0x00000000000006c7676171937C444f6BDe3D6282);
+
+ constructor() {
+ // Derive hash of the name of the contract.
+ _NAME_HASH = keccak256(bytes("Seaport"));
+
+ // Derive hash of the version string of the contract.
+ _VERSION_HASH = keccak256(bytes("1.2"));
+
+ bytes memory offerItemTypeString = abi.encodePacked(
+ "OfferItem(",
+ "uint8 itemType,",
+ "address token,",
+ "uint256 identifierOrCriteria,",
+ "uint256 startAmount,",
+ "uint256 endAmount",
+ ")"
+ );
+
+ // Construct the ConsiderationItem type string.
+ // prettier-ignore
+ bytes memory considerationItemTypeString = abi.encodePacked(
+ "ConsiderationItem(",
+ "uint8 itemType,",
+ "address token,",
+ "uint256 identifierOrCriteria,",
+ "uint256 startAmount,",
+ "uint256 endAmount,",
+ "address recipient",
+ ")"
+ );
+
+ // Construct the OrderComponents type string, not including the above.
+ // prettier-ignore
+ bytes memory orderComponentsPartialTypeString = abi.encodePacked(
+ "OrderComponents(",
+ "address offerer,",
+ "address zone,",
+ "OfferItem[] offer,",
+ "ConsiderationItem[] consideration,",
+ "uint8 orderType,",
+ "uint256 startTime,",
+ "uint256 endTime,",
+ "bytes32 zoneHash,",
+ "uint256 salt,",
+ "bytes32 conduitKey,",
+ "uint256 counter",
+ ")"
+ );
+ // Derive the OfferItem type hash using the corresponding type string.
+ bytes32 offerItemTypehash = keccak256(offerItemTypeString);
+
+ // Derive ConsiderationItem type hash using corresponding type string.
+ bytes32 considerationItemTypehash = keccak256(
+ considerationItemTypeString
+ );
+
+ // Construct the primary EIP-712 domain type string.
+ // prettier-ignore
+ _EIP_712_DOMAIN_TYPEHASH = keccak256(
+ abi.encodePacked(
+ "EIP712Domain(",
+ "string name,",
+ "string version,",
+ "uint256 chainId,",
+ "address verifyingContract",
+ ")"
+ )
+ );
+
+ _OFFER_ITEM_TYPEHASH = offerItemTypehash;
+ _CONSIDERATION_ITEM_TYPEHASH = considerationItemTypehash;
+
+ // Derive OrderItem type hash via combination of relevant type strings.
+ _ORDER_TYPEHASH = keccak256(
+ abi.encodePacked(
+ orderComponentsPartialTypeString,
+ considerationItemTypeString,
+ offerItemTypeString
+ )
+ );
+
+ _DOMAIN_SEPARATOR = _deriveDomainSeparator();
+ }
+
+ /**
+ * @dev Internal view function to derive the EIP-712 domain separator.
+ *
+ * @return The derived domain separator.
+ */
+ function _deriveDomainSeparator() internal view returns (bytes32) {
+ // prettier-ignore
+ return keccak256(
+ abi.encode(
+ _EIP_712_DOMAIN_TYPEHASH,
+ _NAME_HASH,
+ _VERSION_HASH,
+ block.chainid,
+ seaportAddress
+ )
+ );
+ }
+
+ /**
+ * @dev Internal pure function to efficiently derive an digest to sign for
+ * an order in accordance with EIP-712.
+ *
+ * @param orderHash The order hash.
+ *
+ * @return value The hash.
+ */
+ function _deriveEIP712Digest(
+ bytes32 orderHash
+ ) internal view returns (bytes32 value) {
+ bytes32 domainSeparator = _DOMAIN_SEPARATOR;
+ // Leverage scratch space to perform an efficient hash.
+ assembly {
+ // Place the EIP-712 prefix at the start of scratch space.
+ mstore(0, EIP_712_PREFIX)
+
+ // Place the domain separator in the next region of scratch space.
+ mstore(EIP712_DomainSeparator_offset, domainSeparator)
+
+ // Place the order hash in scratch space, spilling into the first
+ // two bytes of the free memory pointer — this should never be set
+ // as memory cannot be expanded to that size, and will be zeroed out
+ // after the hash is performed.
+ mstore(EIP712_OrderHash_offset, orderHash)
+
+ // Hash the relevant region (65 bytes).
+ value := keccak256(0, EIP712_DigestPayload_size)
+
+ // Clear out the dirtied bits in the memory pointer.
+ mstore(EIP712_OrderHash_offset, 0)
+ }
+ }
+
+ /**
+ * @dev Internal view function to derive the EIP-712 hash for an offer item.
+ *
+ * @param offerItem The offered item to hash.
+ *
+ * @return The hash.
+ */
+ function _hashOfferItem(
+ OfferItem memory offerItem
+ ) internal view returns (bytes32) {
+ return
+ keccak256(
+ abi.encode(
+ _OFFER_ITEM_TYPEHASH,
+ offerItem.itemType,
+ offerItem.token,
+ offerItem.identifierOrCriteria,
+ offerItem.startAmount,
+ offerItem.endAmount
+ )
+ );
+ }
+
+ /**
+ * @dev Internal view function to derive the EIP-712 hash for a consideration item.
+ *
+ * @param considerationItem The consideration item to hash.
+ *
+ * @return The hash.
+ */
+ function _hashConsiderationItem(
+ ConsiderationItem memory considerationItem
+ ) internal view returns (bytes32) {
+ return
+ keccak256(
+ abi.encode(
+ _CONSIDERATION_ITEM_TYPEHASH,
+ considerationItem.itemType,
+ considerationItem.token,
+ considerationItem.identifierOrCriteria,
+ considerationItem.startAmount,
+ considerationItem.endAmount,
+ considerationItem.recipient
+ )
+ );
+ }
+
+ /**
+ * @dev Internal view function to derive the order hash for a given order.
+ * Note that only the original consideration items are included in the
+ * order hash, as additional consideration items may be supplied by the
+ * caller.
+ *
+ * @param orderParameters The parameters of the order to hash.
+ * @param counter The counter of the order to hash.
+ *
+ * @return orderHash The hash.
+ */
+ function _deriveOrderHash(
+ OrderParameters memory orderParameters,
+ uint256 counter
+ ) internal view returns (bytes32 orderHash) {
+ // Designate new memory regions for offer and consideration item hashes.
+ bytes32[] memory offerHashes = new bytes32[](
+ orderParameters.offer.length
+ );
+ bytes32[] memory considerationHashes = new bytes32[](
+ orderParameters.totalOriginalConsiderationItems
+ );
+
+ // Iterate over each offer on the order.
+ for (uint256 i = 0; i < orderParameters.offer.length; ++i) {
+ // Hash the offer and place the result into memory.
+ offerHashes[i] = _hashOfferItem(orderParameters.offer[i]);
+ }
+
+ // Iterate over each consideration on the order.
+ for (
+ uint256 i = 0;
+ i < orderParameters.totalOriginalConsiderationItems;
+ ++i
+ ) {
+ // Hash the consideration and place the result into memory.
+ considerationHashes[i] = _hashConsiderationItem(
+ orderParameters.consideration[i]
+ );
+ }
+
+ // Derive and return the order hash as specified by EIP-712.
+
+ return
+ keccak256(
+ abi.encode(
+ _ORDER_TYPEHASH,
+ orderParameters.offerer,
+ orderParameters.zone,
+ keccak256(abi.encodePacked(offerHashes)),
+ keccak256(abi.encodePacked(considerationHashes)),
+ orderParameters.orderType,
+ orderParameters.startTime,
+ orderParameters.endTime,
+ orderParameters.zoneHash,
+ orderParameters.salt,
+ orderParameters.conduitKey,
+ counter
+ )
+ );
+ }
+}
diff --git a/contracts/helpers/order-validator/lib/ErrorsAndWarnings.sol b/contracts/helpers/order-validator/lib/ErrorsAndWarnings.sol
new file mode 100644
index 000000000..e9934f446
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/ErrorsAndWarnings.sol
@@ -0,0 +1,284 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {
+ ConduitIssue,
+ ConsiderationIssue,
+ ERC20Issue,
+ ERC721Issue,
+ ERC1155Issue,
+ GenericIssue,
+ OfferIssue,
+ SignatureIssue,
+ StatusIssue,
+ TimeIssue,
+ NativeIssue,
+ IssueParser
+} from "./SeaportValidatorTypes.sol";
+
+struct ErrorsAndWarnings {
+ uint16[] errors;
+ uint16[] warnings;
+}
+
+library ErrorsAndWarningsLib {
+ using IssueParser for ConduitIssue;
+ using IssueParser for ConsiderationIssue;
+ using IssueParser for ERC20Issue;
+ using IssueParser for ERC721Issue;
+ using IssueParser for ERC1155Issue;
+ using IssueParser for GenericIssue;
+ using IssueParser for OfferIssue;
+ using IssueParser for SignatureIssue;
+ using IssueParser for StatusIssue;
+ using IssueParser for TimeIssue;
+ using IssueParser for NativeIssue;
+
+ function concat(
+ ErrorsAndWarnings memory ew1,
+ ErrorsAndWarnings memory ew2
+ ) internal pure {
+ ew1.errors = concatMemory(ew1.errors, ew2.errors);
+ ew1.warnings = concatMemory(ew1.warnings, ew2.warnings);
+ }
+
+ function empty() internal pure returns (ErrorsAndWarnings memory) {
+ return ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+ }
+
+ function addError(
+ uint16 err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ ErrorsAndWarnings memory ew = ErrorsAndWarnings(
+ new uint16[](0),
+ new uint16[](0)
+ );
+ ew.errors = pushMemory(ew.errors, err);
+ return ew;
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ uint16 err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ ew.errors = pushMemory(ew.errors, err);
+ return ew;
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ GenericIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ ERC20Issue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ ERC721Issue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ ERC1155Issue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ ConsiderationIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ OfferIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ SignatureIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ TimeIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ ConduitIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addError(
+ ErrorsAndWarnings memory ew,
+ StatusIssue err
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addError(ew, err.parseInt());
+ }
+
+ function addWarning(
+ uint16 warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ ErrorsAndWarnings memory ew = ErrorsAndWarnings(
+ new uint16[](0),
+ new uint16[](0)
+ );
+ ew.warnings = pushMemory(ew.warnings, warn);
+ return ew;
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ uint16 warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ ew.warnings = pushMemory(ew.warnings, warn);
+ return ew;
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ GenericIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ ERC20Issue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ ERC721Issue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ ERC1155Issue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ OfferIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ ConsiderationIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ SignatureIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ TimeIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ ConduitIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ StatusIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function addWarning(
+ ErrorsAndWarnings memory ew,
+ NativeIssue warn
+ ) internal pure returns (ErrorsAndWarnings memory) {
+ return addWarning(ew, warn.parseInt());
+ }
+
+ function hasErrors(
+ ErrorsAndWarnings memory ew
+ ) internal pure returns (bool) {
+ return ew.errors.length != 0;
+ }
+
+ function hasWarnings(
+ ErrorsAndWarnings memory ew
+ ) internal pure returns (bool) {
+ return ew.warnings.length != 0;
+ }
+
+ // Helper Functions
+ function concatMemory(
+ uint16[] memory array1,
+ uint16[] memory array2
+ ) private pure returns (uint16[] memory) {
+ if (array1.length == 0) {
+ return array2;
+ } else if (array2.length == 0) {
+ return array1;
+ }
+
+ uint16[] memory returnValue = new uint16[](
+ array1.length + array2.length
+ );
+
+ for (uint256 i = 0; i < array1.length; i++) {
+ returnValue[i] = array1[i];
+ }
+ for (uint256 i = 0; i < array2.length; i++) {
+ returnValue[i + array1.length] = array2[i];
+ }
+
+ return returnValue;
+ }
+
+ function pushMemory(
+ uint16[] memory uint16Array,
+ uint16 newValue
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory returnValue = new uint16[](uint16Array.length + 1);
+
+ for (uint256 i = 0; i < uint16Array.length; i++) {
+ returnValue[i] = uint16Array[i];
+ }
+ returnValue[uint16Array.length] = newValue;
+
+ return returnValue;
+ }
+}
diff --git a/contracts/helpers/order-validator/lib/Murky.sol b/contracts/helpers/order-validator/lib/Murky.sol
new file mode 100644
index 000000000..d49675a3c
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/Murky.sol
@@ -0,0 +1,400 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {
+ ErrorsAndWarnings,
+ ErrorsAndWarningsLib
+} from "./ErrorsAndWarnings.sol";
+
+import { IssueParser, MerkleIssue } from "./SeaportValidatorTypes.sol";
+
+contract Murky {
+ using ErrorsAndWarningsLib for ErrorsAndWarnings;
+ using IssueParser for MerkleIssue;
+
+ bool internal constant HASH_ODD_WITH_ZERO = false;
+
+ function _verifyProof(
+ bytes32 root,
+ bytes32[] memory proof,
+ bytes32 valueToProve
+ ) internal pure returns (bool) {
+ // proof length must be less than max array size
+ bytes32 rollingHash = valueToProve;
+ uint256 length = proof.length;
+ unchecked {
+ for (uint256 i = 0; i < length; ++i) {
+ rollingHash = _hashLeafPairs(rollingHash, proof[i]);
+ }
+ }
+ return root == rollingHash;
+ }
+
+ /********************
+ * HASHING FUNCTION *
+ ********************/
+
+ /// ascending sort and concat prior to hashing
+ function _hashLeafPairs(bytes32 left, bytes32 right)
+ internal
+ pure
+ returns (bytes32 _hash)
+ {
+ assembly {
+ switch lt(left, right)
+ case 0 {
+ mstore(0x0, right)
+ mstore(0x20, left)
+ }
+ default {
+ mstore(0x0, left)
+ mstore(0x20, right)
+ }
+ _hash := keccak256(0x0, 0x40)
+ }
+ }
+
+ /********************
+ * PROOF GENERATION *
+ ********************/
+
+ function _getRoot(uint256[] memory data)
+ internal
+ pure
+ returns (bytes32 result, ErrorsAndWarnings memory errorsAndWarnings)
+ {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ if (data.length < 2) {
+ errorsAndWarnings.addError(MerkleIssue.SingleLeaf.parseInt());
+ return (0, errorsAndWarnings);
+ }
+
+ bool hashOddWithZero = HASH_ODD_WITH_ZERO;
+
+ if (!_processInput(data)) {
+ errorsAndWarnings.addError(MerkleIssue.Unsorted.parseInt());
+ return (0, errorsAndWarnings);
+ }
+
+ assembly {
+ function hashLeafPairs(left, right) -> _hash {
+ switch lt(left, right)
+ case 0 {
+ mstore(0x0, right)
+ mstore(0x20, left)
+ }
+ default {
+ mstore(0x0, left)
+ mstore(0x20, right)
+ }
+ _hash := keccak256(0x0, 0x40)
+ }
+ function hashLevel(_data, length, _hashOddWithZero) -> newLength {
+ // we will be modifying data in-place, so set result pointer to data pointer
+ let _result := _data
+ // get length of original data array
+ // let length := mload(_data)
+ // bool to track if we need to hash the last element of an odd-length array with zero
+ let oddLength
+
+ // if length is odd, we need to hash the last element with zero
+ switch and(length, 1)
+ case 1 {
+ // if length is odd, add 1 so division by 2 will round up
+ newLength := add(1, div(length, 2))
+ oddLength := 1
+ }
+ default {
+ newLength := div(length, 2)
+ }
+ // todo: necessary?
+ // mstore(_data, newLength)
+ let resultIndexPointer := add(0x20, _data)
+ let dataIndexPointer := resultIndexPointer
+
+ // stop iterating over for loop at length-1
+ let stopIteration := add(_data, mul(length, 0x20))
+ // write result array in-place over data array
+ for {
+
+ } lt(dataIndexPointer, stopIteration) {
+
+ } {
+ // get next two elements from data, hash them together
+ let data1 := mload(dataIndexPointer)
+ let data2 := mload(add(dataIndexPointer, 0x20))
+ let hashedPair := hashLeafPairs(data1, data2)
+ // overwrite an element of data array with
+ mstore(resultIndexPointer, hashedPair)
+ // increment result pointer by 1 slot
+ resultIndexPointer := add(0x20, resultIndexPointer)
+ // increment data pointer by 2 slot
+ dataIndexPointer := add(0x40, dataIndexPointer)
+ }
+ // we did not yet hash last index if odd-length
+ if oddLength {
+ let data1 := mload(dataIndexPointer)
+ let nextValue
+ switch _hashOddWithZero
+ case 0 {
+ nextValue := data1
+ }
+ default {
+ nextValue := hashLeafPairs(data1, 0)
+ }
+ mstore(resultIndexPointer, nextValue)
+ }
+ }
+
+ let dataLength := mload(data)
+ for {
+
+ } gt(dataLength, 1) {
+
+ } {
+ dataLength := hashLevel(data, dataLength, hashOddWithZero)
+ }
+ result := mload(add(0x20, data))
+ }
+ }
+
+ function _getProof(uint256[] memory data, uint256 node)
+ internal
+ pure
+ returns (
+ bytes32[] memory result,
+ ErrorsAndWarnings memory errorsAndWarnings
+ )
+ {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ if (data.length < 2) {
+ errorsAndWarnings.addError(MerkleIssue.SingleLeaf.parseInt());
+ return (new bytes32[](0), errorsAndWarnings);
+ }
+
+ bool hashOddWithZero = HASH_ODD_WITH_ZERO;
+
+ if (!_processInput(data)) {
+ errorsAndWarnings.addError(MerkleIssue.Unsorted.parseInt());
+ return (new bytes32[](0), errorsAndWarnings);
+ }
+
+ // The size of the proof is equal to the ceiling of log2(numLeaves)
+ // Two overflow risks: node, pos
+ // node: max array size is 2**256-1. Largest index in the array will be 1 less than that. Also,
+ // for dynamic arrays, size is limited to 2**64-1
+ // pos: pos is bounded by log2(data.length), which should be less than type(uint256).max
+ assembly {
+ function hashLeafPairs(left, right) -> _hash {
+ switch lt(left, right)
+ case 0 {
+ mstore(0x0, right)
+ mstore(0x20, left)
+ }
+ default {
+ mstore(0x0, left)
+ mstore(0x20, right)
+ }
+ _hash := keccak256(0x0, 0x40)
+ }
+ function hashLevel(_data, length, _hashOddWithZero) -> newLength {
+ // we will be modifying data in-place, so set result pointer to data pointer
+ let _result := _data
+ // get length of original data array
+ // let length := mload(_data)
+ // bool to track if we need to hash the last element of an odd-length array with zero
+ let oddLength
+
+ // if length is odd, we'll need to hash the last element with zero
+ switch and(length, 1)
+ case 1 {
+ // if length is odd, add 1 so division by 2 will round up
+ newLength := add(1, div(length, 2))
+ oddLength := 1
+ }
+ default {
+ newLength := div(length, 2)
+ }
+ // todo: necessary?
+ // mstore(_data, newLength)
+ let resultIndexPointer := add(0x20, _data)
+ let dataIndexPointer := resultIndexPointer
+
+ // stop iterating over for loop at length-1
+ let stopIteration := add(_data, mul(length, 0x20))
+ // write result array in-place over data array
+ for {
+
+ } lt(dataIndexPointer, stopIteration) {
+
+ } {
+ // get next two elements from data, hash them together
+ let data1 := mload(dataIndexPointer)
+ let data2 := mload(add(dataIndexPointer, 0x20))
+ let hashedPair := hashLeafPairs(data1, data2)
+ // overwrite an element of data array with
+ mstore(resultIndexPointer, hashedPair)
+ // increment result pointer by 1 slot
+ resultIndexPointer := add(0x20, resultIndexPointer)
+ // increment data pointer by 2 slot
+ dataIndexPointer := add(0x40, dataIndexPointer)
+ }
+ // we did not yet hash last index if odd-length
+ if oddLength {
+ let data1 := mload(dataIndexPointer)
+ let nextValue
+ switch _hashOddWithZero
+ case 0 {
+ nextValue := data1
+ }
+ default {
+ nextValue := hashLeafPairs(data1, 0)
+ }
+ mstore(resultIndexPointer, nextValue)
+ }
+ }
+
+ // set result pointer to free memory
+ result := mload(0x40)
+ // get pointer to first index of result
+ let resultIndexPtr := add(0x20, result)
+ // declare so we can use later
+ let newLength
+ // put length of data onto stack
+ let dataLength := mload(data)
+ for {
+ // repeat until only one element is left
+ } gt(dataLength, 1) {
+
+ } {
+ // bool if node is odd
+ let oddNodeIndex := and(node, 1)
+ // bool if node is last
+ let lastNodeIndex := eq(dataLength, add(1, node))
+ // store both bools in one value so we can switch on it
+ let switchVal := or(shl(1, lastNodeIndex), oddNodeIndex)
+ switch switchVal
+ // 00 - neither odd nor last
+ case 0 {
+ // store data[node+1] at result[i]
+ // get pointer to result[node+1] by adding 2 to node and multiplying by 0x20
+ // to account for the fact that result points to array length, not first index
+ mstore(
+ resultIndexPtr,
+ mload(add(data, mul(0x20, add(2, node))))
+ )
+ }
+ // 10 - node is last
+ case 2 {
+ // store 0 at result[i]
+ mstore(resultIndexPtr, 0)
+ }
+ // 01 or 11 - node is odd (and possibly also last)
+ default {
+ // store data[node-1] at result[i]
+ mstore(resultIndexPtr, mload(add(data, mul(0x20, node))))
+ }
+ // increment result index
+ resultIndexPtr := add(0x20, resultIndexPtr)
+
+ // get new node index
+ node := div(node, 2)
+ // keep track of how long result array is
+ newLength := add(1, newLength)
+ // compute the next hash level, overwriting data, and get the new length
+ dataLength := hashLevel(data, dataLength, hashOddWithZero)
+ }
+ // store length of result array at pointer
+ mstore(result, newLength)
+ // set free mem pointer to word after end of result array
+ mstore(0x40, resultIndexPtr)
+ }
+ }
+
+ /**
+ * Hashes each element of the input array in place using keccak256
+ */
+ function _processInput(uint256[] memory data)
+ private
+ pure
+ returns (bool sorted)
+ {
+ sorted = true;
+
+ // Hash inputs with keccak256
+ for (uint256 i = 0; i < data.length; ++i) {
+ assembly {
+ mstore(
+ add(data, mul(0x20, add(1, i))),
+ keccak256(add(data, mul(0x20, add(1, i))), 0x20)
+ )
+ // for every element after the first, hashed value must be greater than the last one
+ if and(
+ gt(i, 0),
+ iszero(
+ gt(
+ mload(add(data, mul(0x20, add(1, i)))),
+ mload(add(data, mul(0x20, add(1, sub(i, 1)))))
+ )
+ )
+ ) {
+ sorted := 0 // Elements not ordered by hash
+ }
+ }
+ }
+ }
+
+ // Sort uint256 in order of the keccak256 hashes
+ struct HashAndIntTuple {
+ uint256 num;
+ bytes32 hash;
+ }
+
+ function _sortUint256ByHash(uint256[] memory values)
+ internal
+ pure
+ returns (uint256[] memory sortedValues)
+ {
+ HashAndIntTuple[] memory toSort = new HashAndIntTuple[](values.length);
+ for (uint256 i = 0; i < values.length; i++) {
+ toSort[i] = HashAndIntTuple(
+ values[i],
+ keccak256(abi.encode(values[i]))
+ );
+ }
+
+ _quickSort(toSort, 0, int256(toSort.length - 1));
+
+ sortedValues = new uint256[](values.length);
+ for (uint256 i = 0; i < values.length; i++) {
+ sortedValues[i] = toSort[i].num;
+ }
+ }
+
+ function _quickSort(
+ HashAndIntTuple[] memory arr,
+ int256 left,
+ int256 right
+ ) internal pure {
+ int256 i = left;
+ int256 j = right;
+ if (i == j) return;
+ bytes32 pivot = arr[uint256(left + (right - left) / 2)].hash;
+ while (i <= j) {
+ while (arr[uint256(i)].hash < pivot) i++;
+ while (pivot < arr[uint256(j)].hash) j--;
+ if (i <= j) {
+ (arr[uint256(i)], arr[uint256(j)]) = (
+ arr[uint256(j)],
+ arr[uint256(i)]
+ );
+ i++;
+ j--;
+ }
+ }
+ if (left < j) _quickSort(arr, left, j);
+ if (i < right) _quickSort(arr, i, right);
+ }
+}
diff --git a/contracts/helpers/order-validator/lib/SafeStaticCall.sol b/contracts/helpers/order-validator/lib/SafeStaticCall.sol
new file mode 100644
index 000000000..1963e01ad
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/SafeStaticCall.sol
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+library SafeStaticCall {
+ function safeStaticCallBool(
+ address target,
+ bytes memory callData,
+ bool expectedReturn
+ ) internal view returns (bool) {
+ (bool success, bytes memory res) = target.staticcall(callData);
+ if (!success) return false;
+ if (res.length != 32) return false;
+
+ if (
+ bytes32(res) &
+ 0x0000000000000000000000000000000000000000000000000000000000000001 !=
+ bytes32(res)
+ ) {
+ return false;
+ }
+
+ return expectedReturn ? res[31] == 0x01 : res[31] == 0;
+ }
+
+ function safeStaticCallAddress(
+ address target,
+ bytes memory callData,
+ address expectedReturn
+ ) internal view returns (bool) {
+ (bool success, bytes memory res) = target.staticcall(callData);
+ if (!success) return false;
+ if (res.length != 32) return false;
+
+ if (
+ bytes32(res) &
+ 0x000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF !=
+ bytes32(res)
+ ) {
+ // Ensure only 20 bytes used
+ return false;
+ }
+
+ return abi.decode(res, (address)) == expectedReturn;
+ }
+
+ function safeStaticCallUint256(
+ address target,
+ bytes memory callData,
+ uint256 minExpectedReturn
+ ) internal view returns (bool) {
+ (bool success, bytes memory res) = target.staticcall(callData);
+ if (!success) return false;
+ if (res.length != 32) return false;
+
+ return abi.decode(res, (uint256)) >= minExpectedReturn;
+ }
+
+ function safeStaticCallBytes4(
+ address target,
+ bytes memory callData,
+ bytes4 expectedReturn
+ ) internal view returns (bool) {
+ (bool success, bytes memory res) = target.staticcall(callData);
+ if (!success) return false;
+ if (res.length != 32) return false;
+ if (
+ bytes32(res) &
+ 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000 !=
+ bytes32(res)
+ ) {
+ // Ensure only 4 bytes used
+ return false;
+ }
+
+ return abi.decode(res, (bytes4)) == expectedReturn;
+ }
+}
diff --git a/contracts/helpers/order-validator/lib/SeaportValidatorHelper.sol b/contracts/helpers/order-validator/lib/SeaportValidatorHelper.sol
new file mode 100644
index 000000000..e597cb453
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/SeaportValidatorHelper.sol
@@ -0,0 +1,958 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ItemType } from "../../../lib/ConsiderationEnums.sol";
+import {
+ Order,
+ OrderParameters,
+ BasicOrderParameters,
+ OfferItem,
+ ConsiderationItem,
+ Schema,
+ ZoneParameters
+} from "../../../lib/ConsiderationStructs.sol";
+import { ConsiderationTypeHashes } from "../lib/ConsiderationTypeHashes.sol";
+import {
+ ConsiderationInterface
+} from "../../../interfaces/ConsiderationInterface.sol";
+import {
+ ConduitControllerInterface
+} from "../../../interfaces/ConduitControllerInterface.sol";
+import {
+ ContractOffererInterface
+} from "../../../interfaces/ContractOffererInterface.sol";
+import { ZoneInterface } from "../../../interfaces/ZoneInterface.sol";
+import { GettersAndDerivers } from "../../../lib/GettersAndDerivers.sol";
+import {
+ SeaportValidatorInterface
+} from "../lib/SeaportValidatorInterface.sol";
+import { ZoneInterface } from "../../../interfaces/ZoneInterface.sol";
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../../../interfaces/AbridgedTokenInterfaces.sol";
+import { IERC165 } from "../../../interfaces/IERC165.sol";
+import { IERC2981 } from "../../../interfaces/IERC2981.sol";
+import {
+ ErrorsAndWarnings,
+ ErrorsAndWarningsLib
+} from "../lib/ErrorsAndWarnings.sol";
+import { SafeStaticCall } from "../lib/SafeStaticCall.sol";
+import { Murky } from "../lib/Murky.sol";
+import {
+ IssueParser,
+ ValidationConfiguration,
+ TimeIssue,
+ StatusIssue,
+ OfferIssue,
+ ContractOffererIssue,
+ ConsiderationIssue,
+ PrimaryFeeIssue,
+ ERC721Issue,
+ ERC1155Issue,
+ ERC20Issue,
+ NativeIssue,
+ ZoneIssue,
+ ConduitIssue,
+ CreatorFeeIssue,
+ SignatureIssue,
+ GenericIssue,
+ ConsiderationItemConfiguration
+} from "../lib/SeaportValidatorTypes.sol";
+import { Verifiers } from "../../../lib/Verifiers.sol";
+
+/**
+ * @title SeaportValidator
+ * @author OpenSea Protocol Team
+ * @notice SeaportValidatorHelper assists in advanced validation to seaport orders.
+ */
+contract SeaportValidatorHelper is Murky {
+ using ErrorsAndWarningsLib for ErrorsAndWarnings;
+ using SafeStaticCall for address;
+ using IssueParser for *;
+
+ /// @notice Ethereum creator fee engine address
+ CreatorFeeEngineInterface public immutable creatorFeeEngine;
+
+ bytes4 public constant ERC20_INTERFACE_ID = 0x36372b07;
+
+ bytes4 public constant ERC721_INTERFACE_ID = 0x80ac58cd;
+
+ bytes4 public constant ERC1155_INTERFACE_ID = 0xd9b67a26;
+
+ constructor() {
+ address creatorFeeEngineAddress;
+ if (block.chainid == 1 || block.chainid == 31337) {
+ creatorFeeEngineAddress = 0x0385603ab55642cb4Dd5De3aE9e306809991804f;
+ } else if (block.chainid == 3) {
+ // Ropsten
+ creatorFeeEngineAddress = 0xFf5A6F7f36764aAD301B7C9E85A5277614Df5E26;
+ } else if (block.chainid == 4) {
+ // Rinkeby
+ creatorFeeEngineAddress = 0x8d17687ea9a6bb6efA24ec11DcFab01661b2ddcd;
+ } else if (block.chainid == 5) {
+ // Goerli
+ creatorFeeEngineAddress = 0xe7c9Cb6D966f76f3B5142167088927Bf34966a1f;
+ } else if (block.chainid == 42) {
+ // Kovan
+ creatorFeeEngineAddress = 0x54D88324cBedfFe1e62c9A59eBb310A11C295198;
+ } else if (block.chainid == 137) {
+ // Polygon
+ creatorFeeEngineAddress = 0x28EdFcF0Be7E86b07493466e7631a213bDe8eEF2;
+ } else if (block.chainid == 80001) {
+ // Mumbai
+ creatorFeeEngineAddress = 0x0a01E11887f727D1b1Cd81251eeEE9BEE4262D07;
+ } else {
+ // No creator fee engine for this chain
+ creatorFeeEngineAddress = address(0);
+ }
+
+ creatorFeeEngine = CreatorFeeEngineInterface(creatorFeeEngineAddress);
+ }
+
+ /**
+ * @notice Strict validation operates under tight assumptions. It validates primary
+ * fee, creator fee, private sale consideration, and overall order format.
+ * @dev Only checks first fee recipient provided by CreatorFeeEngine.
+ * Order of consideration items must be as follows:
+ * 1. Primary consideration
+ * 2. Primary fee
+ * 3. Creator fee
+ * 4. Private sale consideration
+ * @param orderParameters The parameters for the order to validate.
+ * @param primaryFeeRecipient The primary fee recipient. Set to null address for no primary fee.
+ * @param primaryFeeBips The primary fee in BIPs.
+ * @param checkCreatorFee Should check for creator fee. If true, creator fee must be present as
+ * according to creator fee engine. If false, must not have creator fee.
+ * @return errorsAndWarnings The errors and warnings.
+ */
+ function validateStrictLogic(
+ OrderParameters memory orderParameters,
+ address primaryFeeRecipient,
+ uint256 primaryFeeBips,
+ bool checkCreatorFee
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Check that order matches the required format (listing or offer)
+ {
+ bool canCheckFee = true;
+ // Single offer item and at least one consideration
+ if (
+ orderParameters.offer.length != 1 ||
+ orderParameters.consideration.length == 0
+ ) {
+ // Not listing or offer, can't check fees
+ canCheckFee = false;
+ } else if (
+ // Can't have both items be fungible
+ isPaymentToken(orderParameters.offer[0].itemType) &&
+ isPaymentToken(orderParameters.consideration[0].itemType)
+ ) {
+ // Not listing or offer, can't check fees
+ canCheckFee = false;
+ } else if (
+ // Can't have both items be non-fungible
+ !isPaymentToken(orderParameters.offer[0].itemType) &&
+ !isPaymentToken(orderParameters.consideration[0].itemType)
+ ) {
+ // Not listing or offer, can't check fees
+ canCheckFee = false;
+ }
+ if (!canCheckFee) {
+ // Does not match required format
+ errorsAndWarnings.addError(
+ GenericIssue.InvalidOrderFormat.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+ }
+
+ // Validate secondary consideration items (fees)
+ (
+ uint256 tertiaryConsiderationIndex,
+ ErrorsAndWarnings memory errorsAndWarningsLocal
+ ) = _validateSecondaryConsiderationItems(
+ orderParameters,
+ ConsiderationItemConfiguration({
+ primaryFeeRecipient: primaryFeeRecipient,
+ primaryFeeBips: primaryFeeBips,
+ checkCreatorFee: checkCreatorFee
+ })
+ );
+
+ errorsAndWarnings.concat(errorsAndWarningsLocal);
+
+ // Validate tertiary consideration items if not 0 (0 indicates error).
+ // Only if no prior errors
+ if (tertiaryConsiderationIndex != 0) {
+ errorsAndWarnings.concat(
+ _validateTertiaryConsiderationItems(
+ orderParameters,
+ tertiaryConsiderationIndex
+ )
+ );
+ }
+ }
+
+ /**
+ * @notice Validate all consideration items for an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItems(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // You must have a consideration item
+ if (orderParameters.consideration.length == 0) {
+ errorsAndWarnings.addWarning(
+ ConsiderationIssue.ZeroItems.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ // Declare a boolean to check if offerer is receiving at least
+ // one consideration item
+ bool offererReceivingAtLeastOneItem = false;
+
+ // Iterate over each consideration item
+ for (uint256 i = 0; i < orderParameters.consideration.length; i++) {
+ // Validate consideration item
+ errorsAndWarnings.concat(
+ validateConsiderationItem(orderParameters, i, seaportAddress)
+ );
+
+ ConsiderationItem memory considerationItem1 = orderParameters
+ .consideration[i];
+
+ // Check if the offerer is the recipient
+ if (!offererReceivingAtLeastOneItem) {
+ if (considerationItem1.recipient == orderParameters.offerer) {
+ offererReceivingAtLeastOneItem = true;
+ }
+ }
+
+ // Check for duplicate consideration items
+ for (
+ uint256 j = i + 1;
+ j < orderParameters.consideration.length;
+ j++
+ ) {
+ // Iterate over each remaining consideration item
+ // (previous items already check with this item)
+ ConsiderationItem memory considerationItem2 = orderParameters
+ .consideration[j];
+
+ // Check if itemType, token, id, and recipient are the same
+ if (
+ considerationItem2.itemType ==
+ considerationItem1.itemType &&
+ considerationItem2.token == considerationItem1.token &&
+ considerationItem2.identifierOrCriteria ==
+ considerationItem1.identifierOrCriteria &&
+ considerationItem2.recipient == considerationItem1.recipient
+ ) {
+ errorsAndWarnings.addWarning(
+ // Duplicate consideration item, warning
+ ConsiderationIssue.DuplicateItem.parseInt()
+ );
+ }
+ }
+ }
+
+ if (!offererReceivingAtLeastOneItem) {
+ // Offerer is not receiving at least one consideration item
+ errorsAndWarnings.addWarning(
+ ConsiderationIssue.OffererNotReceivingAtLeastOneItem.parseInt()
+ );
+ }
+ }
+
+ /**
+ * @notice Validate a consideration item
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItem(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ // Validate the consideration item at considerationItemIndex
+ errorsAndWarnings.concat(
+ validateConsiderationItemParameters(
+ orderParameters,
+ considerationItemIndex,
+ seaportAddress
+ )
+ );
+ }
+
+ /**
+ * @notice Validates the parameters of a consideration item including contract validation
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItemParameters(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) public view returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ ConsiderationItem memory considerationItem = orderParameters
+ .consideration[considerationItemIndex];
+
+ // Check if startAmount and endAmount are zero
+ if (
+ considerationItem.startAmount == 0 &&
+ considerationItem.endAmount == 0
+ ) {
+ errorsAndWarnings.addError(
+ ConsiderationIssue.AmountZero.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ // Check if the recipient is the null address
+ if (considerationItem.recipient == address(0)) {
+ errorsAndWarnings.addError(
+ ConsiderationIssue.NullRecipient.parseInt()
+ );
+ }
+
+ if (
+ considerationItem.startAmount != considerationItem.endAmount &&
+ orderParameters.endTime > orderParameters.startTime
+ ) {
+ // Check that amount velocity is not too high.
+ // Assign larger and smaller amount values
+ (uint256 maxAmount, uint256 minAmount) = considerationItem
+ .startAmount > considerationItem.endAmount
+ ? (considerationItem.startAmount, considerationItem.endAmount)
+ : (considerationItem.endAmount, considerationItem.startAmount);
+
+ uint256 amountDelta = maxAmount - minAmount;
+ // delta of time that order exists for
+ uint256 timeDelta = orderParameters.endTime -
+ orderParameters.startTime;
+
+ // Velocity scaled by 1e10 for precision
+ uint256 velocity = (amountDelta * 1e10) / timeDelta;
+ // gives velocity percentage in hundredth of a basis points per second in terms of larger value
+ uint256 velocityPercentage = velocity / (maxAmount * 1e4);
+
+ // 278 * 60 * 30 ~= 500,000
+ if (velocityPercentage > 278) {
+ // Over 50% change per 30 min
+ errorsAndWarnings.addError(
+ ConsiderationIssue.AmountVelocityHigh.parseInt()
+ );
+ }
+ // 28 * 60 * 30 ~= 50,000
+ else if (velocityPercentage > 28) {
+ // Over 5% change per 30 min
+ errorsAndWarnings.addWarning(
+ ConsiderationIssue.AmountVelocityHigh.parseInt()
+ );
+ }
+
+ // Check for large amount steps
+ if (minAmount <= 1e15) {
+ errorsAndWarnings.addWarning(
+ ConsiderationIssue.AmountStepLarge.parseInt()
+ );
+ }
+ }
+
+ if (considerationItem.itemType == ItemType.ERC721) {
+ // ERC721 type requires amounts to be 1
+ if (
+ considerationItem.startAmount != 1 ||
+ considerationItem.endAmount != 1
+ ) {
+ errorsAndWarnings.addError(ERC721Issue.AmountNotOne.parseInt());
+ }
+
+ // Check EIP165 interface
+ if (!checkInterface(considerationItem.token, ERC721_INTERFACE_ID)) {
+ errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt());
+ return errorsAndWarnings;
+ }
+
+ // Check that token exists
+ if (
+ !considerationItem.token.safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC721Interface.ownerOf.selector,
+ considerationItem.identifierOrCriteria
+ ),
+ 1
+ )
+ ) {
+ // Token does not exist
+ errorsAndWarnings.addError(
+ ERC721Issue.IdentifierDNE.parseInt()
+ );
+ }
+ } else if (
+ considerationItem.itemType == ItemType.ERC721_WITH_CRITERIA
+ ) {
+ // Check EIP165 interface
+ if (!checkInterface(considerationItem.token, ERC721_INTERFACE_ID)) {
+ // Does not implement required interface
+ errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt());
+ }
+ } else if (
+ considerationItem.itemType == ItemType.ERC1155 ||
+ considerationItem.itemType == ItemType.ERC1155_WITH_CRITERIA
+ ) {
+ // Check EIP165 interface
+ if (
+ !checkInterface(considerationItem.token, ERC1155_INTERFACE_ID)
+ ) {
+ // Does not implement required interface
+ errorsAndWarnings.addError(
+ ERC1155Issue.InvalidToken.parseInt()
+ );
+ }
+ } else if (considerationItem.itemType == ItemType.ERC20) {
+ // ERC20 must have `identifierOrCriteria` be zero
+ if (considerationItem.identifierOrCriteria != 0) {
+ errorsAndWarnings.addError(
+ ERC20Issue.IdentifierNonZero.parseInt()
+ );
+ }
+
+ // Check that it is an ERC20 token. ERC20 will return a uint256
+ if (
+ !considerationItem.token.safeStaticCallUint256(
+ abi.encodeWithSelector(
+ ERC20Interface.allowance.selector,
+ seaportAddress,
+ seaportAddress
+ ),
+ 0
+ )
+ ) {
+ // Not an ERC20 token
+ errorsAndWarnings.addError(ERC20Issue.InvalidToken.parseInt());
+ }
+ } else {
+ // Must be native
+ // NATIVE must have `token` be zero address
+ if (considerationItem.token != address(0)) {
+ errorsAndWarnings.addError(NativeIssue.TokenAddress.parseInt());
+ }
+ // NATIVE must have `identifierOrCriteria` be zero
+ if (considerationItem.identifierOrCriteria != 0) {
+ errorsAndWarnings.addError(
+ NativeIssue.IdentifierNonZero.parseInt()
+ );
+ }
+ }
+ }
+
+ function _validateSecondaryConsiderationItems(
+ OrderParameters memory orderParameters,
+ ConsiderationItemConfiguration memory config
+ )
+ internal
+ view
+ returns (
+ uint256 /* tertiaryConsiderationIndex */,
+ ErrorsAndWarnings memory /* errorsAndWarnings */
+ )
+ {
+ ErrorsAndWarnings memory errorsAndWarnings = ErrorsAndWarnings(
+ new uint16[](0),
+ new uint16[](0)
+ );
+
+ // Consideration item to hold expected creator fee info
+ ConsiderationItem memory creatorFeeConsideration;
+
+ bool primaryFeePresent;
+
+ {
+ // non-fungible item address
+ address itemAddress;
+ // non-fungible item identifier
+ uint256 itemIdentifier;
+ // fungible item start amount
+ uint256 transactionAmountStart;
+ // fungible item end amount
+ uint256 transactionAmountEnd;
+
+ if (isPaymentToken(orderParameters.offer[0].itemType)) {
+ // Offer is an offer. Offer item is fungible and used for fees
+ creatorFeeConsideration.itemType = orderParameters
+ .offer[0]
+ .itemType;
+ creatorFeeConsideration.token = orderParameters.offer[0].token;
+ transactionAmountStart = orderParameters.offer[0].startAmount;
+ transactionAmountEnd = orderParameters.offer[0].endAmount;
+
+ // Set non-fungible information for calculating creator fee
+ itemAddress = orderParameters.consideration[0].token;
+ itemIdentifier = orderParameters
+ .consideration[0]
+ .identifierOrCriteria;
+ } else {
+ // Offer is an offer. Consideration item is fungible and used for fees
+ creatorFeeConsideration.itemType = orderParameters
+ .consideration[0]
+ .itemType;
+ creatorFeeConsideration.token = orderParameters
+ .consideration[0]
+ .token;
+ transactionAmountStart = orderParameters
+ .consideration[0]
+ .startAmount;
+ transactionAmountEnd = orderParameters
+ .consideration[0]
+ .endAmount;
+
+ // Set non-fungible information for calculating creator fees
+ itemAddress = orderParameters.offer[0].token;
+ itemIdentifier = orderParameters.offer[0].identifierOrCriteria;
+ }
+
+ // Store flag if primary fee is present
+ primaryFeePresent = false;
+ {
+ // Calculate primary fee start and end amounts
+ uint256 primaryFeeStartAmount = (transactionAmountStart *
+ config.primaryFeeBips) / 10000;
+ uint256 primaryFeeEndAmount = (transactionAmountEnd *
+ config.primaryFeeBips) / 10000;
+
+ // Check if primary fee check is desired. Skip if calculated amount is zero.
+ if (
+ config.primaryFeeRecipient != address(0) &&
+ (primaryFeeStartAmount > 0 || primaryFeeEndAmount > 0)
+ ) {
+ // Ensure primary fee is present
+ if (orderParameters.consideration.length < 2) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.Missing.parseInt()
+ );
+ return (0, errorsAndWarnings);
+ }
+ primaryFeePresent = true;
+
+ ConsiderationItem memory primaryFeeItem = orderParameters
+ .consideration[1];
+
+ // Check item type
+ if (
+ primaryFeeItem.itemType !=
+ creatorFeeConsideration.itemType
+ ) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.ItemType.parseInt()
+ );
+ return (0, errorsAndWarnings);
+ }
+ // Check token
+ if (primaryFeeItem.token != creatorFeeConsideration.token) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.Token.parseInt()
+ );
+ }
+ // Check start amount
+ if (primaryFeeItem.startAmount < primaryFeeStartAmount) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.StartAmount.parseInt()
+ );
+ }
+ // Check end amount
+ if (primaryFeeItem.endAmount < primaryFeeEndAmount) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.EndAmount.parseInt()
+ );
+ }
+ // Check recipient
+ if (
+ primaryFeeItem.recipient != config.primaryFeeRecipient
+ ) {
+ errorsAndWarnings.addError(
+ PrimaryFeeIssue.Recipient.parseInt()
+ );
+ }
+ }
+ }
+
+ // Check creator fee
+ (
+ creatorFeeConsideration.recipient,
+ creatorFeeConsideration.startAmount,
+ creatorFeeConsideration.endAmount
+ ) = getCreatorFeeInfo(
+ itemAddress,
+ itemIdentifier,
+ transactionAmountStart,
+ transactionAmountEnd
+ );
+ }
+
+ // Flag indicating if creator fee is present in considerations
+ bool creatorFeePresent = false;
+
+ // Determine if should check for creator fee
+ if (
+ creatorFeeConsideration.recipient != address(0) &&
+ config.checkCreatorFee &&
+ (creatorFeeConsideration.startAmount > 0 ||
+ creatorFeeConsideration.endAmount > 0)
+ ) {
+ // Calculate index of creator fee consideration item
+ uint16 creatorFeeConsiderationIndex = primaryFeePresent ? 2 : 1; // 2 if primary fee, ow 1
+
+ // Check that creator fee consideration item exists
+ if (
+ orderParameters.consideration.length - 1 <
+ creatorFeeConsiderationIndex
+ ) {
+ errorsAndWarnings.addError(CreatorFeeIssue.Missing.parseInt());
+ return (0, errorsAndWarnings);
+ }
+
+ ConsiderationItem memory creatorFeeItem = orderParameters
+ .consideration[creatorFeeConsiderationIndex];
+
+ creatorFeePresent = true;
+
+ // Check type
+ if (creatorFeeItem.itemType != creatorFeeConsideration.itemType) {
+ errorsAndWarnings.addError(CreatorFeeIssue.ItemType.parseInt());
+ return (0, errorsAndWarnings);
+ }
+ // Check token
+ if (creatorFeeItem.token != creatorFeeConsideration.token) {
+ errorsAndWarnings.addError(CreatorFeeIssue.Token.parseInt());
+ }
+ // Check start amount
+ if (
+ creatorFeeItem.startAmount < creatorFeeConsideration.startAmount
+ ) {
+ errorsAndWarnings.addError(
+ CreatorFeeIssue.StartAmount.parseInt()
+ );
+ }
+ // Check end amount
+ if (creatorFeeItem.endAmount < creatorFeeConsideration.endAmount) {
+ errorsAndWarnings.addError(
+ CreatorFeeIssue.EndAmount.parseInt()
+ );
+ }
+ // Check recipient
+ if (creatorFeeItem.recipient != creatorFeeConsideration.recipient) {
+ errorsAndWarnings.addError(
+ CreatorFeeIssue.Recipient.parseInt()
+ );
+ }
+ }
+
+ // Calculate index of first tertiary consideration item
+ uint256 tertiaryConsiderationIndex = 1 +
+ (primaryFeePresent ? 1 : 0) +
+ (creatorFeePresent ? 1 : 0);
+
+ return (tertiaryConsiderationIndex, errorsAndWarnings);
+ }
+
+ /**
+ * @notice Internal function for validating all consideration items after the fee items.
+ * Only additional acceptable consideration is private sale.
+ */
+ function _validateTertiaryConsiderationItems(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex
+ ) internal pure returns (ErrorsAndWarnings memory errorsAndWarnings) {
+ errorsAndWarnings = ErrorsAndWarnings(new uint16[](0), new uint16[](0));
+
+ if (orderParameters.consideration.length <= considerationItemIndex) {
+ // No more consideration items
+ return errorsAndWarnings;
+ }
+
+ ConsiderationItem memory privateSaleConsideration = orderParameters
+ .consideration[considerationItemIndex];
+
+ // Check if offer is payment token. Private sale not possible if so.
+ if (isPaymentToken(orderParameters.offer[0].itemType)) {
+ errorsAndWarnings.addError(
+ ConsiderationIssue.ExtraItems.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ // Check if private sale to self
+ if (privateSaleConsideration.recipient == orderParameters.offerer) {
+ errorsAndWarnings.addError(
+ ConsiderationIssue.PrivateSaleToSelf.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ // Ensure that private sale parameters match offer item.
+ if (
+ privateSaleConsideration.itemType !=
+ orderParameters.offer[0].itemType ||
+ privateSaleConsideration.token != orderParameters.offer[0].token ||
+ orderParameters.offer[0].startAmount !=
+ privateSaleConsideration.startAmount ||
+ orderParameters.offer[0].endAmount !=
+ privateSaleConsideration.endAmount ||
+ orderParameters.offer[0].identifierOrCriteria !=
+ privateSaleConsideration.identifierOrCriteria
+ ) {
+ // Invalid private sale, say extra consideration item
+ errorsAndWarnings.addError(
+ ConsiderationIssue.ExtraItems.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+
+ errorsAndWarnings.addWarning(ConsiderationIssue.PrivateSale.parseInt());
+
+ // Should not be any additional consideration items
+ if (orderParameters.consideration.length - 1 > considerationItemIndex) {
+ // Extra consideration items
+ errorsAndWarnings.addError(
+ ConsiderationIssue.ExtraItems.parseInt()
+ );
+ return errorsAndWarnings;
+ }
+ }
+
+ /**
+ * @notice Fetches the on chain creator fees.
+ * @dev Uses the creatorFeeEngine when available, otherwise fallback to `IERC2981`.
+ * @param token The token address
+ * @param tokenId The token identifier
+ * @param transactionAmountStart The transaction start amount
+ * @param transactionAmountEnd The transaction end amount
+ * @return recipient creator fee recipient
+ * @return creatorFeeAmountStart creator fee start amount
+ * @return creatorFeeAmountEnd creator fee end amount
+ */
+ function getCreatorFeeInfo(
+ address token,
+ uint256 tokenId,
+ uint256 transactionAmountStart,
+ uint256 transactionAmountEnd
+ )
+ public
+ view
+ returns (
+ address payable recipient,
+ uint256 creatorFeeAmountStart,
+ uint256 creatorFeeAmountEnd
+ )
+ {
+ // Check if creator fee engine is on this chain
+ if (address(creatorFeeEngine) != address(0)) {
+ // Creator fee engine may revert if no creator fees are present.
+ try
+ creatorFeeEngine.getRoyaltyView(
+ token,
+ tokenId,
+ transactionAmountStart
+ )
+ returns (
+ address payable[] memory creatorFeeRecipients,
+ uint256[] memory creatorFeeAmountsStart
+ ) {
+ if (creatorFeeRecipients.length != 0) {
+ // Use first recipient and amount
+ recipient = creatorFeeRecipients[0];
+ creatorFeeAmountStart = creatorFeeAmountsStart[0];
+ }
+ } catch {
+ // Creator fee not found
+ }
+
+ // If fees found for start amount, check end amount
+ if (recipient != address(0)) {
+ // Creator fee engine may revert if no creator fees are present.
+ try
+ creatorFeeEngine.getRoyaltyView(
+ token,
+ tokenId,
+ transactionAmountEnd
+ )
+ returns (
+ address payable[] memory,
+ uint256[] memory creatorFeeAmountsEnd
+ ) {
+ creatorFeeAmountEnd = creatorFeeAmountsEnd[0];
+ } catch {}
+ }
+ } else {
+ // Fallback to ERC2981
+ {
+ // Static call to token using ERC2981
+ (bool success, bytes memory res) = token.staticcall(
+ abi.encodeWithSelector(
+ IERC2981.royaltyInfo.selector,
+ tokenId,
+ transactionAmountStart
+ )
+ );
+ // Check if call succeeded
+ if (success) {
+ // Ensure 64 bytes returned
+ if (res.length == 64) {
+ // Decode result and assign recipient and start amount
+ (recipient, creatorFeeAmountStart) = abi.decode(
+ res,
+ (address, uint256)
+ );
+ }
+ }
+ }
+
+ // Only check end amount if start amount found
+ if (recipient != address(0)) {
+ // Static call to token using ERC2981
+ (bool success, bytes memory res) = token.staticcall(
+ abi.encodeWithSelector(
+ IERC2981.royaltyInfo.selector,
+ tokenId,
+ transactionAmountEnd
+ )
+ );
+ // Check if call succeeded
+ if (success) {
+ // Ensure 64 bytes returned
+ if (res.length == 64) {
+ // Decode result and assign end amount
+ (, creatorFeeAmountEnd) = abi.decode(
+ res,
+ (address, uint256)
+ );
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @notice Safely check that a contract implements an interface
+ * @param token The token address to check
+ * @param interfaceHash The interface hash to check
+ */
+ function checkInterface(
+ address token,
+ bytes4 interfaceHash
+ ) public view returns (bool) {
+ return
+ token.safeStaticCallBool(
+ abi.encodeWithSelector(
+ IERC165.supportsInterface.selector,
+ interfaceHash
+ ),
+ true
+ );
+ }
+
+ /*//////////////////////////////////////////////////////////////
+ Merkle Helpers
+ //////////////////////////////////////////////////////////////*/
+
+ /**
+ * @notice Sorts an array of token ids by the keccak256 hash of the id. Required ordering of ids
+ * for other merkle operations.
+ * @param includedTokens An array of included token ids.
+ * @return sortedTokens The sorted `includedTokens` array.
+ */
+ function sortMerkleTokens(
+ uint256[] memory includedTokens
+ ) public pure returns (uint256[] memory sortedTokens) {
+ // Sort token ids by the keccak256 hash of the id
+ return _sortUint256ByHash(includedTokens);
+ }
+
+ /**
+ * @notice Creates a merkle root for includedTokens.
+ * @dev `includedTokens` must be sorting in strictly ascending order according to the keccak256 hash of the value.
+ * @return merkleRoot The merkle root
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleRoot(
+ uint256[] memory includedTokens
+ )
+ public
+ pure
+ returns (bytes32 merkleRoot, ErrorsAndWarnings memory errorsAndWarnings)
+ {
+ (merkleRoot, errorsAndWarnings) = _getRoot(includedTokens);
+ }
+
+ /**
+ * @notice Creates a merkle proof for the the targetIndex contained in includedTokens.
+ * @dev `targetIndex` is referring to the index of an element in `includedTokens`.
+ * `includedTokens` must be sorting in ascending order according to the keccak256 hash of the value.
+ * @return merkleProof The merkle proof
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleProof(
+ uint256[] memory includedTokens,
+ uint256 targetIndex
+ )
+ public
+ pure
+ returns (
+ bytes32[] memory merkleProof,
+ ErrorsAndWarnings memory errorsAndWarnings
+ )
+ {
+ (merkleProof, errorsAndWarnings) = _getProof(
+ includedTokens,
+ targetIndex
+ );
+ }
+
+ /**
+ * @notice Verifies a merkle proof for the value to prove and given root and proof.
+ * @dev The `valueToProve` is hashed prior to executing the proof verification.
+ * @param merkleRoot The root of the merkle tree
+ * @param merkleProof The merkle proof
+ * @param valueToProve The value to prove
+ * @return whether proof is valid
+ */
+ function verifyMerkleProof(
+ bytes32 merkleRoot,
+ bytes32[] memory merkleProof,
+ uint256 valueToProve
+ ) public pure returns (bool) {
+ bytes32 hashedValue = keccak256(abi.encode(valueToProve));
+
+ return _verifyProof(merkleRoot, merkleProof, hashedValue);
+ }
+
+ function isPaymentToken(ItemType itemType) public pure returns (bool) {
+ return itemType == ItemType.NATIVE || itemType == ItemType.ERC20;
+ }
+}
+
+interface CreatorFeeEngineInterface {
+ function getRoyaltyView(
+ address tokenAddress,
+ uint256 tokenId,
+ uint256 value
+ )
+ external
+ view
+ returns (address payable[] memory recipients, uint256[] memory amounts);
+}
diff --git a/contracts/helpers/order-validator/lib/SeaportValidatorInterface.sol b/contracts/helpers/order-validator/lib/SeaportValidatorInterface.sol
new file mode 100644
index 000000000..5dd5925a6
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/SeaportValidatorInterface.sol
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import { ItemType } from "../../../lib/ConsiderationEnums.sol";
+import {
+ Order,
+ OrderParameters,
+ ZoneParameters
+} from "../../../lib/ConsiderationStructs.sol";
+import { ErrorsAndWarnings } from "./ErrorsAndWarnings.sol";
+import { ValidationConfiguration } from "./SeaportValidatorTypes.sol";
+
+/**
+ * @title SeaportValidator
+ * @notice SeaportValidator validates simple orders that adhere to a set of rules defined below:
+ * - The order is either a listing or an offer order (one NFT to buy or one NFT to sell).
+ * - The first consideration is the primary consideration.
+ * - The order pays up to two fees in the fungible token currency. First fee is primary fee, second is creator fee.
+ * - In private orders, the last consideration specifies a recipient for the offer item.
+ * - Offer items must be owned and properly approved by the offerer.
+ * - Consideration items must exist.
+ */
+interface SeaportValidatorInterface {
+ /**
+ * @notice Conduct a comprehensive validation of the given order.
+ * @param order The order to validate.
+ * @return errorsAndWarnings The errors and warnings found in the order.
+ */
+ function isValidOrder(
+ Order calldata order,
+ address seaportAddress
+ ) external returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Same as `isValidOrder` but allows for more configuration related to fee validation.
+ */
+ function isValidOrderWithConfiguration(
+ ValidationConfiguration memory validationConfiguration,
+ Order memory order
+ ) external returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Same as `isValidOrderWithConfiguration` but doesn't call `validate` on Seaport.
+ */
+ function isValidOrderWithConfigurationReadOnly(
+ ValidationConfiguration memory validationConfiguration,
+ Order memory order
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Checks if a conduit key is valid.
+ * @param conduitKey The conduit key to check.
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function isValidConduit(
+ bytes32 conduitKey,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ // TODO: Need to add support for order with extra data
+ /**
+ * @notice Checks that the zone of an order implements the required interface
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function isValidZone(
+ OrderParameters memory orderParameters
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ function validateSignature(
+ Order memory order,
+ address seaportAddress
+ ) external returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ function validateSignatureWithCounter(
+ Order memory order,
+ uint256 counter,
+ address seaportAddress
+ ) external returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Check the time validity of an order
+ * @param orderParameters The parameters for the order to validate
+ * @param shortOrderDuration The duration of which an order is considered short
+ * @param distantOrderExpiration Distant order expiration delta in seconds.
+ * @return errorsAndWarnings The Issues and warnings
+ */
+ function validateTime(
+ OrderParameters memory orderParameters,
+ uint256 shortOrderDuration,
+ uint256 distantOrderExpiration
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validate the status of an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateOrderStatus(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validate all offer items for an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateOfferItems(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validate all consideration items for an order
+ * @param orderParameters The parameters for the order to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItems(
+ OrderParameters memory orderParameters,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Strict validation operates under tight assumptions. It validates primary
+ * fee, creator fee, private sale consideration, and overall order format.
+ * @dev Only checks first fee recipient provided by CreatorFeeRegistry.
+ * Order of consideration items must be as follows:
+ * 1. Primary consideration
+ * 2. Primary fee
+ * 3. Creator Fee
+ * 4. Private sale consideration
+ * @param orderParameters The parameters for the order to validate.
+ * @param primaryFeeRecipient The primary fee recipient. Set to null address for no primary fee.
+ * @param primaryFeeBips The primary fee in BIPs.
+ * @param checkCreatorFee Should check for creator fee. If true, creator fee must be present as
+ * according to creator fee engine. If false, must not have creator fee.
+ * @return errorsAndWarnings The errors and warnings.
+ */
+ function validateStrictLogic(
+ OrderParameters memory orderParameters,
+ address primaryFeeRecipient,
+ uint256 primaryFeeBips,
+ bool checkCreatorFee
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validate a consideration item
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItem(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validates the parameters of a consideration item including contract validation
+ * @param orderParameters The parameters for the order to validate
+ * @param considerationItemIndex The index of the consideration item to validate
+ * @return errorsAndWarnings The errors and warnings
+ */
+ function validateConsiderationItemParameters(
+ OrderParameters memory orderParameters,
+ uint256 considerationItemIndex,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validates an offer item
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItem(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validates the OfferItem parameters. This includes token contract validation
+ * @dev OfferItems with criteria are currently not allowed
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItemParameters(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Validates the OfferItem approvals and balances
+ * @param orderParameters The parameters for the order to validate
+ * @param offerItemIndex The index of the offerItem in offer array to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOfferItemApprovalAndBalance(
+ OrderParameters memory orderParameters,
+ uint256 offerItemIndex,
+ address seaportAddress
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Calls validateOrder on the order's zone with the given zoneParameters
+ * @param orderParameters The parameters for the order to validate
+ * @param zoneParameters The parameters for the zone to validate
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function validateOrderWithZone(
+ OrderParameters memory orderParameters,
+ ZoneParameters memory zoneParameters
+ ) external view returns (ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Gets the approval address for the given conduit key
+ * @param conduitKey Conduit key to get approval address for
+ * @return errorsAndWarnings An ErrorsAndWarnings structs with results
+ */
+ function getApprovalAddress(
+ bytes32 conduitKey,
+ address seaportAddress
+ )
+ external
+ view
+ returns (address, ErrorsAndWarnings memory errorsAndWarnings);
+
+ /**
+ * @notice Safely check that a contract implements an interface
+ * @param token The token address to check
+ * @param interfaceHash The interface hash to check
+ */
+ function checkInterface(
+ address token,
+ bytes4 interfaceHash
+ ) external view returns (bool);
+
+ function isPaymentToken(ItemType itemType) external pure returns (bool);
+
+ /*//////////////////////////////////////////////////////////////
+ Merkle Helpers
+ //////////////////////////////////////////////////////////////*/
+
+ /**
+ * @notice Sorts an array of token ids by the keccak256 hash of the id. Required ordering of ids
+ * for other merkle operations.
+ * @param includedTokens An array of included token ids.
+ * @return sortedTokens The sorted `includedTokens` array.
+ */
+ function sortMerkleTokens(
+ uint256[] memory includedTokens
+ ) external view returns (uint256[] memory sortedTokens);
+
+ /**
+ * @notice Creates a merkle root for includedTokens.
+ * @dev `includedTokens` must be sorting in strictly ascending order according to the keccak256 hash of the value.
+ * @return merkleRoot The merkle root
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleRoot(
+ uint256[] memory includedTokens
+ )
+ external
+ view
+ returns (
+ bytes32 merkleRoot,
+ ErrorsAndWarnings memory errorsAndWarnings
+ );
+
+ /**
+ * @notice Creates a merkle proof for the the targetIndex contained in includedTokens.
+ * @dev `targetIndex` is referring to the index of an element in `includedTokens`.
+ * `includedTokens` must be sorting in ascending order according to the keccak256 hash of the value.
+ * @return merkleProof The merkle proof
+ * @return errorsAndWarnings Errors and warnings from the operation
+ */
+ function getMerkleProof(
+ uint256[] memory includedTokens,
+ uint256 targetIndex
+ )
+ external
+ view
+ returns (
+ bytes32[] memory merkleProof,
+ ErrorsAndWarnings memory errorsAndWarnings
+ );
+
+ function verifyMerkleProof(
+ bytes32 merkleRoot,
+ bytes32[] memory merkleProof,
+ uint256 valueToProve
+ ) external view returns (bool);
+}
diff --git a/contracts/helpers/order-validator/lib/SeaportValidatorTypes.sol b/contracts/helpers/order-validator/lib/SeaportValidatorTypes.sol
new file mode 100644
index 000000000..065e8933a
--- /dev/null
+++ b/contracts/helpers/order-validator/lib/SeaportValidatorTypes.sol
@@ -0,0 +1,508 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+struct ValidationConfiguration {
+ /// @notice The seaport address.
+ address seaport;
+ /// @notice Recipient for primary fee payments.
+ address primaryFeeRecipient;
+ /// @notice Bips for primary fee payments.
+ uint256 primaryFeeBips;
+ /// @notice Should creator fees be checked?
+ bool checkCreatorFee;
+ /// @notice Should strict validation be skipped?
+ bool skipStrictValidation;
+ /// @notice Short order duration in seconds
+ uint256 shortOrderDuration;
+ /// @notice Distant order expiration delta in seconds. Warning if order expires in longer than this.
+ uint256 distantOrderExpiration;
+}
+
+struct ConsiderationItemConfiguration {
+ address primaryFeeRecipient;
+ uint256 primaryFeeBips;
+ bool checkCreatorFee;
+}
+
+enum GenericIssue {
+ InvalidOrderFormat // 100
+}
+
+enum ERC20Issue {
+ IdentifierNonZero, // 200
+ InvalidToken, // 201
+ InsufficientAllowance, // 202
+ InsufficientBalance // 203
+}
+
+enum ERC721Issue {
+ AmountNotOne, // 300
+ InvalidToken, // 301
+ IdentifierDNE, // 302
+ NotOwner, // 303
+ NotApproved, // 304
+ CriteriaNotPartialFill // 305
+}
+
+enum ERC1155Issue {
+ InvalidToken, // 400
+ NotApproved, // 401
+ InsufficientBalance // 402
+}
+
+enum ConsiderationIssue {
+ AmountZero, // 500
+ NullRecipient, // 501
+ ExtraItems, // 502
+ PrivateSaleToSelf, // 503
+ ZeroItems, // 504
+ DuplicateItem, // 505
+ OffererNotReceivingAtLeastOneItem, // 506
+ PrivateSale, // 507
+ AmountVelocityHigh, // 508
+ AmountStepLarge // 509
+}
+
+enum OfferIssue {
+ ZeroItems, // 600
+ AmountZero, // 601
+ MoreThanOneItem, // 602
+ NativeItem, // 603
+ DuplicateItem, // 604
+ AmountVelocityHigh, // 605
+ AmountStepLarge // 606
+}
+
+enum PrimaryFeeIssue {
+ Missing, // 700
+ ItemType, // 701
+ Token, // 702
+ StartAmount, // 703
+ EndAmount, // 704
+ Recipient // 705
+}
+
+enum StatusIssue {
+ Cancelled, // 800
+ FullyFilled, // 801
+ ContractOrder // 802
+}
+
+enum TimeIssue {
+ EndTimeBeforeStartTime, // 900
+ Expired, // 901
+ DistantExpiration, // 902
+ NotActive, // 903
+ ShortOrder // 904
+}
+
+enum ConduitIssue {
+ KeyInvalid, // 1000
+ MissingSeaportChannel // 1001
+}
+
+enum SignatureIssue {
+ Invalid, // 1100
+ ContractOrder, // 1101
+ LowCounter, // 1102
+ HighCounter, // 1103
+ OriginalConsiderationItems // 1104
+}
+
+enum CreatorFeeIssue {
+ Missing, // 1200
+ ItemType, // 1201
+ Token, // 1202
+ StartAmount, // 1203
+ EndAmount, // 1204
+ Recipient // 1205
+}
+
+enum NativeIssue {
+ TokenAddress, // 1300
+ IdentifierNonZero, // 1301
+ InsufficientBalance // 1302
+}
+
+enum ZoneIssue {
+ InvalidZone, // 1400
+ RejectedOrder, // 1401
+ NotSet, // 1402
+ EOAZone // 1403
+}
+
+enum MerkleIssue {
+ SingleLeaf, // 1500
+ Unsorted // 1501
+}
+
+enum ContractOffererIssue {
+ InvalidContractOfferer // 1600
+}
+
+/**
+ * @title IssueParser - parse issues into integers
+ * @notice Implements a `parseInt` function for each issue type.
+ * offsets the enum value to place within the issue range.
+ */
+library IssueParser {
+ function parseInt(GenericIssue err) internal pure returns (uint16) {
+ return uint16(err) + 100;
+ }
+
+ function parseInt(ERC20Issue err) internal pure returns (uint16) {
+ return uint16(err) + 200;
+ }
+
+ function parseInt(ERC721Issue err) internal pure returns (uint16) {
+ return uint16(err) + 300;
+ }
+
+ function parseInt(ERC1155Issue err) internal pure returns (uint16) {
+ return uint16(err) + 400;
+ }
+
+ function parseInt(ConsiderationIssue err) internal pure returns (uint16) {
+ return uint16(err) + 500;
+ }
+
+ function parseInt(OfferIssue err) internal pure returns (uint16) {
+ return uint16(err) + 600;
+ }
+
+ function parseInt(PrimaryFeeIssue err) internal pure returns (uint16) {
+ return uint16(err) + 700;
+ }
+
+ function parseInt(StatusIssue err) internal pure returns (uint16) {
+ return uint16(err) + 800;
+ }
+
+ function parseInt(TimeIssue err) internal pure returns (uint16) {
+ return uint16(err) + 900;
+ }
+
+ function parseInt(ConduitIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1000;
+ }
+
+ function parseInt(SignatureIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1100;
+ }
+
+ function parseInt(CreatorFeeIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1200;
+ }
+
+ function parseInt(NativeIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1300;
+ }
+
+ function parseInt(ZoneIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1400;
+ }
+
+ function parseInt(MerkleIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1500;
+ }
+
+ function parseInt(ContractOffererIssue err) internal pure returns (uint16) {
+ return uint16(err) + 1600;
+ }
+}
+
+library IssueStringHelpers {
+ function toString(GenericIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == GenericIssue.InvalidOrderFormat) {
+ code = "InvalidOrderFormat";
+ }
+ return string.concat("GenericIssue: ", code);
+ }
+
+ function toString(ERC20Issue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == ERC20Issue.IdentifierNonZero) {
+ code = "IdentifierNonZero";
+ } else if (id == ERC20Issue.InvalidToken) {
+ code = "InvalidToken";
+ } else if (id == ERC20Issue.InsufficientAllowance) {
+ code = "InsufficientAllowance";
+ } else if (id == ERC20Issue.InsufficientBalance) {
+ code = "InsufficientBalance";
+ }
+ return string.concat("ERC20Issue: ", code);
+ }
+
+ function toString(ERC721Issue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == ERC721Issue.AmountNotOne) {
+ code = "AmountNotOne";
+ } else if (id == ERC721Issue.InvalidToken) {
+ code = "InvalidToken";
+ } else if (id == ERC721Issue.IdentifierDNE) {
+ code = "IdentifierDNE";
+ } else if (id == ERC721Issue.NotOwner) {
+ code = "NotOwner";
+ } else if (id == ERC721Issue.NotApproved) {
+ code = "NotApproved";
+ } else if (id == ERC721Issue.CriteriaNotPartialFill) {
+ code = "CriteriaNotPartialFill";
+ }
+ return string.concat("ERC721Issue: ", code);
+ }
+
+ function toString(ERC1155Issue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == ERC1155Issue.InvalidToken) {
+ code = "InvalidToken";
+ } else if (id == ERC1155Issue.NotApproved) {
+ code = "NotApproved";
+ } else if (id == ERC1155Issue.InsufficientBalance) {
+ code = "InsufficientBalance";
+ }
+ return string.concat("ERC1155Issue: ", code);
+ }
+
+ function toString(
+ ConsiderationIssue id
+ ) internal pure returns (string memory) {
+ string memory code;
+ if (id == ConsiderationIssue.AmountZero) {
+ code = "AmountZero";
+ } else if (id == ConsiderationIssue.NullRecipient) {
+ code = "NullRecipient";
+ } else if (id == ConsiderationIssue.ExtraItems) {
+ code = "ExtraItems";
+ } else if (id == ConsiderationIssue.PrivateSaleToSelf) {
+ code = "PrivateSaleToSelf";
+ } else if (id == ConsiderationIssue.ZeroItems) {
+ code = "ZeroItems";
+ } else if (id == ConsiderationIssue.DuplicateItem) {
+ code = "DuplicateItem";
+ } else if (id == ConsiderationIssue.OffererNotReceivingAtLeastOneItem) {
+ code = "OffererNotReceivingAtLeastOneItem";
+ } else if (id == ConsiderationIssue.PrivateSale) {
+ code = "PrivateSale";
+ } else if (id == ConsiderationIssue.AmountVelocityHigh) {
+ code = "AmountVelocityHigh";
+ } else if (id == ConsiderationIssue.AmountStepLarge) {
+ code = "AmountStepLarge";
+ }
+ return string.concat("ConsiderationIssue: ", code);
+ }
+
+ function toString(OfferIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == OfferIssue.ZeroItems) {
+ code = "ZeroItems";
+ } else if (id == OfferIssue.AmountZero) {
+ code = "AmountZero";
+ } else if (id == OfferIssue.MoreThanOneItem) {
+ code = "MoreThanOneItem";
+ } else if (id == OfferIssue.NativeItem) {
+ code = "NativeItem";
+ } else if (id == OfferIssue.DuplicateItem) {
+ code = "DuplicateItem";
+ } else if (id == OfferIssue.AmountVelocityHigh) {
+ code = "AmountVelocityHigh";
+ } else if (id == OfferIssue.AmountStepLarge) {
+ code = "AmountStepLarge";
+ }
+ return string.concat("OfferIssue: ", code);
+ }
+
+ function toString(
+ PrimaryFeeIssue id
+ ) internal pure returns (string memory) {
+ string memory code;
+ if (id == PrimaryFeeIssue.Missing) {
+ code = "Missing";
+ } else if (id == PrimaryFeeIssue.ItemType) {
+ code = "ItemType";
+ } else if (id == PrimaryFeeIssue.Token) {
+ code = "Token";
+ } else if (id == PrimaryFeeIssue.StartAmount) {
+ code = "StartAmount";
+ } else if (id == PrimaryFeeIssue.EndAmount) {
+ code = "EndAmount";
+ } else if (id == PrimaryFeeIssue.Recipient) {
+ code = "Recipient";
+ }
+ return string.concat("PrimaryFeeIssue: ", code);
+ }
+
+ function toString(StatusIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == StatusIssue.Cancelled) {
+ code = "Cancelled";
+ } else if (id == StatusIssue.FullyFilled) {
+ code = "FullyFilled";
+ } else if (id == StatusIssue.ContractOrder) {
+ code = "ContractOrder";
+ }
+ return string.concat("StatusIssue: ", code);
+ }
+
+ function toString(TimeIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == TimeIssue.EndTimeBeforeStartTime) {
+ code = "EndTimeBeforeStartTime";
+ } else if (id == TimeIssue.Expired) {
+ code = "Expired";
+ } else if (id == TimeIssue.DistantExpiration) {
+ code = "DistantExpiration";
+ } else if (id == TimeIssue.NotActive) {
+ code = "NotActive";
+ } else if (id == TimeIssue.ShortOrder) {
+ code = "ShortOrder";
+ }
+ return string.concat("TimeIssue: ", code);
+ }
+
+ function toString(ConduitIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == ConduitIssue.KeyInvalid) {
+ code = "KeyInvalid";
+ } else if (id == ConduitIssue.MissingSeaportChannel) {
+ code = "MissingSeaportChannel";
+ }
+ return string.concat("ConduitIssue: ", code);
+ }
+
+ function toString(SignatureIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == SignatureIssue.Invalid) {
+ code = "Invalid";
+ } else if (id == SignatureIssue.ContractOrder) {
+ code = "ContractOrder";
+ } else if (id == SignatureIssue.LowCounter) {
+ code = "LowCounter";
+ } else if (id == SignatureIssue.HighCounter) {
+ code = "HighCounter";
+ } else if (id == SignatureIssue.OriginalConsiderationItems) {
+ code = "OriginalConsiderationItems";
+ }
+ return string.concat("SignatureIssue: ", code);
+ }
+
+ function toString(
+ CreatorFeeIssue id
+ ) internal pure returns (string memory) {
+ string memory code;
+ if (id == CreatorFeeIssue.Missing) {
+ code = "Missing";
+ } else if (id == CreatorFeeIssue.ItemType) {
+ code = "ItemType";
+ } else if (id == CreatorFeeIssue.Token) {
+ code = "Token";
+ } else if (id == CreatorFeeIssue.StartAmount) {
+ code = "StartAmount";
+ } else if (id == CreatorFeeIssue.EndAmount) {
+ code = "EndAmount";
+ } else if (id == CreatorFeeIssue.Recipient) {
+ code = "Recipient";
+ }
+ return string.concat("CreatorFeeIssue: ", code);
+ }
+
+ function toString(NativeIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == NativeIssue.TokenAddress) {
+ code = "TokenAddress";
+ } else if (id == NativeIssue.IdentifierNonZero) {
+ code = "IdentifierNonZero";
+ } else if (id == NativeIssue.InsufficientBalance) {
+ code = "InsufficientBalance";
+ }
+ return string.concat("NativeIssue: ", code);
+ }
+
+ function toString(ZoneIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == ZoneIssue.InvalidZone) {
+ code = "InvalidZone";
+ } else if (id == ZoneIssue.RejectedOrder) {
+ code = "RejectedOrder";
+ } else if (id == ZoneIssue.NotSet) {
+ code = "NotSet";
+ } else if (id == ZoneIssue.EOAZone) {
+ code = "EOAZone";
+ }
+ return string.concat("ZoneIssue: ", code);
+ }
+
+ function toString(MerkleIssue id) internal pure returns (string memory) {
+ string memory code;
+ if (id == MerkleIssue.SingleLeaf) {
+ code = "SingleLeaf";
+ } else if (id == MerkleIssue.Unsorted) {
+ code = "Unsorted";
+ }
+ return string.concat("MerkleIssue: ", code);
+ }
+
+ function toString(
+ ContractOffererIssue id
+ ) internal pure returns (string memory) {
+ string memory code;
+ if (id == ContractOffererIssue.InvalidContractOfferer) {
+ code = "InvalidContractOfferer";
+ }
+ return string.concat("ContractOffererIssue: ", code);
+ }
+
+ function toIssueString(
+ uint16 issueCode
+ ) internal pure returns (string memory issueString) {
+ uint16 issue = (issueCode / 100) * 100;
+ uint8 id = uint8(issueCode % 100);
+ if (issue == 100) {
+ return toString(GenericIssue(id));
+ } else if (issue == 200) {
+ return toString(ERC20Issue(id));
+ } else if (issue == 300) {
+ return toString(ERC721Issue(id));
+ } else if (issue == 400) {
+ return toString(ERC1155Issue(id));
+ } else if (issue == 500) {
+ return toString(ConsiderationIssue(id));
+ } else if (issue == 600) {
+ return toString(OfferIssue(id));
+ } else if (issue == 700) {
+ return toString(PrimaryFeeIssue(id));
+ } else if (issue == 800) {
+ return toString(StatusIssue(id));
+ } else if (issue == 900) {
+ return toString(TimeIssue(id));
+ } else if (issue == 1000) {
+ return toString(ConduitIssue(id));
+ } else if (issue == 1100) {
+ return toString(SignatureIssue(id));
+ } else if (issue == 1200) {
+ return toString(CreatorFeeIssue(id));
+ } else if (issue == 1300) {
+ return toString(NativeIssue(id));
+ } else if (issue == 1400) {
+ return toString(ZoneIssue(id));
+ } else if (issue == 1500) {
+ return toString(MerkleIssue(id));
+ } else if (issue == 1600) {
+ return toString(ContractOffererIssue(id));
+ } else {
+ revert("IssueStringHelpers: Unknown issue code");
+ }
+ }
+
+ function toIssueString(
+ uint16[] memory issueCodes
+ ) internal pure returns (string memory issueString) {
+ for (uint256 i; i < issueCodes.length; i++) {
+ issueString = string.concat(
+ issueString,
+ "\n ",
+ toIssueString(issueCodes[i])
+ );
+ }
+ }
+}
diff --git a/contracts/helpers/sol/ConduitControllerInterface.sol b/contracts/helpers/sol/ConduitControllerInterface.sol
new file mode 100644
index 000000000..b9f1c4b41
--- /dev/null
+++ b/contracts/helpers/sol/ConduitControllerInterface.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ ConduitControllerInterface
+} from "../../interfaces/ConduitControllerInterface.sol";
diff --git a/contracts/helpers/sol/ConduitInterface.sol b/contracts/helpers/sol/ConduitInterface.sol
new file mode 100644
index 000000000..5b634ad5a
--- /dev/null
+++ b/contracts/helpers/sol/ConduitInterface.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ConduitInterface } from "../../interfaces/ConduitInterface.sol";
diff --git a/contracts/helpers/sol/ContractOffererInterface.sol b/contracts/helpers/sol/ContractOffererInterface.sol
new file mode 100644
index 000000000..42b47e1c2
--- /dev/null
+++ b/contracts/helpers/sol/ContractOffererInterface.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ ContractOffererInterface
+} from "../../interfaces/ContractOffererInterface.sol";
diff --git a/contracts/helpers/sol/ErrorSpaceEnums.sol b/contracts/helpers/sol/ErrorSpaceEnums.sol
new file mode 100644
index 000000000..cecd2bb41
--- /dev/null
+++ b/contracts/helpers/sol/ErrorSpaceEnums.sol
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+enum ErrorType {
+ CORE_CONSIDERATION_ERROR,
+ TOKEN_TRANSFER_ERROR,
+ SIGNATURE_VERIFICATION_ERROR,
+ REENTRANCY_ERROR,
+ CONDUIT_ERROR,
+ ZONE_ERROR,
+ AMOUNT_DERIVATION_ERROR,
+ TRANSFER_HELPER_ERROR,
+ CRITERIA_RESOLUTION_ERROR,
+ FULFILLMENT_APPLICATION_ERROR,
+ PAUSABLE_ZONE_ERROR,
+ ZONE_INTERACTION_ERROR
+}
+
+enum CoreConsiderationErrors {
+ BAD_FRACTION,
+ CANNOT_CANCEL_ORDER,
+ CONSIDERATION_LENGTH_NOT_EQUAL_TO_TOTAL_ORIGINAL,
+ CONSIDERATION_NOT_MET,
+ INSUFFICIENT_NATIVE_TOKENS_SUPPLIED,
+ INVALID_BASIC_ORDER_PARAMETER_ENCODING,
+ INVALID_CALL_TO_CONDUIT,
+ INVALID_MSG_VALUE,
+ INVALID_NATIVE_OFFER_ITEM,
+ INVALID_TIME,
+ MISMATCHED_OFFER_AND_CONSIDERATION_COMPONENTS,
+ MISSING_ORIGINAL_CONSIDERATION_ITEMS,
+ NO_SPECIFIED_ORDERS_AVAILABLE,
+ ORDER_ALREADY_FILLED,
+ ORDER_IS_CANCELLED,
+ ORDER_PARTIALLY_FILLED,
+ PARTIAL_FILLS_NOT_ENABLED_FOR_ORDER
+}
+
+enum TokenTransferrerErrors {
+ INVALID_ERC721_TRANSFER_AMOUNT,
+ MISSING_ITEM_AMOUNT,
+ UNUSED_ITEM_PARAMETERS,
+ TOKEN_TRANSFER_GENERIC_FAILURE,
+ ERC1155_BATCH_TRANSFER_GENERIC_FAILURE,
+ BAD_RETURN_VALUE_FROM_ERC20_ON_TRANSFER,
+ NO_CONTRACT,
+ INVALID1155_BATCH_TRANSFER_ENCODING
+}
+
+enum SignatureVerificationErrors {
+ BAD_SIGNATURE_V,
+ INVALID_SIGNER,
+ INVALID_SIGNATURE,
+ BAD_CONTRACT_SIGNATURE
+}
+
+enum ReentrancyErrors {
+ NO_REENTRANT_CALLS
+}
+
+enum AmountDerivationErrors {
+ INEXACT_FRACTION
+}
+
+enum TransferHelperErrors {
+ INVALID_ITEM_TYPE,
+ INVALID_ERC721_TRANSFER_AMOUNT,
+ INVALID_ERC721_RECIPIENT,
+ ERC721_RECEIVER_ERROR_REVERT_BYTES,
+ ERC721_RECEIVER_ERROR_REVERT_STRING,
+ INVALID_ERC20_IDENTIFIER,
+ RECIPIENT_CANNOT_BE_ZERO_ADDRESS,
+ INVALID_CONDUIT,
+ CONDUIT_ERROR_REVERT_STRING,
+ CONDUIT_ERROR_REVERT_BYTES
+}
+
+enum CriteriaResolutionErrors {
+ ORDER_CRITERIA_RESOLVER_OUT_OF_RANGE,
+ UNRESOLVED_OFFER_CRITERIA,
+ UNRESOLVED_CONSIDERATION_CRITERIA,
+ OFFER_CRITERIA_RESOLVER_OUT_OF_RANGE,
+ CONSIDERATION_CRITERIA_RESOLVER_OUT_OF_RANGE,
+ CRITERIA_NOT_ENABLED_FOR_ITEM,
+ INVALID_PROOF
+}
+
+enum FulfillmentApplicationErrors {
+ MISSING_FULFILLMENT_COMPONENT_ON_AGGREGATION,
+ OFFER_AND_CONSIDERATION_REQUIRED_ON_FULFILLMENT,
+ MISMATCHED_FULFILLMENT_OFFER_AND_CONSIDERATION_COMPONENTS,
+ INVALID_FULFILLMENT_COMPONENT_DATA
+}
+
+enum PausableZoneErrors {
+ INVALID_PAUSER,
+ INVALID_OPERATOR,
+ INVALID_CONTROLLER,
+ ZONE_ALREADY_EXISTS,
+ CALLER_IS_NOT_OWNER,
+ CALLER_IS_NOT_OPERATOR,
+ OWNER_CAN_NOT_BE_SET_AS_ZERO,
+ PAUSER_CAN_NOT_BE_SET_AS_ZERO,
+ CALLER_IS_NOT_POTENTIAL_OWNER
+}
+
+enum ZoneInteractionErrors {
+ INVALID_RESTRICTED_ORDER,
+ INVALID_CONTRACT_ORDER
+}
diff --git a/contracts/helpers/sol/SeaportEnums.sol b/contracts/helpers/sol/SeaportEnums.sol
new file mode 100644
index 000000000..ed84184b2
--- /dev/null
+++ b/contracts/helpers/sol/SeaportEnums.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../lib/ConsiderationEnums.sol";
diff --git a/contracts/helpers/sol/SeaportInterface.sol b/contracts/helpers/sol/SeaportInterface.sol
new file mode 100644
index 000000000..04eb51311
--- /dev/null
+++ b/contracts/helpers/sol/SeaportInterface.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ ConsiderationInterface as SeaportInterface
+} from "../../interfaces/ConsiderationInterface.sol";
diff --git a/contracts/helpers/sol/SeaportSol.sol b/contracts/helpers/sol/SeaportSol.sol
new file mode 100644
index 000000000..49c79ef4c
--- /dev/null
+++ b/contracts/helpers/sol/SeaportSol.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./SeaportStructs.sol";
+import "./SeaportEnums.sol";
+import "./lib/SeaportStructLib.sol";
+import "./lib/SeaportEnumsLib.sol";
+import "./fulfillments/lib/Structs.sol";
+import { SeaportArrays } from "./lib/SeaportArrays.sol";
+import { SeaportInterface } from "./SeaportInterface.sol";
+import {
+ ConsiderationInterface
+} from "../../interfaces/ConsiderationInterface.sol";
+import { ConduitInterface } from "./ConduitInterface.sol";
+import { ConduitControllerInterface } from "./ConduitControllerInterface.sol";
+import { ZoneInterface } from "./ZoneInterface.sol";
+import { ContractOffererInterface } from "./ContractOffererInterface.sol";
+import { Solarray } from "./Solarray.sol";
+import {
+ FulfillAvailableHelper
+} from "./fulfillments/available/FulfillAvailableHelper.sol";
+import {
+ MatchFulfillmentHelper
+} from "./fulfillments/match/MatchFulfillmentHelper.sol";
+import {
+ MatchComponent,
+ MatchComponentType
+} from "./lib/types/MatchComponentType.sol";
diff --git a/contracts/helpers/sol/SeaportStructs.sol b/contracts/helpers/sol/SeaportStructs.sol
new file mode 100644
index 000000000..505e04960
--- /dev/null
+++ b/contracts/helpers/sol/SeaportStructs.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../lib/ConsiderationStructs.sol";
diff --git a/contracts/helpers/sol/Solarray.sol b/contracts/helpers/sol/Solarray.sol
new file mode 100644
index 000000000..827bbf4c3
--- /dev/null
+++ b/contracts/helpers/sol/Solarray.sol
@@ -0,0 +1,2098 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2 <0.9.0;
+
+library Solarray {
+ function uint8s(uint8 a) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint8s(uint8 a, uint8 b) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint8s(
+ uint8 a,
+ uint8 b,
+ uint8 c
+ ) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint8s(
+ uint8 a,
+ uint8 b,
+ uint8 c,
+ uint8 d
+ ) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint8s(
+ uint8 a,
+ uint8 b,
+ uint8 c,
+ uint8 d,
+ uint8 e
+ ) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint8s(
+ uint8 a,
+ uint8 b,
+ uint8 c,
+ uint8 d,
+ uint8 e,
+ uint8 f
+ ) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint8s(
+ uint8 a,
+ uint8 b,
+ uint8 c,
+ uint8 d,
+ uint8 e,
+ uint8 f,
+ uint8 g
+ ) internal pure returns (uint8[] memory) {
+ uint8[] memory arr = new uint8[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint16s(uint16 a) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b,
+ uint16 c
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b,
+ uint16 c,
+ uint16 d
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b,
+ uint16 c,
+ uint16 d,
+ uint16 e
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b,
+ uint16 c,
+ uint16 d,
+ uint16 e,
+ uint16 f
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint16s(
+ uint16 a,
+ uint16 b,
+ uint16 c,
+ uint16 d,
+ uint16 e,
+ uint16 f,
+ uint16 g
+ ) internal pure returns (uint16[] memory) {
+ uint16[] memory arr = new uint16[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint32s(uint32 a) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b,
+ uint32 c
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b,
+ uint32 c,
+ uint32 d
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b,
+ uint32 c,
+ uint32 d,
+ uint32 e
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b,
+ uint32 c,
+ uint32 d,
+ uint32 e,
+ uint32 f
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint32s(
+ uint32 a,
+ uint32 b,
+ uint32 c,
+ uint32 d,
+ uint32 e,
+ uint32 f,
+ uint32 g
+ ) internal pure returns (uint32[] memory) {
+ uint32[] memory arr = new uint32[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint40s(uint40 a) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b,
+ uint40 c
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b,
+ uint40 c,
+ uint40 d
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b,
+ uint40 c,
+ uint40 d,
+ uint40 e
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b,
+ uint40 c,
+ uint40 d,
+ uint40 e,
+ uint40 f
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint40s(
+ uint40 a,
+ uint40 b,
+ uint40 c,
+ uint40 d,
+ uint40 e,
+ uint40 f,
+ uint40 g
+ ) internal pure returns (uint40[] memory) {
+ uint40[] memory arr = new uint40[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint64s(uint64 a) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b,
+ uint64 c
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b,
+ uint64 c,
+ uint64 d
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b,
+ uint64 c,
+ uint64 d,
+ uint64 e
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b,
+ uint64 c,
+ uint64 d,
+ uint64 e,
+ uint64 f
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint64s(
+ uint64 a,
+ uint64 b,
+ uint64 c,
+ uint64 d,
+ uint64 e,
+ uint64 f,
+ uint64 g
+ ) internal pure returns (uint64[] memory) {
+ uint64[] memory arr = new uint64[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint128s(uint128 a) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b,
+ uint128 c
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b,
+ uint128 c,
+ uint128 d
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b,
+ uint128 c,
+ uint128 d,
+ uint128 e
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b,
+ uint128 c,
+ uint128 d,
+ uint128 e,
+ uint128 f
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint128s(
+ uint128 a,
+ uint128 b,
+ uint128 c,
+ uint128 d,
+ uint128 e,
+ uint128 f,
+ uint128 g
+ ) internal pure returns (uint128[] memory) {
+ uint128[] memory arr = new uint128[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uint256s(uint256 a) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b,
+ uint256 c
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b,
+ uint256 c,
+ uint256 d
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b,
+ uint256 c,
+ uint256 d,
+ uint256 e
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b,
+ uint256 c,
+ uint256 d,
+ uint256 e,
+ uint256 f
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uint256s(
+ uint256 a,
+ uint256 b,
+ uint256 c,
+ uint256 d,
+ uint256 e,
+ uint256 f,
+ uint256 g
+ ) internal pure returns (uint256[] memory) {
+ uint256[] memory arr = new uint256[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int8s(int8 a) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int8s(int8 a, int8 b) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int8s(
+ int8 a,
+ int8 b,
+ int8 c
+ ) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int8s(
+ int8 a,
+ int8 b,
+ int8 c,
+ int8 d
+ ) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int8s(
+ int8 a,
+ int8 b,
+ int8 c,
+ int8 d,
+ int8 e
+ ) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int8s(
+ int8 a,
+ int8 b,
+ int8 c,
+ int8 d,
+ int8 e,
+ int8 f
+ ) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int8s(
+ int8 a,
+ int8 b,
+ int8 c,
+ int8 d,
+ int8 e,
+ int8 f,
+ int8 g
+ ) internal pure returns (int8[] memory) {
+ int8[] memory arr = new int8[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int16s(int16 a) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int16s(int16 a, int16 b) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int16s(
+ int16 a,
+ int16 b,
+ int16 c
+ ) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int16s(
+ int16 a,
+ int16 b,
+ int16 c,
+ int16 d
+ ) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int16s(
+ int16 a,
+ int16 b,
+ int16 c,
+ int16 d,
+ int16 e
+ ) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int16s(
+ int16 a,
+ int16 b,
+ int16 c,
+ int16 d,
+ int16 e,
+ int16 f
+ ) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int16s(
+ int16 a,
+ int16 b,
+ int16 c,
+ int16 d,
+ int16 e,
+ int16 f,
+ int16 g
+ ) internal pure returns (int16[] memory) {
+ int16[] memory arr = new int16[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int32s(int32 a) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int32s(int32 a, int32 b) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int32s(
+ int32 a,
+ int32 b,
+ int32 c
+ ) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int32s(
+ int32 a,
+ int32 b,
+ int32 c,
+ int32 d
+ ) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int32s(
+ int32 a,
+ int32 b,
+ int32 c,
+ int32 d,
+ int32 e
+ ) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int32s(
+ int32 a,
+ int32 b,
+ int32 c,
+ int32 d,
+ int32 e,
+ int32 f
+ ) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int32s(
+ int32 a,
+ int32 b,
+ int32 c,
+ int32 d,
+ int32 e,
+ int32 f,
+ int32 g
+ ) internal pure returns (int32[] memory) {
+ int32[] memory arr = new int32[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int64s(int64 a) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int64s(int64 a, int64 b) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int64s(
+ int64 a,
+ int64 b,
+ int64 c
+ ) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int64s(
+ int64 a,
+ int64 b,
+ int64 c,
+ int64 d
+ ) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int64s(
+ int64 a,
+ int64 b,
+ int64 c,
+ int64 d,
+ int64 e
+ ) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int64s(
+ int64 a,
+ int64 b,
+ int64 c,
+ int64 d,
+ int64 e,
+ int64 f
+ ) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int64s(
+ int64 a,
+ int64 b,
+ int64 c,
+ int64 d,
+ int64 e,
+ int64 f,
+ int64 g
+ ) internal pure returns (int64[] memory) {
+ int64[] memory arr = new int64[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int128s(int128 a) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b,
+ int128 c
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b,
+ int128 c,
+ int128 d
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b,
+ int128 c,
+ int128 d,
+ int128 e
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b,
+ int128 c,
+ int128 d,
+ int128 e,
+ int128 f
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int128s(
+ int128 a,
+ int128 b,
+ int128 c,
+ int128 d,
+ int128 e,
+ int128 f,
+ int128 g
+ ) internal pure returns (int128[] memory) {
+ int128[] memory arr = new int128[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function int256s(int256 a) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b,
+ int256 c
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b,
+ int256 c,
+ int256 d
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b,
+ int256 c,
+ int256 d,
+ int256 e
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b,
+ int256 c,
+ int256 d,
+ int256 e,
+ int256 f
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function int256s(
+ int256 a,
+ int256 b,
+ int256 c,
+ int256 d,
+ int256 e,
+ int256 f,
+ int256 g
+ ) internal pure returns (int256[] memory) {
+ int256[] memory arr = new int256[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytes1s(bytes1 a) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b,
+ bytes1 c
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b,
+ bytes1 c,
+ bytes1 d
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b,
+ bytes1 c,
+ bytes1 d,
+ bytes1 e
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b,
+ bytes1 c,
+ bytes1 d,
+ bytes1 e,
+ bytes1 f
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytes1s(
+ bytes1 a,
+ bytes1 b,
+ bytes1 c,
+ bytes1 d,
+ bytes1 e,
+ bytes1 f,
+ bytes1 g
+ ) internal pure returns (bytes1[] memory) {
+ bytes1[] memory arr = new bytes1[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytes8s(bytes8 a) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b,
+ bytes8 c
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b,
+ bytes8 c,
+ bytes8 d
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b,
+ bytes8 c,
+ bytes8 d,
+ bytes8 e
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b,
+ bytes8 c,
+ bytes8 d,
+ bytes8 e,
+ bytes8 f
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytes8s(
+ bytes8 a,
+ bytes8 b,
+ bytes8 c,
+ bytes8 d,
+ bytes8 e,
+ bytes8 f,
+ bytes8 g
+ ) internal pure returns (bytes8[] memory) {
+ bytes8[] memory arr = new bytes8[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytes16s(bytes16 a) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b,
+ bytes16 c
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b,
+ bytes16 c,
+ bytes16 d
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b,
+ bytes16 c,
+ bytes16 d,
+ bytes16 e
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b,
+ bytes16 c,
+ bytes16 d,
+ bytes16 e,
+ bytes16 f
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytes16s(
+ bytes16 a,
+ bytes16 b,
+ bytes16 c,
+ bytes16 d,
+ bytes16 e,
+ bytes16 f,
+ bytes16 g
+ ) internal pure returns (bytes16[] memory) {
+ bytes16[] memory arr = new bytes16[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytes20s(bytes20 a) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b,
+ bytes20 c
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b,
+ bytes20 c,
+ bytes20 d
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b,
+ bytes20 c,
+ bytes20 d,
+ bytes20 e
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b,
+ bytes20 c,
+ bytes20 d,
+ bytes20 e,
+ bytes20 f
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytes20s(
+ bytes20 a,
+ bytes20 b,
+ bytes20 c,
+ bytes20 d,
+ bytes20 e,
+ bytes20 f,
+ bytes20 g
+ ) internal pure returns (bytes20[] memory) {
+ bytes20[] memory arr = new bytes20[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytes32s(bytes32 a) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b,
+ bytes32 c
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b,
+ bytes32 c,
+ bytes32 d
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b,
+ bytes32 c,
+ bytes32 d,
+ bytes32 e
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b,
+ bytes32 c,
+ bytes32 d,
+ bytes32 e,
+ bytes32 f
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytes32s(
+ bytes32 a,
+ bytes32 b,
+ bytes32 c,
+ bytes32 d,
+ bytes32 e,
+ bytes32 f,
+ bytes32 g
+ ) internal pure returns (bytes32[] memory) {
+ bytes32[] memory arr = new bytes32[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bytess(bytes memory a) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b,
+ bytes memory c
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b,
+ bytes memory c,
+ bytes memory d
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b,
+ bytes memory c,
+ bytes memory d,
+ bytes memory e
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b,
+ bytes memory c,
+ bytes memory d,
+ bytes memory e,
+ bytes memory f
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bytess(
+ bytes memory a,
+ bytes memory b,
+ bytes memory c,
+ bytes memory d,
+ bytes memory e,
+ bytes memory f,
+ bytes memory g
+ ) internal pure returns (bytes[] memory) {
+ bytes[] memory arr = new bytes[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function addresses(address a) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b,
+ address c
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b,
+ address c,
+ address d
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b,
+ address c,
+ address d,
+ address e
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b,
+ address c,
+ address d,
+ address e,
+ address f
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function addresses(
+ address a,
+ address b,
+ address c,
+ address d,
+ address e,
+ address f,
+ address g
+ ) internal pure returns (address[] memory) {
+ address[] memory arr = new address[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function bools(bool a) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function bools(bool a, bool b) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function bools(
+ bool a,
+ bool b,
+ bool c
+ ) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function bools(
+ bool a,
+ bool b,
+ bool c,
+ bool d
+ ) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function bools(
+ bool a,
+ bool b,
+ bool c,
+ bool d,
+ bool e
+ ) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function bools(
+ bool a,
+ bool b,
+ bool c,
+ bool d,
+ bool e,
+ bool f
+ ) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function bools(
+ bool a,
+ bool b,
+ bool c,
+ bool d,
+ bool e,
+ bool f,
+ bool g
+ ) internal pure returns (bool[] memory) {
+ bool[] memory arr = new bool[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function strings(string memory a) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b,
+ string memory c
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b,
+ string memory c,
+ string memory d
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b,
+ string memory c,
+ string memory d,
+ string memory e
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b,
+ string memory c,
+ string memory d,
+ string memory e,
+ string memory f
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function strings(
+ string memory a,
+ string memory b,
+ string memory c,
+ string memory d,
+ string memory e,
+ string memory f,
+ string memory g
+ ) internal pure returns (string[] memory) {
+ string[] memory arr = new string[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+}
diff --git a/contracts/helpers/sol/SpaceEnums.sol b/contracts/helpers/sol/SpaceEnums.sol
new file mode 100644
index 000000000..b84f0102b
--- /dev/null
+++ b/contracts/helpers/sol/SpaceEnums.sol
@@ -0,0 +1,382 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+enum Method {
+ BASIC,
+ FULFILL,
+ MATCH,
+ FULFILL_AVAILABLE,
+ FULFILL_ADVANCED,
+ MATCH_ADVANCED,
+ FULFILL_AVAILABLE_ADVANCED,
+ CANCEL,
+ VALIDATE,
+ INCREMENT_COUNTER,
+ GET_ORDER_HASH,
+ GET_ORDER_STATUS,
+ GET_COUNTER,
+ INFORMATION,
+ NAME
+}
+
+enum OrderStatusEnum {
+ AVAILABLE, // not validated or fulfilled; implicitly validated via signature except when match is called
+ VALIDATED, // validated on-chain
+ PARTIAL, // partially fulfilled
+ FULFILLED, // completely fulfilled
+ CANCELLED_EXPLICIT, // explicit cancellation
+ CANCELLED_COUNTER, // canceled via counter increment (reverts due to invalid sig)
+ REVERT // fulfilling reverts
+}
+
+enum BroadOrderType {
+ FULL,
+ PARTIAL,
+ CONTRACT
+}
+
+// !BroadOrderType.CONTRACT <- Zone
+enum Zone {
+ NONE,
+ PASS,
+ FAIL
+}
+
+// !BroadOrderType.CONTRACT <- OrderAuth
+enum NumOrders {
+ ONE,
+ MULTIPLE
+}
+
+// NumOrders.MULTIPLE && any(OrderFulfillment.PARTIAL) <- OrderComposition
+enum OrdersComposition {
+ HOMOGENOUS,
+ HETEROGENOUS
+}
+
+// OrderStatus.REVERT && !Zone.FAIL && !Offerer.CONTRACT_OFFERER <- OrderStatusRevertReason
+enum OrderStatusRevertReason {
+ NATIVE, // receive hook fails
+ ERC1155 // receive hook fails
+}
+
+// ItemType.ERC20/ERC1155/ERC721 <- TokenIndex
+// (test contracts have 3 of each token deployed; can mix and match)
+enum TokenIndex {
+ ONE,
+ TWO,
+ THREE
+}
+
+enum Criteria {
+ MERKLE, // non-zero criteria
+ WILDCARD // criteria zero
+}
+
+// Criteria.WILDCARD/MERKLE <- CriteriaResolved
+enum CriteriaResolved {
+ VALID, // correctly resolved
+ INVALID, // incorrectly resolved
+ UNAVAILABLE // resolved but not owned/approved
+}
+
+enum Amount {
+ FIXED,
+ ASCENDING,
+ DESCENDING
+}
+
+enum AmountDegree {
+ // ZERO, ?
+ SMALL,
+ MEDIUM,
+ LARGE,
+ WUMBO
+}
+
+enum FulfillmentRecipient {
+ ZERO,
+ ALICE,
+ BOB,
+ EVE
+}
+
+// ConsiderationItem.* / ReceivedItem.* / Method.*ADVANCED <- Recipient
+enum Recipient {
+ // ZERO,?
+ OFFERER,
+ RECIPIENT,
+ DILLON,
+ EVE,
+ FRANK
+ // INVALID
+}
+
+enum RecipientDirty {
+ CLEAN,
+ DIRTY
+}
+
+enum Caller {
+ TEST_CONTRACT,
+ ALICE,
+ BOB,
+ CAROL,
+ DILLON,
+ EVE,
+ FRANK
+}
+
+// disregarded in the self_ad_hoc case
+enum Offerer {
+ TEST_CONTRACT,
+ ALICE, // consider EOA space enum
+ BOB,
+ CONTRACT_OFFERER,
+ EIP1271
+}
+
+// debatable if needed but we do need to test zonehash permutations
+enum ZoneHash {
+ NONE,
+ VALID,
+ INVALID
+}
+
+// Offerer.CONTRACT_OFFERER <- ContractOfferer
+enum ContractOfferer {
+ PASS,
+ FAIL_GENERATE,
+ FAIL_MIN_RECEIVED,
+ FAIL_MAX_SPENT,
+ FAIL_RATIFY
+}
+
+// ContractOfferer.PASS <- ContractOffererPassGenerated
+enum ContractOffererPassGenerated {
+ IDENTITY,
+ MIN_RECEIVED,
+ MAX_SPENT,
+ BOTH
+}
+
+// ContractOffererPassGenerated.MIN_RECEIVED/BOTH <- ContractOffererPassMinReceived
+enum ContractOffererPassMinReceived {
+ MORE_MIN_RECEIVED,
+ EXTRA_MIN_RECEIVED,
+ BOTH
+}
+
+// ContractOffererPassGenerated.MAX_SPENT/BOTH <- ContractOffererPassMaxSpent
+enum ContractOffererPassMaxSpent {
+ LESS_MAX_SPENT,
+ TRUNCATED_MAX_SPENT,
+ BOTH
+}
+
+enum ContractOffererFailGenerated {
+ MIN_RECEIVED,
+ MAX_SPENT,
+ BOTH
+}
+
+// ContractOffererFailGenerated.MIN_RECEIVED/BOTH <- ContractOffererFailMinReceived
+enum ContractOffererFailMinReceived {
+ LESS_MIN_RECEIVED,
+ TRUNCATED_MIN_RECEIVED,
+ BOTH
+}
+
+// ContractOffererFailGenerated.MAX_SPENT/BOTH <- ContractOffererFailMaxSpent
+enum ContractOffererFailMaxSpent {
+ MORE_MAX_SPENT,
+ EXTRA_MAX_SPENT,
+ BOTH
+}
+
+enum Time {
+ // valid granularity important for ascending/descending
+ STARTS_IN_FUTURE,
+ EXACT_START, // order is live
+ ONGOING,
+ EXACT_END, // order is expired
+ EXPIRED
+}
+
+// Method.MATCH* <- MatchValidation
+enum MatchValidation {
+ SELF_AD_HOC,
+ SIGNATURE
+}
+
+enum SignatureMethod {
+ EOA,
+ VALIDATE,
+ EIP1271,
+ CONTRACT,
+ SELF_AD_HOC
+}
+
+// Offerer.EOA <- EOASignature
+enum EOASignature {
+ STANDARD,
+ EIP2098,
+ BULK,
+ BULK2098
+}
+
+// Offerer.EIP1271 <- EIP1271Signature
+enum EIP1271Signature {
+ EIP1271,
+ EIP1271_BULKLIKE
+}
+
+// Validation.SIGNATURE <- SignatureValidity
+enum SignatureValidity {
+ VALID,
+ INVALID
+}
+
+// EOASignature.BULK/BULK2098+EIP1271Signature.EIP1271_BULKLIKE <- BulkSignatureSize
+enum BulkSignatureSize {
+ ONE,
+ TWO,
+ THREE,
+ FOUR,
+ FIVE,
+ SIX,
+ SEVEN,
+ EIGHT,
+ NINE,
+ TEN,
+ ELEVEN,
+ TWELVE,
+ THIRTEEN,
+ FOURTEEN,
+ FIFTEEN,
+ SIXTEEN,
+ SEVENTEEN,
+ EIGHTEEN,
+ NINETEEN,
+ TWENTY,
+ TWENTYONE,
+ TWENTYTWO,
+ TWENTYTHREE,
+ TWENTYFOUR
+}
+
+enum Salt {
+ VALID,
+ DUPLICATE // ?
+}
+
+enum ConduitChoice {
+ NONE,
+ ONE,
+ TWO
+}
+
+enum Counter {
+ VALID,
+ INVALID
+}
+
+// Counter.INVALID <- CounterValue
+enum CounterValue {
+ LESS,
+ GREATER
+}
+
+enum TotalOriginalConsiderationItems {
+ LESS,
+ EQUAL,
+ GREATER
+}
+
+// Method.*Advanced <- Fraction
+enum Fraction {
+ INVALID,
+ VALID
+}
+
+// Fraction.VALID <- ValidFraction
+enum ValidFraction {
+ SMALL,
+ HALF,
+ LARGE,
+ WHOLE
+}
+
+enum InvalidFraction {
+ INVALID, // order is a full order
+ UNEVEN, // cannot divide into amount
+ IRREGULAR // N/M where N > M
+}
+
+enum CriteriaProofs {
+ LESS, // too few proofs
+ EQUAL, // sufficient number of proofs
+ GREATER // extra proofs
+}
+
+// Method.FULFILL_AVAILABLE* <= FulfillAvailableFulfillments
+enum FulfillAvailableFulfillments {
+ NAIVE, // one component per offer + consideration item, ie, unaggregated
+ AGGREGATED,
+ INVALID
+}
+
+// FulfillAvailableFulfillments.INVALID <- InvalidFulfillAvailableFulfillments
+enum InvalidFulfillAvailableFulfillments {
+ OFFER,
+ CONSIDERATION,
+ BOTH
+}
+
+// InvalidFulfillAvailableFulfillments.* <- InvalidFulfillAvailableFulfillmentsCondition
+enum InvalidFulfillAvailableFulfillmentsCondition {
+ INVALID, // ie not correctly constructed, duplicates, etc
+ LESS, // ie missing fulfillments
+ GREATER // ie including duplicates
+}
+
+// FulfillAvailableFulfillments.AGGREGATED <- AggregatedFulfillAvailableFulfillments
+enum AggregatedFulfillAvailableFulfillments {
+ OFFER,
+ CONSIDERATION,
+ BOTH
+}
+
+enum BasicOrderCategory {
+ NONE,
+ LISTING,
+ BID
+}
+
+enum Tips {
+ NONE,
+ TIPS
+}
+
+enum UnavailableReason {
+ AVAILABLE,
+ EXPIRED,
+ STARTS_IN_FUTURE,
+ CANCELLED,
+ ALREADY_FULFILLED,
+ MAX_FULFILLED_SATISFIED,
+ GENERATE_ORDER_FAILURE
+}
+
+enum ExtraData {
+ NONE,
+ RANDOM
+}
+
+enum ContractOrderRebate {
+ NONE,
+ MORE_OFFER_ITEMS,
+ MORE_OFFER_ITEM_AMOUNTS,
+ LESS_CONSIDERATION_ITEMS,
+ LESS_CONSIDERATION_ITEM_AMOUNTS
+}
diff --git a/contracts/helpers/sol/StructSpace.sol b/contracts/helpers/sol/StructSpace.sol
new file mode 100644
index 000000000..e2291e6a9
--- /dev/null
+++ b/contracts/helpers/sol/StructSpace.sol
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ItemType } from "./SeaportEnums.sol";
+
+import {
+ Amount,
+ BroadOrderType,
+ Caller,
+ ConduitChoice,
+ ContractOrderRebate,
+ Criteria,
+ EOASignature,
+ ExtraData,
+ FulfillmentRecipient,
+ Offerer,
+ Recipient,
+ SignatureMethod,
+ Time,
+ Tips,
+ TokenIndex,
+ UnavailableReason,
+ Zone,
+ ZoneHash
+} from "./SpaceEnums.sol";
+
+import {
+ FulfillmentStrategy
+} from "./fulfillments/lib/FulfillmentLib.sol";
+
+struct OfferItemSpace {
+ ItemType itemType;
+ TokenIndex tokenIndex;
+ Criteria criteria;
+ Amount amount;
+}
+
+struct ConsiderationItemSpace {
+ ItemType itemType;
+ TokenIndex tokenIndex;
+ Criteria criteria;
+ Amount amount;
+ Recipient recipient;
+}
+
+struct SpentItemSpace {
+ ItemType itemType;
+ TokenIndex tokenIndex;
+}
+
+struct ReceivedItemSpace {
+ ItemType itemType;
+ TokenIndex tokenIndex;
+ Recipient recipient;
+}
+
+struct OrderComponentsSpace {
+ Offerer offerer;
+ Zone zone;
+ OfferItemSpace[] offer;
+ ConsiderationItemSpace[] consideration;
+ BroadOrderType orderType;
+ Time time;
+ ZoneHash zoneHash;
+ SignatureMethod signatureMethod;
+ EOASignature eoaSignatureType;
+ uint256 bulkSigHeight;
+ uint256 bulkSigIndex;
+ ConduitChoice conduit;
+ Tips tips;
+ UnavailableReason unavailableReason; // ignored unless unavailable
+ ExtraData extraData;
+ ContractOrderRebate rebate;
+}
+
+struct AdvancedOrdersSpace {
+ OrderComponentsSpace[] orders;
+ bool isMatchable;
+ uint256 maximumFulfilled;
+ FulfillmentRecipient recipient;
+ ConduitChoice conduit;
+ Caller caller;
+ FulfillmentStrategy strategy;
+}
diff --git a/contracts/helpers/sol/ZoneInterface.sol b/contracts/helpers/sol/ZoneInterface.sol
new file mode 100644
index 000000000..6a2531209
--- /dev/null
+++ b/contracts/helpers/sol/ZoneInterface.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ZoneInterface } from "../../interfaces/ZoneInterface.sol";
diff --git a/contracts/helpers/sol/executions/ExecutionHelper.sol b/contracts/helpers/sol/executions/ExecutionHelper.sol
new file mode 100644
index 000000000..b1fda3ee7
--- /dev/null
+++ b/contracts/helpers/sol/executions/ExecutionHelper.sol
@@ -0,0 +1,1188 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ AmountDeriverHelper
+} from "../lib/fulfillment/AmountDeriverHelper.sol";
+
+import { AdvancedOrderLib } from "../lib/AdvancedOrderLib.sol";
+
+import { SpentItemLib } from "../lib/SpentItemLib.sol";
+
+import { ReceivedItemLib } from "../lib/ReceivedItemLib.sol";
+
+import {
+ AdvancedOrder,
+ CriteriaResolver,
+ Execution,
+ Fulfillment,
+ FulfillmentComponent,
+ Order,
+ ReceivedItem,
+ SpentItem
+} from "../../../lib/ConsiderationStructs.sol";
+
+import { ItemType, Side } from "../../../lib/ConsiderationEnums.sol";
+
+import {
+ FulfillmentDetails,
+ OrderDetails
+} from "../fulfillments/lib/Structs.sol";
+
+import { UnavailableReason } from "../SpaceEnums.sol";
+
+/**
+ * @dev Helper contract for deriving explicit and executions from orders and
+ * fulfillment details
+ *
+ * @dev TODO: move to the tests folder? not really useful for normal scripting
+ */
+library ExecutionHelper {
+ using AdvancedOrderLib for AdvancedOrder[];
+ using SpentItemLib for SpentItem[];
+ using ReceivedItemLib for ReceivedItem[];
+
+ /**
+ * @dev get explicit and implicit executions for a fulfillAvailable call
+ *
+ * @param fulfillmentDetails the fulfillment details
+ * @param offerFulfillments 2d array of offer fulfillment components
+ * @param considerationFulfillments 2d array of consideration fulfillment
+ *
+ * @return explicitExecutions the explicit executions
+ * @return implicitExecutionsPre the implicit executions (unspecified offer
+ * items)
+ * @return implicitExecutionsPost the implicit executions (unspecified offer
+ * items)
+ */
+ function getFulfillAvailableExecutions(
+ FulfillmentDetails memory fulfillmentDetails,
+ FulfillmentComponent[][] memory offerFulfillments,
+ FulfillmentComponent[][] memory considerationFulfillments,
+ OrderDetails[] memory orderDetails
+ )
+ public
+ pure
+ returns (
+ Execution[] memory explicitExecutions,
+ Execution[] memory implicitExecutionsPre,
+ Execution[] memory implicitExecutionsPost,
+ uint256 nativeTokensReturned
+ )
+ {
+ FulfillmentDetails memory details = copy(fulfillmentDetails);
+
+ bool[] memory availableOrders = new bool[](orderDetails.length);
+
+ for (uint256 i = 0; i < orderDetails.length; ++i) {
+ availableOrders[i] =
+ orderDetails[i].unavailableReason ==
+ UnavailableReason.AVAILABLE;
+ }
+
+ implicitExecutionsPre = processImplicitPreOrderExecutions(
+ details,
+ availableOrders
+ );
+
+ explicitExecutions = processExplicitExecutionsFromAggregatedComponents(
+ details,
+ offerFulfillments,
+ considerationFulfillments,
+ availableOrders
+ );
+
+ implicitExecutionsPost = processImplicitPostOrderExecutions(
+ details,
+ availableOrders
+ );
+
+ nativeTokensReturned = _handleExcessNativeTokens(
+ details,
+ explicitExecutions,
+ implicitExecutionsPre,
+ implicitExecutionsPost
+ );
+ }
+
+ /**
+ * @dev Process an array of fulfillments into an array of explicit and
+ * implicit executions.
+ *
+ * @param fulfillmentDetails The fulfillment details.
+ * @param fulfillments An array of fulfillments.
+ *
+ * @return explicitExecutions The explicit executions
+ * @return implicitExecutionsPre The implicit executions
+ * @return implicitExecutionsPost The implicit executions
+ */
+ function getMatchExecutions(
+ FulfillmentDetails memory fulfillmentDetails,
+ Fulfillment[] memory fulfillments
+ )
+ internal
+ pure
+ returns (
+ Execution[] memory explicitExecutions,
+ Execution[] memory implicitExecutionsPre,
+ Execution[] memory implicitExecutionsPost,
+ uint256 nativeTokensReturned
+ )
+ {
+ FulfillmentDetails memory details = copy(fulfillmentDetails);
+
+ explicitExecutions = new Execution[](fulfillments.length);
+
+ uint256 filteredExecutions = 0;
+
+ bool[] memory availableOrders = new bool[](details.orders.length);
+
+ for (uint256 i = 0; i < details.orders.length; ++i) {
+ availableOrders[i] = true;
+ }
+
+ implicitExecutionsPre = processImplicitPreOrderExecutions(
+ details,
+ availableOrders
+ );
+
+ for (uint256 i = 0; i < fulfillments.length; i++) {
+ Execution memory execution = processExecutionFromFulfillment(
+ details,
+ fulfillments[i]
+ );
+
+ if (
+ execution.item.recipient == execution.offerer &&
+ execution.item.itemType != ItemType.NATIVE
+ ) {
+ filteredExecutions++;
+ } else {
+ explicitExecutions[i - filteredExecutions] = execution;
+ }
+ }
+
+ // If some number of executions have been filtered...
+ if (filteredExecutions != 0) {
+ // reduce the total length of the executions array.
+ assembly {
+ mstore(
+ explicitExecutions,
+ sub(mload(explicitExecutions), filteredExecutions)
+ )
+ }
+ }
+
+ implicitExecutionsPost = processImplicitPostOrderExecutions(
+ details,
+ availableOrders
+ );
+
+ nativeTokensReturned = _handleExcessNativeTokens(
+ details,
+ explicitExecutions,
+ implicitExecutionsPre,
+ implicitExecutionsPost
+ );
+ }
+
+ function processExcessNativeTokens(
+ Execution[] memory explicitExecutions,
+ Execution[] memory implicitExecutionsPre,
+ Execution[] memory implicitExecutionsPost
+ ) internal pure returns (uint256 excessNativeTokens) {
+ for (uint256 i; i < implicitExecutionsPre.length; i++) {
+ excessNativeTokens += implicitExecutionsPre[i].item.amount;
+ }
+ for (uint256 i; i < explicitExecutions.length; i++) {
+ ReceivedItem memory item = explicitExecutions[i].item;
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > excessNativeTokens) {
+ revert(
+ "ExecutionsHelper: explicit execution amount exceeds seaport balance"
+ );
+ }
+ excessNativeTokens -= item.amount;
+ }
+ }
+ for (uint256 i; i < implicitExecutionsPost.length; i++) {
+ ReceivedItem memory item = implicitExecutionsPost[i].item;
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > excessNativeTokens) {
+ revert(
+ "ExecutionsHelper: post execution amount exceeds seaport balance"
+ );
+ }
+ excessNativeTokens -= item.amount;
+ }
+ }
+ }
+
+ function getStandardExecutions(
+ FulfillmentDetails memory details
+ )
+ public
+ pure
+ returns (
+ Execution[] memory implicitExecutions,
+ uint256 nativeTokensReturned
+ )
+ {
+ if (details.orders.length != 1) {
+ revert("ExecutionHelper: bad orderDetails length for standard");
+ }
+
+ return
+ getStandardExecutions(
+ details.orders[0],
+ details.fulfiller,
+ details.fulfillerConduitKey,
+ details.recipient,
+ details.nativeTokensSupplied,
+ details.seaport
+ );
+ }
+
+ /**
+ * @dev Return executions for fulfilOrder and fulfillAdvancedOrder.
+ */
+ function getStandardExecutions(
+ OrderDetails memory orderDetails,
+ address fulfiller,
+ bytes32 fulfillerConduitKey,
+ address recipient,
+ uint256 nativeTokensSupplied,
+ address seaport
+ )
+ public
+ pure
+ returns (
+ Execution[] memory implicitExecutions,
+ uint256 nativeTokensReturned
+ )
+ {
+ uint256 currentSeaportBalance = 0;
+
+ // implicit executions (use max and resize at end):
+ // - supplying native tokens (0-1)
+ // - providing native tokens from contract offerer (0-offer.length)
+ // - transferring offer items to recipient (offer.length)
+ // - transferring consideration items to each recipient (consideration.length)
+ // - returning unspent native tokens (0-1)
+ implicitExecutions = new Execution[](
+ 2 *
+ orderDetails.offer.length +
+ orderDetails.consideration.length +
+ 2
+ );
+
+ uint256 executionIndex = 0;
+
+ if (nativeTokensSupplied > 0) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: uint256(0),
+ amount: nativeTokensSupplied,
+ recipient: payable(seaport)
+ })
+ });
+ currentSeaportBalance += nativeTokensSupplied;
+ }
+
+ if (orderDetails.isContract) {
+ for (uint256 i = 0; i < orderDetails.offer.length; i++) {
+ SpentItem memory item = orderDetails.offer[i];
+ if (item.itemType == ItemType.NATIVE) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: orderDetails.offerer,
+ conduitKey: orderDetails.conduitKey,
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: uint256(0),
+ amount: orderDetails.offer[i].amount,
+ recipient: payable(seaport)
+ })
+ });
+ currentSeaportBalance += orderDetails.offer[i].amount;
+ }
+ }
+ }
+
+ for (uint256 i = 0; i < orderDetails.offer.length; i++) {
+ SpentItem memory item = orderDetails.offer[i];
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: item.itemType == ItemType.NATIVE
+ ? seaport
+ : orderDetails.offerer,
+ conduitKey: orderDetails.conduitKey,
+ item: ReceivedItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifier,
+ amount: item.amount,
+ recipient: payable(recipient)
+ })
+ });
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > currentSeaportBalance) {
+ revert(
+ "ExecutionHelper: offer item amount exceeds seaport balance"
+ );
+ }
+
+ currentSeaportBalance -= item.amount;
+ }
+ }
+
+ for (uint256 i = 0; i < orderDetails.consideration.length; i++) {
+ ReceivedItem memory item = orderDetails.consideration[i];
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: item.itemType == ItemType.NATIVE ? seaport : fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: item
+ });
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > currentSeaportBalance) {
+ revert(
+ "ExecutionHelper: consideration item amount exceeds seaport balance"
+ );
+ }
+
+ currentSeaportBalance -= item.amount;
+ }
+ }
+
+ nativeTokensReturned = currentSeaportBalance;
+
+ if (currentSeaportBalance > 0) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: seaport,
+ conduitKey: bytes32(0),
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: 0,
+ amount: currentSeaportBalance,
+ recipient: payable(fulfiller)
+ })
+ });
+ }
+
+ // Set actual length of the implicit executions array.
+ assembly {
+ mstore(implicitExecutions, executionIndex)
+ }
+ }
+
+ function getBasicExecutions(
+ FulfillmentDetails memory details
+ )
+ public
+ pure
+ returns (
+ Execution[] memory implicitExecutions,
+ uint256 nativeTokensReturned
+ )
+ {
+ if (details.orders.length != 1) {
+ revert("ExecutionHelper: bad orderDetails length for basic");
+ }
+
+ return
+ getBasicExecutions(
+ details.orders[0],
+ details.fulfiller,
+ details.fulfillerConduitKey,
+ details.nativeTokensSupplied,
+ details.seaport
+ );
+ }
+
+ /**
+ * @dev return executions for fulfillBasicOrder and
+ * fulfillBasicOrderEfficient.
+ */
+ function getBasicExecutions(
+ OrderDetails memory orderDetails,
+ address fulfiller,
+ bytes32 fulfillerConduitKey,
+ uint256 nativeTokensSupplied,
+ address seaport
+ )
+ public
+ pure
+ returns (
+ Execution[] memory implicitExecutions,
+ uint256 nativeTokensReturned
+ )
+ {
+ if (orderDetails.offer.length != 1) {
+ revert("not a basic order");
+ }
+
+ if (orderDetails.offer[0].itemType == ItemType.ERC20) {
+ require(nativeTokensSupplied == 0, "native tokens not allowed");
+ require(orderDetails.consideration.length > 0, "no items received");
+
+ implicitExecutions = new Execution[](
+ 1 + orderDetails.consideration.length
+ );
+
+ implicitExecutions[0] = Execution({
+ offerer: fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: orderDetails.consideration[0]
+ });
+
+ uint256 additionalAmounts = 0;
+
+ for (uint256 i = 1; i < orderDetails.consideration.length; i++) {
+ implicitExecutions[i] = Execution({
+ offerer: orderDetails.offerer,
+ conduitKey: orderDetails.conduitKey,
+ item: orderDetails.consideration[i]
+ });
+ additionalAmounts += orderDetails.consideration[i].amount;
+ }
+
+ implicitExecutions[orderDetails.consideration.length] = Execution({
+ offerer: orderDetails.offerer,
+ conduitKey: orderDetails.conduitKey,
+ item: ReceivedItem({
+ itemType: orderDetails.offer[0].itemType,
+ token: orderDetails.offer[0].token,
+ identifier: orderDetails.offer[0].identifier,
+ amount: orderDetails.offer[0].amount - additionalAmounts,
+ recipient: payable(fulfiller)
+ })
+ });
+ } else {
+ uint256 currentSeaportBalance = 0;
+
+ // implicit executions (use max and resize at end):
+ // - supplying native tokens (0-1)
+ // - transferring offer item to recipient (1)
+ // - transfer additional recipient consideration items (consideration.length - 1)
+ // - transfer first consideration item to the fulfiller (1)
+ // - returning unspent native tokens (0-1)
+ implicitExecutions = new Execution[](
+ orderDetails.consideration.length + 3
+ );
+
+ uint256 executionIndex = 0;
+
+ if (nativeTokensSupplied > 0) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: uint256(0),
+ amount: nativeTokensSupplied,
+ recipient: payable(seaport)
+ })
+ });
+ currentSeaportBalance += nativeTokensSupplied;
+ }
+
+ {
+ if (orderDetails.offer.length != 1) {
+ revert("ExecutionHelper: wrong length for basic offer");
+ }
+ SpentItem memory offerItem = orderDetails.offer[0];
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: orderDetails.offerer,
+ conduitKey: orderDetails.conduitKey,
+ item: ReceivedItem({
+ itemType: offerItem.itemType,
+ token: offerItem.token,
+ identifier: offerItem.identifier,
+ amount: offerItem.amount,
+ recipient: payable(fulfiller)
+ })
+ });
+ }
+
+ for (uint256 i = 1; i < orderDetails.consideration.length; i++) {
+ ReceivedItem memory item = orderDetails.consideration[i];
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: item.itemType == ItemType.NATIVE
+ ? seaport
+ : fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: item
+ });
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > currentSeaportBalance) {
+ revert(
+ "ExecutionHelper: basic consideration item amount exceeds seaport balance"
+ );
+ }
+
+ currentSeaportBalance -= item.amount;
+ }
+ }
+
+ {
+ if (orderDetails.consideration.length < 1) {
+ revert(
+ "ExecutionHelper: wrong length for basic consideration"
+ );
+ }
+ ReceivedItem memory item = orderDetails.consideration[0];
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: item.itemType == ItemType.NATIVE
+ ? seaport
+ : fulfiller,
+ conduitKey: fulfillerConduitKey,
+ item: item
+ });
+ if (item.itemType == ItemType.NATIVE) {
+ if (item.amount > currentSeaportBalance) {
+ revert(
+ "ExecutionHelper: first basic consideration item amount exceeds seaport balance"
+ );
+ }
+
+ currentSeaportBalance -= item.amount;
+ }
+ }
+
+ nativeTokensReturned = currentSeaportBalance;
+
+ if (currentSeaportBalance > 0) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: seaport,
+ conduitKey: bytes32(0),
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: 0,
+ amount: currentSeaportBalance,
+ recipient: payable(fulfiller)
+ })
+ });
+ }
+
+ // Set actual length of the implicit executions array.
+ assembly {
+ mstore(implicitExecutions, executionIndex)
+ }
+ }
+ }
+
+ /**
+ * @dev Get the item and recipient for a given fulfillment component.
+ *
+ * @param fulfillmentDetails The order fulfillment details
+ * @param offerRecipient The offer recipient
+ * @param component The fulfillment component
+ * @param side The side of the order
+ *
+ * @return item The item
+ * @return trueRecipient The actual recipient
+ */
+ function getItemAndRecipient(
+ FulfillmentDetails memory fulfillmentDetails,
+ address payable offerRecipient,
+ FulfillmentComponent memory component,
+ Side side
+ )
+ internal
+ pure
+ returns (SpentItem memory item, address payable trueRecipient)
+ {
+ OrderDetails memory details = fulfillmentDetails.orders[
+ component.orderIndex
+ ];
+
+ if (side == Side.OFFER) {
+ item = details.offer[component.itemIndex];
+ trueRecipient = offerRecipient;
+ } else {
+ ReceivedItem memory _item = details.consideration[
+ component.itemIndex
+ ];
+ // cast to SpentItem
+ assembly {
+ item := _item
+ }
+ trueRecipient = _item.recipient;
+ }
+ }
+
+ /**
+ * @dev Process the aggregated fulfillment components for a given side of an
+ * order.
+ *
+ * @param fulfillmentDetails The order fulfillment details
+ * @param offerRecipient The recipient for any offer items. Note: may
+ * not be FulfillmentDetails' recipient, eg,
+ * when processing matchOrders fulfillments
+ * @param aggregatedComponents The aggregated fulfillment components
+ * @param side The side of the order
+ *
+ * @return The execution
+ */
+ function processExecutionFromAggregatedFulfillmentComponents(
+ FulfillmentDetails memory fulfillmentDetails,
+ address payable offerRecipient,
+ FulfillmentComponent[] memory aggregatedComponents,
+ Side side
+ ) internal pure returns (Execution memory) {
+ // aggregate the amounts of each item
+ uint256 aggregatedAmount;
+ for (uint256 j = 0; j < aggregatedComponents.length; j++) {
+ (SpentItem memory item, ) = getItemAndRecipient(
+ fulfillmentDetails,
+ offerRecipient,
+ aggregatedComponents[j],
+ side
+ );
+ aggregatedAmount += item.amount;
+ }
+
+ // use the first fulfillment component to get the order details
+ FulfillmentComponent memory first = aggregatedComponents[0];
+ (
+ SpentItem memory firstItem,
+ address payable trueRecipient
+ ) = getItemAndRecipient(
+ fulfillmentDetails,
+ offerRecipient,
+ first,
+ side
+ );
+ OrderDetails memory details = fulfillmentDetails.orders[
+ first.orderIndex
+ ];
+
+ return
+ Execution({
+ offerer: side == Side.OFFER
+ ? details.offerer
+ : fulfillmentDetails.fulfiller,
+ conduitKey: side == Side.OFFER
+ ? details.conduitKey
+ : fulfillmentDetails.fulfillerConduitKey,
+ item: ReceivedItem({
+ itemType: firstItem.itemType,
+ token: firstItem.token,
+ identifier: firstItem.identifier,
+ amount: aggregatedAmount,
+ recipient: trueRecipient
+ })
+ });
+ }
+
+ /**
+ * @dev Process explicit executions from 2d aggregated fulfillAvailable
+ * fulfillment components arrays. Note that amounts on OrderDetails are
+ * modified in-place during fulfillment processing.
+ *
+ * @param fulfillmentDetails The fulfillment details
+ * @param offerComponents The offer components
+ * @param considerationComponents The consideration components
+ *
+ * @return explicitExecutions The explicit executions
+ */
+ function processExplicitExecutionsFromAggregatedComponents(
+ FulfillmentDetails memory fulfillmentDetails,
+ FulfillmentComponent[][] memory offerComponents,
+ FulfillmentComponent[][] memory considerationComponents,
+ bool[] memory availableOrders
+ ) internal pure returns (Execution[] memory explicitExecutions) {
+ explicitExecutions = new Execution[](
+ offerComponents.length + considerationComponents.length
+ );
+
+ uint256 filteredExecutions = 0;
+
+ // process offer components
+ // iterate over each array of fulfillment components
+ for (uint256 i = 0; i < offerComponents.length; i++) {
+ FulfillmentComponent[]
+ memory aggregatedComponents = offerComponents[i];
+
+ // aggregate & zero-out the amounts of each offer item
+ uint256 aggregatedAmount;
+ for (uint256 j = 0; j < aggregatedComponents.length; j++) {
+ FulfillmentComponent memory component = aggregatedComponents[j];
+
+ if (!availableOrders[component.orderIndex]) {
+ continue;
+ }
+
+ OrderDetails memory offerOrderDetails = fulfillmentDetails
+ .orders[component.orderIndex];
+
+ if (component.itemIndex < offerOrderDetails.offer.length) {
+ SpentItem memory item = offerOrderDetails.offer[
+ component.itemIndex
+ ];
+
+ aggregatedAmount += item.amount;
+
+ item.amount = 0;
+ }
+ }
+
+ if (aggregatedAmount == 0) {
+ filteredExecutions++;
+ continue;
+ }
+
+ // use the first fulfillment component to get the order details
+ FulfillmentComponent memory first = aggregatedComponents[0];
+ OrderDetails memory details = fulfillmentDetails.orders[
+ first.orderIndex
+ ];
+ SpentItem memory firstItem = details.offer[first.itemIndex];
+
+ if (
+ fulfillmentDetails.recipient == details.offerer &&
+ firstItem.itemType != ItemType.NATIVE
+ ) {
+ filteredExecutions++;
+ } else {
+ explicitExecutions[i - filteredExecutions] = Execution({
+ offerer: details.offerer,
+ conduitKey: details.conduitKey,
+ item: ReceivedItem({
+ itemType: firstItem.itemType,
+ token: firstItem.token,
+ identifier: firstItem.identifier,
+ amount: aggregatedAmount,
+ recipient: fulfillmentDetails.recipient
+ })
+ });
+ }
+ }
+
+ // process consideration components
+ // iterate over each array of fulfillment components
+ for (uint256 i; i < considerationComponents.length; i++) {
+ FulfillmentComponent[]
+ memory aggregatedComponents = considerationComponents[i];
+
+ // aggregate & zero-out the amounts of each offer item
+ uint256 aggregatedAmount;
+ for (uint256 j = 0; j < aggregatedComponents.length; j++) {
+ FulfillmentComponent memory component = aggregatedComponents[j];
+
+ if (!availableOrders[component.orderIndex]) {
+ continue;
+ }
+
+ OrderDetails
+ memory considerationOrderDetails = fulfillmentDetails
+ .orders[component.orderIndex];
+
+ if (
+ component.itemIndex <
+ considerationOrderDetails.consideration.length
+ ) {
+ ReceivedItem memory item = considerationOrderDetails
+ .consideration[component.itemIndex];
+
+ aggregatedAmount += item.amount;
+
+ item.amount = 0;
+ }
+ }
+
+ if (aggregatedAmount == 0) {
+ filteredExecutions++;
+ continue;
+ }
+
+ // use the first fulfillment component to get the order details
+ FulfillmentComponent memory first = aggregatedComponents[0];
+ OrderDetails memory details = fulfillmentDetails.orders[
+ first.orderIndex
+ ];
+ ReceivedItem memory firstItem = details.consideration[
+ first.itemIndex
+ ];
+
+ if (
+ firstItem.recipient == fulfillmentDetails.fulfiller &&
+ firstItem.itemType != ItemType.NATIVE
+ ) {
+ filteredExecutions++;
+ } else {
+ explicitExecutions[
+ i + offerComponents.length - filteredExecutions
+ ] = Execution({
+ offerer: fulfillmentDetails.fulfiller,
+ conduitKey: fulfillmentDetails.fulfillerConduitKey,
+ item: ReceivedItem({
+ itemType: firstItem.itemType,
+ token: firstItem.token,
+ identifier: firstItem.identifier,
+ amount: aggregatedAmount,
+ recipient: firstItem.recipient
+ })
+ });
+ }
+ }
+
+ // If some number of executions have been filtered...
+ if (filteredExecutions != 0) {
+ // reduce the total length of the executions array.
+ assembly {
+ mstore(
+ explicitExecutions,
+ sub(mload(explicitExecutions), filteredExecutions)
+ )
+ }
+ }
+ }
+
+ /**
+ * @dev Process an array of *sorted* fulfillment components into an array of
+ * executions. Note that components must be sorted.
+ *
+ * @param orderDetails The order details
+ * @param components The fulfillment components
+ * @param recipient The recipient of implicit executions
+ *
+ * @return executions The executions
+ */
+ function processExecutionsFromIndividualOfferFulfillmentComponents(
+ OrderDetails[] memory orderDetails,
+ address payable recipient,
+ FulfillmentComponent[] memory components
+ ) internal pure returns (Execution[] memory executions) {
+ executions = new Execution[](components.length);
+
+ for (uint256 i = 0; i < components.length; i++) {
+ FulfillmentComponent memory component = components[i];
+ OrderDetails memory details = orderDetails[component.orderIndex];
+ SpentItem memory item = details.offer[component.itemIndex];
+ executions[i] = Execution({
+ offerer: details.offerer,
+ conduitKey: details.conduitKey,
+ item: ReceivedItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifier,
+ amount: item.amount,
+ recipient: recipient
+ })
+ });
+ }
+ }
+
+ /**
+ * @dev Generate implicit Executions for a set of orders by getting all
+ * offer items that are not fully spent as part of a fulfillment.
+ *
+ * @param fulfillmentDetails fulfillment details
+ *
+ * @return implicitExecutions The implicit executions
+ */
+ function processImplicitPreOrderExecutions(
+ FulfillmentDetails memory fulfillmentDetails,
+ bool[] memory availableOrders
+ ) internal pure returns (Execution[] memory implicitExecutions) {
+ // Get the maximum possible number of implicit executions.
+ uint256 maxPossible = 1;
+ for (uint256 i = 0; i < fulfillmentDetails.orders.length; ++i) {
+ if (availableOrders[i]) {
+ maxPossible += fulfillmentDetails.orders[i].offer.length;
+ }
+ }
+ implicitExecutions = new Execution[](maxPossible);
+
+ uint256 executionIndex;
+ if (fulfillmentDetails.nativeTokensSupplied > 0) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: fulfillmentDetails.fulfiller,
+ conduitKey: bytes32(0),
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: uint256(0),
+ amount: fulfillmentDetails.nativeTokensSupplied,
+ recipient: payable(fulfillmentDetails.seaport)
+ })
+ });
+ }
+
+ for (uint256 o; o < fulfillmentDetails.orders.length; o++) {
+ OrderDetails memory orderDetails = fulfillmentDetails.orders[o];
+ if (!availableOrders[o]) {
+ continue;
+ }
+
+ if (orderDetails.isContract) {
+ for (uint256 i = 0; i < orderDetails.offer.length; i++) {
+ SpentItem memory item = orderDetails.offer[i];
+ if (item.itemType == ItemType.NATIVE) {
+ implicitExecutions[executionIndex++] = Execution({
+ offerer: orderDetails.offerer,
+ conduitKey: bytes32(0),
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: uint256(0),
+ amount: item.amount,
+ recipient: payable(fulfillmentDetails.seaport)
+ })
+ });
+ }
+ }
+ }
+ }
+
+ // Set the final length of the implicit executions array.
+ // Leave space for possible excess native token return.
+ assembly {
+ mstore(implicitExecutions, executionIndex)
+ }
+ }
+
+ /**
+ * @dev Generate implicit Executions for a set of orders by getting all
+ * offer items that are not fully spent as part of a fulfillment.
+ *
+ * @param fulfillmentDetails fulfillment details
+ *
+ * @return implicitExecutions The implicit executions
+ */
+ function processImplicitPostOrderExecutions(
+ FulfillmentDetails memory fulfillmentDetails,
+ bool[] memory availableOrders
+ ) internal pure returns (Execution[] memory implicitExecutions) {
+ OrderDetails[] memory orderDetails = fulfillmentDetails.orders;
+
+ // Get the maximum possible number of implicit executions.
+ uint256 maxPossible = 1;
+ for (uint256 i = 0; i < orderDetails.length; ++i) {
+ if (availableOrders[i]) {
+ maxPossible += orderDetails[i].offer.length;
+ }
+ }
+
+ // Insert an implicit execution for each non-zero offer item.
+ implicitExecutions = new Execution[](maxPossible);
+ uint256 insertionIndex = 0;
+ for (uint256 i = 0; i < orderDetails.length; ++i) {
+ if (!availableOrders[i]) {
+ continue;
+ }
+
+ OrderDetails memory details = orderDetails[i];
+ for (uint256 j; j < details.offer.length; ++j) {
+ SpentItem memory item = details.offer[j];
+ if (item.amount != 0) {
+ // Insert the item and increment insertion index.
+ implicitExecutions[insertionIndex++] = Execution({
+ offerer: item.itemType == ItemType.NATIVE
+ ? fulfillmentDetails.seaport
+ : details.offerer,
+ conduitKey: details.conduitKey,
+ item: ReceivedItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifier,
+ amount: item.amount,
+ recipient: fulfillmentDetails.recipient
+ })
+ });
+ }
+ }
+ }
+
+ // Set the final length of the implicit executions array.
+ // Leave space for possible excess native token return.
+ assembly {
+ mstore(implicitExecutions, add(insertionIndex, 1))
+ }
+ }
+
+ /**
+ * @dev Process a Fulfillment into an Execution
+ *
+ * @param fulfillmentDetails fulfillment details
+ * @param fulfillment A Fulfillment.
+ *
+ * @return An Execution.
+ */
+ function processExecutionFromFulfillment(
+ FulfillmentDetails memory fulfillmentDetails,
+ Fulfillment memory fulfillment
+ ) internal pure returns (Execution memory) {
+ // aggregate & zero-out the amounts of each offer item
+ uint256 aggregatedOfferAmount;
+ for (uint256 j = 0; j < fulfillment.offerComponents.length; j++) {
+ FulfillmentComponent memory component = fulfillment.offerComponents[
+ j
+ ];
+
+ OrderDetails memory details = fulfillmentDetails.orders[
+ component.orderIndex
+ ];
+
+ if (component.itemIndex < details.offer.length) {
+ SpentItem memory offerSpentItem = details.offer[
+ component.itemIndex
+ ];
+
+ aggregatedOfferAmount += offerSpentItem.amount;
+
+ offerSpentItem.amount = 0;
+ }
+ }
+
+ // aggregate & zero-out the amounts of each offer item
+ uint256 aggregatedConsiderationAmount;
+ for (
+ uint256 j = 0;
+ j < fulfillment.considerationComponents.length;
+ j++
+ ) {
+ FulfillmentComponent memory component = fulfillment
+ .considerationComponents[j];
+
+ OrderDetails memory details = fulfillmentDetails.orders[
+ component.orderIndex
+ ];
+
+ if (component.itemIndex < details.consideration.length) {
+ ReceivedItem memory considerationSpentItem = details
+ .consideration[component.itemIndex];
+
+ aggregatedConsiderationAmount += considerationSpentItem.amount;
+
+ considerationSpentItem.amount = 0;
+ }
+ }
+
+ // Get the first item on each side
+ FulfillmentComponent memory firstOfferComponent = fulfillment
+ .offerComponents[0];
+ OrderDetails memory sourceOrder = fulfillmentDetails.orders[
+ firstOfferComponent.orderIndex
+ ];
+
+ FulfillmentComponent memory firstConsiderationComponent = fulfillment
+ .considerationComponents[0];
+ ReceivedItem memory item = fulfillmentDetails
+ .orders[firstConsiderationComponent.orderIndex]
+ .consideration[firstConsiderationComponent.itemIndex];
+
+ // put back any extra (TODO: put it on first *in-range* item)
+ uint256 amount = aggregatedOfferAmount;
+ if (aggregatedOfferAmount > aggregatedConsiderationAmount) {
+ sourceOrder
+ .offer[firstOfferComponent.itemIndex]
+ .amount += (aggregatedOfferAmount -
+ aggregatedConsiderationAmount);
+ amount = aggregatedConsiderationAmount;
+ } else if (aggregatedOfferAmount < aggregatedConsiderationAmount) {
+ item.amount += (aggregatedConsiderationAmount -
+ aggregatedOfferAmount);
+ }
+
+ return
+ Execution({
+ offerer: sourceOrder.offerer,
+ conduitKey: sourceOrder.conduitKey,
+ item: ReceivedItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifier,
+ amount: amount,
+ recipient: item.recipient
+ })
+ });
+ }
+
+ /**
+ * @dev Process excess native tokens. If there are excess native tokens,
+ * insert an implicit execution at the end of the implicitExecutions
+ * array. If not, reduce the length of the implicitExecutions array.
+ *
+ * @param fulfillmentDetails fulfillment details
+ * @param explicitExecutions explicit executions
+ * @param implicitExecutionsPre implicit executions
+ * @param implicitExecutionsPost implicit executions
+ */
+ function _handleExcessNativeTokens(
+ FulfillmentDetails memory fulfillmentDetails,
+ Execution[] memory explicitExecutions,
+ Execution[] memory implicitExecutionsPre,
+ Execution[] memory implicitExecutionsPost
+ ) internal pure returns (uint256 excessNativeTokens) {
+ excessNativeTokens = processExcessNativeTokens(
+ explicitExecutions,
+ implicitExecutionsPre,
+ implicitExecutionsPost
+ );
+
+ if (excessNativeTokens > 0) {
+ implicitExecutionsPost[
+ implicitExecutionsPost.length - 1
+ ] = Execution({
+ offerer: fulfillmentDetails.seaport,
+ conduitKey: bytes32(0),
+ item: ReceivedItem({
+ itemType: ItemType.NATIVE,
+ token: address(0),
+ identifier: 0,
+ amount: excessNativeTokens,
+ recipient: fulfillmentDetails.fulfiller
+ })
+ });
+ } else {
+ // Reduce length of the implicit executions array by one.
+ assembly {
+ mstore(
+ implicitExecutionsPost,
+ sub(mload(implicitExecutionsPost), 1)
+ )
+ }
+ }
+ }
+
+ function copy(
+ OrderDetails[] memory orderDetails
+ ) internal pure returns (OrderDetails[] memory copiedOrderDetails) {
+ copiedOrderDetails = new OrderDetails[](orderDetails.length);
+ for (uint256 i = 0; i < orderDetails.length; ++i) {
+ OrderDetails memory order = orderDetails[i];
+
+ copiedOrderDetails[i] = OrderDetails({
+ offerer: order.offerer,
+ conduitKey: order.conduitKey,
+ offer: order.offer.copy(),
+ consideration: order.consideration.copy(),
+ isContract: order.isContract,
+ orderHash: order.orderHash,
+ unavailableReason: order.unavailableReason
+ });
+ }
+ }
+
+ function copy(
+ FulfillmentDetails memory fulfillmentDetails
+ ) internal pure returns (FulfillmentDetails memory) {
+ return
+ FulfillmentDetails({
+ orders: copy(fulfillmentDetails.orders),
+ recipient: fulfillmentDetails.recipient,
+ fulfiller: fulfillmentDetails.fulfiller,
+ nativeTokensSupplied: fulfillmentDetails.nativeTokensSupplied,
+ fulfillerConduitKey: fulfillmentDetails.fulfillerConduitKey,
+ seaport: fulfillmentDetails.seaport
+ });
+ }
+}
diff --git a/contracts/helpers/sol/executions/FulfillmentComponentSet.sol b/contracts/helpers/sol/executions/FulfillmentComponentSet.sol
new file mode 100644
index 000000000..0bc9e7901
--- /dev/null
+++ b/contracts/helpers/sol/executions/FulfillmentComponentSet.sol
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { FulfillmentComponent } from "../SeaportStructs.sol";
+
+struct FulfillmentComponentSet {
+ mapping(bytes32 => uint256) offByOneIndex;
+ FulfillmentComponent[] enumeration;
+}
+
+library FulfillmentComponentSetLib {
+ error NotPresent();
+
+ function add(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal returns (bool added) {
+ // add value to enumeration; hash it to set its entry in the offByOneIndex
+ bytes32 key = keccak256(abi.encode(value));
+ if (set.offByOneIndex[key] == 0) {
+ set.enumeration.push(value);
+ set.offByOneIndex[key] = set.enumeration.length;
+ added = true;
+ } else {
+ added = false;
+ }
+ }
+
+ // remove value from enumeration and replace it with last member of enumeration
+ // if not last member, update offByOneIndex of last member
+ function remove(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal returns (bool removed) {
+ bytes32 key = keccak256(abi.encode(value));
+ uint256 index = set.offByOneIndex[key];
+ if (index > 0) {
+ uint256 lastIndex = set.enumeration.length - 1;
+ FulfillmentComponent memory lastValue = set.enumeration[lastIndex];
+ set.enumeration[index - 1] = lastValue;
+ bytes32 lastKey = keccak256(abi.encode(lastValue));
+ // if lastKey is the same as key, then we are removing the last element; do not update it
+ if (lastKey != key) {
+ set.offByOneIndex[lastKey] = index;
+ }
+ set.enumeration.pop();
+ delete set.offByOneIndex[key];
+ removed = true;
+ } else {
+ removed = false;
+ }
+ }
+
+ function removeAll(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent[] memory values
+ ) internal {
+ for (uint256 i = 0; i < values.length; i++) {
+ remove(set, values[i]);
+ }
+ }
+
+ function removeAll(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent[][] memory values
+ ) internal {
+ for (uint256 i = 0; i < values.length; i++) {
+ removeAll(set, values[i]);
+ }
+ }
+
+ function contains(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal view returns (bool) {
+ return set.offByOneIndex[keccak256(abi.encode(value))] > 0;
+ }
+
+ function length(
+ FulfillmentComponentSet storage set
+ ) internal view returns (uint256) {
+ return set.enumeration.length;
+ }
+
+ function at(
+ FulfillmentComponentSet storage set,
+ uint256 index
+ ) internal view returns (FulfillmentComponent memory) {
+ return set.enumeration[index];
+ }
+
+ function clear(FulfillmentComponentSet storage set) internal {
+ while (set.enumeration.length > 0) {
+ FulfillmentComponent memory component = set.enumeration[
+ set.enumeration.length - 1
+ ];
+ delete set.offByOneIndex[keccak256(abi.encode(component))];
+ set.enumeration.pop();
+ }
+ }
+}
diff --git a/contracts/helpers/sol/executions/FulfillmentComponentSortLib.sol b/contracts/helpers/sol/executions/FulfillmentComponentSortLib.sol
new file mode 100644
index 000000000..8b9ef90c1
--- /dev/null
+++ b/contracts/helpers/sol/executions/FulfillmentComponentSortLib.sol
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { FulfillmentComponent } from "../SeaportStructs.sol";
+
+library FulfillmentComponentSortLib {
+ function key(
+ FulfillmentComponent memory component
+ ) internal pure returns (uint256) {
+ return (uint256(component.orderIndex) << 8) | component.itemIndex;
+ }
+
+ function sort(FulfillmentComponent[] memory components) internal pure {
+ sort(components, key);
+ }
+
+ // Sorts the array in-place with intro-quicksort.
+ function sort(
+ FulfillmentComponent[] memory a,
+ function(FulfillmentComponent memory)
+ internal
+ pure
+ returns (uint256) accessor
+ ) internal pure {
+ if (a.length < 2) {
+ return;
+ }
+
+ uint256[] memory stack = new uint256[](2 * a.length);
+ uint256 stackIndex = 0;
+
+ uint256 l = 0;
+ uint256 h = a.length - 1;
+
+ stack[stackIndex++] = l;
+ stack[stackIndex++] = h;
+
+ while (stackIndex > 0) {
+ h = stack[--stackIndex];
+ l = stack[--stackIndex];
+
+ if (h - l <= 12) {
+ // Insertion sort for small subarrays
+ for (uint256 i = l + 1; i <= h; i++) {
+ FulfillmentComponent memory k = a[i];
+ uint256 j = i;
+ while (j > l && accessor(a[j - 1]) > accessor(k)) {
+ a[j] = a[j - 1];
+ j--;
+ }
+ a[j] = k;
+ }
+ } else {
+ // Intro-Quicksort
+ uint256 p = (l + h) / 2;
+
+ // Median of 3
+ if (accessor(a[l]) > accessor(a[p])) {
+ (a[l], a[p]) = (a[p], a[l]);
+ }
+ if (accessor(a[l]) > accessor(a[h])) {
+ (a[l], a[h]) = (a[h], a[l]);
+ }
+ if (accessor(a[p]) > accessor(a[h])) {
+ (a[p], a[h]) = (a[h], a[p]);
+ }
+
+ uint256 pivot = accessor(a[p]);
+ uint256 i = l;
+ uint256 j = h;
+
+ while (i <= j) {
+ while (accessor(a[i]) < pivot) {
+ i++;
+ }
+ while (accessor(a[j]) > pivot) {
+ j--;
+ }
+ if (i <= j) {
+ (a[i], a[j]) = (a[j], a[i]);
+ i++;
+ j--;
+ }
+ }
+
+ if (j > l) {
+ stack[stackIndex++] = l;
+ stack[stackIndex++] = j;
+ }
+ if (i < h) {
+ stack[stackIndex++] = i;
+ stack[stackIndex++] = h;
+ }
+ }
+ }
+ }
+}
diff --git a/contracts/helpers/sol/executions/GenericEnumerableMapping.sol b/contracts/helpers/sol/executions/GenericEnumerableMapping.sol
new file mode 100644
index 000000000..0bc9e7901
--- /dev/null
+++ b/contracts/helpers/sol/executions/GenericEnumerableMapping.sol
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { FulfillmentComponent } from "../SeaportStructs.sol";
+
+struct FulfillmentComponentSet {
+ mapping(bytes32 => uint256) offByOneIndex;
+ FulfillmentComponent[] enumeration;
+}
+
+library FulfillmentComponentSetLib {
+ error NotPresent();
+
+ function add(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal returns (bool added) {
+ // add value to enumeration; hash it to set its entry in the offByOneIndex
+ bytes32 key = keccak256(abi.encode(value));
+ if (set.offByOneIndex[key] == 0) {
+ set.enumeration.push(value);
+ set.offByOneIndex[key] = set.enumeration.length;
+ added = true;
+ } else {
+ added = false;
+ }
+ }
+
+ // remove value from enumeration and replace it with last member of enumeration
+ // if not last member, update offByOneIndex of last member
+ function remove(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal returns (bool removed) {
+ bytes32 key = keccak256(abi.encode(value));
+ uint256 index = set.offByOneIndex[key];
+ if (index > 0) {
+ uint256 lastIndex = set.enumeration.length - 1;
+ FulfillmentComponent memory lastValue = set.enumeration[lastIndex];
+ set.enumeration[index - 1] = lastValue;
+ bytes32 lastKey = keccak256(abi.encode(lastValue));
+ // if lastKey is the same as key, then we are removing the last element; do not update it
+ if (lastKey != key) {
+ set.offByOneIndex[lastKey] = index;
+ }
+ set.enumeration.pop();
+ delete set.offByOneIndex[key];
+ removed = true;
+ } else {
+ removed = false;
+ }
+ }
+
+ function removeAll(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent[] memory values
+ ) internal {
+ for (uint256 i = 0; i < values.length; i++) {
+ remove(set, values[i]);
+ }
+ }
+
+ function removeAll(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent[][] memory values
+ ) internal {
+ for (uint256 i = 0; i < values.length; i++) {
+ removeAll(set, values[i]);
+ }
+ }
+
+ function contains(
+ FulfillmentComponentSet storage set,
+ FulfillmentComponent memory value
+ ) internal view returns (bool) {
+ return set.offByOneIndex[keccak256(abi.encode(value))] > 0;
+ }
+
+ function length(
+ FulfillmentComponentSet storage set
+ ) internal view returns (uint256) {
+ return set.enumeration.length;
+ }
+
+ function at(
+ FulfillmentComponentSet storage set,
+ uint256 index
+ ) internal view returns (FulfillmentComponent memory) {
+ return set.enumeration[index];
+ }
+
+ function clear(FulfillmentComponentSet storage set) internal {
+ while (set.enumeration.length > 0) {
+ FulfillmentComponent memory component = set.enumeration[
+ set.enumeration.length - 1
+ ];
+ delete set.offByOneIndex[keccak256(abi.encode(component))];
+ set.enumeration.pop();
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/available/FulfillAvailableHelper.sol b/contracts/helpers/sol/fulfillments/available/FulfillAvailableHelper.sol
new file mode 100644
index 000000000..f1460c0b2
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/available/FulfillAvailableHelper.sol
@@ -0,0 +1,402 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SeaportStructs.sol";
+import "../../lib/SeaportArrays.sol";
+import {
+ FulfillAvailableHelperStorageLayout,
+ FulfillmentHelperCounterLayout,
+ AggregatableOffer,
+ AggregatableConsideration
+} from "../lib/Structs.sol";
+import { FulfillAvailableLayout } from "./FulfillAvailableLayout.sol";
+import {
+ FULFILL_AVAILABLE_COUNTER_KEY,
+ FULFILL_AVAILABLE_STORAGE_BASE_KEY
+} from "../lib/Constants.sol";
+import { OrderDetails } from "../lib/Structs.sol";
+
+contract FulfillAvailableHelper {
+ /**
+ * @notice get naive 2d fulfillment component arrays for
+ * fulfillAvailableOrders, one 1d array for each offer and consideration
+ * item
+ * @param orders orders
+ * @return offer
+ * @return consideration
+ */
+ function getNaiveFulfillmentComponents(
+ Order[] memory orders
+ )
+ public
+ pure
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ OrderParameters[] memory orderParameters = new OrderParameters[](
+ orders.length
+ );
+ for (uint256 i = 0; i < orders.length; i++) {
+ orderParameters[i] = orders[i].parameters;
+ }
+ return getNaiveFulfillmentComponents(orderParameters);
+ }
+
+ /**
+ * @notice get naive 2d fulfillment component arrays for
+ * fulfillAvailableOrders, one 1d array for each offer and consideration
+ * item
+ * @param orders orders
+ * @return offer
+ * @return consideration
+ */
+ function getNaiveFulfillmentComponents(
+ AdvancedOrder[] memory orders
+ )
+ public
+ pure
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ OrderParameters[] memory orderParameters = new OrderParameters[](
+ orders.length
+ );
+ for (uint256 i = 0; i < orders.length; i++) {
+ orderParameters[i] = orders[i].parameters;
+ }
+ return getNaiveFulfillmentComponents(orderParameters);
+ }
+
+ /**
+ * @notice get naive 2d fulfillment component arrays for
+ * fulfillAvailableOrders, one 1d array for each offer and consideration
+ * item
+ * @param orderParameters orderParameters
+ * @return offer
+ * @return consideration
+ */
+ function getNaiveFulfillmentComponents(
+ OrderParameters[] memory orderParameters
+ )
+ public
+ pure
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ {
+ // get total number of offer items and consideration items
+ uint256 numOffers;
+ uint256 numConsiderations;
+ for (uint256 i = 0; i < orderParameters.length; i++) {
+ OrderParameters memory parameters = orderParameters[i];
+
+ numOffers += parameters.offer.length;
+ numConsiderations += parameters.consideration.length;
+ }
+
+ // create arrays
+ offer = new FulfillmentComponent[][](numOffers);
+ consideration = new FulfillmentComponent[][](numConsiderations);
+ }
+
+ uint256 offerIndex;
+ uint256 considerationIndex;
+ // iterate over orders again, creating one one-element array per offer and consideration item
+ for (uint256 i = 0; i < orderParameters.length; i++) {
+ OrderParameters memory parameters = orderParameters[i];
+ for (uint256 j; j < parameters.offer.length; j++) {
+ offer[offerIndex] = SeaportArrays.FulfillmentComponents(
+ FulfillmentComponent({ orderIndex: i, itemIndex: j })
+ );
+ ++offerIndex;
+ }
+ // do the same for consideration
+ for (uint256 j; j < parameters.consideration.length; j++) {
+ consideration[considerationIndex] = SeaportArrays
+ .FulfillmentComponents(
+ FulfillmentComponent({ orderIndex: i, itemIndex: j })
+ );
+ ++considerationIndex;
+ }
+ }
+ return (offer, consideration);
+ }
+
+ /**
+ * @notice get naive 2d fulfillment component arrays for
+ * fulfillAvailableOrders, one 1d array for each offer and consideration
+ * item
+ * @param orders OrderDetails[]
+ * @return offer
+ * @return consideration
+ */
+ function getNaiveFulfillmentComponents(
+ OrderDetails[] memory orders
+ )
+ public
+ pure
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ {
+ // get total number of offer items and consideration items
+ uint256 numOffers;
+ uint256 numConsiderations;
+ for (uint256 i = 0; i < orders.length; i++) {
+ OrderDetails memory order = orders[i];
+
+ numOffers += order.offer.length;
+ numConsiderations += order.consideration.length;
+ }
+
+ // create arrays
+ offer = new FulfillmentComponent[][](numOffers);
+ consideration = new FulfillmentComponent[][](numConsiderations);
+ }
+
+ uint256 offerIndex;
+ uint256 considerationIndex;
+ // iterate over orders again, creating one one-element array per offer and consideration item
+ for (uint256 i = 0; i < orders.length; i++) {
+ OrderDetails memory order = orders[i];
+ for (uint256 j; j < order.offer.length; j++) {
+ offer[offerIndex] = SeaportArrays.FulfillmentComponents(
+ FulfillmentComponent({ orderIndex: i, itemIndex: j })
+ );
+ ++offerIndex;
+ }
+ // do the same for consideration
+ for (uint256 j; j < order.consideration.length; j++) {
+ consideration[considerationIndex] = SeaportArrays
+ .FulfillmentComponents(
+ FulfillmentComponent({ orderIndex: i, itemIndex: j })
+ );
+ ++considerationIndex;
+ }
+ }
+ return (offer, consideration);
+ }
+
+ /**
+ * @notice Get aggregated fulfillment components for aggregatable types from the same offerer or to the same recipient
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @return offer
+ * @return consideration
+ */
+ function getAggregatedFulfillmentComponents(
+ Order[] memory orders
+ )
+ public
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ OrderParameters[] memory orderParameters = new OrderParameters[](
+ orders.length
+ );
+ for (uint256 i = 0; i < orders.length; i++) {
+ orderParameters[i] = orders[i].parameters;
+ }
+ return getAggregatedFulfillmentComponents(orderParameters);
+ }
+
+ /**
+ * @notice Get aggregated fulfillment components for aggregatable types from the same offerer or to the same recipient
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @return offer
+ * @return consideration
+ */
+ function getAggregatedFulfillmentComponents(
+ AdvancedOrder[] memory orders
+ )
+ public
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ OrderParameters[] memory orderParameters = new OrderParameters[](
+ orders.length
+ );
+ for (uint256 i = 0; i < orders.length; i++) {
+ orderParameters[i] = orders[i].parameters;
+ }
+ return getAggregatedFulfillmentComponents(orderParameters);
+ }
+
+ /**
+ * @notice Get aggregated fulfillment components for aggregatable types from the same offerer or to the same recipient
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @return offer
+ * @return consideration
+ */
+ function getAggregatedFulfillmentComponents(
+ OrderParameters[] memory orders
+ )
+ public
+ returns (
+ FulfillmentComponent[][] memory offer,
+ FulfillmentComponent[][] memory consideration
+ )
+ {
+ // increment counter to get clean mappings and enumeration
+ FulfillAvailableLayout.incrementFulfillmentCounter();
+ FulfillAvailableHelperStorageLayout
+ storage layout = FulfillAvailableLayout.getStorageLayout();
+
+ // iterate over each order
+ for (uint256 i; i < orders.length; ++i) {
+ OrderParameters memory parameters = orders[i];
+ preProcessOffer(
+ parameters.offer,
+ parameters.offerer,
+ parameters.conduitKey,
+ i,
+ layout
+ );
+ preProcessConsideration(parameters.consideration, i, layout);
+ }
+
+ // allocate offer arrays
+ offer = new FulfillmentComponent[][](layout.offerEnumeration.length);
+ // iterate over enumerated groupings and add to array
+ for (uint256 i; i < layout.offerEnumeration.length; ++i) {
+ AggregatableOffer memory token = layout.offerEnumeration[i];
+
+ offer[i] = layout.offerMap[token.contractAddress][token.tokenId][
+ token.offerer
+ ][token.conduitKey];
+ }
+ // do the same for considerations
+ consideration = new FulfillmentComponent[][](
+ layout.considerationEnumeration.length
+ );
+ for (uint256 i; i < layout.considerationEnumeration.length; ++i) {
+ AggregatableConsideration memory token = layout
+ .considerationEnumeration[i];
+ consideration[i] = layout.considerationMap[token.recipient][
+ token.contractAddress
+ ][token.tokenId];
+ }
+ return (offer, consideration);
+ }
+
+ function extend(
+ FulfillmentComponent[][] memory array,
+ FulfillmentComponent[] memory toAdd
+ ) internal pure returns (FulfillmentComponent[][] memory extended) {
+ extended = new FulfillmentComponent[][](array.length + 1);
+ for (uint256 i = 0; i < array.length; i++) {
+ extended[i] = array[i];
+ }
+ extended[array.length] = toAdd;
+ }
+
+ /**
+ * @notice Process offer items and insert them into enumeration and map
+ * @param offer offer items
+ * @param offerer offerer
+ * @param orderIndex order index of processed items
+ * @param layout layout
+ */
+ function preProcessOffer(
+ OfferItem[] memory offer,
+ address offerer,
+ bytes32 conduitKey,
+ uint256 orderIndex,
+ FulfillAvailableHelperStorageLayout storage layout
+ ) private {
+ // iterate over each offer item
+ for (uint256 j; j < offer.length; ++j) {
+ // create the fulfillment component for this offer item
+ FulfillmentComponent memory component = FulfillmentComponent({
+ orderIndex: orderIndex,
+ itemIndex: j
+ });
+ // grab order parameters to get offerer
+ // grab offer item
+ OfferItem memory item = offer[j];
+ // create enumeration struct
+ AggregatableOffer memory aggregatableOffer = AggregatableOffer({
+ offerer: offerer,
+ conduitKey: conduitKey,
+ contractAddress: item.token,
+ tokenId: item.identifierOrCriteria
+ });
+ // if it does not exist in the map, add it to our enumeration
+ if (
+ !FulfillAvailableLayout.aggregatableOfferExists(
+ aggregatableOffer,
+ layout
+ )
+ ) {
+ layout.offerEnumeration.push(aggregatableOffer);
+ }
+ // update mapping with this component
+ layout
+ .offerMap[aggregatableOffer.contractAddress][
+ aggregatableOffer.tokenId
+ ][aggregatableOffer.offerer][aggregatableOffer.conduitKey].push(
+ component
+ );
+ }
+ }
+
+ /**
+ * @notice Process consideration items and insert them into enumeration and map
+ * @param consideration consideration items
+ * @param orderIndex order index of processed items
+ * @param layout layout
+ */
+ function preProcessConsideration(
+ ConsiderationItem[] memory consideration,
+ uint256 orderIndex,
+ FulfillAvailableHelperStorageLayout storage layout
+ ) private {
+ // iterate over each offer item
+ for (uint256 j; j < consideration.length; ++j) {
+ // create the fulfillment component for this offer item
+ FulfillmentComponent memory component = FulfillmentComponent({
+ orderIndex: orderIndex,
+ itemIndex: j
+ });
+ // grab consideration item
+ ConsiderationItem memory item = consideration[j];
+ // create enumeration struct
+ AggregatableConsideration memory token = AggregatableConsideration({
+ recipient: item.recipient,
+ contractAddress: item.token,
+ tokenId: item.identifierOrCriteria
+ });
+ // if it does not exist in the map, add it to our enumeration
+ if (
+ !FulfillAvailableLayout.aggregatableConsiderationExists(
+ token,
+ layout
+ )
+ ) {
+ layout.considerationEnumeration.push(token);
+ }
+ // update mapping with this component
+ layout
+ .considerationMap[token.recipient][token.contractAddress][
+ token.tokenId
+ ].push(component);
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/available/FulfillAvailableLayout.sol b/contracts/helpers/sol/fulfillments/available/FulfillAvailableLayout.sol
new file mode 100644
index 000000000..d9fa4db8c
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/available/FulfillAvailableLayout.sol
@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ MatchComponent,
+ MatchComponentType
+} from "../../lib/types/MatchComponentType.sol";
+import {
+ FulfillAvailableHelperStorageLayout,
+ FulfillmentHelperCounterLayout,
+ AggregatableConsideration,
+ AggregatableOffer
+} from "../lib/Structs.sol";
+import {
+ FULFILL_AVAILABLE_COUNTER_KEY,
+ FULFILL_AVAILABLE_STORAGE_BASE_KEY
+} from "../lib/Constants.sol";
+
+library FulfillAvailableLayout {
+ /**
+ * @notice Check if a token already exists in a mapping by checking the length of the array at that slot
+ * @param token token to check
+ * @param layout storage layout
+ */
+ function aggregatableConsiderationExists(
+ AggregatableConsideration memory token,
+ FulfillAvailableHelperStorageLayout storage layout
+ ) internal view returns (bool) {
+ return
+ layout
+ .considerationMap[token.recipient][token.contractAddress][
+ token.tokenId
+ ].length > 0;
+ }
+
+ /**
+ * @notice Check if an entry into the offer component mapping already exists by checking its length
+ */
+ function aggregatableOfferExists(
+ AggregatableOffer memory offer,
+ FulfillAvailableHelperStorageLayout storage layout
+ ) internal view returns (bool) {
+ return
+ layout
+ .offerMap[offer.contractAddress][offer.tokenId][offer.offerer][
+ offer.conduitKey
+ ].length > 0;
+ }
+
+ /**
+ * @notice load storage layout for the current fulfillmentCounter
+ */
+ function getStorageLayout()
+ internal
+ view
+ returns (FulfillAvailableHelperStorageLayout storage layout)
+ {
+ FulfillmentHelperCounterLayout
+ storage counterLayout = getCounterLayout();
+ uint256 counter = counterLayout.fulfillmentCounter;
+ bytes32 storageLayoutKey = FULFILL_AVAILABLE_STORAGE_BASE_KEY;
+ assembly {
+ mstore(0, counter)
+ mstore(0x20, storageLayoutKey)
+ layout.slot := keccak256(0, 0x40)
+ }
+ }
+
+ /**
+ * @notice load storage layout for the counter itself
+ */
+ function getCounterLayout()
+ internal
+ pure
+ returns (FulfillmentHelperCounterLayout storage layout)
+ {
+ bytes32 counterLayoutKey = FULFILL_AVAILABLE_COUNTER_KEY;
+ assembly {
+ layout.slot := counterLayoutKey
+ }
+ }
+
+ /**
+ * @notice increment the fulfillmentCounter to effectively clear the mappings and enumerations between calls
+ */
+ function incrementFulfillmentCounter() internal {
+ FulfillmentHelperCounterLayout
+ storage counterLayout = getCounterLayout();
+ counterLayout.fulfillmentCounter += 1;
+ }
+
+ /**
+ * @notice Get the mapping of tokens for a given key (offer or consideration), derived from the hash of the key and the current fulfillmentCounter value
+ * @param key Original key used to derive the slot of the enumeration
+ */
+ function getMap(
+ bytes32 key
+ )
+ internal
+ view
+ returns (
+ mapping(address /*offererOrRecipient*/ => mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => MatchComponent[] /*components*/)))
+ storage map
+ )
+ {
+ bytes32 counterKey = FULFILL_AVAILABLE_COUNTER_KEY;
+ assembly {
+ mstore(0, key)
+ mstore(0x20, sload(counterKey))
+ map.slot := keccak256(0, 0x40)
+ }
+ }
+
+ /**
+ * @notice Get the enumeration of AggregatableConsiderations for a given key (offer or consideration), derived from the hash of the key and the current fulfillmentCounter value
+ * @param key Original key used to derive the slot of the enumeration
+ */
+ function getEnumeration(
+ bytes32 key
+ ) internal view returns (AggregatableConsideration[] storage tokens) {
+ bytes32 counterKey = FULFILL_AVAILABLE_COUNTER_KEY;
+ assembly {
+ mstore(0, key)
+ mstore(0x20, sload(counterKey))
+ tokens.slot := keccak256(0, 0x40)
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/lib/Constants.sol b/contracts/helpers/sol/fulfillments/lib/Constants.sol
new file mode 100644
index 000000000..d97eb31e7
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/lib/Constants.sol
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+// used to effectively "wipe" the mappings and enumerations each time getAggregated is called
+bytes32 constant MATCH_FULFILLMENT_COUNTER_KEY = keccak256(
+ "MatchFulfillmentHelper.fulfillmentCounter"
+);
+
+bytes32 constant MATCH_FULFILLMENT_STORAGE_BASE_KEY = keccak256(
+ "MatchFulfillmentHelper.storageBase"
+);
+
+// used to effectively "wipe" the mappings and enumerations each time getAggregated is called
+bytes32 constant FULFILL_AVAILABLE_COUNTER_KEY = keccak256(
+ "FulfillAvailableHelper.fulfillmentCounter"
+);
+
+bytes32 constant FULFILL_AVAILABLE_STORAGE_BASE_KEY = keccak256(
+ "FulfillAvailableHelper.storageBase"
+);
diff --git a/contracts/helpers/sol/fulfillments/lib/FulfillmentLib.sol b/contracts/helpers/sol/fulfillments/lib/FulfillmentLib.sol
new file mode 100644
index 000000000..4fa28488f
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/lib/FulfillmentLib.sol
@@ -0,0 +1,2271 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { LibPRNG } from "solady/src/utils/LibPRNG.sol";
+
+import { LibSort } from "solady/src/utils/LibSort.sol";
+
+import {
+ FulfillmentComponent,
+ Fulfillment,
+ Order,
+ AdvancedOrder,
+ OrderParameters,
+ SpentItem,
+ ReceivedItem,
+ CriteriaResolver
+} from "../../SeaportStructs.sol";
+
+import { ItemType, Side } from "../../SeaportEnums.sol";
+
+import { MatchComponent, OrderDetails } from "./Structs.sol";
+
+enum FulfillmentEligibility {
+ NONE,
+ FULFILL_AVAILABLE,
+ MATCH,
+ BOTH
+}
+
+enum AggregationStrategy {
+ MINIMUM, // Aggregate as few items as possible
+ MAXIMUM, // Aggregate as many items as possible
+ RANDOM // Randomize aggregation quantity
+ // NOTE: for match cases, there may be more sophisticated optimal strategies
+}
+
+enum FulfillAvailableStrategy {
+ KEEP_ALL, // Persist default aggregation strategy
+ DROP_SINGLE_OFFER, // Exclude aggregations for single offer items
+ DROP_ALL_OFFER, // Exclude offer aggregations (keep one if no consideration)
+ DROP_RANDOM_OFFER, // Exclude random offer aggregations
+ DROP_SINGLE_KEEP_FILTERED, // Exclude single unless it would be filtered
+ DROP_ALL_KEEP_FILTERED, // Exclude all unfilterable offer aggregations
+ DROP_RANDOM_KEEP_FILTERED // Exclude random, unfilterable offer aggregations
+}
+
+enum MatchStrategy {
+ MAX_FILTERS, // prioritize locating filterable executions
+ MIN_FILTERS, // prioritize avoiding filterable executions where possible
+ MAX_INCLUSION, // try not to leave any unspent offer items
+ MIN_INCLUSION, // leave as many unspent offer items as possible
+ MIN_INCLUSION_MAX_FILTERS, // leave unspent items if not filterable
+ MAX_EXECUTIONS, // use as many fulfillments as possible given aggregations
+ MIN_EXECUTIONS, // use as few fulfillments as possible given aggregations
+ MIN_EXECUTIONS_MAX_FILTERS // minimize fulfillments and prioritize filters
+ // NOTE: more sophisticated match strategies require modifying aggregations
+}
+
+enum ItemCategory {
+ NATIVE,
+ ERC721,
+ OTHER
+}
+
+struct FulfillmentStrategy {
+ AggregationStrategy aggregationStrategy;
+ FulfillAvailableStrategy fulfillAvailableStrategy;
+ MatchStrategy matchStrategy;
+}
+
+struct FulfillmentItem {
+ uint256 orderIndex;
+ uint256 itemIndex;
+ uint256 amount;
+ address account;
+}
+
+struct FulfillmentItems {
+ ItemCategory itemCategory;
+ uint256 totalAmount;
+ FulfillmentItem[] items;
+}
+
+struct DualFulfillmentItems {
+ FulfillmentItems[] offer;
+ FulfillmentItems[] consideration;
+}
+
+struct DualFulfillmentMatchContext {
+ ItemCategory itemCategory;
+ uint256 totalOfferAmount;
+ uint256 totalConsiderationAmount;
+}
+
+struct FulfillAvailableDetails {
+ DualFulfillmentItems items;
+ address caller;
+ address recipient;
+ uint256 totalItems;
+}
+
+struct MatchDetails {
+ DualFulfillmentItems[] items;
+ DualFulfillmentMatchContext[] context;
+ address recipient;
+ uint256 totalItems;
+}
+
+library FulfillmentGeneratorLib {
+ using LibPRNG for LibPRNG.PRNG;
+ using ItemReferenceLib for OrderDetails[];
+ using FulfillmentPrepLib for ItemReferenceLib.ItemReference[];
+
+ function getDefaultFulfillmentStrategy()
+ internal
+ pure
+ returns (FulfillmentStrategy memory)
+ {
+ return
+ FulfillmentStrategy({
+ aggregationStrategy: AggregationStrategy.MAXIMUM,
+ fulfillAvailableStrategy: FulfillAvailableStrategy.KEEP_ALL,
+ matchStrategy: MatchStrategy.MAX_INCLUSION
+ });
+ }
+
+ // This uses the "default" set of strategies and applies no randomization.
+ function getFulfillments(
+ OrderDetails[] memory orderDetails,
+ address recipient,
+ address caller
+ )
+ internal
+ pure
+ returns (
+ FulfillmentEligibility eligibility,
+ FulfillmentComponent[][] memory offerFulfillments,
+ FulfillmentComponent[][] memory considerationFulfillments,
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ uint256 seed = 0;
+
+ return
+ getFulfillments(
+ orderDetails,
+ getDefaultFulfillmentStrategy(),
+ recipient,
+ caller,
+ seed
+ );
+ }
+
+ function getFulfillments(
+ OrderDetails[] memory orderDetails,
+ FulfillmentStrategy memory strategy,
+ address recipient,
+ address caller,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ FulfillmentEligibility eligibility,
+ FulfillmentComponent[][] memory offerFulfillments,
+ FulfillmentComponent[][] memory considerationFulfillments,
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ ItemReferenceLib.ItemReference[] memory references = orderDetails
+ .getItemReferences(seed);
+
+ (
+ FulfillAvailableDetails memory fulfillAvailableDetails,
+ MatchDetails memory matchDetails
+ ) = references.getDetails(recipient, caller);
+
+ return
+ getFulfillmentsFromDetails(
+ fulfillAvailableDetails,
+ matchDetails,
+ strategy,
+ seed
+ );
+ }
+
+ function getFulfillmentsFromDetails(
+ FulfillAvailableDetails memory fulfillAvailableDetails,
+ MatchDetails memory matchDetails,
+ FulfillmentStrategy memory strategy,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ FulfillmentEligibility eligibility,
+ FulfillmentComponent[][] memory offerFulfillments,
+ FulfillmentComponent[][] memory considerationFulfillments,
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ assertSupportedStrategy(strategy);
+
+ (
+ fulfillments,
+ unspentOfferComponents,
+ unmetConsiderationComponents
+ ) = getMatchFulfillments(matchDetails, strategy, seed);
+
+ eligibility = determineEligibility(
+ fulfillAvailableDetails,
+ unmetConsiderationComponents.length
+ );
+
+ if (
+ eligibility == FulfillmentEligibility.FULFILL_AVAILABLE ||
+ eligibility == FulfillmentEligibility.BOTH
+ ) {
+ (
+ offerFulfillments,
+ considerationFulfillments
+ ) = getFulfillAvailableFulfillments(
+ fulfillAvailableDetails,
+ strategy,
+ seed
+ );
+ }
+ }
+
+ function assertSupportedStrategy(
+ FulfillmentStrategy memory strategy
+ ) internal pure {
+ // TODO: add more strategies here as support is added for them.
+ if (uint256(strategy.fulfillAvailableStrategy) > 3) {
+ revert(
+ "FulfillmentGeneratorLib: unsupported fulfillAvailable strategy"
+ );
+ }
+
+ MatchStrategy matchStrategy = strategy.matchStrategy;
+ if (matchStrategy != MatchStrategy.MAX_INCLUSION) {
+ revert("FulfillmentGeneratorLib: unsupported match strategy");
+ }
+ }
+
+ function determineEligibility(
+ FulfillAvailableDetails memory fulfillAvailableDetails,
+ uint256 totalUnmetConsiderationComponents
+ ) internal pure returns (FulfillmentEligibility) {
+ // FulfillAvailable: cannot be used if native offer items are present on
+ // non-contract orders or if ERC721 items with amounts != 1 are present.
+ // There must also be at least one unfiltered explicit execution. Note
+ // that it is also *very* tricky to use FulfillAvailable in cases where
+ // ERC721 items are present on both the offer side & consideration side.
+ bool eligibleForFulfillAvailable = determineFulfillAvailableEligibility(
+ fulfillAvailableDetails
+ );
+
+ // Match: cannot be used if there is no way to meet each consideration
+ // item. In these cases, remaining offer components should be returned.
+ bool eligibleForMatch = totalUnmetConsiderationComponents == 0;
+
+ if (eligibleForFulfillAvailable) {
+ return
+ eligibleForMatch
+ ? FulfillmentEligibility.BOTH
+ : FulfillmentEligibility.FULFILL_AVAILABLE;
+ }
+
+ return
+ eligibleForMatch
+ ? FulfillmentEligibility.MATCH
+ : FulfillmentEligibility.NONE;
+ }
+
+ // This uses the "default" set of strategies, applies no randomization, and
+ // does not give a recipient & will not properly detect filtered executions.
+ function getMatchedFulfillments(
+ OrderDetails[] memory orderDetails
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ return
+ getMatchFulfillments(
+ orderDetails.getItemReferences(0).getMatchDetailsFromReferences(
+ address(0)
+ )
+ );
+ }
+
+ // This does not give a recipient & so will not detect filtered executions.
+ function getMatchedFulfillments(
+ OrderDetails[] memory orderDetails,
+ FulfillmentStrategy memory strategy,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ return
+ getMatchFulfillments(
+ orderDetails.getItemReferences(0).getMatchDetailsFromReferences(
+ address(0)
+ ),
+ strategy,
+ seed
+ );
+ }
+
+ function getMatchDetails(
+ OrderDetails[] memory orderDetails,
+ FulfillmentStrategy memory strategy,
+ address recipient,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ return
+ getMatchFulfillments(
+ orderDetails
+ .getItemReferences(seed)
+ .getMatchDetailsFromReferences(recipient),
+ strategy,
+ seed
+ );
+ }
+
+ // This uses the "default" set of strategies and applies no randomization.
+ function getMatchFulfillments(
+ MatchDetails memory matchDetails
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ uint256 seed = 0;
+
+ return
+ getMatchFulfillments(
+ matchDetails,
+ getDefaultFulfillmentStrategy(),
+ seed
+ );
+ }
+
+ function getMatchFulfillments(
+ MatchDetails memory matchDetails,
+ FulfillmentStrategy memory strategy,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ MatchStrategy matchStrategy = strategy.matchStrategy;
+
+ if (matchStrategy == MatchStrategy.MAX_INCLUSION) {
+ (
+ fulfillments,
+ unspentOfferComponents,
+ unmetConsiderationComponents
+ ) = getMatchFulfillmentsUsingConsumeMethod(
+ matchDetails,
+ getMaxInclusionConsumeMethod(strategy.aggregationStrategy),
+ seed
+ );
+ } else {
+ revert("FulfillmentGeneratorLib: unsupported match strategy");
+ }
+ }
+
+ function getMaxInclusionConsumeMethod(
+ AggregationStrategy aggregationStrategy
+ )
+ internal
+ pure
+ returns (
+ function(FulfillmentItems memory, FulfillmentItems memory, uint256)
+ internal
+ pure
+ returns (Fulfillment memory)
+ )
+ {
+ if (aggregationStrategy == AggregationStrategy.MAXIMUM) {
+ return consumeMaximumItemsAndGetFulfillment;
+ } else if (aggregationStrategy == AggregationStrategy.MINIMUM) {
+ return consumeMinimumItemsAndGetFulfillment;
+ } else if (aggregationStrategy == AggregationStrategy.RANDOM) {
+ return consumeRandomItemsAndGetFulfillment;
+ } else {
+ revert(
+ "FulfillmentGeneratorLib: unknown match aggregation strategy"
+ );
+ }
+ }
+
+ function getTotalUncoveredComponents(
+ DualFulfillmentMatchContext[] memory contexts
+ )
+ internal
+ pure
+ returns (
+ uint256 totalUnspentOfferComponents,
+ uint256 totalUnmetConsiderationComponents
+ )
+ {
+ for (uint256 i = 0; i < contexts.length; ++i) {
+ DualFulfillmentMatchContext memory context = contexts[i];
+
+ if (context.totalConsiderationAmount > context.totalOfferAmount) {
+ ++totalUnmetConsiderationComponents;
+ } else if (
+ context.totalConsiderationAmount < context.totalOfferAmount
+ ) {
+ ++totalUnspentOfferComponents;
+ }
+ }
+ }
+
+ function getUncoveredComponents(
+ MatchDetails memory matchDetails
+ )
+ internal
+ pure
+ returns (
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ (
+ uint256 totalUnspentOfferComponents,
+ uint256 totalUnmetConsiderationComponents
+ ) = getTotalUncoveredComponents(matchDetails.context);
+
+ unspentOfferComponents = (
+ new MatchComponent[](totalUnspentOfferComponents)
+ );
+
+ unmetConsiderationComponents = (
+ new MatchComponent[](totalUnmetConsiderationComponents)
+ );
+
+ if (
+ totalUnspentOfferComponents + totalUnmetConsiderationComponents == 0
+ ) {
+ return (unspentOfferComponents, unmetConsiderationComponents);
+ }
+
+ totalUnspentOfferComponents = 0;
+ totalUnmetConsiderationComponents = 0;
+
+ for (uint256 i = 0; i < matchDetails.items.length; ++i) {
+ DualFulfillmentMatchContext memory context = (
+ matchDetails.context[i]
+ );
+
+ FulfillmentItems[] memory offer = matchDetails.items[i].offer;
+
+ FulfillmentItems[] memory consideration = (
+ matchDetails.items[i].consideration
+ );
+
+ if (context.totalConsiderationAmount > context.totalOfferAmount) {
+ uint256 amount = (context.totalConsiderationAmount -
+ context.totalOfferAmount);
+
+ if (consideration.length == 0) {
+ revert(
+ "FulfillmentGeneratorLib: empty consideration array"
+ );
+ }
+
+ if (consideration[0].items.length == 0) {
+ revert(
+ "FulfillmentGeneratorLib: empty consideration items"
+ );
+ }
+
+ FulfillmentItem memory item = consideration[0].items[0];
+
+ if (
+ item.orderIndex > type(uint8).max ||
+ item.itemIndex > type(uint8).max
+ ) {
+ revert(
+ "FulfillmentGeneratorLib: OOR consideration item index"
+ );
+ }
+
+ unmetConsiderationComponents[
+ totalUnmetConsiderationComponents++
+ ] = MatchComponent({
+ amount: amount,
+ orderIndex: uint8(item.orderIndex),
+ itemIndex: uint8(item.itemIndex)
+ });
+ } else if (
+ context.totalConsiderationAmount < context.totalOfferAmount
+ ) {
+ uint256 amount = (context.totalOfferAmount -
+ context.totalConsiderationAmount);
+
+ if (offer.length == 0) {
+ revert("FulfillmentGeneratorLib: empty offer array");
+ }
+
+ if (offer[0].items.length == 0) {
+ revert("FulfillmentGeneratorLib: empty offer items");
+ }
+
+ FulfillmentItem memory item = offer[0].items[0];
+
+ if (
+ item.orderIndex > type(uint8).max ||
+ item.itemIndex > type(uint8).max
+ ) {
+ revert("FulfillmentGeneratorLib: OOR offer item index");
+ }
+
+ unspentOfferComponents[
+ totalUnspentOfferComponents++
+ ] = MatchComponent({
+ amount: amount,
+ orderIndex: uint8(item.orderIndex),
+ itemIndex: uint8(item.itemIndex)
+ });
+ }
+ }
+
+ // Sanity checks
+ if (unspentOfferComponents.length != totalUnspentOfferComponents) {
+ revert(
+ "FulfillmentGeneratorLib: unspent match item assignment error"
+ );
+ }
+
+ if (
+ unmetConsiderationComponents.length !=
+ totalUnmetConsiderationComponents
+ ) {
+ revert(
+ "FulfillmentGeneratorLib: unmet match item assignment error"
+ );
+ }
+
+ for (uint256 i = 0; i < unspentOfferComponents.length; ++i) {
+ if (unspentOfferComponents[i].amount == 0) {
+ revert("FulfillmentGeneratorLib: unspent match amount of zero");
+ }
+ }
+
+ for (uint256 i = 0; i < unmetConsiderationComponents.length; ++i) {
+ if (unmetConsiderationComponents[i].amount == 0) {
+ revert("FulfillmentGeneratorLib: unmet match amount of zero");
+ }
+ }
+ }
+
+ function getMatchFulfillmentsUsingConsumeMethod(
+ MatchDetails memory matchDetails,
+ function(FulfillmentItems memory, FulfillmentItems memory, uint256)
+ internal
+ pure
+ returns (Fulfillment memory) consumeMethod,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory unspentOfferComponents,
+ MatchComponent[] memory unmetConsiderationComponents
+ )
+ {
+ if (matchDetails.totalItems == 0) {
+ return (
+ fulfillments,
+ unspentOfferComponents,
+ unmetConsiderationComponents
+ );
+ }
+
+ (
+ unspentOfferComponents,
+ unmetConsiderationComponents
+ ) = getUncoveredComponents(matchDetails);
+
+ // Allocate based on max possible fulfillments; reduce after assignment.
+ fulfillments = new Fulfillment[](matchDetails.totalItems - 1);
+ uint256 currentFulfillment = 0;
+
+ // The outer loop processes each matchable group.
+ for (uint256 i = 0; i < matchDetails.items.length; ++i) {
+ // This is actually a "while" loop, but bound it as a sanity check.
+ bool allProcessed = false;
+ for (uint256 j = 0; j < matchDetails.totalItems; ++j) {
+ Fulfillment memory fulfillment = consumeItems(
+ matchDetails.items[i],
+ consumeMethod,
+ seed
+ );
+
+ // Exit the inner loop if no fulfillment was located.
+ if (fulfillment.offerComponents.length == 0) {
+ allProcessed = true;
+ break;
+ }
+
+ // append the located fulfillment and continue searching.
+ fulfillments[currentFulfillment++] = fulfillment;
+ }
+ if (!allProcessed) {
+ revert("FulfillmentGeneratorLib: did not complete processing");
+ }
+ }
+
+ // Resize the fulfillments array based on number of elements assigned.
+ assembly {
+ mstore(fulfillments, currentFulfillment)
+ }
+ }
+
+ // NOTE: this does not currently minimize the number of fulfillments.
+ function consumeItems(
+ DualFulfillmentItems memory matchItems,
+ function(FulfillmentItems memory, FulfillmentItems memory, uint256)
+ internal
+ pure
+ returns (Fulfillment memory) consumeMethod,
+ uint256 seed
+ ) internal pure returns (Fulfillment memory) {
+ // Search for something that can be offered.
+ for (uint256 i = 0; i < matchItems.offer.length; ++i) {
+ FulfillmentItems memory offerItems = matchItems.offer[i];
+ if (offerItems.totalAmount != 0) {
+ // Search for something it can be matched against.
+ for (uint256 j = 0; j < matchItems.consideration.length; ++j) {
+ FulfillmentItems memory considerationItems = (
+ matchItems.consideration[j]
+ );
+
+ if (considerationItems.totalAmount != 0) {
+ return
+ consumeMethod(offerItems, considerationItems, seed);
+ }
+ }
+ }
+ }
+
+ // If none were found, return an empty fulfillment.
+ return emptyFulfillment();
+ }
+
+ function consumeMinimumItemsAndGetFulfillment(
+ FulfillmentItems memory offerItems,
+ FulfillmentItems memory considerationItems,
+ uint256 /* seed */
+ ) internal pure returns (Fulfillment memory) {
+ if (
+ offerItems.totalAmount == 0 || considerationItems.totalAmount == 0
+ ) {
+ revert("FulfillmentGeneratorLib: missing item amounts to consume");
+ }
+
+ // Allocate fulfillment component arrays with a single element.
+ FulfillmentComponent[] memory offerComponents = (
+ new FulfillmentComponent[](1)
+ );
+ FulfillmentComponent[] memory considerationComponents = (
+ new FulfillmentComponent[](1)
+ );
+
+ FulfillmentItem memory offerItem;
+ for (uint256 i = 0; i < offerItems.items.length; ++i) {
+ offerItem = offerItems.items[i];
+
+ if (offerItem.amount != 0) {
+ break;
+ }
+ }
+
+ FulfillmentItem memory considerationItem;
+ for (uint256 i = 0; i < considerationItems.items.length; ++i) {
+ considerationItem = considerationItems.items[i];
+
+ if (considerationItem.amount != 0) {
+ break;
+ }
+ }
+
+ offerComponents[0] = getFulfillmentComponent(offerItem);
+ considerationComponents[0] = getFulfillmentComponent(considerationItem);
+
+ if (offerItem.amount < considerationItem.amount) {
+ offerItems.totalAmount -= offerItem.amount;
+ considerationItems.totalAmount -= offerItem.amount;
+ considerationItem.amount -= offerItem.amount;
+ offerItem.amount = 0;
+ } else {
+ offerItems.totalAmount -= considerationItem.amount;
+ considerationItems.totalAmount -= considerationItem.amount;
+ offerItem.amount -= considerationItem.amount;
+ considerationItem.amount = 0;
+ }
+
+ return
+ Fulfillment({
+ offerComponents: offerComponents,
+ considerationComponents: considerationComponents
+ });
+ }
+
+ function consumeMaximumItemsAndGetFulfillment(
+ FulfillmentItems memory offerItems,
+ FulfillmentItems memory considerationItems,
+ uint256 /* seed */
+ ) internal pure returns (Fulfillment memory) {
+ if (
+ offerItems.totalAmount == 0 || considerationItems.totalAmount == 0
+ ) {
+ revert("FulfillmentGeneratorLib: missing item amounts to consume");
+ }
+
+ // Allocate fulfillment component arrays using total items; reduce
+ // length after based on the total number of elements assigned to each.
+ FulfillmentComponent[] memory offerComponents = (
+ new FulfillmentComponent[](offerItems.items.length)
+ );
+ FulfillmentComponent[] memory considerationComponents = (
+ new FulfillmentComponent[](considerationItems.items.length)
+ );
+
+ uint256 assignmentIndex = 0;
+
+ uint256 amountToConsume = offerItems.totalAmount >
+ considerationItems.totalAmount
+ ? considerationItems.totalAmount
+ : offerItems.totalAmount;
+
+ uint256 amountToCredit = amountToConsume;
+
+ bool firstConsumedItemLocated = false;
+ uint256 firstConsumedItemIndex;
+
+ for (uint256 i = 0; i < offerItems.items.length; ++i) {
+ FulfillmentItem memory item = offerItems.items[i];
+ if (item.amount != 0) {
+ if (!firstConsumedItemLocated) {
+ firstConsumedItemLocated = true;
+ firstConsumedItemIndex = i;
+ }
+
+ offerComponents[assignmentIndex++] = getFulfillmentComponent(
+ item
+ );
+
+ if (item.amount >= amountToConsume) {
+ uint256 amountToAddBack = item.amount - amountToConsume;
+
+ item.amount = 0;
+
+ offerItems.items[firstConsumedItemIndex].amount += (
+ amountToAddBack
+ );
+
+ offerItems.totalAmount -= amountToConsume;
+
+ amountToConsume = 0;
+ break;
+ } else {
+ amountToConsume -= item.amount;
+ offerItems.totalAmount -= item.amount;
+
+ item.amount = 0;
+ }
+ }
+ }
+
+ // Sanity check
+ if (amountToConsume != 0) {
+ revert("FulfillmentGeneratorLib: did not consume expected amount");
+ }
+
+ // Reduce offerComponents length based on number of elements assigned.
+ assembly {
+ mstore(offerComponents, assignmentIndex)
+ }
+
+ firstConsumedItemLocated = false;
+ assignmentIndex = 0;
+
+ for (uint256 i = 0; i < considerationItems.items.length; ++i) {
+ FulfillmentItem memory item = considerationItems.items[i];
+ if (item.amount != 0) {
+ if (!firstConsumedItemLocated) {
+ firstConsumedItemLocated = true;
+ firstConsumedItemIndex = i;
+ }
+
+ considerationComponents[assignmentIndex++] = (
+ getFulfillmentComponent(item)
+ );
+
+ if (item.amount >= amountToCredit) {
+ uint256 amountToAddBack = item.amount - amountToCredit;
+
+ item.amount = 0;
+
+ considerationItems.items[firstConsumedItemIndex].amount += (
+ amountToAddBack
+ );
+
+ considerationItems.totalAmount -= amountToCredit;
+
+ amountToCredit = 0;
+ break;
+ } else {
+ amountToCredit -= item.amount;
+ considerationItems.totalAmount -= item.amount;
+
+ item.amount = 0;
+ }
+ }
+ }
+
+ // Sanity check
+ if (amountToCredit != 0) {
+ revert("FulfillmentGeneratorLib: did not credit expected amount");
+ }
+
+ // Reduce considerationComponents length based on # elements assigned.
+ assembly {
+ mstore(considerationComponents, assignmentIndex)
+ }
+
+ // Sanity check
+ if (
+ offerComponents.length == 0 || considerationComponents.length == 0
+ ) {
+ revert("FulfillmentGeneratorLib: empty match component generated");
+ }
+
+ return
+ Fulfillment({
+ offerComponents: offerComponents,
+ considerationComponents: considerationComponents
+ });
+ }
+
+ function consumeRandomItemsAndGetFulfillment(
+ FulfillmentItems memory offerItems,
+ FulfillmentItems memory considerationItems,
+ uint256 seed
+ ) internal pure returns (Fulfillment memory) {
+ if (
+ offerItems.totalAmount == 0 || considerationItems.totalAmount == 0
+ ) {
+ revert("FulfillmentGeneratorLib: missing item amounts to consume");
+ }
+
+ // Allocate fulfillment component arrays using total items; reduce
+ // length after based on the total number of elements assigned to each.
+ FulfillmentComponent[] memory offerComponents = (
+ new FulfillmentComponent[](offerItems.items.length)
+ );
+
+ FulfillmentComponent[] memory considerationComponents = (
+ new FulfillmentComponent[](considerationItems.items.length)
+ );
+
+ uint256[] memory consumableOfferIndices = new uint256[](
+ offerItems.items.length
+ );
+ uint256[] memory consumableConsiderationIndices = new uint256[](
+ considerationItems.items.length
+ );
+
+ {
+ uint256 assignmentIndex = 0;
+
+ for (uint256 i = 0; i < offerItems.items.length; ++i) {
+ FulfillmentItem memory item = offerItems.items[i];
+ if (item.amount != 0) {
+ consumableOfferIndices[assignmentIndex++] = i;
+ }
+ }
+
+ assembly {
+ mstore(consumableOfferIndices, assignmentIndex)
+ }
+
+ assignmentIndex = 0;
+
+ for (uint256 i = 0; i < considerationItems.items.length; ++i) {
+ FulfillmentItem memory item = considerationItems.items[i];
+ if (item.amount != 0) {
+ consumableConsiderationIndices[assignmentIndex++] = i;
+ }
+ }
+
+ assembly {
+ mstore(consumableConsiderationIndices, assignmentIndex)
+ }
+
+ // Sanity check
+ if (
+ consumableOfferIndices.length == 0 ||
+ consumableConsiderationIndices.length == 0
+ ) {
+ revert(
+ "FulfillmentGeneratorLib: did not find consumable items"
+ );
+ }
+
+ LibPRNG.PRNG memory prng;
+ prng.seed(seed ^ 0xdd);
+
+ prng.shuffle(consumableOfferIndices);
+ prng.shuffle(consumableConsiderationIndices);
+
+ assignmentIndex = prng.uniform(consumableOfferIndices.length) + 1;
+ assembly {
+ mstore(offerComponents, assignmentIndex)
+ mstore(consumableOfferIndices, assignmentIndex)
+ }
+
+ assignmentIndex =
+ prng.uniform(consumableConsiderationIndices.length) +
+ 1;
+ assembly {
+ mstore(considerationComponents, assignmentIndex)
+ mstore(consumableConsiderationIndices, assignmentIndex)
+ }
+ }
+
+ uint256 totalOfferAmount = 0;
+ uint256 totalConsiderationAmount = 0;
+
+ for (uint256 i = 0; i < consumableOfferIndices.length; ++i) {
+ FulfillmentItem memory item = offerItems.items[
+ consumableOfferIndices[i]
+ ];
+
+ offerComponents[i] = getFulfillmentComponent(item);
+
+ totalOfferAmount += item.amount;
+ item.amount = 0;
+ }
+
+ for (uint256 i = 0; i < consumableConsiderationIndices.length; ++i) {
+ FulfillmentItem memory item = considerationItems.items[
+ consumableConsiderationIndices[i]
+ ];
+
+ considerationComponents[i] = getFulfillmentComponent(item);
+
+ totalConsiderationAmount += item.amount;
+ item.amount = 0;
+ }
+
+ if (totalOfferAmount > totalConsiderationAmount) {
+ uint256 remainingAmount = (totalOfferAmount -
+ totalConsiderationAmount);
+
+ // add back excess to first offer item
+ offerItems.items[consumableOfferIndices[0]].amount += (
+ remainingAmount
+ );
+
+ offerItems.totalAmount -= totalConsiderationAmount;
+ considerationItems.totalAmount -= totalConsiderationAmount;
+ } else {
+ uint256 remainingAmount = (totalConsiderationAmount -
+ totalOfferAmount);
+
+ // add back excess to first consideration item
+ considerationItems
+ .items[consumableConsiderationIndices[0]]
+ .amount += remainingAmount;
+
+ offerItems.totalAmount -= totalOfferAmount;
+ considerationItems.totalAmount -= totalOfferAmount;
+ }
+
+ return
+ Fulfillment({
+ offerComponents: offerComponents,
+ considerationComponents: considerationComponents
+ });
+ }
+
+ function emptyFulfillment() internal pure returns (Fulfillment memory) {
+ FulfillmentComponent[] memory components;
+ return
+ Fulfillment({
+ offerComponents: components,
+ considerationComponents: components
+ });
+ }
+
+ function getFulfillAvailableFulfillments(
+ FulfillAvailableDetails memory fulfillAvailableDetails,
+ FulfillmentStrategy memory strategy,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[][] memory offerFulfillments,
+ FulfillmentComponent[][] memory considerationFulfillments
+ )
+ {
+ ItemCategory[] memory offerCategories;
+ (
+ offerFulfillments,
+ offerCategories,
+ considerationFulfillments,
+
+ ) = getFulfillmentComponentsUsingMethod(
+ fulfillAvailableDetails,
+ getFulfillmentMethod(strategy.aggregationStrategy),
+ seed
+ );
+
+ FulfillAvailableStrategy dropStrategy = (
+ strategy.fulfillAvailableStrategy
+ );
+
+ if (dropStrategy == FulfillAvailableStrategy.KEEP_ALL) {
+ return (offerFulfillments, considerationFulfillments);
+ }
+
+ if (dropStrategy == FulfillAvailableStrategy.DROP_SINGLE_OFFER) {
+ return (
+ dropSingle(offerFulfillments, offerCategories),
+ considerationFulfillments
+ );
+ }
+
+ if (dropStrategy == FulfillAvailableStrategy.DROP_ALL_OFFER) {
+ return (
+ dropAllNon721(offerFulfillments, offerCategories),
+ considerationFulfillments
+ );
+ }
+
+ if (dropStrategy == FulfillAvailableStrategy.DROP_RANDOM_OFFER) {
+ return (
+ dropRandom(offerFulfillments, offerCategories, seed),
+ considerationFulfillments
+ );
+ }
+
+ if (
+ dropStrategy == FulfillAvailableStrategy.DROP_SINGLE_KEEP_FILTERED
+ ) {
+ revert(
+ "FulfillmentGeneratorLib: DROP_SINGLE_KEEP_FILTERED unsupported"
+ );
+ }
+
+ if (dropStrategy == FulfillAvailableStrategy.DROP_ALL_KEEP_FILTERED) {
+ revert(
+ "FulfillmentGeneratorLib: DROP_ALL_KEEP_FILTERED unsupported"
+ );
+ }
+
+ if (
+ dropStrategy == FulfillAvailableStrategy.DROP_RANDOM_KEEP_FILTERED
+ ) {
+ revert(
+ "FulfillmentGeneratorLib: DROP_RANDOM_KEEP_FILTERED unsupported"
+ );
+ }
+
+ revert("FulfillmentGeneratorLib: unknown fulfillAvailable strategy");
+ }
+
+ function dropSingle(
+ FulfillmentComponent[][] memory offerFulfillments,
+ ItemCategory[] memory offerCategories
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](offerFulfillments.length)
+ );
+
+ uint256 assignmentIndex = 0;
+
+ for (uint256 i = 0; i < offerFulfillments.length; ++i) {
+ FulfillmentComponent[] memory components = offerFulfillments[i];
+ if (
+ offerCategories[i] == ItemCategory.ERC721 ||
+ components.length > 1
+ ) {
+ fulfillments[assignmentIndex++] = components;
+ }
+ }
+
+ assembly {
+ mstore(fulfillments, assignmentIndex)
+ }
+
+ return fulfillments;
+ }
+
+ function dropAllNon721(
+ FulfillmentComponent[][] memory offerFulfillments,
+ ItemCategory[] memory offerCategories
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](offerFulfillments.length)
+ );
+
+ uint256 assignmentIndex = 0;
+
+ for (uint256 i = 0; i < offerFulfillments.length; ++i) {
+ FulfillmentComponent[] memory components = offerFulfillments[i];
+ if (offerCategories[i] == ItemCategory.ERC721) {
+ fulfillments[assignmentIndex++] = components;
+ }
+ }
+
+ assembly {
+ mstore(fulfillments, assignmentIndex)
+ }
+
+ return fulfillments;
+ }
+
+ function dropRandom(
+ FulfillmentComponent[][] memory offerFulfillments,
+ ItemCategory[] memory offerCategories,
+ uint256 seed
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ LibPRNG.PRNG memory prng;
+ prng.seed(seed ^ 0xbb);
+
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](offerFulfillments.length)
+ );
+
+ uint256 assignmentIndex = 0;
+
+ for (uint256 i = 0; i < offerFulfillments.length; ++i) {
+ FulfillmentComponent[] memory components = offerFulfillments[i];
+ if (
+ offerCategories[i] == ItemCategory.ERC721 ||
+ prng.uniform(2) == 0
+ ) {
+ fulfillments[assignmentIndex++] = components;
+ }
+ }
+
+ assembly {
+ mstore(fulfillments, assignmentIndex)
+ }
+
+ return fulfillments;
+ }
+
+ function getFulfillmentMethod(
+ AggregationStrategy aggregationStrategy
+ )
+ internal
+ pure
+ returns (
+ function(FulfillmentItems[] memory, uint256)
+ internal
+ pure
+ returns (FulfillmentComponent[][] memory, ItemCategory[] memory)
+ )
+ {
+ if (aggregationStrategy == AggregationStrategy.MAXIMUM) {
+ return getMaxFulfillmentComponents;
+ } else if (aggregationStrategy == AggregationStrategy.MINIMUM) {
+ return getMinFulfillmentComponents;
+ } else if (aggregationStrategy == AggregationStrategy.RANDOM) {
+ return getRandomFulfillmentComponents;
+ } else {
+ revert("FulfillmentGeneratorLib: unknown aggregation strategy");
+ }
+ }
+
+ function getFulfillmentComponentsUsingMethod(
+ FulfillAvailableDetails memory fulfillAvailableDetails,
+ function(FulfillmentItems[] memory, uint256)
+ internal
+ pure
+ returns (
+ FulfillmentComponent[][] memory,
+ ItemCategory[] memory
+ ) fulfillmentMethod,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[][] memory offerFulfillments,
+ ItemCategory[] memory offerCategories,
+ FulfillmentComponent[][] memory considerationFulfillments,
+ ItemCategory[] memory considerationCategories
+ )
+ {
+ (offerFulfillments, offerCategories) = fulfillmentMethod(
+ fulfillAvailableDetails.items.offer,
+ seed
+ );
+
+ (
+ considerationFulfillments,
+ considerationCategories
+ ) = fulfillmentMethod(
+ fulfillAvailableDetails.items.consideration,
+ seed
+ );
+ }
+
+ function getMaxFulfillmentComponents(
+ FulfillmentItems[] memory fulfillmentItems,
+ uint256 /* seed */
+ )
+ internal
+ pure
+ returns (FulfillmentComponent[][] memory, ItemCategory[] memory)
+ {
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](fulfillmentItems.length)
+ );
+
+ ItemCategory[] memory categories = new ItemCategory[](
+ fulfillmentItems.length
+ );
+
+ for (uint256 i = 0; i < fulfillmentItems.length; ++i) {
+ fulfillments[i] = getFulfillmentComponents(
+ fulfillmentItems[i].items
+ );
+ categories[i] = fulfillmentItems[i].itemCategory;
+ }
+
+ return (fulfillments, categories);
+ }
+
+ function getRandomFulfillmentComponents(
+ FulfillmentItems[] memory fulfillmentItems,
+ uint256 seed
+ )
+ internal
+ pure
+ returns (FulfillmentComponent[][] memory, ItemCategory[] memory)
+ {
+ uint256 fulfillmentCount = 0;
+
+ for (uint256 i = 0; i < fulfillmentItems.length; ++i) {
+ fulfillmentCount += fulfillmentItems[i].items.length;
+ }
+
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](fulfillmentCount)
+ );
+
+ ItemCategory[] memory categories = new ItemCategory[](fulfillmentCount);
+
+ LibPRNG.PRNG memory prng;
+ prng.seed(seed ^ 0xcc);
+
+ fulfillmentCount = 0;
+ for (uint256 i = 0; i < fulfillmentItems.length; ++i) {
+ FulfillmentItem[] memory items = fulfillmentItems[i].items;
+
+ for (uint256 j = 0; j < items.length; ++j) {
+ FulfillmentComponent[] memory fulfillment = (
+ consumeRandomFulfillmentItems(items, prng)
+ );
+
+ if (fulfillment.length == 0) {
+ break;
+ }
+
+ categories[fulfillmentCount] = fulfillmentItems[i].itemCategory;
+ fulfillments[fulfillmentCount++] = fulfillment;
+ }
+ }
+
+ assembly {
+ mstore(fulfillments, fulfillmentCount)
+ mstore(categories, fulfillmentCount)
+ }
+
+ uint256[] memory componentIndices = new uint256[](fulfillments.length);
+ for (uint256 i = 0; i < fulfillments.length; ++i) {
+ componentIndices[i] = i;
+ }
+
+ prng.shuffle(componentIndices);
+
+ FulfillmentComponent[][] memory shuffledFulfillments = (
+ new FulfillmentComponent[][](fulfillments.length)
+ );
+
+ ItemCategory[] memory shuffledCategories = (
+ new ItemCategory[](fulfillments.length)
+ );
+
+ for (uint256 i = 0; i < fulfillments.length; ++i) {
+ uint256 priorIndex = componentIndices[i];
+ shuffledFulfillments[i] = fulfillments[priorIndex];
+ shuffledCategories[i] = categories[priorIndex];
+ }
+
+ return (shuffledFulfillments, shuffledCategories);
+ }
+
+ function consumeRandomFulfillmentItems(
+ FulfillmentItem[] memory items,
+ LibPRNG.PRNG memory prng
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ uint256[] memory consumableItemIndices = new uint256[](items.length);
+ uint256 assignmentIndex = 0;
+ for (uint256 i = 0; i < items.length; ++i) {
+ if (items[i].amount != 0) {
+ consumableItemIndices[assignmentIndex++] = i;
+ }
+ }
+
+ if (assignmentIndex == 0) {
+ return new FulfillmentComponent[](0);
+ }
+
+ assembly {
+ mstore(consumableItemIndices, assignmentIndex)
+ }
+
+ prng.shuffle(consumableItemIndices);
+
+ assignmentIndex = prng.uniform(assignmentIndex) + 1;
+
+ assembly {
+ mstore(consumableItemIndices, assignmentIndex)
+ }
+
+ FulfillmentComponent[] memory fulfillment = new FulfillmentComponent[](
+ consumableItemIndices.length
+ );
+
+ for (uint256 i = 0; i < consumableItemIndices.length; ++i) {
+ FulfillmentItem memory item = items[consumableItemIndices[i]];
+
+ fulfillment[i] = getFulfillmentComponent(item);
+
+ item.amount = 0;
+ }
+
+ return fulfillment;
+ }
+
+ function getMinFulfillmentComponents(
+ FulfillmentItems[] memory fulfillmentItems,
+ uint256 /* seed */
+ )
+ internal
+ pure
+ returns (FulfillmentComponent[][] memory, ItemCategory[] memory)
+ {
+ uint256 fulfillmentCount = 0;
+
+ for (uint256 i = 0; i < fulfillmentItems.length; ++i) {
+ fulfillmentCount += fulfillmentItems[i].items.length;
+ }
+
+ FulfillmentComponent[][] memory fulfillments = (
+ new FulfillmentComponent[][](fulfillmentCount)
+ );
+
+ ItemCategory[] memory categories = (
+ new ItemCategory[](fulfillmentCount)
+ );
+
+ fulfillmentCount = 0;
+ for (uint256 i = 0; i < fulfillmentItems.length; ++i) {
+ FulfillmentItem[] memory items = fulfillmentItems[i].items;
+
+ for (uint256 j = 0; j < items.length; ++j) {
+ FulfillmentComponent[] memory fulfillment = (
+ new FulfillmentComponent[](1)
+ );
+ fulfillment[0] = getFulfillmentComponent(items[j]);
+ categories[fulfillmentCount] = fulfillmentItems[i].itemCategory;
+ fulfillments[fulfillmentCount++] = fulfillment;
+ }
+ }
+
+ return (fulfillments, categories);
+ }
+
+ function getFulfillmentComponents(
+ FulfillmentItem[] memory items
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory fulfillment = new FulfillmentComponent[](
+ items.length
+ );
+
+ for (uint256 i = 0; i < items.length; ++i) {
+ fulfillment[i] = getFulfillmentComponent(items[i]);
+ }
+
+ return fulfillment;
+ }
+
+ function getFulfillmentComponent(
+ FulfillmentItem memory item
+ ) internal pure returns (FulfillmentComponent memory) {
+ return
+ FulfillmentComponent({
+ orderIndex: item.orderIndex,
+ itemIndex: item.itemIndex
+ });
+ }
+
+ function determineFulfillAvailableEligibility(
+ FulfillAvailableDetails memory fulfillAvailableDetails
+ ) internal pure returns (bool) {
+ bool atLeastOneExecution = false;
+
+ FulfillmentItems[] memory offer = fulfillAvailableDetails.items.offer;
+ for (uint256 i = 0; i < offer.length; ++i) {
+ FulfillmentItems memory fulfillmentItems = offer[i];
+ if (
+ fulfillmentItems.itemCategory == ItemCategory.NATIVE ||
+ (fulfillmentItems.itemCategory == ItemCategory.ERC721 &&
+ fulfillmentItems.totalAmount != 1)
+ ) {
+ return false;
+ }
+
+ // TODO: Ensure that the same ERC721 item doesn't appear on both the
+ // offer side and the consideration side if the recipient does not
+ // equal the caller.
+
+ if (!atLeastOneExecution) {
+ for (uint256 j = 0; j < fulfillmentItems.items.length; ++j) {
+ FulfillmentItem memory item = fulfillmentItems.items[j];
+ if (item.account != fulfillAvailableDetails.recipient) {
+ atLeastOneExecution = true;
+ break;
+ }
+ }
+ }
+ }
+
+ FulfillmentItems[] memory consideration = (
+ fulfillAvailableDetails.items.consideration
+ );
+ for (uint256 i = 0; i < consideration.length; ++i) {
+ FulfillmentItems memory fulfillmentItems = consideration[i];
+ if (
+ fulfillmentItems.itemCategory == ItemCategory.ERC721 &&
+ fulfillmentItems.totalAmount != 1
+ ) {
+ return false;
+ }
+
+ if (!atLeastOneExecution) {
+ for (uint256 j = 0; j < fulfillmentItems.items.length; ++j) {
+ FulfillmentItem memory item = fulfillmentItems.items[j];
+ if (item.account != fulfillAvailableDetails.caller) {
+ atLeastOneExecution = true;
+ break;
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+}
+
+library FulfillmentPrepLib {
+ using ItemReferenceLib for OrderDetails[];
+ using ItemReferenceGroupLib for ItemReferenceLib.ItemReference[];
+ using ItemReferenceGroupLib for ItemReferenceGroupLib.ItemReferenceGroup[];
+ using MatchableItemReferenceGroupLib for MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[];
+ using FulfillAvailableReferenceGroupLib for FulfillAvailableReferenceGroupLib.FulfillAvailableReferenceGroup;
+
+ function getFulfillAvailableDetails(
+ OrderDetails[] memory orderDetails,
+ address recipient,
+ address caller,
+ uint256 seed
+ ) internal pure returns (FulfillAvailableDetails memory) {
+ return
+ getFulfillAvailableDetailsFromReferences(
+ orderDetails.getItemReferences(seed),
+ recipient,
+ caller
+ );
+ }
+
+ function getDetails(
+ ItemReferenceLib.ItemReference[] memory itemReferences,
+ address recipient,
+ address caller
+ )
+ internal
+ pure
+ returns (FulfillAvailableDetails memory, MatchDetails memory)
+ {
+ ItemReferenceGroupLib.ItemReferenceGroup[]
+ memory groups = itemReferences.bundleByAggregatable();
+
+ return (
+ groups.splitBySide(recipient, caller).getFulfillAvailableDetails(),
+ groups.bundleByMatchable(itemReferences).getMatchDetails(recipient)
+ );
+ }
+
+ function getFulfillAvailableDetailsFromReferences(
+ ItemReferenceLib.ItemReference[] memory itemReferences,
+ address recipient,
+ address caller
+ ) internal pure returns (FulfillAvailableDetails memory) {
+ return
+ itemReferences
+ .bundleByAggregatable()
+ .splitBySide(recipient, caller)
+ .getFulfillAvailableDetails();
+ }
+
+ function getMatchDetails(
+ OrderDetails[] memory orderDetails,
+ address recipient,
+ uint256 seed
+ ) internal pure returns (MatchDetails memory) {
+ return
+ getMatchDetailsFromReferences(
+ orderDetails.getItemReferences(seed),
+ recipient
+ );
+ }
+
+ function getMatchDetailsFromReferences(
+ ItemReferenceLib.ItemReference[] memory itemReferences,
+ address recipient
+ ) internal pure returns (MatchDetails memory) {
+ return
+ itemReferences
+ .bundleByAggregatable()
+ .bundleByMatchable(itemReferences)
+ .getMatchDetails(recipient);
+ }
+
+ function getFulfillmentMatchContext(
+ DualFulfillmentItems[] memory matchItems
+ ) internal pure returns (DualFulfillmentMatchContext[] memory) {
+ DualFulfillmentMatchContext[] memory context = (
+ new DualFulfillmentMatchContext[](matchItems.length)
+ );
+
+ for (uint256 i = 0; i < matchItems.length; ++i) {
+ bool itemCategorySet = false;
+ ItemCategory itemCategory;
+ uint256 totalOfferAmount = 0;
+ uint256 totalConsiderationAmount = 0;
+
+ FulfillmentItems[] memory offer = matchItems[i].offer;
+ for (uint256 j = 0; j < offer.length; ++j) {
+ FulfillmentItems memory items = offer[j];
+
+ if (!itemCategorySet) {
+ itemCategory = items.itemCategory;
+ } else if (itemCategory != items.itemCategory) {
+ revert("FulfillmentPrepLib: mismatched item categories");
+ }
+
+ totalOfferAmount += items.totalAmount;
+ }
+
+ FulfillmentItems[] memory consideration = (
+ matchItems[i].consideration
+ );
+ for (uint256 j = 0; j < consideration.length; ++j) {
+ FulfillmentItems memory items = consideration[j];
+
+ if (!itemCategorySet) {
+ itemCategory = items.itemCategory;
+ } else if (itemCategory != items.itemCategory) {
+ revert("FulfillmentPrepLib: mismatched item categories");
+ }
+
+ totalConsiderationAmount += items.totalAmount;
+ }
+
+ context[i] = DualFulfillmentMatchContext({
+ itemCategory: itemCategory,
+ totalOfferAmount: totalOfferAmount,
+ totalConsiderationAmount: totalConsiderationAmount
+ });
+ }
+
+ return context;
+ }
+
+ function getDualFulfillmentItems(
+ ItemReferenceGroupLib.ItemReferenceGroup[] memory offerGroups,
+ ItemReferenceGroupLib.ItemReferenceGroup[] memory considerationGroups
+ ) internal pure returns (DualFulfillmentItems memory, uint256 totalItems) {
+ DualFulfillmentItems memory items = DualFulfillmentItems({
+ offer: new FulfillmentItems[](offerGroups.length),
+ consideration: new FulfillmentItems[](considerationGroups.length)
+ });
+
+ uint256 currentItems;
+
+ for (uint256 i = 0; i < offerGroups.length; ++i) {
+ (items.offer[i], currentItems) = getFulfillmentItems(
+ offerGroups[i].references
+ );
+
+ totalItems += currentItems;
+ }
+
+ for (uint256 i = 0; i < considerationGroups.length; ++i) {
+ (items.consideration[i], currentItems) = getFulfillmentItems(
+ considerationGroups[i].references
+ );
+
+ totalItems += currentItems;
+ }
+
+ return (items, totalItems);
+ }
+
+ function getFulfillmentItems(
+ ItemReferenceLib.ItemReference[] memory itemReferences
+ ) internal pure returns (FulfillmentItems memory, uint256 totalItems) {
+ // Sanity check: ensure there's at least one reference
+ if (itemReferences.length == 0) {
+ revert("FulfillmentPrepLib: empty item references supplied");
+ }
+
+ ItemReferenceLib.ItemReference memory firstReference = itemReferences[
+ 0
+ ];
+ FulfillmentItems memory fulfillmentItems = FulfillmentItems({
+ itemCategory: firstReference.itemCategory,
+ totalAmount: 0,
+ items: new FulfillmentItem[](itemReferences.length)
+ });
+
+ for (uint256 i = 0; i < itemReferences.length; ++i) {
+ ItemReferenceLib.ItemReference
+ memory itemReference = itemReferences[i];
+ uint256 amount = itemReference.amount;
+ fulfillmentItems.totalAmount += amount;
+ fulfillmentItems.items[i] = FulfillmentItem({
+ orderIndex: itemReference.orderIndex,
+ itemIndex: itemReference.itemIndex,
+ amount: amount,
+ account: itemReference.account
+ });
+ }
+
+ totalItems = itemReferences.length;
+
+ return (fulfillmentItems, totalItems);
+ }
+}
+
+library FulfillAvailableReferenceGroupLib {
+ struct FulfillAvailableReferenceGroup {
+ ItemReferenceGroupLib.ItemReferenceGroup[] offerGroups;
+ ItemReferenceGroupLib.ItemReferenceGroup[] considerationGroups;
+ address recipient;
+ address caller;
+ }
+
+ function getFulfillAvailableDetails(
+ FulfillAvailableReferenceGroup memory group
+ ) internal pure returns (FulfillAvailableDetails memory) {
+ (
+ DualFulfillmentItems memory items,
+ uint256 totalItems
+ ) = FulfillmentPrepLib.getDualFulfillmentItems(
+ group.offerGroups,
+ group.considerationGroups
+ );
+
+ return
+ FulfillAvailableDetails({
+ items: items,
+ caller: group.caller,
+ recipient: group.recipient,
+ totalItems: totalItems
+ });
+ }
+}
+
+library MatchableItemReferenceGroupLib {
+ struct MatchableItemReferenceGroup {
+ bytes32 dataHash;
+ ItemReferenceGroupLib.ItemReferenceGroup[] offerGroups;
+ ItemReferenceGroupLib.ItemReferenceGroup[] considerationGroups;
+ uint256 offerAssigned;
+ uint256 considerationAssigned;
+ }
+
+ function getMatchDetails(
+ MatchableItemReferenceGroup[] memory matchableGroups,
+ address recipient
+ ) internal pure returns (MatchDetails memory) {
+ DualFulfillmentItems[] memory items = new DualFulfillmentItems[](
+ matchableGroups.length
+ );
+
+ uint256 totalItems = 0;
+ uint256 itemsInGroup = 0;
+
+ for (uint256 i = 0; i < matchableGroups.length; ++i) {
+ MatchableItemReferenceGroup memory matchableGroup = (
+ matchableGroups[i]
+ );
+
+ (items[i], itemsInGroup) = FulfillmentPrepLib
+ .getDualFulfillmentItems(
+ matchableGroup.offerGroups,
+ matchableGroup.considerationGroups
+ );
+
+ totalItems += itemsInGroup;
+ }
+
+ return
+ MatchDetails({
+ items: items,
+ context: FulfillmentPrepLib.getFulfillmentMatchContext(items),
+ recipient: recipient,
+ totalItems: totalItems
+ });
+ }
+}
+
+library ItemReferenceGroupLib {
+ using HashCountLib for ItemReferenceLib.ItemReference[];
+ using HashAllocatorLib for HashCountLib.HashCount[];
+
+ struct ItemReferenceGroup {
+ bytes32 fullHash;
+ ItemReferenceLib.ItemReference[] references;
+ uint256 assigned;
+ }
+
+ function bundleByAggregatable(
+ ItemReferenceLib.ItemReference[] memory itemReferences
+ ) internal pure returns (ItemReferenceGroup[] memory) {
+ ItemReferenceGroup[] memory groups = itemReferences
+ .getUniqueFullHashes()
+ .allocateItemReferenceGroup();
+
+ for (uint256 i = 0; i < itemReferences.length; ++i) {
+ ItemReferenceLib.ItemReference
+ memory itemReference = itemReferences[i];
+ for (uint256 j = 0; j < groups.length; ++j) {
+ ItemReferenceGroup memory group = groups[j];
+ if (group.fullHash == itemReference.fullHash) {
+ group.references[group.assigned++] = itemReference;
+ break;
+ }
+ }
+ }
+
+ // Sanity check: ensure at least one reference item on each group
+ for (uint256 i = 0; i < groups.length; ++i) {
+ if (groups[i].references.length == 0) {
+ revert(
+ "ItemReferenceGroupLib: missing item reference in group"
+ );
+ }
+ }
+
+ return groups;
+ }
+
+ function splitBySide(
+ ItemReferenceGroup[] memory groups,
+ address recipient,
+ address caller
+ )
+ internal
+ pure
+ returns (
+ FulfillAvailableReferenceGroupLib.FulfillAvailableReferenceGroup
+ memory
+ )
+ {
+ // NOTE: lengths are overallocated; reduce after assignment.
+ ItemReferenceGroup[] memory offerGroups = (
+ new ItemReferenceGroup[](groups.length)
+ );
+ ItemReferenceGroup[] memory considerationGroups = (
+ new ItemReferenceGroup[](groups.length)
+ );
+ uint256 offerItems = 0;
+ uint256 considerationItems = 0;
+
+ for (uint256 i = 0; i < groups.length; ++i) {
+ ItemReferenceGroup memory group = groups[i];
+
+ if (group.references.length == 0) {
+ revert("ItemReferenceGroupLib: no items in group");
+ }
+
+ Side side = group.references[0].side;
+
+ if (side == Side.OFFER) {
+ offerGroups[offerItems++] = group;
+ } else if (side == Side.CONSIDERATION) {
+ considerationGroups[considerationItems++] = group;
+ } else {
+ revert("ItemReferenceGroupLib: invalid side located (split)");
+ }
+ }
+
+ // Reduce group lengths based on number of elements assigned.
+ assembly {
+ mstore(offerGroups, offerItems)
+ mstore(considerationGroups, considerationItems)
+ }
+
+ return
+ FulfillAvailableReferenceGroupLib.FulfillAvailableReferenceGroup({
+ offerGroups: offerGroups,
+ considerationGroups: considerationGroups,
+ recipient: recipient,
+ caller: caller
+ });
+ }
+
+ function bundleByMatchable(
+ ItemReferenceGroup[] memory groups,
+ ItemReferenceLib.ItemReference[] memory itemReferences
+ )
+ internal
+ pure
+ returns (
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[] memory
+ )
+ {
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[]
+ memory matchableGroups = (
+ itemReferences
+ .getUniqueDataHashes()
+ .allocateMatchableItemReferenceGroup()
+ );
+
+ for (uint256 i = 0; i < groups.length; ++i) {
+ ItemReferenceGroup memory group = groups[i];
+
+ if (group.references.length == 0) {
+ revert(
+ "ItemReferenceGroupLib: empty item reference group supplied"
+ );
+ }
+
+ ItemReferenceLib.ItemReference memory firstReference = group
+ .references[0];
+ for (uint256 j = 0; j < matchableGroups.length; ++j) {
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup
+ memory matchableGroup = (matchableGroups[j]);
+
+ if (matchableGroup.dataHash == firstReference.dataHash) {
+ if (firstReference.side == Side.OFFER) {
+ matchableGroup.offerGroups[
+ matchableGroup.offerAssigned++
+ ] = group;
+ } else if (firstReference.side == Side.CONSIDERATION) {
+ matchableGroup.considerationGroups[
+ matchableGroup.considerationAssigned++
+ ] = group;
+ } else {
+ revert(
+ "ItemReferenceGroupLib: invalid match side located"
+ );
+ }
+
+ break;
+ }
+ }
+ }
+
+ // Reduce reference group array lengths based on assigned elements.
+ for (uint256 i = 0; i < matchableGroups.length; ++i) {
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup
+ memory group = matchableGroups[i];
+ uint256 offerAssigned = group.offerAssigned;
+ uint256 considerationAssigned = group.considerationAssigned;
+ ItemReferenceGroup[] memory offerGroups = (group.offerGroups);
+ ItemReferenceGroup[] memory considerationGroups = (
+ group.considerationGroups
+ );
+
+ assembly {
+ mstore(offerGroups, offerAssigned)
+ mstore(considerationGroups, considerationAssigned)
+ }
+ }
+
+ return matchableGroups;
+ }
+}
+
+library HashAllocatorLib {
+ function allocateItemReferenceGroup(
+ HashCountLib.HashCount[] memory hashCount
+ )
+ internal
+ pure
+ returns (ItemReferenceGroupLib.ItemReferenceGroup[] memory)
+ {
+ ItemReferenceGroupLib.ItemReferenceGroup[]
+ memory group = new ItemReferenceGroupLib.ItemReferenceGroup[](
+ hashCount.length
+ );
+
+ for (uint256 i = 0; i < hashCount.length; ++i) {
+ group[i] = ItemReferenceGroupLib.ItemReferenceGroup({
+ fullHash: hashCount[i].hash,
+ references: new ItemReferenceLib.ItemReference[](
+ hashCount[i].count
+ ),
+ assigned: 0
+ });
+ }
+
+ return group;
+ }
+
+ function allocateMatchableItemReferenceGroup(
+ HashCountLib.HashCount[] memory hashCount
+ )
+ internal
+ pure
+ returns (
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[] memory
+ )
+ {
+ MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[]
+ memory group = (
+ new MatchableItemReferenceGroupLib.MatchableItemReferenceGroup[](
+ hashCount.length
+ )
+ );
+
+ for (uint256 i = 0; i < hashCount.length; ++i) {
+ // NOTE: reference group lengths are overallocated and will need to
+ // be reduced once their respective elements have been assigned.
+ uint256 count = hashCount[i].count;
+ group[i] = MatchableItemReferenceGroupLib
+ .MatchableItemReferenceGroup({
+ dataHash: hashCount[i].hash,
+ offerGroups: new ItemReferenceGroupLib.ItemReferenceGroup[](
+ count
+ ),
+ considerationGroups: (
+ new ItemReferenceGroupLib.ItemReferenceGroup[](count)
+ ),
+ offerAssigned: 0,
+ considerationAssigned: 0
+ });
+ }
+
+ return group;
+ }
+}
+
+library HashCountLib {
+ using LibPRNG for LibPRNG.PRNG;
+ using LibSort for uint256[];
+ using ItemReferenceLib for OrderDetails[];
+ using ItemReferenceLib for ItemReferenceLib.ItemReference[];
+
+ struct HashCount {
+ bytes32 hash;
+ uint256 count;
+ }
+
+ function getUniqueFullHashes(
+ ItemReferenceLib.ItemReference[] memory itemReferences
+ ) internal pure returns (HashCount[] memory) {
+ uint256[] memory fullHashes = new uint256[](itemReferences.length);
+
+ for (uint256 i = 0; i < itemReferences.length; ++i) {
+ fullHashes[i] = uint256(itemReferences[i].fullHash);
+ }
+
+ return getHashCount(fullHashes);
+ }
+
+ function getUniqueDataHashes(
+ ItemReferenceLib.ItemReference[] memory itemReferences
+ ) internal pure returns (HashCount[] memory) {
+ uint256[] memory dataHashes = new uint256[](itemReferences.length);
+
+ for (uint256 i = 0; i < itemReferences.length; ++i) {
+ dataHashes[i] = uint256(itemReferences[i].dataHash);
+ }
+
+ return getHashCount(dataHashes);
+ }
+
+ function getHashCount(
+ uint256[] memory hashes
+ ) internal pure returns (HashCount[] memory) {
+ if (hashes.length == 0) {
+ return new HashCount[](0);
+ }
+
+ hashes.sort();
+
+ HashCount[] memory hashCount = new HashCount[](hashes.length);
+ hashCount[0] = HashCount({ hash: bytes32(hashes[0]), count: 1 });
+
+ uint256 hashCountPointer = 0;
+ for (uint256 i = 1; i < hashes.length; ++i) {
+ bytes32 element = bytes32(hashes[i]);
+
+ if (element != hashCount[hashCountPointer].hash) {
+ hashCount[++hashCountPointer] = HashCount({
+ hash: element,
+ count: 1
+ });
+ } else {
+ ++hashCount[hashCountPointer].count;
+ }
+ }
+
+ // update length of the hashCount array based on the hash count pointer.
+ assembly {
+ mstore(hashCount, add(hashCountPointer, 1))
+ }
+
+ return hashCount;
+ }
+}
+
+library ItemReferenceLib {
+ using LibPRNG for LibPRNG.PRNG;
+ using LibSort for uint256[];
+
+ struct ItemReference {
+ uint256 orderIndex;
+ uint256 itemIndex;
+ Side side;
+ bytes32 dataHash; // itemType ++ token ++ identifier
+ bytes32 fullHash; // dataHash ++ [offerer ++ conduitKey || recipient]
+ uint256 amount;
+ ItemCategory itemCategory;
+ address account;
+ }
+
+ function getItemReferences(
+ OrderDetails[] memory orderDetails,
+ uint256 seed
+ ) internal pure returns (ItemReference[] memory) {
+ ItemReference[] memory itemReferences = new ItemReference[](
+ getTotalItems(orderDetails)
+ );
+
+ uint256 itemReferenceIndex = 0;
+
+ for (
+ uint256 orderIndex = 0;
+ orderIndex < orderDetails.length;
+ ++orderIndex
+ ) {
+ OrderDetails memory order = orderDetails[orderIndex];
+ for (
+ uint256 itemIndex = 0;
+ itemIndex < order.offer.length;
+ ++itemIndex
+ ) {
+ itemReferences[itemReferenceIndex++] = getItemReference(
+ order.offer[itemIndex],
+ orderIndex,
+ itemIndex,
+ order.offerer,
+ order.conduitKey
+ );
+ }
+ for (
+ uint256 itemIndex = 0;
+ itemIndex < order.consideration.length;
+ ++itemIndex
+ ) {
+ itemReferences[itemReferenceIndex++] = getItemReference(
+ order.consideration[itemIndex],
+ orderIndex,
+ itemIndex
+ );
+ }
+ }
+
+ if (seed == 0) {
+ return itemReferences;
+ }
+
+ return shuffle(itemReferences, seed);
+ }
+
+ function shuffle(
+ ItemReference[] memory itemReferences,
+ uint256 seed
+ ) internal pure returns (ItemReference[] memory) {
+ ItemReference[] memory shuffledItemReferences = new ItemReference[](
+ itemReferences.length
+ );
+
+ uint256[] memory indices = new uint256[](itemReferences.length);
+ for (uint256 i = 0; i < indices.length; ++i) {
+ indices[i] = i;
+ }
+
+ LibPRNG.PRNG memory prng;
+ prng.seed(seed ^ 0xee);
+ prng.shuffle(indices);
+
+ for (uint256 i = 0; i < indices.length; ++i) {
+ shuffledItemReferences[i] = itemReferences[indices[i]];
+ }
+
+ return shuffledItemReferences;
+ }
+
+ function getItemReference(
+ SpentItem memory item,
+ uint256 orderIndex,
+ uint256 itemIndex,
+ address offerer,
+ bytes32 conduitKey
+ ) internal pure returns (ItemReference memory) {
+ return
+ getItemReference(
+ orderIndex,
+ itemIndex,
+ Side.OFFER,
+ item.itemType,
+ item.token,
+ item.identifier,
+ offerer,
+ conduitKey,
+ item.amount
+ );
+ }
+
+ function getItemReference(
+ ReceivedItem memory item,
+ uint256 orderIndex,
+ uint256 itemIndex
+ ) internal pure returns (ItemReference memory) {
+ return
+ getItemReference(
+ orderIndex,
+ itemIndex,
+ Side.CONSIDERATION,
+ item.itemType,
+ item.token,
+ item.identifier,
+ item.recipient,
+ bytes32(0),
+ item.amount
+ );
+ }
+
+ function getItemReference(
+ uint256 orderIndex,
+ uint256 itemIndex,
+ Side side,
+ ItemType itemType,
+ address token,
+ uint256 identifier,
+ address account,
+ bytes32 conduitKey,
+ uint256 amount
+ ) internal pure returns (ItemReference memory) {
+ bytes32 dataHash = keccak256(
+ abi.encodePacked(itemType, token, identifier)
+ );
+
+ bytes32 fullHash;
+ if (side == Side.OFFER) {
+ fullHash = keccak256(
+ abi.encodePacked(dataHash, account, conduitKey)
+ );
+ } else if (side == Side.CONSIDERATION) {
+ fullHash = keccak256(abi.encodePacked(dataHash, account));
+ } else {
+ revert("ItemReferenceLib: invalid side located");
+ }
+
+ ItemCategory itemCategory;
+ if (itemType == ItemType.NATIVE) {
+ itemCategory = ItemCategory.NATIVE;
+ } else if (itemType == ItemType.ERC721) {
+ itemCategory = ItemCategory.ERC721;
+ } else if (itemType == ItemType.ERC20 || itemType == ItemType.ERC1155) {
+ itemCategory = ItemCategory.OTHER;
+ } else {
+ revert("ItemReferenceLib: invalid item type located");
+ }
+
+ return
+ ItemReference({
+ orderIndex: orderIndex,
+ itemIndex: itemIndex,
+ side: side,
+ dataHash: dataHash,
+ fullHash: fullHash,
+ amount: amount,
+ itemCategory: itemCategory,
+ account: account
+ });
+ }
+
+ function getTotalItems(
+ OrderDetails[] memory orderDetails
+ ) internal pure returns (uint256) {
+ uint256 totalItems = 0;
+
+ for (uint256 i = 0; i < orderDetails.length; ++i) {
+ totalItems += getTotalItems(orderDetails[i]);
+ }
+
+ return totalItems;
+ }
+
+ function getTotalItems(
+ OrderDetails memory order
+ ) internal pure returns (uint256) {
+ return (order.offer.length + order.consideration.length);
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/lib/MatchArrays.sol b/contracts/helpers/sol/fulfillments/lib/MatchArrays.sol
new file mode 100644
index 000000000..52c3168e4
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/lib/MatchArrays.sol
@@ -0,0 +1,3036 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+import "../../SeaportStructs.sol";
+import "../../lib/types/MatchComponentType.sol";
+
+library MatchArrays {
+ function FulfillmentComponents(
+ FulfillmentComponent memory a
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e,
+ FulfillmentComponent memory f
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function FulfillmentComponents(
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e,
+ FulfillmentComponent memory f,
+ FulfillmentComponent memory g
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e,
+ FulfillmentComponent memory f
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function FulfillmentComponentsWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent memory a,
+ FulfillmentComponent memory b,
+ FulfillmentComponent memory c,
+ FulfillmentComponent memory d,
+ FulfillmentComponent memory e,
+ FulfillmentComponent memory f,
+ FulfillmentComponent memory g
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[] memory arr = new FulfillmentComponent[](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function extend(
+ FulfillmentComponent[] memory arr1,
+ FulfillmentComponent[] memory arr2
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ uint256 length1 = arr1.length;
+ uint256 length2 = arr2.length;
+ newArr = new FulfillmentComponent[](length1 + length2);
+ for (uint256 i = 0; i < length1; ) {
+ newArr[i] = arr1[i];
+ unchecked {
+ ++i;
+ }
+ }
+ for (uint256 i = 0; i < arr2.length; ) {
+ uint256 j;
+ unchecked {
+ j = i + length1;
+ }
+ newArr[j] = arr2[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function allocateFulfillmentComponents(
+ uint256 length
+ ) internal pure returns (FulfillmentComponent[] memory arr) {
+ arr = new FulfillmentComponent[](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function truncate(
+ FulfillmentComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[] memory _arr) {
+ // truncate the array
+ assembly {
+ let oldLength := mload(arr)
+ returndatacopy(
+ returndatasize(),
+ returndatasize(),
+ gt(newLength, oldLength)
+ )
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function truncateUnsafe(
+ FulfillmentComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[] memory _arr) {
+ // truncate the array
+ assembly {
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function append(
+ FulfillmentComponent[] memory arr,
+ FulfillmentComponent memory value
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new FulfillmentComponent[](length + 1);
+ newArr[length] = value;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function appendUnsafe(
+ FulfillmentComponent[] memory arr,
+ FulfillmentComponent memory value
+ ) internal pure returns (FulfillmentComponent[] memory modifiedArr) {
+ uint256 length = arr.length;
+ modifiedArr = arr;
+ assembly {
+ mstore(modifiedArr, add(length, 1))
+ mstore(add(modifiedArr, shl(5, add(length, 1))), value)
+ }
+ }
+
+ function copy(
+ FulfillmentComponent[] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new FulfillmentComponent[](length);
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function copyAndResize(
+ FulfillmentComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](newLength);
+ uint256 length = arr.length;
+ // allow shrinking a copy without copying extra members
+ length = (length > newLength) ? newLength : length;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ // TODO: consider writing 0-pointer to the rest of the array if longer for dynamic elements
+ }
+
+ function copyAndAllocate(
+ FulfillmentComponent[] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ uint256 originalLength = arr.length;
+ for (uint256 i = 0; i < originalLength; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, originalLength)
+ }
+ }
+
+ function pop(
+ FulfillmentComponent[] memory arr
+ ) internal pure returns (FulfillmentComponent memory value) {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popUnsafe(
+ FulfillmentComponent[] memory arr
+ ) internal pure returns (FulfillmentComponent memory value) {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popLeft(
+ FulfillmentComponent[] memory arr
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[] memory newArr,
+ FulfillmentComponent memory value
+ )
+ {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function popLeftUnsafe(
+ FulfillmentComponent[] memory arr
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[] memory newArr,
+ FulfillmentComponent memory value
+ )
+ {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[1] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](1);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[1] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 1)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[2] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](2);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[2] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 2)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[3] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](3);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[3] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 3)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[4] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](4);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[4] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 4)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[5] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](5);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[5] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 5)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[6] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](6);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[6] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 6)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[7] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](7);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[7] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[] memory newArr) {
+ newArr = new FulfillmentComponent[](maxLength);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 7)
+ }
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e,
+ FulfillmentComponent[] memory f
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function FulfillmentComponentArrays(
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e,
+ FulfillmentComponent[] memory f,
+ FulfillmentComponent[] memory g
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e,
+ FulfillmentComponent[] memory f
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function FulfillmentComponentArraysWithMaxLength(
+ uint256 maxLength,
+ FulfillmentComponent[] memory a,
+ FulfillmentComponent[] memory b,
+ FulfillmentComponent[] memory c,
+ FulfillmentComponent[] memory d,
+ FulfillmentComponent[] memory e,
+ FulfillmentComponent[] memory f,
+ FulfillmentComponent[] memory g
+ ) internal pure returns (FulfillmentComponent[][] memory) {
+ FulfillmentComponent[][] memory arr = new FulfillmentComponent[][](
+ maxLength
+ );
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function extend(
+ FulfillmentComponent[][] memory arr1,
+ FulfillmentComponent[][] memory arr2
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ uint256 length1 = arr1.length;
+ uint256 length2 = arr2.length;
+ newArr = new FulfillmentComponent[][](length1 + length2);
+ for (uint256 i = 0; i < length1; ) {
+ newArr[i] = arr1[i];
+ unchecked {
+ ++i;
+ }
+ }
+ for (uint256 i = 0; i < arr2.length; ) {
+ uint256 j;
+ unchecked {
+ j = i + length1;
+ }
+ newArr[j] = arr2[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function allocateFulfillmentComponentArrays(
+ uint256 length
+ ) internal pure returns (FulfillmentComponent[][] memory arr) {
+ arr = new FulfillmentComponent[][](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function truncate(
+ FulfillmentComponent[][] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[][] memory _arr) {
+ // truncate the array
+ assembly {
+ let oldLength := mload(arr)
+ returndatacopy(
+ returndatasize(),
+ returndatasize(),
+ gt(newLength, oldLength)
+ )
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function truncateUnsafe(
+ FulfillmentComponent[][] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[][] memory _arr) {
+ // truncate the array
+ assembly {
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function append(
+ FulfillmentComponent[][] memory arr,
+ FulfillmentComponent[] memory value
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new FulfillmentComponent[][](length + 1);
+ newArr[length] = value;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function appendUnsafe(
+ FulfillmentComponent[][] memory arr,
+ FulfillmentComponent[] memory value
+ ) internal pure returns (FulfillmentComponent[][] memory modifiedArr) {
+ uint256 length = arr.length;
+ modifiedArr = arr;
+ assembly {
+ mstore(modifiedArr, add(length, 1))
+ mstore(add(modifiedArr, shl(5, add(length, 1))), value)
+ }
+ }
+
+ function copy(
+ FulfillmentComponent[][] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new FulfillmentComponent[][](length);
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function copyAndResize(
+ FulfillmentComponent[][] memory arr,
+ uint256 newLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](newLength);
+ uint256 length = arr.length;
+ // allow shrinking a copy without copying extra members
+ length = (length > newLength) ? newLength : length;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ // TODO: consider writing 0-pointer to the rest of the array if longer for dynamic elements
+ }
+
+ function copyAndAllocate(
+ FulfillmentComponent[][] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ uint256 originalLength = arr.length;
+ for (uint256 i = 0; i < originalLength; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, originalLength)
+ }
+ }
+
+ function pop(
+ FulfillmentComponent[][] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory value) {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popUnsafe(
+ FulfillmentComponent[][] memory arr
+ ) internal pure returns (FulfillmentComponent[] memory value) {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popLeft(
+ FulfillmentComponent[][] memory arr
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[][] memory newArr,
+ FulfillmentComponent[] memory value
+ )
+ {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function popLeftUnsafe(
+ FulfillmentComponent[][] memory arr
+ )
+ internal
+ pure
+ returns (
+ FulfillmentComponent[][] memory newArr,
+ FulfillmentComponent[] memory value
+ )
+ {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][1] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](1);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][1] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 1)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][2] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](2);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][2] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 2)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][3] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](3);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][3] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 3)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][4] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](4);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][4] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 4)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][5] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](5);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][5] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 5)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][6] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](6);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][6] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 6)
+ }
+ }
+
+ function fromFixed(
+ FulfillmentComponent[][7] memory arr
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](7);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ FulfillmentComponent[][7] memory arr,
+ uint256 maxLength
+ ) internal pure returns (FulfillmentComponent[][] memory newArr) {
+ newArr = new FulfillmentComponent[][](maxLength);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 7)
+ }
+ }
+
+ function Fulfillments(
+ Fulfillment memory a
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e,
+ Fulfillment memory f
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function Fulfillments(
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e,
+ Fulfillment memory f,
+ Fulfillment memory g
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e,
+ Fulfillment memory f
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function FulfillmentsWithMaxLength(
+ uint256 maxLength,
+ Fulfillment memory a,
+ Fulfillment memory b,
+ Fulfillment memory c,
+ Fulfillment memory d,
+ Fulfillment memory e,
+ Fulfillment memory f,
+ Fulfillment memory g
+ ) internal pure returns (Fulfillment[] memory) {
+ Fulfillment[] memory arr = new Fulfillment[](maxLength);
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function extend(
+ Fulfillment[] memory arr1,
+ Fulfillment[] memory arr2
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ uint256 length1 = arr1.length;
+ uint256 length2 = arr2.length;
+ newArr = new Fulfillment[](length1 + length2);
+ for (uint256 i = 0; i < length1; ) {
+ newArr[i] = arr1[i];
+ unchecked {
+ ++i;
+ }
+ }
+ for (uint256 i = 0; i < arr2.length; ) {
+ uint256 j;
+ unchecked {
+ j = i + length1;
+ }
+ newArr[j] = arr2[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function allocateFulfillments(
+ uint256 length
+ ) internal pure returns (Fulfillment[] memory arr) {
+ arr = new Fulfillment[](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function truncate(
+ Fulfillment[] memory arr,
+ uint256 newLength
+ ) internal pure returns (Fulfillment[] memory _arr) {
+ // truncate the array
+ assembly {
+ let oldLength := mload(arr)
+ returndatacopy(
+ returndatasize(),
+ returndatasize(),
+ gt(newLength, oldLength)
+ )
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function truncateUnsafe(
+ Fulfillment[] memory arr,
+ uint256 newLength
+ ) internal pure returns (Fulfillment[] memory _arr) {
+ // truncate the array
+ assembly {
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function append(
+ Fulfillment[] memory arr,
+ Fulfillment memory value
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new Fulfillment[](length + 1);
+ newArr[length] = value;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function appendUnsafe(
+ Fulfillment[] memory arr,
+ Fulfillment memory value
+ ) internal pure returns (Fulfillment[] memory modifiedArr) {
+ uint256 length = arr.length;
+ modifiedArr = arr;
+ assembly {
+ mstore(modifiedArr, add(length, 1))
+ mstore(add(modifiedArr, shl(5, add(length, 1))), value)
+ }
+ }
+
+ function copy(
+ Fulfillment[] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new Fulfillment[](length);
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function copyAndResize(
+ Fulfillment[] memory arr,
+ uint256 newLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](newLength);
+ uint256 length = arr.length;
+ // allow shrinking a copy without copying extra members
+ length = (length > newLength) ? newLength : length;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ // TODO: consider writing 0-pointer to the rest of the array if longer for dynamic elements
+ }
+
+ function copyAndAllocate(
+ Fulfillment[] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ uint256 originalLength = arr.length;
+ for (uint256 i = 0; i < originalLength; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, originalLength)
+ }
+ }
+
+ function pop(
+ Fulfillment[] memory arr
+ ) internal pure returns (Fulfillment memory value) {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popUnsafe(
+ Fulfillment[] memory arr
+ ) internal pure returns (Fulfillment memory value) {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popLeft(
+ Fulfillment[] memory arr
+ )
+ internal
+ pure
+ returns (Fulfillment[] memory newArr, Fulfillment memory value)
+ {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function popLeftUnsafe(
+ Fulfillment[] memory arr
+ )
+ internal
+ pure
+ returns (Fulfillment[] memory newArr, Fulfillment memory value)
+ {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[1] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](1);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[1] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 1)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[2] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](2);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[2] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 2)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[3] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](3);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[3] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 3)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[4] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](4);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[4] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 4)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[5] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](5);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[5] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 5)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[6] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](6);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[6] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 6)
+ }
+ }
+
+ function fromFixed(
+ Fulfillment[7] memory arr
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](7);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ Fulfillment[7] memory arr,
+ uint256 maxLength
+ ) internal pure returns (Fulfillment[] memory newArr) {
+ newArr = new Fulfillment[](maxLength);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 7)
+ }
+ }
+
+ function MatchComponents(
+ MatchComponent memory a
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e,
+ MatchComponent memory f
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function MatchComponents(
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e,
+ MatchComponent memory f,
+ MatchComponent memory g
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e,
+ MatchComponent memory f
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function MatchComponentsWithMaxLength(
+ uint256 maxLength,
+ MatchComponent memory a,
+ MatchComponent memory b,
+ MatchComponent memory c,
+ MatchComponent memory d,
+ MatchComponent memory e,
+ MatchComponent memory f,
+ MatchComponent memory g
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory arr = new MatchComponent[](maxLength);
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function extend(
+ MatchComponent[] memory arr1,
+ MatchComponent[] memory arr2
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ uint256 length1 = arr1.length;
+ uint256 length2 = arr2.length;
+ newArr = new MatchComponent[](length1 + length2);
+ for (uint256 i = 0; i < length1; ) {
+ newArr[i] = arr1[i];
+ unchecked {
+ ++i;
+ }
+ }
+ for (uint256 i = 0; i < arr2.length; ) {
+ uint256 j;
+ unchecked {
+ j = i + length1;
+ }
+ newArr[j] = arr2[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function allocateMatchComponents(
+ uint256 length
+ ) internal pure returns (MatchComponent[] memory arr) {
+ arr = new MatchComponent[](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function truncate(
+ MatchComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (MatchComponent[] memory _arr) {
+ // truncate the array
+ assembly {
+ let oldLength := mload(arr)
+ returndatacopy(
+ returndatasize(),
+ returndatasize(),
+ gt(newLength, oldLength)
+ )
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function truncateUnsafe(
+ MatchComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (MatchComponent[] memory _arr) {
+ // truncate the array
+ assembly {
+ mstore(arr, newLength)
+ _arr := arr
+ }
+ }
+
+ function append(
+ MatchComponent[] memory arr,
+ MatchComponent memory value
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new MatchComponent[](length + 1);
+ newArr[length] = value;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function appendUnsafe(
+ MatchComponent[] memory arr,
+ MatchComponent memory value
+ ) internal pure returns (MatchComponent[] memory modifiedArr) {
+ uint256 length = arr.length;
+ modifiedArr = arr;
+ assembly {
+ mstore(modifiedArr, add(length, 1))
+ mstore(add(modifiedArr, shl(5, add(length, 1))), value)
+ }
+ }
+
+ function copy(
+ MatchComponent[] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ uint256 length = arr.length;
+ newArr = new MatchComponent[](length);
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function copyAndResize(
+ MatchComponent[] memory arr,
+ uint256 newLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](newLength);
+ uint256 length = arr.length;
+ // allow shrinking a copy without copying extra members
+ length = (length > newLength) ? newLength : length;
+ for (uint256 i = 0; i < length; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ // TODO: consider writing 0-pointer to the rest of the array if longer for dynamic elements
+ }
+
+ function copyAndAllocate(
+ MatchComponent[] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ uint256 originalLength = arr.length;
+ for (uint256 i = 0; i < originalLength; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, originalLength)
+ }
+ }
+
+ function pop(
+ MatchComponent[] memory arr
+ ) internal pure returns (MatchComponent memory value) {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popUnsafe(
+ MatchComponent[] memory arr
+ ) internal pure returns (MatchComponent memory value) {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, shl(5, length)))
+ mstore(arr, sub(length, 1))
+ }
+ }
+
+ function popLeft(
+ MatchComponent[] memory arr
+ )
+ internal
+ pure
+ returns (MatchComponent[] memory newArr, MatchComponent memory value)
+ {
+ assembly {
+ let length := mload(arr)
+ returndatacopy(returndatasize(), returndatasize(), iszero(length))
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function popLeftUnsafe(
+ MatchComponent[] memory arr
+ )
+ internal
+ pure
+ returns (MatchComponent[] memory newArr, MatchComponent memory value)
+ {
+ // This function is unsafe because it does not check if the array is empty.
+ assembly {
+ let length := mload(arr)
+ value := mload(add(arr, 0x20))
+ newArr := add(arr, 0x20)
+ mstore(newArr, sub(length, 1))
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[1] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](1);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[1] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 1; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 1)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[2] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](2);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[2] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 2; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 2)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[3] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](3);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[3] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 3; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 3)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[4] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](4);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[4] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 4; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 4)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[5] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](5);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[5] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 5; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 5)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[6] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](6);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[6] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 6; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 6)
+ }
+ }
+
+ function fromFixed(
+ MatchComponent[7] memory arr
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](7);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ }
+
+ function fromFixedWithMaxLength(
+ MatchComponent[7] memory arr,
+ uint256 maxLength
+ ) internal pure returns (MatchComponent[] memory newArr) {
+ newArr = new MatchComponent[](maxLength);
+ for (uint256 i = 0; i < 7; ) {
+ newArr[i] = arr[i];
+ unchecked {
+ ++i;
+ }
+ }
+ assembly {
+ mstore(newArr, 7)
+ }
+ }
+
+ function uints(uint a) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function uints(uint a, uint b) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uints(
+ uint a,
+ uint b,
+ uint c
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uints(
+ uint a,
+ uint b,
+ uint c,
+ uint d
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uints(
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uints(
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e,
+ uint f
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uints(
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e,
+ uint f,
+ uint g
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b,
+ uint c
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b,
+ uint c,
+ uint d
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e,
+ uint f
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function uintsWithMaxLength(
+ uint256 maxLength,
+ uint a,
+ uint b,
+ uint c,
+ uint d,
+ uint e,
+ uint f,
+ uint g
+ ) internal pure returns (uint[] memory) {
+ uint[] memory arr = new uint[](maxLength);
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function allocateUints(
+ uint256 length
+ ) internal pure returns (uint[] memory arr) {
+ arr = new uint[](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function ints(int a) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](1);
+ arr[0] = a;
+ return arr;
+ }
+
+ function ints(int a, int b) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](2);
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function ints(int a, int b, int c) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](3);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function ints(
+ int a,
+ int b,
+ int c,
+ int d
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](4);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function ints(
+ int a,
+ int b,
+ int c,
+ int d,
+ int e
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](5);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function ints(
+ int a,
+ int b,
+ int c,
+ int d,
+ int e,
+ int f
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](6);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function ints(
+ int a,
+ int b,
+ int c,
+ int d,
+ int e,
+ int f,
+ int g
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](7);
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 1)
+ }
+ arr[0] = a;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 2)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b,
+ int c
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 3)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b,
+ int c,
+ int d
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 4)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b,
+ int c,
+ int d,
+ int e
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 5)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b,
+ int c,
+ int d,
+ int e,
+ int f
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 6)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ return arr;
+ }
+
+ function intsWithMaxLength(
+ uint256 maxLength,
+ int a,
+ int b,
+ int c,
+ int d,
+ int e,
+ int f,
+ int g
+ ) internal pure returns (int[] memory) {
+ int[] memory arr = new int[](maxLength);
+ assembly {
+ mstore(arr, 7)
+ }
+ arr[0] = a;
+ arr[1] = b;
+ arr[2] = c;
+ arr[3] = d;
+ arr[4] = e;
+ arr[5] = f;
+ arr[6] = g;
+ return arr;
+ }
+
+ function allocateInts(
+ uint256 length
+ ) internal pure returns (int[] memory arr) {
+ arr = new int[](length);
+ assembly {
+ mstore(arr, 0)
+ }
+ }
+
+ function amountKey(
+ MatchComponent memory component
+ ) internal pure returns (uint256) {
+ return component.amount;
+ }
+
+ function indexKey(
+ MatchComponent memory component
+ ) internal pure returns (uint256) {
+ return (component.orderIndex << 8) | component.itemIndex;
+ }
+
+ function sortByAmount(MatchComponent[] memory components) internal pure {
+ sort(components, amountKey);
+ }
+
+ function sortByIndex(MatchComponent[] memory components) internal pure {
+ sort(components, indexKey);
+ }
+
+ // Sorts the array in-place with intro-quicksort.
+ function sort(
+ MatchComponent[] memory a,
+ function(MatchComponent memory) internal pure returns (uint256) accessor
+ ) internal pure {
+ if (a.length < 2) {
+ return;
+ }
+
+ uint256[] memory stack = new uint256[](2 * a.length);
+ uint256 stackIndex = 0;
+
+ uint256 l = 0;
+ uint256 h = a.length - 1;
+
+ stack[stackIndex++] = l;
+ stack[stackIndex++] = h;
+
+ while (stackIndex > 0) {
+ h = stack[--stackIndex];
+ l = stack[--stackIndex];
+
+ if (h - l <= 12) {
+ // Insertion sort for small subarrays
+ for (uint256 i = l + 1; i <= h; i++) {
+ MatchComponent memory k = a[i];
+ uint256 j = i;
+ while (j > l && accessor(a[j - 1]) > accessor(k)) {
+ a[j] = a[j - 1];
+ j--;
+ }
+ a[j] = k;
+ }
+ } else {
+ // Intro-Quicksort
+ uint256 p = (l + h) / 2;
+
+ // Median of 3
+ if (accessor(a[l]) > accessor(a[p])) {
+ (a[l], a[p]) = (a[p], a[l]);
+ }
+ if (accessor(a[l]) > accessor(a[h])) {
+ (a[l], a[h]) = (a[h], a[l]);
+ }
+ if (accessor(a[p]) > accessor(a[h])) {
+ (a[p], a[h]) = (a[h], a[p]);
+ }
+
+ uint256 pivot = accessor(a[p]);
+ uint256 i = l;
+ uint256 j = h;
+
+ while (i <= j) {
+ while (accessor(a[i]) < pivot) {
+ i++;
+ }
+ while (accessor(a[j]) > pivot) {
+ j--;
+ }
+ if (i <= j) {
+ (a[i], a[j]) = (a[j], a[i]);
+ i++;
+ j--;
+ }
+ }
+
+ if (j > l) {
+ stack[stackIndex++] = l;
+ stack[stackIndex++] = j;
+ }
+ if (i < h) {
+ stack[stackIndex++] = i;
+ stack[stackIndex++] = h;
+ }
+ }
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/lib/Structs.sol b/contracts/helpers/sol/fulfillments/lib/Structs.sol
new file mode 100644
index 000000000..acd9e539d
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/lib/Structs.sol
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ MatchComponent,
+ MatchComponentType
+} from "../../lib/types/MatchComponentType.sol";
+
+import {
+ FulfillmentComponent,
+ SpentItem,
+ ReceivedItem
+} from "../../SeaportStructs.sol";
+
+import { UnavailableReason } from "../../SpaceEnums.sol";
+
+struct FulfillmentHelperCounterLayout {
+ uint256 fulfillmentCounter;
+}
+
+// TODO: won't work for partial fulfills of criteria resolved
+// TODO: won't work for hybrid tokens that implement multiple token interfaces
+struct MatchFulfillmentStorageLayout {
+ mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => mapping(address /*offerer*/ => mapping(bytes32 /*conduitKey*/ => MatchComponent[] /*components*/)))) offerMap;
+ mapping(address /*recipient*/ => mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => MatchComponent[] /*components*/))) considerationMap;
+ // a given aggregatable consideration component will have its own set of aggregatable offer components
+ mapping(address /*token*/ => mapping(uint256 /*tokenId*/ => AggregatableOfferer[] /*offererEnumeration*/)) tokenToOffererEnumeration;
+ // aggregatable consideration components can be enumerated normally
+ AggregatableConsideration[] considerationEnumeration;
+}
+
+struct FulfillAvailableHelperStorageLayout {
+ mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => mapping(address /*offerer*/ => mapping(bytes32 /*conduitKey*/ => FulfillmentComponent[] /*components*/)))) offerMap;
+ mapping(address /*recipient*/ => mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => FulfillmentComponent[] /*components*/))) considerationMap;
+ // a given aggregatable consideration component will have its own set of aggregatable offer components
+ AggregatableOffer[] offerEnumeration;
+ // aggregatable consideration components can be enumerated normally
+ AggregatableConsideration[] considerationEnumeration;
+}
+
+/**
+ * @notice Offers can only be aggregated if they share an offerer *and* conduitKey
+ */
+struct AggregatableOfferer {
+ address offerer;
+ bytes32 conduitKey;
+}
+
+struct AggregatableOffer {
+ address offerer;
+ bytes32 conduitKey;
+ address contractAddress;
+ uint256 tokenId;
+}
+/**
+ *
+ * @notice Considerations can only be aggregated if they share a token address, id, and recipient (and itemType, but in the vast majority of cases, a token is only one type)
+ */
+
+struct AggregatableConsideration {
+ address recipient;
+ address contractAddress;
+ uint256 tokenId;
+}
+
+struct ProcessComponentParams {
+ FulfillmentComponent[] offerFulfillmentComponents;
+ FulfillmentComponent[] considerationFulfillmentComponents;
+ uint256 offerItemIndex;
+ uint256 considerationItemIndex;
+ bool midCredit;
+}
+
+struct OrderDetails {
+ address offerer;
+ bytes32 conduitKey;
+ SpentItem[] offer;
+ ReceivedItem[] consideration;
+ bool isContract;
+ bytes32 orderHash;
+ UnavailableReason unavailableReason;
+}
+
+/**
+ * @dev Represents the details of a single fulfill/match call to Seaport.
+ *
+ * @param orders processed details of individual orders
+ * @param recipient the explicit recipient of all offer items in
+ * the fulfillAvailable case; implicit recipient
+ * of excess offer items in the match case
+ * @param fulfiller the explicit recipient of all unspent native
+ * tokens; provides all consideration items in
+ * the fulfillAvailable case
+ * @param fulfillerConduitKey used to transfer tokens from the fulfiller
+ * providing all consideration items in the
+ * fulfillAvailable case
+ */
+struct FulfillmentDetails {
+ OrderDetails[] orders;
+ address payable recipient;
+ address payable fulfiller;
+ uint256 nativeTokensSupplied;
+ bytes32 fulfillerConduitKey;
+ address seaport;
+}
diff --git a/contracts/helpers/sol/fulfillments/match/MatchFulfillmentHelper.sol b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentHelper.sol
new file mode 100644
index 000000000..be3ae1389
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentHelper.sol
@@ -0,0 +1,356 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ AggregatableConsideration,
+ ProcessComponentParams,
+ AggregatableOfferer,
+ OrderDetails,
+ MatchFulfillmentStorageLayout
+} from "../lib/Structs.sol";
+import {
+ MatchComponent,
+ MatchComponentType
+} from "../../lib/types/MatchComponentType.sol";
+import {
+ FulfillmentComponent,
+ Fulfillment,
+ Order,
+ AdvancedOrder,
+ OrderParameters,
+ SpentItem,
+ ReceivedItem,
+ CriteriaResolver
+} from "../../SeaportStructs.sol";
+import { UnavailableReason } from "../../SpaceEnums.sol";
+import { MatchFulfillmentLib } from "./MatchFulfillmentLib.sol";
+import { MatchFulfillmentLayout } from "./MatchFulfillmentLayout.sol";
+
+import {
+ AmountDeriverHelper
+} from "../../lib/fulfillment/AmountDeriverHelper.sol";
+import { MatchArrays } from "../lib/MatchArrays.sol";
+
+contract MatchFulfillmentHelper is AmountDeriverHelper {
+ /**
+ * @notice Generate matched fulfillments for a list of orders
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @return fulfillments
+ */
+ function getMatchedFulfillments(
+ Order[] memory orders,
+ bytes32[] memory orderHashes,
+ UnavailableReason[] memory unavailableReasons
+ )
+ public
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory remainingOfferComponents,
+ MatchComponent[] memory remainingConsiderationComponents
+ )
+ {
+ OrderDetails[] memory orderDetails = toOrderDetails(
+ orders,
+ orderHashes,
+ unavailableReasons
+ );
+
+ return getMatchedFulfillments(orderDetails);
+ }
+
+ /**
+ * @notice Generate matched fulfillments for a list of orders
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @param resolvers resolvers
+ * @return fulfillments
+ */
+ function getMatchedFulfillments(
+ AdvancedOrder[] memory orders,
+ CriteriaResolver[] memory resolvers,
+ bytes32[] memory orderHashes,
+ UnavailableReason[] memory unavailableReasons
+ )
+ public
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory remainingOfferComponents,
+ MatchComponent[] memory remainingConsiderationComponents
+ )
+ {
+ OrderDetails[] memory details = toOrderDetails(
+ orders,
+ resolvers,
+ orderHashes,
+ unavailableReasons
+ );
+ return getMatchedFulfillments(details);
+ }
+
+ /**
+ * @notice Generate matched fulfillments for a list of orders
+ * NOTE: this will break for multiple criteria items that resolve
+ * to different identifiers
+ * @param orders orders
+ * @return fulfillments
+ */
+ function getMatchedFulfillments(
+ OrderDetails[] memory orders
+ )
+ public
+ returns (
+ Fulfillment[] memory fulfillments,
+ MatchComponent[] memory remainingOfferComponents,
+ MatchComponent[] memory remainingConsiderationComponents
+ )
+ {
+ // increment counter to get clean mappings and enumeration
+ MatchFulfillmentLayout.incrementFulfillmentCounter();
+ // load the storage layout
+ MatchFulfillmentStorageLayout storage layout = MatchFulfillmentLayout
+ .getStorageLayout();
+
+ // iterate over each order and process the offer and consideration components
+ for (uint256 i; i < orders.length; ++i) {
+ OrderDetails memory details = orders[i];
+
+ // insert MatchComponents into the offer mapping, grouped by token, tokenId, offerer, and conduitKey
+ // also update per-token+tokenId enumerations of AggregatableOfferer
+
+ preProcessSpentItems(
+ details.offer,
+ details.offerer,
+ details.conduitKey,
+ i,
+ layout
+ );
+ // insert MatchComponents into the offer mapping, grouped by token, tokenId, and recipient
+ // also update AggregatableConsideration enumeration
+ preProcessSpentItems(details.consideration, i, layout);
+ }
+
+ // iterate over groups of consideration components and find matching offer components
+ uint256 considerationLength = layout.considerationEnumeration.length;
+ for (uint256 i; i < considerationLength; ++i) {
+ // get the token information
+ AggregatableConsideration storage token = layout
+ .considerationEnumeration[i];
+ // load the consideration components
+ MatchComponent[] storage considerationComponents = layout
+ .considerationMap[token.recipient][token.contractAddress][
+ token.tokenId
+ ];
+ // load the enumeration of offerer+conduit keys for offer components that match this token
+ AggregatableOfferer[] storage offererEnumeration = layout
+ .tokenToOffererEnumeration[token.contractAddress][
+ token.tokenId
+ ];
+ // iterate over each offerer+conduit with offer components that match this token and create matching fulfillments
+ // this will update considerationComponents in-place in storage, which we check at the beginning of each loop
+ for (uint256 j; j < offererEnumeration.length; ++j) {
+ // if all consideration components have been fulfilled, break
+ if (considerationComponents.length == 0) {
+ break;
+ }
+ // load the AggregatableOfferer
+ AggregatableOfferer
+ storage aggregatableOfferer = offererEnumeration[j];
+ // load the associated offer components for this offerer+conduit
+ MatchComponent[] storage offerComponents = layout.offerMap[
+ token.contractAddress
+ ][token.tokenId][aggregatableOfferer.offerer][
+ aggregatableOfferer.conduitKey
+ ];
+ // if there are no offer components left, continue
+ // TODO: remove from enumeration?
+ if (offerComponents.length == 0) {
+ continue;
+ }
+
+ // create a fulfillment matching the offer and consideration components until either or both are exhausted
+ Fulfillment memory fulfillment = MatchFulfillmentLib
+ .createFulfillment(
+ offerComponents,
+ considerationComponents
+ );
+ // append the fulfillment to the array of fulfillments
+ fulfillments = MatchArrays.append(fulfillments, fulfillment);
+ // loop back around in case not all considerationComponents have been completely fulfilled
+ }
+ }
+
+ // get any remaining offer components
+ for (uint256 i; i < orders.length; ++i) {
+ OrderDetails memory details = orders[i];
+
+ // insert MatchComponents into the offer mapping, grouped by token, tokenId, offerer, and conduitKey
+ // also update per-token+tokenId enumerations of AggregatableOfferer
+ remainingOfferComponents = MatchArrays.extend(
+ remainingOfferComponents,
+ postProcessSpentItems(
+ details.offer,
+ details.offerer,
+ details.conduitKey,
+ layout
+ )
+ );
+
+ remainingConsiderationComponents = MatchArrays.extend(
+ remainingConsiderationComponents,
+ postProcessReceivedItems(details.consideration, layout)
+ );
+ }
+ remainingOfferComponents = MatchFulfillmentLib.dedupe(
+ remainingOfferComponents
+ );
+ remainingConsiderationComponents = MatchFulfillmentLib.dedupe(
+ remainingConsiderationComponents
+ );
+ }
+
+ /**
+ * @notice Process offer items and insert them into enumeration and map
+ * @param offer offer items
+ * @param offerer offerer
+ * @param orderIndex order index of processed items
+ * @param layout storage layout of helper
+ */
+ function preProcessSpentItems(
+ SpentItem[] memory offer,
+ address offerer,
+ bytes32 conduitKey,
+ uint256 orderIndex,
+ MatchFulfillmentStorageLayout storage layout
+ ) private {
+ // iterate over each offer item
+ for (uint256 j; j < offer.length; ++j) {
+ // grab offer item
+ // TODO: spentItems?
+ SpentItem memory item = offer[j];
+ MatchComponent memory component = MatchComponentType
+ .createMatchComponent({
+ amount: uint240(item.amount),
+ orderIndex: uint8(orderIndex),
+ itemIndex: uint8(j)
+ });
+ AggregatableOfferer
+ memory aggregatableOfferer = AggregatableOfferer({
+ offerer: offerer,
+ conduitKey: conduitKey
+ });
+
+ // if it does not exist in the map, add it to our per-token+id enumeration
+ if (
+ !MatchFulfillmentLib.aggregatableOffererExists(
+ item.token,
+ item.identifier,
+ aggregatableOfferer,
+ layout
+ )
+ ) {
+ // add to enumeration for specific tokenhash (tokenAddress+tokenId)
+ layout
+ .tokenToOffererEnumeration[item.token][item.identifier].push(
+ aggregatableOfferer
+ );
+ }
+ // update aggregatable mapping array with this component
+ layout
+ .offerMap[item.token][item.identifier][offerer][conduitKey].push(
+ component
+ );
+ }
+ }
+
+ function postProcessSpentItems(
+ SpentItem[] memory offer,
+ address offerer,
+ bytes32 conduitKey,
+ MatchFulfillmentStorageLayout storage layout
+ ) private view returns (MatchComponent[] memory remainingOfferComponents) {
+ // iterate over each offer item
+ for (uint256 j; j < offer.length; ++j) {
+ // grab offer item
+ // TODO: spentItems?
+ SpentItem memory item = offer[j];
+
+ // update aggregatable mapping array with this component
+ remainingOfferComponents = MatchArrays.extend(
+ remainingOfferComponents,
+ layout.offerMap[item.token][item.identifier][offerer][
+ conduitKey
+ ]
+ );
+ }
+ }
+
+ /**
+ * @notice Process consideration items and insert them into enumeration and map
+ * @param consideration consideration items
+ * @param orderIndex order index of processed items
+ * @param layout storage layout of helper
+ */
+ function preProcessSpentItems(
+ ReceivedItem[] memory consideration,
+ uint256 orderIndex,
+ MatchFulfillmentStorageLayout storage layout
+ ) private {
+ // iterate over each consideration item
+ for (uint256 j; j < consideration.length; ++j) {
+ // grab consideration item
+ ReceivedItem memory item = consideration[j];
+ // TODO: use receivedItem here?
+ MatchComponent memory component = MatchComponentType
+ .createMatchComponent({
+ amount: uint240(item.amount),
+ orderIndex: uint8(orderIndex),
+ itemIndex: uint8(j)
+ });
+ // create enumeration struct
+ AggregatableConsideration memory token = AggregatableConsideration({
+ recipient: item.recipient,
+ contractAddress: item.token,
+ tokenId: item.identifier
+ });
+ // if it does not exist in the map, add it to our enumeration
+ if (
+ !MatchFulfillmentLib.aggregatableConsiderationExists(
+ token,
+ layout
+ )
+ ) {
+ layout.considerationEnumeration.push(token);
+ }
+ // update mapping with this component
+ layout
+ .considerationMap[token.recipient][token.contractAddress][
+ token.tokenId
+ ].push(component);
+ }
+ }
+
+ function postProcessReceivedItems(
+ ReceivedItem[] memory consideration,
+ MatchFulfillmentStorageLayout storage layout
+ )
+ private
+ view
+ returns (MatchComponent[] memory remainingConsiderationComponents)
+ {
+ // iterate over each consideration item
+ for (uint256 j; j < consideration.length; ++j) {
+ // grab consideration item
+ ReceivedItem memory item = consideration[j];
+
+ remainingConsiderationComponents = MatchArrays.extend(
+ remainingConsiderationComponents,
+ layout.considerationMap[item.recipient][item.token][
+ item.identifier
+ ]
+ );
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLayout.sol b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLayout.sol
new file mode 100644
index 000000000..c0d06ed68
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLayout.sol
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ MatchComponent,
+ MatchComponentType
+} from "../../lib/types/MatchComponentType.sol";
+import {
+ MatchFulfillmentStorageLayout,
+ FulfillmentHelperCounterLayout,
+ AggregatableConsideration
+} from "../lib/Structs.sol";
+import {
+ MATCH_FULFILLMENT_COUNTER_KEY,
+ MATCH_FULFILLMENT_STORAGE_BASE_KEY
+} from "../lib/Constants.sol";
+
+library MatchFulfillmentLayout {
+ /**
+ * @notice load storage layout for the current fulfillmentCounter
+ */
+ function getStorageLayout()
+ internal
+ view
+ returns (MatchFulfillmentStorageLayout storage layout)
+ {
+ FulfillmentHelperCounterLayout
+ storage counterLayout = getCounterLayout();
+ uint256 counter = counterLayout.fulfillmentCounter;
+ bytes32 storageLayoutKey = MATCH_FULFILLMENT_STORAGE_BASE_KEY;
+ assembly {
+ mstore(0, counter)
+ mstore(0x20, storageLayoutKey)
+ layout.slot := keccak256(0, 0x40)
+ }
+ }
+
+ /**
+ * @notice load storage layout for the counter itself
+ */
+ function getCounterLayout()
+ internal
+ pure
+ returns (FulfillmentHelperCounterLayout storage layout)
+ {
+ bytes32 counterLayoutKey = MATCH_FULFILLMENT_COUNTER_KEY;
+ assembly {
+ layout.slot := counterLayoutKey
+ }
+ }
+
+ /**
+ * @notice increment the fulfillmentCounter to effectively clear the mappings and enumerations between calls
+ */
+ function incrementFulfillmentCounter() internal {
+ FulfillmentHelperCounterLayout
+ storage counterLayout = getCounterLayout();
+ counterLayout.fulfillmentCounter += 1;
+ }
+
+ /**
+ * @notice Get the mapping of tokens for a given key (offer or consideration), derived from the hash of the key and the current fulfillmentCounter value
+ * @param key Original key used to derive the slot of the enumeration
+ */
+ function getMap(
+ bytes32 key
+ )
+ internal
+ view
+ returns (
+ mapping(address /*offererOrRecipient*/ => mapping(address /*tokenContract*/ => mapping(uint256 /*identifier*/ => MatchComponent[] /*components*/)))
+ storage map
+ )
+ {
+ bytes32 counterKey = MATCH_FULFILLMENT_COUNTER_KEY;
+ assembly {
+ mstore(0, key)
+ mstore(0x20, sload(counterKey))
+ map.slot := keccak256(0, 0x40)
+ }
+ }
+
+ /**
+ * @notice Get the enumeration of AggregatableConsiderations for a given key (offer or consideration), derived from the hash of the key and the current fulfillmentCounter value
+ * @param key Original key used to derive the slot of the enumeration
+ */
+ function getEnumeration(
+ bytes32 key
+ ) internal view returns (AggregatableConsideration[] storage tokens) {
+ bytes32 counterKey = MATCH_FULFILLMENT_COUNTER_KEY;
+ assembly {
+ mstore(0, key)
+ mstore(0x20, sload(counterKey))
+ tokens.slot := keccak256(0, 0x40)
+ }
+ }
+}
diff --git a/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLib.sol b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLib.sol
new file mode 100644
index 000000000..e220f6894
--- /dev/null
+++ b/contracts/helpers/sol/fulfillments/match/MatchFulfillmentLib.sol
@@ -0,0 +1,314 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {
+ AggregatableConsideration,
+ ProcessComponentParams,
+ MatchFulfillmentStorageLayout,
+ AggregatableOfferer
+} from "../lib/Structs.sol";
+import {
+ MatchComponent,
+ MatchComponentType
+} from "../../lib/types/MatchComponentType.sol";
+import { FulfillmentComponent, Fulfillment } from "../../SeaportStructs.sol";
+import { LibSort } from "solady/src/utils/LibSort.sol";
+import { MatchArrays } from "../lib/MatchArrays.sol";
+
+library MatchFulfillmentLib {
+ using MatchComponentType for MatchComponent[];
+ using MatchComponentType for MatchComponent;
+
+ /**
+ * @notice Check if a token already exists in a mapping by checking the length of the array at that slot
+ * @param token token to check
+ * @param layout storage layout
+ */
+ function aggregatableConsiderationExists(
+ AggregatableConsideration memory token,
+ MatchFulfillmentStorageLayout storage layout
+ ) internal view returns (bool) {
+ return
+ layout
+ .considerationMap[token.recipient][token.contractAddress][
+ token.tokenId
+ ].length > 0;
+ }
+
+ /**
+ * @notice Check if an entry into the offer component mapping already exists by checking its length
+ */
+ function aggregatableOffererExists(
+ address token,
+ uint256 tokenId,
+ AggregatableOfferer memory offerer,
+ MatchFulfillmentStorageLayout storage layout
+ ) internal view returns (bool) {
+ return
+ layout
+ .offerMap[token][tokenId][offerer.offerer][offerer.conduitKey]
+ .length > 0;
+ }
+
+ function processConsiderationComponent(
+ MatchComponent[] storage offerComponents,
+ MatchComponent[] storage considerationComponents,
+ ProcessComponentParams memory params
+ ) internal {
+ while (params.offerItemIndex < offerComponents.length) {
+ MatchComponent
+ memory considerationComponent = considerationComponents[
+ params.considerationItemIndex
+ ];
+
+ // if consideration has been completely credited, break to next consideration component
+ if (considerationComponent.getAmount() == 0) {
+ break;
+ }
+ processOfferComponent({
+ offerComponents: offerComponents,
+ considerationComponents: considerationComponents,
+ params: params
+ });
+ }
+
+ MatchArrays.appendUnsafe(
+ params.considerationFulfillmentComponents,
+ considerationComponents[params.considerationItemIndex]
+ .toFulfillmentComponent()
+ );
+ }
+
+ function processOfferComponent(
+ MatchComponent[] storage offerComponents,
+ MatchComponent[] storage considerationComponents,
+ ProcessComponentParams memory params
+ ) internal {
+ // re-load components each iteration as they may have been modified
+ MatchComponent memory offerComponent = offerComponents[
+ params.offerItemIndex
+ ];
+ MatchComponent memory considerationComponent = considerationComponents[
+ params.considerationItemIndex
+ ];
+
+ if (offerComponent.getAmount() > considerationComponent.getAmount()) {
+ // if offer amount is greater than consideration amount, set consideration to zero and credit from offer amount
+ offerComponent = offerComponent.subtractAmount(
+ considerationComponent
+ );
+ considerationComponent = considerationComponent.setAmount(0);
+ offerComponents[params.offerItemIndex] = offerComponent;
+ considerationComponents[
+ params.considerationItemIndex
+ ] = considerationComponent;
+ // note that this offerItemIndex should be included when consolidating
+ params.midCredit = true;
+ } else {
+ // otherwise deplete offer amount and credit consideration amount
+
+ considerationComponent = considerationComponent.subtractAmount(
+ offerComponent
+ );
+ offerComponent = offerComponent.setAmount(0);
+
+ considerationComponents[
+ params.considerationItemIndex
+ ] = considerationComponent;
+
+ offerComponents[params.offerItemIndex] = offerComponent;
+ ++params.offerItemIndex;
+ // note that this offerItemIndex should not be included when consolidating
+ params.midCredit = false;
+ }
+ // an offer component may have already been added if it was not depleted by an earlier consideration item
+ if (
+ !previouslyAdded(
+ params.offerFulfillmentComponents,
+ offerComponent.toFulfillmentComponent()
+ )
+ ) {
+ MatchArrays.appendUnsafe(
+ params.offerFulfillmentComponents,
+ offerComponent.toFulfillmentComponent()
+ );
+ }
+ }
+
+ function scuffLength(
+ FulfillmentComponent[] memory components,
+ uint256 newLength
+ ) internal pure {
+ assembly {
+ mstore(components, newLength)
+ }
+ }
+
+ function previouslyAdded(
+ FulfillmentComponent[] memory components,
+ FulfillmentComponent memory fulfillmentComponent
+ ) internal pure returns (bool) {
+ if (components.length == 0) {
+ return false;
+ }
+
+ FulfillmentComponent memory lastComponent = components[
+ components.length - 1
+ ];
+ return
+ lastComponent.orderIndex == fulfillmentComponent.orderIndex &&
+ lastComponent.itemIndex == fulfillmentComponent.itemIndex;
+ }
+
+ /**
+ * Credit offer components to consideration components until either or both are exhausted
+ * Updates arrays in storage to remove 0-item components after credits
+ * @param offerComponents Aggregatable offer components
+ * @param considerationComponents Aggregatable consideration components
+ */
+ function createFulfillment(
+ MatchComponent[] storage offerComponents,
+ MatchComponent[] storage considerationComponents
+ ) internal returns (Fulfillment memory) {
+ // optimistically allocate arrays of fulfillment components
+ FulfillmentComponent[] memory offerFulfillmentComponents = MatchArrays
+ .allocateFulfillmentComponents(offerComponents.length);
+ FulfillmentComponent[]
+ memory considerationFulfillmentComponents = MatchArrays
+ .allocateFulfillmentComponents(considerationComponents.length);
+ // iterate over consideration components
+ ProcessComponentParams memory params = ProcessComponentParams({
+ offerFulfillmentComponents: offerFulfillmentComponents,
+ considerationFulfillmentComponents: considerationFulfillmentComponents,
+ offerItemIndex: 0,
+ considerationItemIndex: 0,
+ midCredit: false
+ });
+
+ // iterate over all consideration components eligible to be fulfilled
+ // in a single transfer; this means that any uncredited amounts will be
+ // consolidated into the first component for later fulfillments
+ // TODO: this may not be optimal in some cases with partial
+ // fulfillments
+ for (
+ uint256 considerationItemIndex;
+ considerationItemIndex < considerationComponents.length;
+ ++considerationItemIndex
+ ) {
+ // params will be updated directly by called functions except for considerationItemIndex
+ params.considerationItemIndex = considerationItemIndex;
+ processConsiderationComponent({
+ offerComponents: offerComponents,
+ considerationComponents: considerationComponents,
+ params: params
+ });
+ }
+
+ // remove any zero-amount components so they are skipped in future
+ // fulfillments, and consolidate any remaining offer amounts used
+ // in this fulfillment into the first component.
+ consolidateComponents(
+ offerComponents,
+ // if mid-credit, offerItemIndex should be included in consolidation
+ (params.midCredit)
+ ? params.offerItemIndex + 1
+ : params.offerItemIndex
+ );
+ // all eligible consideration components will be processed when matched
+ // with the first eligible offer components, whether or not there are
+ // enough offer items to credit each consideration item. This means
+ // that all remaining amounts will be consolidated into the first
+ // consideration component for later fulfillments.
+ consolidateComponents(
+ considerationComponents,
+ considerationComponents.length
+ );
+
+ // return a discrete fulfillment since either or both of the sets of components have been exhausted
+ // if offer or consideration items remain, they will be revisited in subsequent calls
+ return
+ Fulfillment({
+ offerComponents: offerFulfillmentComponents,
+ considerationComponents: considerationFulfillmentComponents
+ });
+ }
+
+ /**
+ * @dev Consolidate any remaining amounts
+ * @param components Components to consolidate
+ * @param excludeIndex First index to exclude from consolidation. For
+ * offerComponents this is the index after the last credited item,
+ * for considerationComponents, this is the length of the array
+ */
+ function consolidateComponents(
+ MatchComponent[] storage components,
+ uint256 excludeIndex
+ ) internal {
+ // cache components in memory
+ MatchComponent[] memory cachedComponents = components;
+ if (cachedComponents.length == 0) {
+ return;
+ } else if (cachedComponents.length == 1) {
+ // check if there is only one component
+ // if it is zero, remove it
+ if (cachedComponents[0].getAmount() == 0) {
+ components.pop();
+ }
+ // otherwise do nothing
+ return;
+ }
+ // otherwise clear the storage array
+ while (components.length > 0) {
+ components.pop();
+ }
+
+ // consolidate the amounts of credited non-zero components into the
+ // first component. This is what Seaport does internally when a
+ // fulfillment is credited.
+ MatchComponent memory first = cachedComponents[0];
+
+ // consolidate all non-zero components used in this fulfillment into the
+ // first component
+ for (uint256 i = 1; i < excludeIndex; ++i) {
+ first = first.addAmount(cachedComponents[i]);
+ }
+
+ // push the first component back into storage if it is non-zero
+ if (first.getAmount() > 0) {
+ components.push(first);
+ }
+ // push any remaining non-zero components back into storage
+ for (uint256 i = excludeIndex; i < cachedComponents.length; ++i) {
+ MatchComponent memory component = cachedComponents[i];
+ if (component.getAmount() > 0) {
+ components.push(component);
+ }
+ }
+ }
+
+ function dedupe(
+ MatchComponent[] memory components
+ ) internal pure returns (MatchComponent[] memory dedupedComponents) {
+ if (components.length == 0 || components.length == 1) {
+ return components;
+ }
+ // sort components
+ // uint256[] memory cast = components.toUints();
+ // LibSort.sort(cast);
+ // components = MatchComponentType.fromUints(cast);
+ // create a new array of same size; it will be truncated if necessary
+ MatchArrays.sortByIndex(components);
+ dedupedComponents = new MatchComponent[](components.length);
+ dedupedComponents[0] = components[0];
+ uint256 dedupedIndex = 1;
+ for (uint256 i = 1; i < components.length; i++) {
+ // compare current component to last deduped component
+ if (!components[i].equals(dedupedComponents[dedupedIndex - 1])) {
+ // if it is different, add it to the deduped array and increment the index
+ dedupedComponents[dedupedIndex] = components[i];
+ ++dedupedIndex;
+ }
+ }
+ return MatchArrays.truncate(dedupedComponents, dedupedIndex);
+ }
+}
diff --git a/contracts/helpers/sol/lib/AdditionalRecipientLib.sol b/contracts/helpers/sol/lib/AdditionalRecipientLib.sol
index 18161efd9..b86ac4230 100644
--- a/contracts/helpers/sol/lib/AdditionalRecipientLib.sol
+++ b/contracts/helpers/sol/lib/AdditionalRecipientLib.sol
@@ -2,16 +2,34 @@
pragma solidity ^0.8.17;
import { AdditionalRecipient } from "../../../lib/ConsiderationStructs.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title AdditionalRecipientLib
+ * @author James Wenzel (emo.eth)
+ * @notice AdditionalRecipientLib is a library for managing AdditionalRecipient
+ * structs and arrays. It allows chaining of functions to make
+ * struct creation more readable.
+ */
library AdditionalRecipientLib {
bytes32 private constant ADDITIONAL_RECIPIENT_MAP_POSITION =
keccak256("seaport.AdditionalRecipientDefaults");
bytes32 private constant ADDITIONAL_RECIPIENTS_MAP_POSITION =
keccak256("seaport.AdditionalRecipientsDefaults");
+ bytes32 private constant EMPTY_ADDITIONAL_RECIPIENT =
+ keccak256(
+ abi.encode(
+ AdditionalRecipient({
+ amount: 0,
+ recipient: payable(address(0))
+ })
+ )
+ );
/**
- * @notice clears a default AdditionalRecipient from storage
+ * @dev Clears a default AdditionalRecipient from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -21,22 +39,35 @@ library AdditionalRecipientLib {
clear(item);
}
+ /**
+ * @dev Clears all fields on an AdditionalRecipient.
+ *
+ * @param item the AdditionalRecipient to clear
+ */
function clear(AdditionalRecipient storage item) internal {
// clear all fields
item.amount = 0;
item.recipient = payable(address(0));
}
- function clear(AdditionalRecipient[] storage item) internal {
- while (item.length > 0) {
- clear(item[item.length - 1]);
- item.pop();
+ /**
+ * @dev Clears an array of AdditionalRecipients from storage.
+ *
+ * @param items the name of the default to clear
+ */
+ function clear(AdditionalRecipient[] storage items) internal {
+ while (items.length > 0) {
+ clear(items[items.length - 1]);
+ items.pop();
}
}
/**
- * @notice gets a default AdditionalRecipient from storage
+ * @dev Gets a default AdditionalRecipient from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the AdditionalRecipient retrieved from storage
*/
function fromDefault(
string memory defaultName
@@ -44,20 +75,38 @@ library AdditionalRecipientLib {
mapping(string => AdditionalRecipient)
storage additionalRecipientMap = _additionalRecipientMap();
item = additionalRecipientMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_ADDITIONAL_RECIPIENT) {
+ revert("Empty AdditionalRecipient selected.");
+ }
}
+ /**
+ * @dev Gets an array of default AdditionalRecipients from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the AdditionalRecipients retrieved from storage
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (AdditionalRecipient[] memory items) {
mapping(string => AdditionalRecipient[])
storage additionalRecipientsMap = _additionalRecipientsMap();
items = additionalRecipientsMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty AdditionalRecipient array selected.");
+ }
}
/**
- * @notice saves an AdditionalRecipient as a named default
+ * @dev Saves an AdditionalRecipient as a named default.
+ *
* @param additionalRecipient the AdditionalRecipient to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the new default
+ *
+ * @return _additionalRecipient the AdditionalRecipient saved as a default
*/
function saveDefault(
AdditionalRecipient memory additionalRecipient,
@@ -69,6 +118,14 @@ library AdditionalRecipientLib {
return additionalRecipient;
}
+ /**
+ * @dev Saves an array of AdditionalRecipients as a named default.
+ *
+ * @param additionalRecipients the AdditionalRecipients to save as a default
+ * @param defaultName the name of the new default
+ *
+ * @return _additionalRecipients the AdditionalRecipients saved as a default
+ */
function saveDefaultMany(
AdditionalRecipient[] memory additionalRecipients,
string memory defaultName
@@ -83,8 +140,11 @@ library AdditionalRecipientLib {
}
/**
- * @notice makes a copy of an AdditionalRecipient in-memory
+ * @dev Makes a copy of an AdditionalRecipient in-memory.
+ *
* @param item the AdditionalRecipient to make a copy of in-memory
+ *
+ * @custom:return additionalRecipient the copy of the AdditionalRecipient
*/
function copy(
AdditionalRecipient memory item
@@ -96,6 +156,13 @@ library AdditionalRecipientLib {
});
}
+ /**
+ * @dev Makes a copy of an array of AdditionalRecipients in-memory.
+ *
+ * @param items the AdditionalRecipients to make a copy of in-memory
+ *
+ * @custom:return additionalRecipients the copy of the AdditionalRecipients
+ */
function copy(
AdditionalRecipient[] memory items
) internal pure returns (AdditionalRecipient[] memory) {
@@ -108,13 +175,21 @@ library AdditionalRecipientLib {
return copiedItems;
}
+ /**
+ * @dev Returns an empty AdditionalRecipient.
+ *
+ * @custom:return item the empty AdditionalRecipient
+ */
function empty() internal pure returns (AdditionalRecipient memory) {
return
AdditionalRecipient({ amount: 0, recipient: payable(address(0)) });
}
/**
- * @notice gets the storage position of the default AdditionalRecipient map
+ * @dev Gets the storage position of the default AdditionalRecipient map.
+ *
+ * @custom:return additionalRecipientMap the storage position of the default
+ * AdditionalRecipient map
*/
function _additionalRecipientMap()
private
@@ -130,6 +205,14 @@ library AdditionalRecipientLib {
}
}
+ /**
+ * @dev Gets the storage position of the default AdditionalRecipients array
+ * map.
+ *
+ * @custom:return additionalRecipientsMap the storage position of the
+ * default AdditionalRecipient array
+ * map
+ */
function _additionalRecipientsMap()
private
pure
@@ -144,10 +227,17 @@ library AdditionalRecipientLib {
}
}
- // methods for configuring a single of each of an AdditionalRecipient's fields, which modifies the
- // AdditionalRecipient in-place and
- // returns it
+ // Methods for configuring a single of each of an AdditionalRecipient's
+ // fields, which modify the AdditionalRecipient in-place and return it.
+ /**
+ * @dev Sets the amount field of an AdditionalRecipient.
+ *
+ * @param item the AdditionalRecipient to modify
+ * @param amount the amount to set
+ *
+ * @custom:return _item the modified AdditionalRecipient
+ */
function withAmount(
AdditionalRecipient memory item,
uint256 amount
@@ -156,6 +246,14 @@ library AdditionalRecipientLib {
return item;
}
+ /**
+ * @dev Sets the recipient field of an AdditionalRecipient.
+ *
+ * @param item the AdditionalRecipient to modify
+ * @param recipient the recipient to set
+ *
+ * @custom:return _item the modified AdditionalRecipient
+ */
function withRecipient(
AdditionalRecipient memory item,
address recipient
diff --git a/contracts/helpers/sol/lib/AdvancedOrderLib.sol b/contracts/helpers/sol/lib/AdvancedOrderLib.sol
index ee820c1e2..68abf444e 100644
--- a/contracts/helpers/sol/lib/AdvancedOrderLib.sol
+++ b/contracts/helpers/sol/lib/AdvancedOrderLib.sol
@@ -2,23 +2,80 @@
pragma solidity ^0.8.17;
import {
+ AdditionalRecipient,
AdvancedOrder,
+ BasicOrderParameters,
+ ConsiderationItem,
+ CriteriaResolver,
+ OfferItem,
Order,
- OrderParameters
+ OrderComponents,
+ OrderParameters,
+ OrderType,
+ ReceivedItem,
+ SpentItem
} from "../../../lib/ConsiderationStructs.sol";
+
+import { BasicOrderType, ItemType } from "../../../lib/ConsiderationEnums.sol";
+
+import { UnavailableReason } from "../SpaceEnums.sol";
+
import { OrderParametersLib } from "./OrderParametersLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+import { SeaportInterface } from "../SeaportInterface.sol";
+
+import { OrderDetails } from "../fulfillments/lib/Structs.sol";
+
+struct ContractNonceDetails {
+ bool set;
+ address offerer;
+ uint256 currentNonce;
+}
+
+/**
+ * @title AdvancedOrderLib
+ * @author James Wenzel (emo.eth)
+ * @notice AdditionalRecipientLib is a library for managing AdvancedOrder
+ * structs and arrays. It allows chaining of functions to make struct
+ * creation more readable.
+ */
library AdvancedOrderLib {
bytes32 private constant ADVANCED_ORDER_MAP_POSITION =
keccak256("seaport.AdvancedOrderDefaults");
bytes32 private constant ADVANCED_ORDERS_MAP_POSITION =
keccak256("seaport.AdvancedOrdersDefaults");
+ bytes32 private constant EMPTY_ADVANCED_ORDER =
+ keccak256(
+ abi.encode(
+ AdvancedOrder({
+ parameters: OrderParameters({
+ offerer: address(0),
+ zone: address(0),
+ offer: new OfferItem[](0),
+ consideration: new ConsiderationItem[](0),
+ orderType: OrderType(0),
+ startTime: 0,
+ endTime: 0,
+ zoneHash: bytes32(0),
+ salt: 0,
+ conduitKey: bytes32(0),
+ totalOriginalConsiderationItems: 0
+ }),
+ numerator: 0,
+ denominator: 0,
+ signature: new bytes(0),
+ extraData: new bytes(0)
+ })
+ )
+ );
using OrderParametersLib for OrderParameters;
/**
- * @notice clears a default AdvancedOrder from storage
+ * @dev Clears a default AdvancedOrder from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -28,6 +85,11 @@ library AdvancedOrderLib {
clear(item);
}
+ /**
+ * @dev Clears all fields on an AdvancedOrder.
+ *
+ * @param item the AdvancedOrder to clear
+ */
function clear(AdvancedOrder storage item) internal {
// clear all fields
item.parameters.clear();
@@ -37,6 +99,11 @@ library AdvancedOrderLib {
item.extraData = "";
}
+ /**
+ * @dev Clears an array of AdvancedOrders from storage.
+ *
+ * @param items the AdvancedOrders to clear
+ */
function clear(AdvancedOrder[] storage items) internal {
while (items.length > 0) {
clear(items[items.length - 1]);
@@ -45,8 +112,11 @@ library AdvancedOrderLib {
}
/**
- * @notice gets a default AdvancedOrder from storage
+ * @dev Gets a default AdvancedOrder from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the AdvancedOrder retrieved from storage
*/
function fromDefault(
string memory defaultName
@@ -54,24 +124,47 @@ library AdvancedOrderLib {
mapping(string => AdvancedOrder)
storage advancedOrderMap = _advancedOrderMap();
item = advancedOrderMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_ADVANCED_ORDER) {
+ revert("Empty AdvancedOrder selected.");
+ }
}
+ /**
+ * @dev Gets an array of default AdvancedOrders from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the AdvancedOrders retrieved from storage
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (AdvancedOrder[] memory items) {
mapping(string => AdvancedOrder[])
storage advancedOrdersMap = _advancedOrdersMap();
items = advancedOrdersMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty AdvancedOrder array selected.");
+ }
}
+ /**
+ * @dev Returns an empty AdvancedOrder.
+ *
+ * @custom:return item the empty AdvancedOrder
+ */
function empty() internal pure returns (AdvancedOrder memory) {
return AdvancedOrder(OrderParametersLib.empty(), 0, 0, "", "");
}
/**
- * @notice saves an AdvancedOrder as a named default
+ * @dev Saves an AdvancedOrder as a named default.
+ *
* @param advancedOrder the AdvancedOrder to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the new default
+ *
+ * @return _advancedOrder the AdvancedOrder saved as a default
*/
function saveDefault(
AdvancedOrder memory advancedOrder,
@@ -86,6 +179,14 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Saves an array of AdvancedOrders as a named default.
+ *
+ * @param advancedOrders the AdvancedOrders to save as a default
+ * @param defaultName the name of the new default
+ *
+ * @return _advancedOrders the AdvancedOrders saved as a default
+ */
function saveDefaultMany(
AdvancedOrder[] memory advancedOrders,
string memory defaultName
@@ -100,8 +201,11 @@ library AdvancedOrderLib {
}
/**
- * @notice makes a copy of an AdvancedOrder in-memory
+ * @dev Makes a copy of an AdvancedOrder in-memory.
+ *
* @param item the AdvancedOrder to make a copy of in-memory
+ *
+ * @custom:return item the copied AdvancedOrder
*/
function copy(
AdvancedOrder memory item
@@ -116,6 +220,13 @@ library AdvancedOrderLib {
});
}
+ /**
+ * @dev Makes a copy of an array of AdvancedOrders in-memory.
+ *
+ * @param items the AdvancedOrders to make a copy of in-memory
+ *
+ * @custom:return items the copied AdvancedOrders
+ */
function copy(
AdvancedOrder[] memory items
) internal pure returns (AdvancedOrder[] memory) {
@@ -127,7 +238,10 @@ library AdvancedOrderLib {
}
/**
- * @notice gets the storage position of the default AdvancedOrder map
+ * @dev Gets the storage position of the default AdvancedOrder map.
+ *
+ * @return advancedOrderMap the storage position of the default
+ * AdvancedOrder map
*/
function _advancedOrderMap()
private
@@ -140,6 +254,12 @@ library AdvancedOrderLib {
}
}
+ /**
+ * @dev Gets the storage position of the default AdvancedOrder array map.
+ *
+ * @return advancedOrdersMap the storage position of the default
+ * AdvancedOrder array map
+ */
function _advancedOrdersMap()
private
pure
@@ -151,10 +271,17 @@ library AdvancedOrderLib {
}
}
- // methods for configuring a single of each of an AdvancedOrder's fields, which modifies the AdvancedOrder in-place
- // and
- // returns it
+ // Methods for configuring a single of each of an AdvancedOrder's fields,
+ // which modify the AdvancedOrder in-place and return it.
+ /**
+ * @dev Configures an AdvancedOrder's parameters.
+ *
+ * @param advancedOrder the AdvancedOrder to configure
+ * @param parameters the parameters to set
+ *
+ * @custom:return _advancedOrder the configured AdvancedOrder
+ */
function withParameters(
AdvancedOrder memory advancedOrder,
OrderParameters memory parameters
@@ -163,6 +290,14 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Configures an AdvancedOrder's numerator.
+ *
+ * @param advancedOrder the AdvancedOrder to configure
+ * @param numerator the numerator to set
+ *
+ * @custom:return _advancedOrder the configured AdvancedOrder
+ */
function withNumerator(
AdvancedOrder memory advancedOrder,
uint120 numerator
@@ -171,6 +306,14 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Configures an AdvancedOrder's denominator.
+ *
+ * @param advancedOrder the AdvancedOrder to configure
+ * @param denominator the denominator to set
+ *
+ * @custom:return _advancedOrder the configured AdvancedOrder
+ */
function withDenominator(
AdvancedOrder memory advancedOrder,
uint120 denominator
@@ -179,6 +322,14 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Configures an AdvancedOrder's signature.
+ *
+ * @param advancedOrder the AdvancedOrder to configure
+ * @param signature the signature to set
+ *
+ * @custom:return _advancedOrder the configured AdvancedOrder
+ */
function withSignature(
AdvancedOrder memory advancedOrder,
bytes memory signature
@@ -187,6 +338,14 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Configures an AdvancedOrder's extra data.
+ *
+ * @param advancedOrder the AdvancedOrder to configure
+ * @param extraData the extra data to set
+ *
+ * @custom:return _advancedOrder the configured AdvancedOrder
+ */
function withExtraData(
AdvancedOrder memory advancedOrder,
bytes memory extraData
@@ -195,10 +354,440 @@ library AdvancedOrderLib {
return advancedOrder;
}
+ /**
+ * @dev Converts an AdvancedOrder to an Order.
+ *
+ * @param advancedOrder the AdvancedOrder to convert
+ *
+ * @return order the converted Order
+ */
function toOrder(
AdvancedOrder memory advancedOrder
) internal pure returns (Order memory order) {
order.parameters = advancedOrder.parameters.copy();
order.signature = advancedOrder.signature;
}
+
+ /**
+ * @dev Converts an AdvancedOrder[] to an Order[].
+ *
+ * @param advancedOrders the AdvancedOrder[] to convert
+ *
+ * @return the converted Order[]
+ */
+ function toOrders(
+ AdvancedOrder[] memory advancedOrders
+ ) internal pure returns (Order[] memory) {
+ Order[] memory orders = new Order[](advancedOrders.length);
+
+ for (uint256 i; i < advancedOrders.length; ++i) {
+ orders[i] = toOrder(advancedOrders[i]);
+ }
+ return orders;
+ }
+
+ /**
+ * @dev Converts an AdvancedOrder to a BasicOrderParameters.
+ *
+ * @param advancedOrder the AdvancedOrder to convert
+ * @param basicOrderType the BasicOrderType to convert to
+ *
+ * @return basicOrderParameters the BasicOrderParameters
+ */
+ function toBasicOrderParameters(
+ AdvancedOrder memory advancedOrder,
+ BasicOrderType basicOrderType
+ ) internal pure returns (BasicOrderParameters memory basicOrderParameters) {
+ basicOrderParameters.considerationToken = advancedOrder
+ .parameters
+ .consideration[0]
+ .token;
+ basicOrderParameters.considerationIdentifier = advancedOrder
+ .parameters
+ .consideration[0]
+ .identifierOrCriteria;
+ basicOrderParameters.considerationAmount = advancedOrder
+ .parameters
+ .consideration[0]
+ .endAmount;
+ basicOrderParameters.offerer = payable(
+ advancedOrder.parameters.offerer
+ );
+ basicOrderParameters.zone = advancedOrder.parameters.zone;
+ basicOrderParameters.offerToken = advancedOrder
+ .parameters
+ .offer[0]
+ .token;
+ basicOrderParameters.offerIdentifier = advancedOrder
+ .parameters
+ .offer[0]
+ .identifierOrCriteria;
+ basicOrderParameters.offerAmount = advancedOrder
+ .parameters
+ .offer[0]
+ .endAmount;
+ basicOrderParameters.basicOrderType = basicOrderType;
+ basicOrderParameters.startTime = advancedOrder.parameters.startTime;
+ basicOrderParameters.endTime = advancedOrder.parameters.endTime;
+ basicOrderParameters.zoneHash = advancedOrder.parameters.zoneHash;
+ basicOrderParameters.salt = advancedOrder.parameters.salt;
+ basicOrderParameters.offererConduitKey = advancedOrder
+ .parameters
+ .conduitKey;
+ basicOrderParameters.fulfillerConduitKey = advancedOrder
+ .parameters
+ .conduitKey;
+ basicOrderParameters.totalOriginalAdditionalRecipients =
+ advancedOrder.parameters.totalOriginalConsiderationItems -
+ 1;
+
+ AdditionalRecipient[]
+ memory additionalRecipients = new AdditionalRecipient[](
+ advancedOrder.parameters.consideration.length - 1
+ );
+ for (
+ uint256 i = 1;
+ i < advancedOrder.parameters.consideration.length;
+ i++
+ ) {
+ additionalRecipients[i - 1] = AdditionalRecipient({
+ recipient: advancedOrder.parameters.consideration[i].recipient,
+ amount: advancedOrder.parameters.consideration[i].startAmount
+ });
+ }
+
+ basicOrderParameters.additionalRecipients = additionalRecipients;
+ basicOrderParameters.signature = advancedOrder.signature;
+
+ return basicOrderParameters;
+ }
+
+ function withCoercedAmountsForPartialFulfillment(
+ AdvancedOrder memory order
+ ) internal pure returns (AdvancedOrder memory) {
+ OrderParameters memory orderParams = order.parameters;
+ for (uint256 i = 0; i < orderParams.offer.length; ++i) {
+ uint256 newStartAmount;
+ uint256 newEndAmount;
+ OfferItem memory item = orderParams.offer[i];
+
+ if (
+ item.itemType == ItemType.ERC721 ||
+ item.itemType == ItemType.ERC721_WITH_CRITERIA
+ ) {
+ uint256 amount = uint256(order.denominator / order.numerator);
+ newStartAmount = amount;
+ newEndAmount = amount;
+ } else {
+ (
+ newStartAmount,
+ newEndAmount
+ ) = deriveFractionCompatibleAmounts(
+ item.startAmount,
+ item.endAmount,
+ orderParams.startTime,
+ orderParams.endTime,
+ order.numerator,
+ order.denominator
+ );
+ }
+
+ order.parameters.offer[i].startAmount = newStartAmount;
+ order.parameters.offer[i].endAmount = newEndAmount;
+ }
+
+ // Adjust consideration item amounts based on the fraction
+ for (uint256 i = 0; i < orderParams.consideration.length; ++i) {
+ uint256 newStartAmount;
+ uint256 newEndAmount;
+ ConsiderationItem memory item = orderParams.consideration[i];
+
+ if (
+ item.itemType == ItemType.ERC721 ||
+ item.itemType == ItemType.ERC721_WITH_CRITERIA
+ ) {
+ uint256 amount = uint256(order.denominator / order.numerator);
+ newStartAmount = amount;
+ newEndAmount = amount;
+ } else {
+ (
+ newStartAmount,
+ newEndAmount
+ ) = deriveFractionCompatibleAmounts(
+ item.startAmount,
+ item.endAmount,
+ orderParams.startTime,
+ orderParams.endTime,
+ order.numerator,
+ order.denominator
+ );
+ }
+
+ order.parameters.consideration[i].startAmount = newStartAmount;
+ order.parameters.consideration[i].endAmount = newEndAmount;
+ }
+
+ return order;
+ }
+
+ function deriveFractionCompatibleAmounts(
+ uint256 originalStartAmount,
+ uint256 originalEndAmount,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) internal pure returns (uint256 newStartAmount, uint256 newEndAmount) {
+ if (
+ startTime >= endTime ||
+ numerator > denominator ||
+ numerator == 0 ||
+ denominator == 0 ||
+ (originalStartAmount == 0 && originalEndAmount == 0)
+ ) {
+ revert(
+ "AdvancedOrderLib: bad inputs to deriveFractionCompatibleAmounts"
+ );
+ }
+
+ bool ensureNotHuge = originalStartAmount != originalEndAmount;
+
+ newStartAmount = minimalChange(
+ originalStartAmount,
+ numerator,
+ denominator,
+ ensureNotHuge
+ );
+
+ newEndAmount = minimalChange(
+ originalEndAmount,
+ numerator,
+ denominator,
+ ensureNotHuge
+ );
+
+ if (newStartAmount == 0 && newEndAmount == 0) {
+ revert("AdvancedOrderLib: derived amount will always be zero");
+ }
+ }
+
+ // Function to find the minimal change in the value so that it results in a
+ // new value with no remainder when the numerator and the denominator are
+ // applied.
+ function minimalChange(
+ uint256 value,
+ uint256 numerator,
+ uint256 denominator,
+ bool ensureNotHuge
+ ) public pure returns (uint256 newValue) {
+ require(denominator != 0, "AdvancedOrderLib: no denominator supplied.");
+
+ if (ensureNotHuge) {
+ value %= type(uint208).max;
+ }
+
+ uint256 remainder = (value * numerator) % denominator;
+
+ uint256 diffToNextMultiple = denominator - remainder;
+ uint256 diffToPrevMultiple = remainder;
+
+ newValue = 0;
+ if (diffToNextMultiple > diffToPrevMultiple) {
+ newValue = value - (diffToPrevMultiple / numerator);
+ }
+
+ if (newValue == 0) {
+ newValue = value + (diffToNextMultiple / numerator);
+ }
+
+ if ((newValue * numerator) % denominator != 0) {
+ revert("AdvancedOrderLib: minimal change failed");
+ }
+ }
+
+ /**
+ * @dev Get the orderHashes of an array of orders.
+ */
+ function getOrderHashes(
+ AdvancedOrder[] memory orders,
+ address seaport
+ ) internal view returns (bytes32[] memory) {
+ SeaportInterface seaportInterface = SeaportInterface(seaport);
+
+ bytes32[] memory orderHashes = new bytes32[](orders.length);
+
+ // Array of (contract offerer, currentNonce)
+ ContractNonceDetails[] memory detailsArray = new ContractNonceDetails[](
+ orders.length
+ );
+
+ for (uint256 i = 0; i < orders.length; ++i) {
+ OrderParameters memory order = orders[i].parameters;
+ bytes32 orderHash;
+ if (
+ order.orderType == OrderType.CONTRACT &&
+ _hasValidTime(order.startTime, order.endTime)
+ ) {
+ bool noneYetLocated = false;
+ uint256 j = 0;
+ uint256 currentNonce;
+ for (; j < detailsArray.length; ++j) {
+ ContractNonceDetails memory details = detailsArray[j];
+ if (!details.set) {
+ noneYetLocated = true;
+ break;
+ } else if (details.offerer == order.offerer) {
+ currentNonce = ++(details.currentNonce);
+ break;
+ }
+ }
+
+ if (noneYetLocated) {
+ currentNonce = seaportInterface.getContractOffererNonce(
+ order.offerer
+ );
+
+ detailsArray[j] = ContractNonceDetails({
+ set: true,
+ offerer: order.offerer,
+ currentNonce: currentNonce
+ });
+ }
+
+ uint256 shiftedOfferer = uint256(uint160(order.offerer)) << 96;
+
+ orderHash = bytes32(shiftedOfferer ^ currentNonce);
+ } else {
+ orderHash = getTipNeutralizedOrderHash(
+ orders[i],
+ seaportInterface
+ );
+ }
+
+ orderHashes[i] = orderHash;
+ }
+
+ return orderHashes;
+ }
+
+ function _hasValidTime(
+ uint256 startTime,
+ uint256 endTime
+ ) internal view returns (bool) {
+ return block.timestamp >= startTime && block.timestamp < endTime;
+ }
+
+ /**
+ * @dev Get the orderHash for an AdvancedOrders and return the orderHash.
+ * This function can be treated as a wrapper around Seaport's
+ * getOrderHash function. It is used to get the orderHash of an
+ * AdvancedOrder that has a tip added onto it. Calling it on an
+ * AdvancedOrder that does not have a tip will return the same
+ * orderHash as calling Seaport's getOrderHash function directly.
+ * Seaport handles tips gracefully inside of the top level fulfill and
+ * match functions, but since we're adding tips early in the fuzz test
+ * lifecycle, it's necessary to flip them back and forth when we need
+ * to pass order components into getOrderHash. Note: they're two
+ * different orders, so e.g. cancelling or validating order with a tip
+ * on it is not the same as cancelling the order without a tip on it.
+ */
+ function getTipNeutralizedOrderHash(
+ AdvancedOrder memory order,
+ SeaportInterface seaport
+ ) internal view returns (bytes32 orderHash) {
+ // Get the counter of the order offerer.
+ uint256 counter = seaport.getCounter(order.parameters.offerer);
+
+ return getTipNeutralizedOrderHash(order, seaport, counter);
+ }
+
+ function getTipNeutralizedOrderHash(
+ AdvancedOrder memory order,
+ SeaportInterface seaport,
+ uint256 counter
+ ) internal view returns (bytes32 orderHash) {
+ // Get the OrderComponents from the OrderParameters.
+ OrderComponents memory components = (
+ order.parameters.toOrderComponents(counter)
+ );
+
+ // Get the length of the consideration array (which might have
+ // additional consideration items set as tips).
+ uint256 lengthWithTips = components.consideration.length;
+
+ // Get the length of the consideration array without tips, which is
+ // stored in the totalOriginalConsiderationItems field.
+ uint256 lengthSansTips = (
+ order.parameters.totalOriginalConsiderationItems
+ );
+
+ // Get a reference to the consideration array.
+ ConsiderationItem[] memory considerationSansTips = (
+ components.consideration
+ );
+
+ // Set proper length of the considerationSansTips array.
+ assembly {
+ mstore(considerationSansTips, lengthSansTips)
+ }
+
+ // Get the orderHash using the tweaked OrderComponents.
+ orderHash = seaport.getOrderHash(components);
+
+ // Restore the length of the considerationSansTips array.
+ assembly {
+ mstore(considerationSansTips, lengthWithTips)
+ }
+ }
+
+ function getOrderDetails(
+ AdvancedOrder[] memory advancedOrders,
+ CriteriaResolver[] memory criteriaResolvers,
+ bytes32[] memory orderHashes,
+ UnavailableReason[] memory unavailableReasons
+ ) internal view returns (OrderDetails[] memory) {
+ OrderDetails[] memory orderDetails = new OrderDetails[](
+ advancedOrders.length
+ );
+
+ for (uint256 i = 0; i < advancedOrders.length; i++) {
+ orderDetails[i] = toOrderDetails(
+ advancedOrders[i],
+ i,
+ criteriaResolvers,
+ orderHashes[i],
+ unavailableReasons[i]
+ );
+ }
+
+ return orderDetails;
+ }
+
+ function toOrderDetails(
+ AdvancedOrder memory order,
+ uint256 orderIndex,
+ CriteriaResolver[] memory resolvers,
+ bytes32 orderHash,
+ UnavailableReason unavailableReason
+ ) internal view returns (OrderDetails memory) {
+ (SpentItem[] memory offer, ReceivedItem[] memory consideration) = order
+ .parameters
+ .getSpentAndReceivedItems(
+ order.numerator,
+ order.denominator,
+ orderIndex,
+ resolvers
+ );
+
+ return
+ OrderDetails({
+ offerer: order.parameters.offerer,
+ conduitKey: order.parameters.conduitKey,
+ offer: offer,
+ consideration: consideration,
+ isContract: order.parameters.orderType == OrderType.CONTRACT,
+ orderHash: orderHash,
+ unavailableReason: unavailableReason
+ });
+ }
}
diff --git a/contracts/helpers/sol/lib/ArrayLib.sol b/contracts/helpers/sol/lib/ArrayLib.sol
index 8c8c25abd..8c74c1fa8 100644
--- a/contracts/helpers/sol/lib/ArrayLib.sol
+++ b/contracts/helpers/sol/lib/ArrayLib.sol
@@ -1,7 +1,18 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
+/**
+ * @title ArrayLib
+ * @author James Wenzel (emo.eth)
+ * @notice ArrayLib is a library for managing arrays.
+ */
library ArrayLib {
+ /**
+ * @dev Sets the values of an array.
+ *
+ * @param array the array to set
+ * @param values the values to set
+ */
function setBytes32s(
bytes32[] storage array,
bytes32[] memory values
@@ -14,6 +25,13 @@ library ArrayLib {
}
}
+ /**
+ * @dev Makes a copy of an array.
+ *
+ * @param array the array to copy
+ *
+ * @custom:return copiedArray the copied array
+ */
function copy(
bytes32[] memory array
) internal pure returns (bytes32[] memory) {
diff --git a/contracts/helpers/sol/lib/BasicOrderParametersLib.sol b/contracts/helpers/sol/lib/BasicOrderParametersLib.sol
index fb8deb965..4436a3a13 100644
--- a/contracts/helpers/sol/lib/BasicOrderParametersLib.sol
+++ b/contracts/helpers/sol/lib/BasicOrderParametersLib.sol
@@ -2,22 +2,24 @@
pragma solidity ^0.8.17;
import {
+ AdditionalRecipient,
BasicOrderParameters,
- OrderComponents,
- OrderParameters,
- ConsiderationItem,
- OrderParameters,
- OfferItem,
- AdditionalRecipient
+ OrderParameters
} from "../../../lib/ConsiderationStructs.sol";
-import {
- OrderType,
- ItemType,
- BasicOrderType
-} from "../../../lib/ConsiderationEnums.sol";
+
+import { BasicOrderType } from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+
import { AdditionalRecipientLib } from "./AdditionalRecipientLib.sol";
+/**
+ * @title BasicOrderParametersLib
+ * @author James Wenzel (emo.eth)
+ * @notice BasicOrderParametersLib is a library for managing
+ * BasicOrderParameters structs and arrays. It allows chaining of
+ * functions to make struct creation more readable.
+ */
library BasicOrderParametersLib {
using BasicOrderParametersLib for BasicOrderParameters;
using AdditionalRecipientLib for AdditionalRecipient[];
@@ -26,7 +28,37 @@ library BasicOrderParametersLib {
keccak256("seaport.BasicOrderParametersDefaults");
bytes32 private constant BASIC_ORDER_PARAMETERS_ARRAY_MAP_POSITION =
keccak256("seaport.BasicOrderParametersArrayDefaults");
+ bytes32 private constant EMPTY_BASIC_ORDER_PARAMETERS =
+ keccak256(
+ abi.encode(
+ BasicOrderParameters({
+ considerationToken: address(0),
+ considerationIdentifier: 0,
+ considerationAmount: 0,
+ offerer: payable(address(0)),
+ zone: address(0),
+ offerToken: address(0),
+ offerIdentifier: 0,
+ offerAmount: 0,
+ basicOrderType: BasicOrderType(0),
+ startTime: 0,
+ endTime: 0,
+ zoneHash: bytes32(0),
+ salt: 0,
+ offererConduitKey: bytes32(0),
+ fulfillerConduitKey: bytes32(0),
+ totalOriginalAdditionalRecipients: 0,
+ additionalRecipients: new AdditionalRecipient[](0),
+ signature: ""
+ })
+ )
+ );
+ /**
+ * @dev Clears a default BasicOrderParameters from storage.
+ *
+ * @param basicParameters the BasicOrderParameters to clear
+ */
function clear(BasicOrderParameters storage basicParameters) internal {
// uninitialized pointers take up no new memory (versus one word for initializing length-0)
AdditionalRecipient[] memory additionalRecipients;
@@ -54,6 +86,11 @@ library BasicOrderParametersLib {
basicParameters.signature = new bytes(0);
}
+ /**
+ * @dev Clears an array of BasicOrderParameters from storage.
+ *
+ * @param basicParametersArray the name of the default to clear
+ */
function clear(
BasicOrderParameters[] storage basicParametersArray
) internal {
@@ -64,18 +101,24 @@ library BasicOrderParametersLib {
}
/**
- * @notice clears a default BasicOrderParameters from storage
+ * @dev Clears a default BasicOrderParameters from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
mapping(string => BasicOrderParameters)
- storage orderComponentsMap = _orderComponentsMap();
- BasicOrderParameters storage basicParameters = orderComponentsMap[
+ storage orderParametersMap = _orderParametersMap();
+ BasicOrderParameters storage basicParameters = orderParametersMap[
defaultName
];
basicParameters.clear();
}
+ /**
+ * @dev Creates an empty BasicOrderParameters.
+ *
+ * @return item the default BasicOrderParameters
+ */
function empty() internal pure returns (BasicOrderParameters memory item) {
AdditionalRecipient[] memory additionalRecipients;
item = BasicOrderParameters({
@@ -101,59 +144,91 @@ library BasicOrderParametersLib {
}
/**
- * @notice gets a default BasicOrderParameters from storage
+ * @dev Gets a default BasicOrderParameters from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the selected default BasicOrderParameters
*/
function fromDefault(
string memory defaultName
) internal view returns (BasicOrderParameters memory item) {
mapping(string => BasicOrderParameters)
- storage orderComponentsMap = _orderComponentsMap();
- item = orderComponentsMap[defaultName];
+ storage orderParametersMap = _orderParametersMap();
+ item = orderParametersMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_BASIC_ORDER_PARAMETERS) {
+ revert("Empty BasicOrderParameters selected.");
+ }
}
+ /**
+ * @dev Gets a default BasicOrderParameters array from storage.
+ *
+ * @param defaultName the name of the default array for retrieval
+ *
+ * @return items the selected default BasicOrderParameters array
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (BasicOrderParameters[] memory items) {
mapping(string => BasicOrderParameters[])
- storage orderComponentsArrayMap = _orderComponentsArrayMap();
- items = orderComponentsArrayMap[defaultName];
+ storage orderParametersArrayMap = _orderParametersArrayMap();
+ items = orderParametersArrayMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty BasicOrderParameters array selected.");
+ }
}
/**
- * @notice saves an BasicOrderParameters as a named default
- * @param orderComponents the BasicOrderParameters to save as a default
- * @param defaultName the name of the default for retrieval
+ * @dev Saves a BasicOrderParameters as a named default.
+ *
+ * @param orderParameters the BasicOrderParameters to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orderParameters the saved BasicOrderParameters
*/
function saveDefault(
- BasicOrderParameters memory orderComponents,
+ BasicOrderParameters memory orderParameters,
string memory defaultName
- ) internal returns (BasicOrderParameters memory _orderComponents) {
+ ) internal returns (BasicOrderParameters memory _orderParameters) {
mapping(string => BasicOrderParameters)
- storage orderComponentsMap = _orderComponentsMap();
- BasicOrderParameters storage destination = orderComponentsMap[
+ storage orderParametersMap = _orderParametersMap();
+ BasicOrderParameters storage destination = orderParametersMap[
defaultName
];
- StructCopier.setBasicOrderParameters(destination, orderComponents);
- return orderComponents;
+ StructCopier.setBasicOrderParameters(destination, orderParameters);
+ return orderParameters;
}
+ /**
+ * @dev Saves an BasicOrderParameters array as a named default.
+ *
+ * @param orderParameters the BasicOrderParameters array to save as a default
+ * @param defaultName the name of the default array for retrieval
+ *
+ * @return _orderParameters the saved BasicOrderParameters array
+ */
function saveDefaultMany(
- BasicOrderParameters[] memory orderComponents,
+ BasicOrderParameters[] memory orderParameters,
string memory defaultName
- ) internal returns (BasicOrderParameters[] memory _orderComponents) {
+ ) internal returns (BasicOrderParameters[] memory _orderParameters) {
mapping(string => BasicOrderParameters[])
- storage orderComponentsArrayMap = _orderComponentsArrayMap();
- BasicOrderParameters[] storage destination = orderComponentsArrayMap[
+ storage orderParametersArrayMap = _orderParametersArrayMap();
+ BasicOrderParameters[] storage destination = orderParametersArrayMap[
defaultName
];
- StructCopier.setBasicOrderParameters(destination, orderComponents);
- return orderComponents;
+ StructCopier.setBasicOrderParameters(destination, orderParameters);
+ return orderParameters;
}
/**
- * @notice makes a copy of an BasicOrderParameters in-memory
+ * @dev Makes a copy of an BasicOrderParameters in-memory.
+ *
* @param item the BasicOrderParameters to make a copy of in-memory
+ *
+ * @return copy the copied BasicOrderParameters
*/
function copy(
BasicOrderParameters memory item
@@ -183,38 +258,60 @@ library BasicOrderParametersLib {
}
/**
- * @notice gets the storage position of the default BasicOrderParameters map
+ * @dev Gets the storage position of the default BasicOrderParameters map.
+ *
+ * @return orderParametersMap the storage position of the default
+ * BasicOrderParameters map
*/
- function _orderComponentsMap()
+ function _orderParametersMap()
private
pure
returns (
- mapping(string => BasicOrderParameters) storage orderComponentsMap
+ mapping(string => BasicOrderParameters) storage orderParametersMap
)
{
bytes32 position = BASIC_ORDER_PARAMETERS_MAP_POSITION;
assembly {
- orderComponentsMap.slot := position
+ orderParametersMap.slot := position
}
}
- function _orderComponentsArrayMap()
+ /**
+ * @dev Gets the storage position of the default BasicOrderParameters array
+ * map.
+ *
+ * @return orderParametersArrayMap the storage position of the default
+ * BasicOrderParameters array map
+ */
+ function _orderParametersArrayMap()
private
pure
returns (
mapping(string => BasicOrderParameters[])
- storage orderComponentsArrayMap
+ storage orderParametersArrayMap
)
{
bytes32 position = BASIC_ORDER_PARAMETERS_ARRAY_MAP_POSITION;
assembly {
- orderComponentsArrayMap.slot := position
+ orderParametersArrayMap.slot := position
}
}
- // methods for configuring a single of each of an in-memory BasicOrderParameters's fields, which modifies the
- // BasicOrderParameters in-memory and returns it
+ // Methods for configuring a single of each of an in-memory
+ // BasicOrderParameters's fields, which modify the BasicOrderParameters
+ // struct in-memory and return it.
+ /**
+ * @dev Sets the considerationToken field of a BasicOrderParameters
+ * in-memory.
+ *
+ * @param item the BasicOrderParameters to set the considerationToken field
+ * of in-memory.
+ * @param value the value to set the considerationToken field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withConsiderationToken(
BasicOrderParameters memory item,
address value
@@ -223,6 +320,17 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the considerationIdentifier field of a BasicOrderParameters
+ * in-memory.
+ *
+ * @param item the BasicOrderParameters to set the considerationIdentifier
+ * field of in-memory.
+ * @param value the value to set the considerationIdentifier field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withConsiderationIdentifier(
BasicOrderParameters memory item,
uint256 value
@@ -231,6 +339,17 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the considerationAmount field of a BasicOrderParameters
+ * in-memory.
+ *
+ * @param item the BasicOrderParameters to set the considerationAmount field
+ * of in-memory.
+ * @param value the value to set the considerationAmount field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withConsiderationAmount(
BasicOrderParameters memory item,
uint256 value
@@ -239,6 +358,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the offerer field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the offerer field of
+ * in-memory.
+ * @param value the value to set the offerer field of the BasicOrderParameters
+ * to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withOfferer(
BasicOrderParameters memory item,
address value
@@ -247,6 +376,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the zone field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the zone field of
+ * in-memory.
+ * @param value the value to set the zone field of the BasicOrderParameters
+ * to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withZone(
BasicOrderParameters memory item,
address value
@@ -255,6 +394,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the offerToken field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the offerToken field of
+ * in-memory.
+ * @param value the value to set the offerToken field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withOfferToken(
BasicOrderParameters memory item,
address value
@@ -263,6 +412,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the offerIdentifier field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the offerIdentifier field of
+ * in-memory.
+ * @param value the value to set the offerIdentifier field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withOfferIdentifier(
BasicOrderParameters memory item,
uint256 value
@@ -271,6 +430,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the offerAmount field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the offerAmount field of
+ * in-memory.
+ * @param value the value to set the offerAmount field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withOfferAmount(
BasicOrderParameters memory item,
uint256 value
@@ -279,6 +448,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the basicOrderType field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the basicOrderType field of
+ * in-memory.
+ * @param value the value to set the basicOrderType field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withBasicOrderType(
BasicOrderParameters memory item,
BasicOrderType value
@@ -287,6 +466,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the startTime field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the startTime field of
+ * in-memory.
+ * @param value the value to set the startTime field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withStartTime(
BasicOrderParameters memory item,
uint256 value
@@ -295,6 +484,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the endTime field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the endTime field of
+ * in-memory.
+ * @param value the value to set the endTime field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withEndTime(
BasicOrderParameters memory item,
uint256 value
@@ -303,6 +502,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the zoneHash field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the zoneHash field of
+ * in-memory.
+ * @param value the value to set the zoneHash field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withZoneHash(
BasicOrderParameters memory item,
bytes32 value
@@ -311,6 +520,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the salt field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the salt field of
+ * in-memory.
+ * @param value the value to set the salt field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withSalt(
BasicOrderParameters memory item,
uint256 value
@@ -319,6 +538,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the offererConduitKey field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the offererConduitKey field of
+ * in-memory.
+ * @param value the value to set the offererConduitKey field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withOffererConduitKey(
BasicOrderParameters memory item,
bytes32 value
@@ -327,6 +556,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the fulfillerConduitKey field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the fulfillerConduitKey field of
+ * in-memory.
+ * @param value the value to set the fulfillerConduitKey field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withFulfillerConduitKey(
BasicOrderParameters memory item,
bytes32 value
@@ -335,6 +574,17 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the totalOriginalAdditionalRecipients field of a
+ * BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the
+ * totalOriginalAdditionalRecipients field of in-memory.
+ * @param value the value to set the totalOriginalAdditionalRecipients field
+ * of the BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withTotalOriginalAdditionalRecipients(
BasicOrderParameters memory item,
uint256 value
@@ -343,6 +593,17 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the additionalRecipients field of a BasicOrderParameters
+ * in-memory.
+ *
+ * @param item the BasicOrderParameters to set the additionalRecipients
+ * field of in-memory.
+ * @param value the value to set the additionalRecipients field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withAdditionalRecipients(
BasicOrderParameters memory item,
AdditionalRecipient[] memory value
@@ -351,6 +612,16 @@ library BasicOrderParametersLib {
return item;
}
+ /**
+ * @dev Sets the signature field of a BasicOrderParameters in-memory.
+ *
+ * @param item the BasicOrderParameters to set the signature field of
+ * in-memory.
+ * @param value the value to set the signature field of the
+ * BasicOrderParameters to set in-memory.
+ *
+ * @custom:return item the modified BasicOrderParameters
+ */
function withSignature(
BasicOrderParameters memory item,
bytes memory value
diff --git a/contracts/helpers/sol/lib/ConsiderationItemLib.sol b/contracts/helpers/sol/lib/ConsiderationItemLib.sol
index dbce2fb99..5f08dc4bd 100644
--- a/contracts/helpers/sol/lib/ConsiderationItemLib.sol
+++ b/contracts/helpers/sol/lib/ConsiderationItemLib.sol
@@ -3,17 +3,46 @@ pragma solidity ^0.8.17;
import {
ConsiderationItem,
- ReceivedItem
+ OfferItem,
+ ReceivedItem,
+ SpentItem
} from "../../../lib/ConsiderationStructs.sol";
+
import { ItemType } from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title ConsiderationItemLib
+ * @author James Wenzel (emo.eth)
+ * @notice ConsiderationItemLib is a library for managing ConsiderationItem
+ * structs and arrays. It allows chaining of functions to make
+ * struct creation more readable.
+ */
library ConsiderationItemLib {
bytes32 private constant CONSIDERATION_ITEM_MAP_POSITION =
keccak256("seaport.ConsiderationItemDefaults");
bytes32 private constant CONSIDERATION_ITEMS_MAP_POSITION =
keccak256("seaport.ConsiderationItemsDefaults");
+ bytes32 private constant EMPTY_CONSIDERATION_ITEM =
+ keccak256(
+ abi.encode(
+ ConsiderationItem({
+ itemType: ItemType(0),
+ token: address(0),
+ identifierOrCriteria: 0,
+ startAmount: 0,
+ endAmount: 0,
+ recipient: payable(address(0))
+ })
+ )
+ );
+ /**
+ * @dev Clears a ConsiderationItem from storage.
+ *
+ * @param item the ConsiderationItem to clear.
+ */
function _clear(ConsiderationItem storage item) internal {
// clear all fields
item.itemType = ItemType.NATIVE;
@@ -25,10 +54,10 @@ library ConsiderationItemLib {
}
/**
- * @notice clears a default ConsiderationItem from storage
+ * @dev Clears a named default ConsiderationItem from storage.
+ *
* @param defaultName the name of the default to clear
*/
-
function clear(string memory defaultName) internal {
mapping(string => ConsiderationItem)
storage considerationItemMap = _considerationItemMap();
@@ -36,6 +65,11 @@ library ConsiderationItemLib {
_clear(item);
}
+ /**
+ * @dev Clears an array of ConsiderationItems from storage.
+ *
+ * @param defaultsName the name of the array to clear
+ */
function clearMany(string memory defaultsName) internal {
mapping(string => ConsiderationItem[])
storage considerationItemsMap = _considerationItemsMap();
@@ -47,8 +81,11 @@ library ConsiderationItemLib {
}
/**
- * @notice gets a default ConsiderationItem from storage
+ * @dev Gets a default ConsiderationItem from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the ConsiderationItem retrieved from storage
*/
function fromDefault(
string memory defaultName
@@ -56,16 +93,37 @@ library ConsiderationItemLib {
mapping(string => ConsiderationItem)
storage considerationItemMap = _considerationItemMap();
item = considerationItemMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_CONSIDERATION_ITEM) {
+ revert("Empty ConsiderationItem selected.");
+ }
}
+ /**
+ * @dev Gets an array of default ConsiderationItems from storage.
+ *
+ * @param defaultsName the name of the array for retrieval
+ *
+ * @return items the array of ConsiderationItems retrieved from storage
+ */
function fromDefaultMany(
string memory defaultsName
) internal view returns (ConsiderationItem[] memory items) {
mapping(string => ConsiderationItem[])
storage considerationItemsMap = _considerationItemsMap();
items = considerationItemsMap[defaultsName];
+
+ if (items.length == 0) {
+ revert("Empty ConsiderationItem array selected.");
+ }
}
+ /**
+ * @dev Creates an empty ConsiderationItem.
+ *
+ * @custom:return considerationItemMap the storage location of the default
+ * ConsiderationItem map
+ */
function empty() internal pure returns (ConsiderationItem memory) {
return
ConsiderationItem({
@@ -79,9 +137,12 @@ library ConsiderationItemLib {
}
/**
- * @notice saves an ConsiderationItem as a named default
+ * @dev Saves a ConsiderationItem as a named default.
+ *
* @param considerationItem the ConsiderationItem to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _considerationItem the saved ConsiderationItem
*/
function saveDefault(
ConsiderationItem memory considerationItem,
@@ -93,6 +154,15 @@ library ConsiderationItemLib {
return considerationItem;
}
+ /**
+ * @dev Saves an array of ConsiderationItems as a named default.
+ *
+ * @param considerationItems the array of ConsiderationItems to save as a
+ * default
+ * @param defaultsName the name of the default array for retrieval
+ *
+ * @return _considerationItems the saved array of ConsiderationItems
+ */
function saveDefaultMany(
ConsiderationItem[] memory considerationItems,
string memory defaultsName
@@ -106,8 +176,11 @@ library ConsiderationItemLib {
}
/**
- * @notice makes a copy of an ConsiderationItem in-memory
+ * @dev Makes a copy of an ConsiderationItem in-memory.
+ *
* @param item the ConsiderationItem to make a copy of in-memory
+ *
+ * @custom:return copy the copy of the ConsiderationItem
*/
function copy(
ConsiderationItem memory item
@@ -123,27 +196,37 @@ library ConsiderationItemLib {
});
}
+ /**
+ * @dev Makes a copy of an array of ConsiderationItems in-memory.
+ *
+ * @param items the array of ConsiderationItems to make a copy of in-memory
+ *
+ * @custom:return copy the copy of the array of ConsiderationItems
+ */
function copy(
- ConsiderationItem[] memory item
+ ConsiderationItem[] memory items
) internal pure returns (ConsiderationItem[] memory) {
ConsiderationItem[] memory copies = new ConsiderationItem[](
- item.length
+ items.length
);
- for (uint256 i = 0; i < item.length; i++) {
+ for (uint256 i = 0; i < items.length; i++) {
copies[i] = ConsiderationItem({
- itemType: item[i].itemType,
- token: item[i].token,
- identifierOrCriteria: item[i].identifierOrCriteria,
- startAmount: item[i].startAmount,
- endAmount: item[i].endAmount,
- recipient: item[i].recipient
+ itemType: items[i].itemType,
+ token: items[i].token,
+ identifierOrCriteria: items[i].identifierOrCriteria,
+ startAmount: items[i].startAmount,
+ endAmount: items[i].endAmount,
+ recipient: items[i].recipient
});
}
return copies;
}
/**
- * @notice gets the storage position of the default ConsiderationItem map
+ * @dev Gets the storage position of the default ConsiderationItem map.
+ *
+ * @custom:return considerationItemMap the storage location of the default
+ * ConsiderationItem map
*/
function _considerationItemMap()
private
@@ -158,6 +241,13 @@ library ConsiderationItemLib {
}
}
+ /**
+ * @dev Gets the storage position of the default array of ConsiderationItems
+ * map.
+ *
+ * @custom:return considerationItemsMap the storage location of the default
+ * array of ConsiderationItems map
+ */
function _considerationItemsMap()
private
pure
@@ -171,15 +261,16 @@ library ConsiderationItemLib {
}
}
- // methods for configuring a single of each of an ConsiderationItem's fields, which modifies the ConsiderationItem
- // in-place and
- // returns it
+ // Methods for configuring a single of each of an ConsiderationItem's
+ // fields, which modify the ConsiderationItem in-place and return it.
/**
- * @notice sets the item type
- * @param item the ConsiderationItem to modify
+ * @dev Sets the item type.
+ *
+ * @param item the ConsiderationItem to modify
* @param itemType the item type to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withItemType(
ConsiderationItem memory item,
@@ -190,10 +281,12 @@ library ConsiderationItemLib {
}
/**
- * @notice sets the token address
- * @param item the ConsiderationItem to modify
+ * @dev Sets the token address.
+ *
+ * @param item the ConsiderationItem to modify
* @param token the token address to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withToken(
ConsiderationItem memory item,
@@ -204,10 +297,12 @@ library ConsiderationItemLib {
}
/**
- * @notice sets the identifier or criteria
+ * @dev Sets the identifier or criteria.
+ *
* @param item the ConsiderationItem to modify
* @param identifierOrCriteria the identifier or criteria to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withIdentifierOrCriteria(
ConsiderationItem memory item,
@@ -218,10 +313,12 @@ library ConsiderationItemLib {
}
/**
- * @notice sets the start amount
+ * @dev Sets the start amount.
+ *
* @param item the ConsiderationItem to modify
* @param startAmount the start amount to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withStartAmount(
ConsiderationItem memory item,
@@ -232,10 +329,12 @@ library ConsiderationItemLib {
}
/**
- * @notice sets the end amount
+ * @dev Sets the end amount.
+ *
* @param item the ConsiderationItem to modify
* @param endAmount the end amount to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withEndAmount(
ConsiderationItem memory item,
@@ -246,10 +345,29 @@ library ConsiderationItemLib {
}
/**
- * @notice sets the recipient
+ * @dev Sets the startAmount and endAmount of an ConsiderationItem.
+ *
+ * @param item the ConsiderationItem to modify
+ * @param amount the amount to set for the start and end amounts
+ *
+ * @custom:return item the modified ConsiderationItem
+ */
+ function withAmount(
+ ConsiderationItem memory item,
+ uint256 amount
+ ) internal pure returns (ConsiderationItem memory) {
+ item.startAmount = amount;
+ item.endAmount = amount;
+ return item;
+ }
+
+ /**
+ * @dev Sets the recipient.
+ *
* @param item the ConsiderationItem to modify
* @param recipient the recipient to set
- * @return the modified ConsiderationItem
+ *
+ * @custom:return item the modified ConsiderationItem
*/
function withRecipient(
ConsiderationItem memory item,
@@ -259,6 +377,13 @@ library ConsiderationItemLib {
return item;
}
+ /**
+ * @dev Converts an ConsiderationItem to a ReceivedItem.
+ *
+ * @param item the ConsiderationItem to convert
+ *
+ * @custom:return receivedItem the converted ReceivedItem
+ */
function toReceivedItem(
ConsiderationItem memory item
) internal pure returns (ReceivedItem memory) {
@@ -271,4 +396,49 @@ library ConsiderationItemLib {
recipient: item.recipient
});
}
+
+ function toReceivedItemArray(
+ ConsiderationItem[] memory items
+ ) internal pure returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ receivedItems[i] = toReceivedItem(items[i]);
+ }
+ return receivedItems;
+ }
+
+ function toSpentItem(
+ ConsiderationItem memory item
+ ) internal pure returns (SpentItem memory) {
+ return
+ SpentItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifierOrCriteria,
+ amount: item.startAmount
+ });
+ }
+
+ function toSpentItemArray(
+ ConsiderationItem[] memory items
+ ) internal pure returns (SpentItem[] memory) {
+ SpentItem[] memory spentItems = new SpentItem[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ spentItems[i] = toSpentItem(items[i]);
+ }
+ return spentItems;
+ }
+
+ function toOfferItem(
+ ConsiderationItem memory item
+ ) internal pure returns (OfferItem memory) {
+ return
+ OfferItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifierOrCriteria: item.identifierOrCriteria,
+ startAmount: item.startAmount,
+ endAmount: item.endAmount
+ });
+ }
}
diff --git a/contracts/helpers/sol/lib/CriteriaResolverLib.sol b/contracts/helpers/sol/lib/CriteriaResolverLib.sol
index e2dd1c840..31cacce5a 100644
--- a/contracts/helpers/sol/lib/CriteriaResolverLib.sol
+++ b/contracts/helpers/sol/lib/CriteriaResolverLib.sol
@@ -1,27 +1,46 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
-import {
- CriteriaResolver,
- OfferItem
-} from "../../../lib/ConsiderationStructs.sol";
+import { CriteriaResolver } from "../../../lib/ConsiderationStructs.sol";
+
import { Side } from "../../../lib/ConsiderationEnums.sol";
+
import { ArrayLib } from "./ArrayLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title CriteriaResolverLib
+ * @author James Wenzel (emo.eth)
+ * @notice CriteriaResolverLib is a library for managing CriteriaResolver
+ * structs and arrays. It allows chaining of functions to make
+ * struct creation more readable.
+ */
library CriteriaResolverLib {
bytes32 private constant CRITERIA_RESOLVER_MAP_POSITION =
keccak256("seaport.CriteriaResolverDefaults");
bytes32 private constant CRITERIA_RESOLVERS_MAP_POSITION =
keccak256("seaport.CriteriaResolversDefaults");
+ bytes32 private constant EMPTY_CRITERIA_RESOLVER =
+ keccak256(
+ abi.encode(
+ CriteriaResolver({
+ orderIndex: 0,
+ side: Side(0),
+ index: 0,
+ identifier: 0,
+ criteriaProof: new bytes32[](0)
+ })
+ )
+ );
using ArrayLib for bytes32[];
/**
- * @notice clears a default CriteriaResolver from storage
+ * @dev Clears a default CriteriaResolver from storage.
+ *
* @param defaultName the name of the default to clear
*/
-
function clear(string memory defaultName) internal {
mapping(string => CriteriaResolver)
storage criteriaResolverMap = _criteriaResolverMap();
@@ -30,6 +49,11 @@ library CriteriaResolverLib {
clear(resolver);
}
+ /**
+ * @dev Clears all fields on a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to clear
+ */
function clear(CriteriaResolver storage resolver) internal {
bytes32[] memory criteriaProof;
resolver.orderIndex = 0;
@@ -39,6 +63,11 @@ library CriteriaResolverLib {
ArrayLib.setBytes32s(resolver.criteriaProof, criteriaProof);
}
+ /**
+ * @dev Clears an array of CriteriaResolvers from storage.
+ *
+ * @param resolvers the CriteriaResolvers to clear
+ */
function clear(CriteriaResolver[] storage resolvers) internal {
while (resolvers.length > 0) {
clear(resolvers[resolvers.length - 1]);
@@ -47,29 +76,48 @@ library CriteriaResolverLib {
}
/**
- * @notice gets a default CriteriaResolver from storage
- * @param defaultName the name of the default for retrieval
+ * @dev Gets a default CriteriaResolver from storage.
+ *
+ * @param item the name of the default for retrieval
*/
function fromDefault(
string memory defaultName
- ) internal view returns (CriteriaResolver memory resolver) {
+ ) internal view returns (CriteriaResolver memory item) {
mapping(string => CriteriaResolver)
storage criteriaResolverMap = _criteriaResolverMap();
- resolver = criteriaResolverMap[defaultName];
+ item = criteriaResolverMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_CRITERIA_RESOLVER) {
+ revert("Empty CriteriaResolver selected.");
+ }
}
+ /**
+ * @dev Gets an array of CriteriaResolvers from storage.
+ *
+ * @param defaultsName the name of the default array for retrieval
+ *
+ * @return items the CriteriaResolvers retrieved from storage
+ */
function fromDefaultMany(
string memory defaultsName
- ) internal view returns (CriteriaResolver[] memory resolvers) {
+ ) internal view returns (CriteriaResolver[] memory items) {
mapping(string => CriteriaResolver[])
storage criteriaResolversMap = _criteriaResolversMap();
- resolvers = criteriaResolversMap[defaultsName];
+ items = criteriaResolversMap[defaultsName];
+
+ if (items.length == 0) {
+ revert("Empty CriteriaResolver array selected.");
+ }
}
/**
- * @notice saves an CriteriaResolver as a named default
+ * @dev Saves an CriteriaResolver as a named default.
+ *
* @param criteriaResolver the CriteriaResolver to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _criteriaResolver the CriteriaResolver that was saved
*/
function saveDefault(
CriteriaResolver memory criteriaResolver,
@@ -89,6 +137,14 @@ library CriteriaResolverLib {
return criteriaResolver;
}
+ /**
+ * @dev Saves an array of CriteriaResolvers as a named default.
+ *
+ * @param criteriaResolvers the CriteriaResolvers to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _criteriaResolvers the CriteriaResolvers that were saved
+ */
function saveDefaultMany(
CriteriaResolver[] memory criteriaResolvers,
string memory defaultName
@@ -105,8 +161,11 @@ library CriteriaResolverLib {
}
/**
- * @notice makes a copy of an CriteriaResolver in-memory
+ * @dev Makes a copy of a CriteriaResolver in-memory.
+ *
* @param resolver the CriteriaResolver to make a copy of in-memory
+ *
+ * @custom:return copiedItem the copied CriteriaResolver
*/
function copy(
CriteriaResolver memory resolver
@@ -121,6 +180,13 @@ library CriteriaResolverLib {
});
}
+ /**
+ * @dev Makes a copy of an array of CriteriaResolvers in-memory.
+ *
+ * @param resolvers the CriteriaResolvers to make a copy of in-memory
+ *
+ * @custom:return copiedItems the copied CriteriaResolvers
+ */
function copy(
CriteriaResolver[] memory resolvers
) internal pure returns (CriteriaResolver[] memory) {
@@ -133,6 +199,11 @@ library CriteriaResolverLib {
return copiedItems;
}
+ /**
+ * @dev Creates an empty CriteriaResolver.
+ *
+ * @custom:return emptyResolver the empty CriteriaResolver
+ */
function empty() internal pure returns (CriteriaResolver memory) {
bytes32[] memory proof;
return
@@ -146,7 +217,11 @@ library CriteriaResolverLib {
}
/**
- * @notice gets the storage position of the default CriteriaResolver map
+ * @dev Gets the storage position of the default CriteriaResolver map.
+ *
+ * @custom:return position the storage position of the default
+ * CriteriaResolver map.
+ *
*/
function _criteriaResolverMap()
private
@@ -161,6 +236,13 @@ library CriteriaResolverLib {
}
}
+ /**
+ * @dev Gets the storage position of the default CriteriaResolver array map.
+ *
+ * @custom:return position the storage position of the default
+ * CriteriaResolver array map.
+ *
+ */
function _criteriaResolversMap()
private
pure
@@ -174,10 +256,17 @@ library CriteriaResolverLib {
}
}
- // methods for configuring a single of each of an CriteriaResolver's fields, which modifies the CriteriaResolver
- // in-place and
- // returns it
+ // Methods for configuring a single of each of an CriteriaResolver's fields,
+ // which modify the CriteriaResolver in-place and return it.
+ /**
+ * @dev Sets the orderIndex of a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to set the orderIndex of
+ * @param orderIndex the orderIndex to set
+ *
+ * @return _resolver the CriteriaResolver with the orderIndex set
+ */
function withOrderIndex(
CriteriaResolver memory resolver,
uint256 orderIndex
@@ -186,6 +275,14 @@ library CriteriaResolverLib {
return resolver;
}
+ /**
+ * @dev Sets the side of a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to set the side of
+ * @param side the side to set
+ *
+ * @return _resolver the CriteriaResolver with the side set
+ */
function withSide(
CriteriaResolver memory resolver,
Side side
@@ -194,6 +291,14 @@ library CriteriaResolverLib {
return resolver;
}
+ /**
+ * @dev Sets the index of a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to set the index of
+ * @param index the index to set
+ *
+ * @return _resolver the CriteriaResolver with the index set
+ */
function withIndex(
CriteriaResolver memory resolver,
uint256 index
@@ -202,6 +307,14 @@ library CriteriaResolverLib {
return resolver;
}
+ /**
+ * @dev Sets the identifier of a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to set the identifier of
+ * @param identifier the identifier to set
+ *
+ * @return _resolver the CriteriaResolver with the identifier set
+ */
function withIdentifier(
CriteriaResolver memory resolver,
uint256 identifier
@@ -210,6 +323,14 @@ library CriteriaResolverLib {
return resolver;
}
+ /**
+ * @dev Sets the criteriaProof of a CriteriaResolver.
+ *
+ * @param resolver the CriteriaResolver to set the criteriaProof of
+ * @param criteriaProof the criteriaProof to set
+ *
+ * @return _resolver the CriteriaResolver with the criteriaProof set
+ */
function withCriteriaProof(
CriteriaResolver memory resolver,
bytes32[] memory criteriaProof
diff --git a/contracts/helpers/sol/lib/ExecutionLib.sol b/contracts/helpers/sol/lib/ExecutionLib.sol
index a77356237..142eba411 100644
--- a/contracts/helpers/sol/lib/ExecutionLib.sol
+++ b/contracts/helpers/sol/lib/ExecutionLib.sol
@@ -1,22 +1,52 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
-import { Execution, ReceivedItem } from "../../../lib/ConsiderationStructs.sol";
+import {
+ Execution,
+ ItemType,
+ ReceivedItem
+} from "../../../lib/ConsiderationStructs.sol";
+
import { ReceivedItemLib } from "./ReceivedItemLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title ExecutionLib
+ * @author James Wenzel (emo.eth)
+ * @notice ExecutionLib is a library for managing Execution structs and arrays.
+ * It allows chaining of functions to make struct creation more
+ * readable.
+ */
library ExecutionLib {
bytes32 private constant EXECUTION_MAP_POSITION =
keccak256("seaport.ExecutionDefaults");
bytes32 private constant EXECUTIONS_MAP_POSITION =
keccak256("seaport.ExecutionsDefaults");
+ bytes32 private constant EMPTY_EXECUTION =
+ keccak256(
+ abi.encode(
+ Execution({
+ item: ReceivedItem({
+ itemType: ItemType(0),
+ token: address(0),
+ identifier: 0,
+ amount: 0,
+ recipient: payable(address(0))
+ }),
+ offerer: address(0),
+ conduitKey: bytes32(0)
+ })
+ )
+ );
using ReceivedItemLib for ReceivedItem;
using ReceivedItemLib for ReceivedItem[];
/**
- * @notice clears a default Execution from storage
- * @param defaultName the name of the default to clear
+ * @dev Clears a default Execution from storage.
+ *
+ * @param defaultName the name of the default to clear.
*/
function clear(string memory defaultName) internal {
mapping(string => Execution) storage executionMap = _executionMap();
@@ -24,6 +54,11 @@ library ExecutionLib {
clear(item);
}
+ /**
+ * @dev Clears all fields on an Execution.
+ *
+ * @param execution the Execution to clear
+ */
function clear(Execution storage execution) internal {
// clear all fields
execution.item = ReceivedItemLib.empty();
@@ -31,6 +66,11 @@ library ExecutionLib {
execution.conduitKey = bytes32(0);
}
+ /**
+ * @dev Clears an array of Executions from storage.
+ *
+ * @param executions the name of the default to clear
+ */
function clear(Execution[] storage executions) internal {
while (executions.length > 0) {
clear(executions[executions.length - 1]);
@@ -39,27 +79,48 @@ library ExecutionLib {
}
/**
- * @notice gets a default Execution from storage
+ * @dev Gets a default Execution from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the Execution retrieved from storage
*/
function fromDefault(
string memory defaultName
) internal view returns (Execution memory item) {
mapping(string => Execution) storage executionMap = _executionMap();
item = executionMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_EXECUTION) {
+ revert("Empty Execution selected.");
+ }
}
+ /**
+ * @dev Gets an array of default Executions from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the Executions retrieved from storage
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (Execution[] memory items) {
mapping(string => Execution[]) storage executionsMap = _executionsMap();
items = executionsMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty Execution array selected.");
+ }
}
/**
- * @notice saves an Execution as a named default
- * @param execution the Execution to save as a default
+ * @dev Saves an Execution as a named default.
+ *
+ * @param execution the Execution to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _execution the Execution saved as a default
*/
function saveDefault(
Execution memory execution,
@@ -70,6 +131,14 @@ library ExecutionLib {
return execution;
}
+ /**
+ * @dev Saves an array of Executions as a named default.
+ *
+ * @param executions the Executions to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _executions the Executions saved as a default
+ */
function saveDefaultMany(
Execution[] memory executions,
string memory defaultName
@@ -80,8 +149,11 @@ library ExecutionLib {
}
/**
- * @notice makes a copy of an Execution in-memory
+ * @dev Makes a copy of an Execution in-memory.
+ *
* @param item the Execution to make a copy of in-memory
+ *
+ * @custom:return copy the copy of the Execution in-memory
*/
function copy(
Execution memory item
@@ -94,16 +166,28 @@ library ExecutionLib {
});
}
+ /**
+ * @dev Makes a copy of an array of Executions in-memory.
+ *
+ * @param items the array of Executions to make a copy of in-memory
+ *
+ * @custom:return copy the copy of the array of Executions in-memory
+ */
function copy(
- Execution[] memory item
+ Execution[] memory items
) internal pure returns (Execution[] memory) {
- Execution[] memory copies = new Execution[](item.length);
- for (uint256 i = 0; i < item.length; i++) {
- copies[i] = copy(item[i]);
+ Execution[] memory copies = new Execution[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ copies[i] = copy(items[i]);
}
return copies;
}
+ /**
+ * @dev Creates an empty Execution.
+ *
+ * @custom:return empty the empty Execution
+ */
function empty() internal pure returns (Execution memory) {
return
Execution({
@@ -114,7 +198,9 @@ library ExecutionLib {
}
/**
- * @notice gets the storage position of the default Execution map
+ * @dev Gets the storage position of the default Execution map.
+ *
+ * @return executionMap the storage position of the default Execution map
*/
function _executionMap()
private
@@ -127,6 +213,11 @@ library ExecutionLib {
}
}
+ /**
+ * @dev Gets the storage position of the default array of Executions map.
+ *
+ * @return executionsMap the storage position of the default Executions map
+ */
function _executionsMap()
private
pure
@@ -138,10 +229,17 @@ library ExecutionLib {
}
}
- // methods for configuring a single of each of an Execution's fields, which modifies the Execution
- // in-place and
- // returns it
+ // Methods for configuring a single of each of an Execution's fields, which
+ // modify the Execution in-place and return it.
+ /**
+ * @dev Configures an Execution's item field.
+ *
+ * @param execution the Execution to configure
+ * @param item the value to set the Execution's item field to
+ *
+ * @return _execution the configured Execution
+ */
function withItem(
Execution memory execution,
ReceivedItem memory item
@@ -150,6 +248,14 @@ library ExecutionLib {
return execution;
}
+ /**
+ * @dev Configures an Execution's offerer field.
+ *
+ * @param execution the Execution to configure
+ * @param offerer the value to set the Execution's offerer field to
+ *
+ * @return _execution the configured Execution
+ */
function withOfferer(
Execution memory execution,
address offerer
@@ -158,6 +264,14 @@ library ExecutionLib {
return execution;
}
+ /**
+ * @dev Configures an Execution's conduitKey field.
+ *
+ * @param execution the Execution to configure
+ * @param conduitKey the value to set the Execution's conduitKey field to
+ *
+ * @return _execution the configured Execution
+ */
function withConduitKey(
Execution memory execution,
bytes32 conduitKey
diff --git a/contracts/helpers/sol/lib/FulfillmentComponentLib.sol b/contracts/helpers/sol/lib/FulfillmentComponentLib.sol
index e5577a0d3..160ae03c4 100644
--- a/contracts/helpers/sol/lib/FulfillmentComponentLib.sol
+++ b/contracts/helpers/sol/lib/FulfillmentComponentLib.sol
@@ -1,14 +1,19 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
-import {
- FulfillmentComponent,
- OfferItem
-} from "../../../lib/ConsiderationStructs.sol";
-import { Side } from "../../../lib/ConsiderationEnums.sol";
+import { FulfillmentComponent } from "../../../lib/ConsiderationStructs.sol";
+
import { ArrayLib } from "./ArrayLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title FulfillmentComponentLib
+ * @author James Wenzel (emo.eth)
+ * @notice FulfillmentComponentLib is a library for managing FulfillmentComponent
+ * structs and arrays. It allows chaining of functions to make
+ * struct creation more readable.
+ */
library FulfillmentComponentLib {
bytes32 private constant FULFILLMENT_COMPONENT_MAP_POSITION =
keccak256("seaport.FulfillmentComponentDefaults");
@@ -18,10 +23,10 @@ library FulfillmentComponentLib {
using ArrayLib for bytes32[];
/**
- * @notice clears a default FulfillmentComponent from storage
+ * @dev Clears a default FulfillmentComponent from storage.
+ *
* @param defaultName the name of the default to clear
*/
-
function clear(string memory defaultName) internal {
mapping(string => FulfillmentComponent)
storage fulfillmentComponentMap = _fulfillmentComponentMap();
@@ -31,11 +36,21 @@ library FulfillmentComponentLib {
clear(component);
}
+ /**
+ * @dev Clears all fields on a FulfillmentComponent.
+ *
+ * @param component the FulfillmentComponent to clear
+ */
function clear(FulfillmentComponent storage component) internal {
component.orderIndex = 0;
component.itemIndex = 0;
}
+ /**
+ * @dev Clears an array of FulfillmentComponents from storage.
+ *
+ * @param components the FulfillmentComponents to clear
+ */
function clear(FulfillmentComponent[] storage components) internal {
while (components.length > 0) {
clear(components[components.length - 1]);
@@ -44,29 +59,42 @@ library FulfillmentComponentLib {
}
/**
- * @notice gets a default FulfillmentComponent from storage
+ * @dev Gets a default FulfillmentComponent from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the FulfillmentComponent retrieved from storage
*/
function fromDefault(
string memory defaultName
- ) internal view returns (FulfillmentComponent memory component) {
+ ) internal view returns (FulfillmentComponent memory item) {
mapping(string => FulfillmentComponent)
storage fulfillmentComponentMap = _fulfillmentComponentMap();
- component = fulfillmentComponentMap[defaultName];
+ item = fulfillmentComponentMap[defaultName];
}
+ /**
+ * @dev Gets an array of default FulfillmentComponents from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the FulfillmentComponents retrieved from storage
+ */
function fromDefaultMany(
string memory defaultName
- ) internal view returns (FulfillmentComponent[] memory components) {
+ ) internal view returns (FulfillmentComponent[] memory items) {
mapping(string => FulfillmentComponent[])
storage fulfillmentComponentMap = _fulfillmentComponentsMap();
- components = fulfillmentComponentMap[defaultName];
+ items = fulfillmentComponentMap[defaultName];
}
/**
- * @notice saves an FulfillmentComponent as a named default
+ * @dev Saves an FulfillmentComponent as a named default.
+ *
* @param fulfillmentComponent the FulfillmentComponent to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _fulfillmentComponent the FulfillmentComponent saved as a default
*/
function saveDefault(
FulfillmentComponent memory fulfillmentComponent,
@@ -82,6 +110,16 @@ library FulfillmentComponentLib {
return fulfillmentComponent;
}
+ /**
+ * @dev Saves an array of FulfillmentComponents as a named default.
+ *
+ * @param fulfillmentComponents the FulfillmentComponents to save as a
+ * default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _fulfillmentComponents the FulfillmentComponents saved as a
+ * default
+ */
function saveDefaultMany(
FulfillmentComponent[] memory fulfillmentComponents,
string memory defaultName
@@ -101,8 +139,11 @@ library FulfillmentComponentLib {
}
/**
- * @notice makes a copy of an FulfillmentComponent in-memory
- * @param component the FulfillmentComponent to make a copy of in-memory
+ * @dev Makes a copy of an FulfillmentComponent in-memory.
+ *
+ * @param component the FulfillmentComponent to make a copy of in-memory.
+ *
+ * @return copiedComponent the copied FulfillmentComponent
*/
function copy(
FulfillmentComponent memory component
@@ -114,6 +155,13 @@ library FulfillmentComponentLib {
});
}
+ /**
+ * @dev Makes a copy of an array of FulfillmentComponents in-memory.
+ *
+ * @param components the FulfillmentComponents to make a copy of in-memory.
+ *
+ * @return copiedComponents the copied FulfillmentComponents
+ */
function copy(
FulfillmentComponent[] memory components
) internal pure returns (FulfillmentComponent[] memory) {
@@ -126,12 +174,22 @@ library FulfillmentComponentLib {
return copiedItems;
}
+ /**
+ * @dev Creates an empty FulfillmentComponent.
+ *
+ * @return component the empty FulfillmentComponent
+ *
+ * @custom:return emptyComponent the empty FulfillmentComponent
+ */
function empty() internal pure returns (FulfillmentComponent memory) {
return FulfillmentComponent({ orderIndex: 0, itemIndex: 0 });
}
/**
- * @notice gets the storage position of the default FulfillmentComponent map
+ * @dev Gets the storage position of the default FulfillmentComponent map.
+ *
+ * @custom:return position the storage position of the default
+ * FulfillmentComponent
*/
function _fulfillmentComponentMap()
private
@@ -147,6 +205,13 @@ library FulfillmentComponentLib {
}
}
+ /**
+ * @dev Gets the storage position of the default FulfillmentComponent array
+ * map.
+ *
+ * @custom:return position the storage position of the default
+ * FulfillmentComponent array
+ */
function _fulfillmentComponentsMap()
private
pure
@@ -161,11 +226,17 @@ library FulfillmentComponentLib {
}
}
- // methods for configuring a single of each of an FulfillmentComponent's fields, which modifies the
- // FulfillmentComponent
- // in-place and
- // returns it
+ // Methods for configuring a single of each of a FulfillmentComponent's
+ // fields, which modify the FulfillmentComponent in-place and return it.
+ /**
+ * @dev Sets the orderIndex of a FulfillmentComponent.
+ *
+ * @param component the FulfillmentComponent to set the orderIndex of
+ * @param orderIndex the orderIndex to set
+ *
+ * @return component the FulfillmentComponent with the orderIndex set
+ */
function withOrderIndex(
FulfillmentComponent memory component,
uint256 orderIndex
@@ -174,6 +245,14 @@ library FulfillmentComponentLib {
return component;
}
+ /**
+ * @dev Sets the itemIndex of a FulfillmentComponent.
+ *
+ * @param component the FulfillmentComponent to set the itemIndex of
+ * @param itemIndex the itemIndex to set
+ *
+ * @return component the FulfillmentComponent with the itemIndex set
+ */
function withItemIndex(
FulfillmentComponent memory component,
uint256 itemIndex
diff --git a/contracts/helpers/sol/lib/FulfillmentLib.sol b/contracts/helpers/sol/lib/FulfillmentLib.sol
index e7c493a70..392a85d0e 100644
--- a/contracts/helpers/sol/lib/FulfillmentLib.sol
+++ b/contracts/helpers/sol/lib/FulfillmentLib.sol
@@ -5,11 +5,18 @@ import {
Fulfillment,
FulfillmentComponent
} from "../../../lib/ConsiderationStructs.sol";
-import { Side } from "../../../lib/ConsiderationEnums.sol";
-import { ArrayLib } from "./ArrayLib.sol";
+
import { FulfillmentComponentLib } from "./FulfillmentComponentLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title FulfillmentLib
+ * @author James Wenzel (emo.eth)
+ * @notice FulfillmentLib is a library for managing Fulfillment structs and
+ * arrays. It allows chaining of functions to make struct creation more
+ * readable.
+ */
library FulfillmentLib {
bytes32 private constant FULFILLMENT_MAP_POSITION =
keccak256("seaport.FulfillmentDefaults");
@@ -20,10 +27,10 @@ library FulfillmentLib {
using StructCopier for FulfillmentComponent[];
/**
- * @notice clears a default Fulfillment from storage
+ * @dev Clears a default Fulfillment from storage.
+ *
* @param defaultName the name of the default to clear
*/
-
function clear(string memory defaultName) internal {
mapping(string => Fulfillment)
storage fulfillmentMap = _fulfillmentMap();
@@ -37,29 +44,42 @@ library FulfillmentLib {
}
/**
- * @notice gets a default Fulfillment from storage
+ * @dev Gets a default Fulfillment from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the Fulfillment retrieved from storage
*/
function fromDefault(
string memory defaultName
- ) internal view returns (Fulfillment memory _fulfillment) {
+ ) internal view returns (Fulfillment memory item) {
mapping(string => Fulfillment)
storage fulfillmentMap = _fulfillmentMap();
- _fulfillment = fulfillmentMap[defaultName];
+ item = fulfillmentMap[defaultName];
}
+ /**
+ * @dev Gets a default Fulfillment array from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the Fulfillment array retrieved from storage
+ */
function fromDefaultMany(
string memory defaultName
- ) internal view returns (Fulfillment[] memory _fulfillments) {
+ ) internal view returns (Fulfillment[] memory items) {
mapping(string => Fulfillment[])
storage fulfillmentsMap = _fulfillmentsMap();
- _fulfillments = fulfillmentsMap[defaultName];
+ items = fulfillmentsMap[defaultName];
}
/**
- * @notice saves an Fulfillment as a named default
+ * @dev Saves a Fulfillment as a named default.
+ *
* @param fulfillment the Fulfillment to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _fulfillment the Fulfillment saved as a default
*/
function saveDefault(
Fulfillment memory fulfillment,
@@ -72,6 +92,14 @@ library FulfillmentLib {
return fulfillment;
}
+ /**
+ * @dev Saves a Fulfillment array as a named default.
+ *
+ * @param fulfillments the Fulfillment array to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _fulfillments the Fulfillment array saved as a default
+ */
function saveDefaultMany(
Fulfillment[] memory fulfillments,
string memory defaultName
@@ -86,8 +114,11 @@ library FulfillmentLib {
}
/**
- * @notice makes a copy of an Fulfillment in-memory
+ * @dev Makes a copy of a Fulfillment in-memory.
+ *
* @param _fulfillment the Fulfillment to make a copy of in-memory
+ *
+ * @custom:return copiedFulfillment the copied Fulfillment
*/
function copy(
Fulfillment memory _fulfillment
@@ -101,6 +132,13 @@ library FulfillmentLib {
});
}
+ /**
+ * @dev Makes a copy of a Fulfillment array in-memory.
+ *
+ * @param _fulfillments the Fulfillment array to make a copy of in-memory
+ *
+ * @custom:return copiedFulfillments the copied Fulfillment array
+ */
function copy(
Fulfillment[] memory _fulfillments
) internal pure returns (Fulfillment[] memory) {
@@ -113,6 +151,11 @@ library FulfillmentLib {
return copiedItems;
}
+ /**
+ * @dev Creates an empty Fulfillment in-memory.
+ *
+ * @custom:return emptyFulfillment the empty Fulfillment
+ */
function empty() internal pure returns (Fulfillment memory) {
FulfillmentComponent[] memory components;
return
@@ -123,7 +166,10 @@ library FulfillmentLib {
}
/**
- * @notice gets the storage position of the default Fulfillment map
+ * @dev Gets the storage position of the default Fulfillment map
+ *
+ * @return fulfillmentMap the storage position of the default Fulfillment
+ * map
*/
function _fulfillmentMap()
private
@@ -136,6 +182,12 @@ library FulfillmentLib {
}
}
+ /**
+ * @dev Gets the storage position of the default Fulfillment array map
+ *
+ * @return fulfillmentsMap the storage position of the default Fulfillment
+ * array map
+ */
function _fulfillmentsMap()
private
pure
@@ -147,11 +199,18 @@ library FulfillmentLib {
}
}
- // methods for configuring a single of each of an Fulfillment's fields, which modifies the
- // Fulfillment
- // in-place and
- // returns it
+ // Methods for configuring a single of each of a Fulfillment's fields, which
+ // modify the FulfillmentComponent in-place and return it.
+ /**
+ * @dev Sets the offer components of a Fulfillment in-place.
+ *
+ * @param _fulfillment the Fulfillment to set the offer components of
+ * @param components the FulfillmentComponent array to set as the offer
+ * components
+ *
+ * @custom:return _fulfillment the Fulfillment with the offer components set
+ */
function withOfferComponents(
Fulfillment memory _fulfillment,
FulfillmentComponent[] memory components
@@ -160,6 +219,17 @@ library FulfillmentLib {
return _fulfillment;
}
+ /**
+ * @dev Sets the consideration components of a Fulfillment in-place.
+ *
+ * @param _fulfillment the Fulfillment to set the consideration components
+ * of
+ * @param components the FulfillmentComponent array to set as the
+ * consideration components
+ *
+ * @custom:return _fulfillment the Fulfillment with the consideration
+ * components set
+ */
function withConsiderationComponents(
Fulfillment memory _fulfillment,
FulfillmentComponent[] memory components
diff --git a/contracts/helpers/sol/lib/OfferItemLib.sol b/contracts/helpers/sol/lib/OfferItemLib.sol
index 944445a40..e98fbdc00 100644
--- a/contracts/helpers/sol/lib/OfferItemLib.sol
+++ b/contracts/helpers/sol/lib/OfferItemLib.sol
@@ -1,16 +1,45 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
-import { OfferItem, SpentItem } from "../../../lib/ConsiderationStructs.sol";
+import {
+ ConsiderationItem,
+ OfferItem,
+ SpentItem
+} from "../../../lib/ConsiderationStructs.sol";
+
import { ItemType } from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title OfferItemLib
+ * @author James Wenzel (emo.eth)
+ * @notice OfferItemLib is a library for managing OfferItem structs and arrays.
+ * It allows chaining of functions to make struct creation more readable.
+ */
library OfferItemLib {
bytes32 private constant OFFER_ITEM_MAP_POSITION =
keccak256("seaport.OfferItemDefaults");
bytes32 private constant OFFER_ITEMS_MAP_POSITION =
keccak256("seaport.OfferItemsDefaults");
+ bytes32 private constant EMPTY_OFFER_ITEM =
+ keccak256(
+ abi.encode(
+ OfferItem({
+ itemType: ItemType(0),
+ token: address(0),
+ identifierOrCriteria: 0,
+ startAmount: 0,
+ endAmount: 0
+ })
+ )
+ );
+ /**
+ * @dev Clears an OfferItem from storage.
+ *
+ * @param item the item to clear
+ */
function _clear(OfferItem storage item) internal {
// clear all fields
item.itemType = ItemType.NATIVE;
@@ -21,7 +50,8 @@ library OfferItemLib {
}
/**
- * @notice clears a default OfferItem from storage
+ * @dev Clears an OfferItem from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -30,6 +60,11 @@ library OfferItemLib {
_clear(item);
}
+ /**
+ * @dev Clears an array of OfferItems from storage.
+ *
+ * @param defaultsName the name of the default to clear
+ */
function clearMany(string memory defaultsName) internal {
mapping(string => OfferItem[]) storage offerItemsMap = _offerItemsMap();
OfferItem[] storage items = offerItemsMap[defaultsName];
@@ -40,27 +75,48 @@ library OfferItemLib {
}
/**
- * @notice gets a default OfferItem from storage
+ * @dev Gets a default OfferItem from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the OfferItem retrieved from storage
*/
function fromDefault(
string memory defaultName
) internal view returns (OfferItem memory item) {
mapping(string => OfferItem) storage offerItemMap = _offerItemMap();
item = offerItemMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_OFFER_ITEM) {
+ revert("Empty OfferItem selected.");
+ }
}
+ /**
+ * @dev Gets a default OfferItem from storage.
+ *
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return items the OfferItems retrieved from storage
+ */
function fromDefaultMany(
string memory defaultsName
) internal view returns (OfferItem[] memory items) {
mapping(string => OfferItem[]) storage offerItemsMap = _offerItemsMap();
items = offerItemsMap[defaultsName];
+
+ if (items.length == 0) {
+ revert("Empty OfferItem array selected.");
+ }
}
/**
- * @notice saves an OfferItem as a named default
- * @param offerItem the OfferItem to save as a default
+ * @dev Saves an OfferItem as a named default.
+ *
+ * @param offerItem the OfferItem to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _offerItem the OfferItem saved as a default
*/
function saveDefault(
OfferItem memory offerItem,
@@ -71,6 +127,14 @@ library OfferItemLib {
return offerItem;
}
+ /**
+ * @dev Saves an array of OfferItems as a named default.
+ *
+ * @param offerItems the OfferItems to save as a default
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return _offerItems the OfferItems saved as a default
+ */
function saveDefaultMany(
OfferItem[] memory offerItems,
string memory defaultsName
@@ -83,8 +147,11 @@ library OfferItemLib {
}
/**
- * @notice makes a copy of an OfferItem in-memory
+ * @dev Makes a copy of an OfferItem in-memory.
+ *
* @param item the OfferItem to make a copy of in-memory
+ *
+ * @custom:return copiedItem the copied OfferItem
*/
function copy(
OfferItem memory item
@@ -99,6 +166,13 @@ library OfferItemLib {
});
}
+ /**
+ * @dev Makes a copy of an array of OfferItems in-memory.
+ *
+ * @param items the OfferItems to make a copy of in-memory
+ *
+ * @custom:return copiedItems the copied OfferItems
+ */
function copy(
OfferItem[] memory items
) internal pure returns (OfferItem[] memory) {
@@ -109,6 +183,11 @@ library OfferItemLib {
return copiedItems;
}
+ /**
+ * @dev Creates an empty OfferItem.
+ *
+ * @custom:return emptyItem the empty OfferItem
+ */
function empty() internal pure returns (OfferItem memory) {
return
OfferItem({
@@ -121,7 +200,9 @@ library OfferItemLib {
}
/**
- * @notice gets the storage position of the default OfferItem map
+ * @dev Gets the storage position of the default OfferItem map.
+ *
+ * @custom:return offerItemMap the default OfferItem map position
*/
function _offerItemMap()
private
@@ -135,7 +216,9 @@ library OfferItemLib {
}
/**
- * @notice gets the storage position of the default OfferItem[] map
+ * @dev Gets the storage position of the default OfferItem array map
+ *
+ * @custom:return offerItemMap the default OfferItem array map position
*/
function _offerItemsMap()
private
@@ -148,14 +231,16 @@ library OfferItemLib {
}
}
- // methods for configuring a single of each of an OfferItem's fields, which modifies the OfferItem in-place and
- // returns it
+ // Methods for configuring a single of each of a OfferItem's fields, which
+ // modify the OfferItem in-place and return it.
/**
- * @notice sets the item type
+ * @dev Sets the item type of an OfferItem.
+ *
* @param item the OfferItem to modify
* @param itemType the item type to set
- * @return the modified OfferItem
+ *
+ * @custom:return _offerItem the modified OfferItem
*/
function withItemType(
OfferItem memory item,
@@ -166,10 +251,12 @@ library OfferItemLib {
}
/**
- * @notice sets the token address
+ * @dev Sets the token of an OfferItem.
+ *
* @param item the OfferItem to modify
- * @param token the token address to set
- * @return the modified OfferItem
+ * @param token the token to set
+ *
+ * @custom:return _offerItem the modified OfferItem
*/
function withToken(
OfferItem memory item,
@@ -180,10 +267,12 @@ library OfferItemLib {
}
/**
- * @notice sets the identifier or criteria
+ * @dev Sets the identifierOrCriteria of an OfferItem.
+ *
* @param item the OfferItem to modify
* @param identifierOrCriteria the identifier or criteria to set
- * @return the modified OfferItem
+ *
+ * @custom:return _offerItem the modified OfferItem
*/
function withIdentifierOrCriteria(
OfferItem memory item,
@@ -194,10 +283,12 @@ library OfferItemLib {
}
/**
- * @notice sets the start amount
+ * @dev Sets the startAmount of an OfferItem.
+ *
* @param item the OfferItem to modify
* @param startAmount the start amount to set
- * @return the modified OfferItem
+ *
+ * @custom:return _offerItem the modified OfferItem
*/
function withStartAmount(
OfferItem memory item,
@@ -208,10 +299,12 @@ library OfferItemLib {
}
/**
- * @notice sets the end amount
+ * @dev Sets the endAmount of an OfferItem.
+ *
* @param item the OfferItem to modify
* @param endAmount the end amount to set
- * @return the modified OfferItem
+ *
+ * @custom:return _offerItem the modified OfferItem
*/
function withEndAmount(
OfferItem memory item,
@@ -221,6 +314,30 @@ library OfferItemLib {
return item;
}
+ /**
+ * @dev Sets the startAmount and endAmount of an OfferItem.
+ *
+ * @param item the OfferItem to modify
+ * @param amount the amount to set for the start and end amounts
+ *
+ * @custom:return _offerItem the modified OfferItem
+ */
+ function withAmount(
+ OfferItem memory item,
+ uint256 amount
+ ) internal pure returns (OfferItem memory) {
+ item.startAmount = amount;
+ item.endAmount = amount;
+ return item;
+ }
+
+ /**
+ * @dev Converts an OfferItem to a SpentItem.
+ *
+ * @param item the OfferItem to convert
+ *
+ * @custom:return spentItem the converted SpentItem
+ */
function toSpentItem(
OfferItem memory item
) internal pure returns (SpentItem memory) {
@@ -232,4 +349,44 @@ library OfferItemLib {
amount: item.startAmount
});
}
+
+ /**
+ * @dev Converts an OfferItem[] to a SpentItem[].
+ *
+ * @param items the OfferItem[] to convert
+ *
+ * @custom:return spentItems the converted SpentItem[]
+ */
+ function toSpentItemArray(
+ OfferItem[] memory items
+ ) internal pure returns (SpentItem[] memory) {
+ SpentItem[] memory spentItems = new SpentItem[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ spentItems[i] = toSpentItem(items[i]);
+ }
+
+ return spentItems;
+ }
+
+ /**
+ * @dev Converts an OfferItem to a ConsiderationItem.
+ *
+ * @param item the OfferItem to convert
+ *
+ * @custom:return considerationItem the converted ConsiderationItem
+ */
+ function toConsiderationItem(
+ OfferItem memory item,
+ address recipient
+ ) internal pure returns (ConsiderationItem memory) {
+ return
+ ConsiderationItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifierOrCriteria: item.identifierOrCriteria,
+ startAmount: item.startAmount,
+ endAmount: item.endAmount,
+ recipient: payable(recipient)
+ });
+ }
}
diff --git a/contracts/helpers/sol/lib/OrderComponentsLib.sol b/contracts/helpers/sol/lib/OrderComponentsLib.sol
index 375c01cd5..98b0779a0 100644
--- a/contracts/helpers/sol/lib/OrderComponentsLib.sol
+++ b/contracts/helpers/sol/lib/OrderComponentsLib.sol
@@ -2,22 +2,31 @@
pragma solidity ^0.8.17;
import {
- BasicOrderParameters,
- OrderComponents,
ConsiderationItem,
- OrderParameters,
OfferItem,
- AdditionalRecipient
+ OrderComponents,
+ OrderParameters
} from "../../../lib/ConsiderationStructs.sol";
+
import {
- OrderType,
+ BasicOrderType,
ItemType,
- BasicOrderType
+ OrderType
} from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+
import { OfferItemLib } from "./OfferItemLib.sol";
+
import { ConsiderationItemLib } from "./ConsiderationItemLib.sol";
+/**
+ * @title OrderComponentsLib
+ * @author James Wenzel (emo.eth)
+ * @notice OrderComponentsLib is a library for managing OrderComponents structs
+ * and arrays. It allows chaining of functions to make struct creation
+ * more readable.
+ */
library OrderComponentsLib {
using OrderComponentsLib for OrderComponents;
using OfferItemLib for OfferItem[];
@@ -27,7 +36,30 @@ library OrderComponentsLib {
keccak256("seaport.OrderComponentsDefaults");
bytes32 private constant ORDER_COMPONENTS_ARRAY_MAP_POSITION =
keccak256("seaport.OrderComponentsArrayDefaults");
+ bytes32 private constant EMPTY_ORDER_COMPONENTS =
+ keccak256(
+ abi.encode(
+ OrderComponents({
+ offerer: address(0),
+ zone: address(0),
+ offer: new OfferItem[](0),
+ consideration: new ConsiderationItem[](0),
+ orderType: OrderType(0),
+ startTime: 0,
+ endTime: 0,
+ zoneHash: bytes32(0),
+ salt: 0,
+ conduitKey: bytes32(0),
+ counter: 0
+ })
+ )
+ );
+ /**
+ * @dev Clears anOrderComponents from storage.
+ *
+ * @param components the OrderComponents to clear
+ */
function clear(OrderComponents storage components) internal {
// uninitialized pointers take up no new memory (versus one word for initializing length-0)
OfferItem[] memory offer;
@@ -50,6 +82,11 @@ library OrderComponentsLib {
components.counter = 0;
}
+ /**
+ * @dev Clears an array of OrderComponents from storage.
+ *
+ * @param components the OrderComponents to clear
+ */
function clear(OrderComponents[] storage components) internal {
while (components.length > 0) {
clear(components[components.length - 1]);
@@ -58,7 +95,8 @@ library OrderComponentsLib {
}
/**
- * @notice clears a default OrderComponents from storage
+ * @dev Clears a default OrderComponents from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -68,6 +106,11 @@ library OrderComponentsLib {
components.clear();
}
+ /**
+ * @dev Creates a new OrderComponents struct.
+ *
+ * @return item the new OrderComponents struct
+ */
function empty() internal pure returns (OrderComponents memory item) {
OfferItem[] memory offer;
ConsiderationItem[] memory consideration;
@@ -87,8 +130,11 @@ library OrderComponentsLib {
}
/**
- * @notice gets a default OrderComponents from storage
+ * @dev Gets a default OrderComponents from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the default OrderComponents
*/
function fromDefault(
string memory defaultName
@@ -96,20 +142,38 @@ library OrderComponentsLib {
mapping(string => OrderComponents)
storage orderComponentsMap = _orderComponentsMap();
item = orderComponentsMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_ORDER_COMPONENTS) {
+ revert("Empty OrderComponents selected.");
+ }
}
+ /**
+ * @dev Gets a default OrderComponents array from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the default OrderComponents array
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (OrderComponents[] memory items) {
mapping(string => OrderComponents[])
storage orderComponentsArrayMap = _orderComponentsArrayMap();
items = orderComponentsArrayMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty OrderComponents array selected.");
+ }
}
/**
- * @notice saves an OrderComponents as a named default
+ * @dev Saves an OrderComponents as a named default.
+ *
* @param orderComponents the OrderComponents to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orderComponents the OrderComponents that was saved
*/
function saveDefault(
OrderComponents memory orderComponents,
@@ -122,6 +186,14 @@ library OrderComponentsLib {
return orderComponents;
}
+ /**
+ * @dev Saves an OrderComponents array as a named default.
+ *
+ * @param orderComponents the OrderComponents array to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orderComponents the OrderComponents array that was saved
+ */
function saveDefaultMany(
OrderComponents[] memory orderComponents,
string memory defaultName
@@ -136,8 +208,11 @@ library OrderComponentsLib {
}
/**
- * @notice makes a copy of an OrderComponents in-memory
+ * @dev Makes a copy of an OrderComponents in-memory.
+ *
* @param item the OrderComponents to make a copy of in-memory
+ *
+ * @return the copy of the OrderComponents
*/
function copy(
OrderComponents memory item
@@ -159,7 +234,10 @@ library OrderComponentsLib {
}
/**
- * @notice gets the storage position of the default OrderComponents map
+ * @dev Gets the storage position of the default OrderComponents map.
+ *
+ * @custom:return position the storage position of the default
+ * OrderComponents map
*/
function _orderComponentsMap()
private
@@ -172,6 +250,12 @@ library OrderComponentsLib {
}
}
+ /**
+ * @dev Gets the storage position of the default OrderComponents array map.
+ *
+ * @custom:return position the storage position of the default
+ * OrderComponents array map
+ */
function _orderComponentsArrayMap()
private
pure
@@ -185,9 +269,17 @@ library OrderComponentsLib {
}
}
- // methods for configuring a single of each of an in-memory OrderComponents's fields, which modifies the
- // OrderComponents in-memory and returns it
+ // Methods for configuring a single of each of a OrderComponents's fields,
+ // which modify the OrderComponents struct in-place and return it.
+ /**
+ * @dev Sets the offerer field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param offerer the new value for the offerer field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withOfferer(
OrderComponents memory components,
address offerer
@@ -196,6 +288,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the zone field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param zone the new value for the zone field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withZone(
OrderComponents memory components,
address zone
@@ -204,6 +304,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the offer field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param offer the new value for the offer field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withOffer(
OrderComponents memory components,
OfferItem[] memory offer
@@ -212,6 +320,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the consideration field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param consideration the new value for the consideration field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withConsideration(
OrderComponents memory components,
ConsiderationItem[] memory consideration
@@ -220,6 +336,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the orderType field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param orderType the new value for the orderType field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withOrderType(
OrderComponents memory components,
OrderType orderType
@@ -228,6 +352,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the startTime field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param startTime the new value for the startTime field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withStartTime(
OrderComponents memory components,
uint256 startTime
@@ -236,6 +368,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the endTime field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param endTime the new value for the endTime field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withEndTime(
OrderComponents memory components,
uint256 endTime
@@ -244,6 +384,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the zoneHash field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param zoneHash the new value for the zoneHash field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withZoneHash(
OrderComponents memory components,
bytes32 zoneHash
@@ -252,6 +400,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the salt field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param salt the new value for the salt field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withSalt(
OrderComponents memory components,
uint256 salt
@@ -260,6 +416,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the conduitKey field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param conduitKey the new value for the conduitKey field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withConduitKey(
OrderComponents memory components,
bytes32 conduitKey
@@ -268,6 +432,14 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Sets the counter field of an OrderComponents struct in-place.
+ *
+ * @param components the OrderComponents struct to modify
+ * @param counter the new value for the counter field
+ *
+ * @custom:return _orderComponents the modified OrderComponents struct
+ */
function withCounter(
OrderComponents memory components,
uint256 counter
@@ -276,6 +448,13 @@ library OrderComponentsLib {
return components;
}
+ /**
+ * @dev Converts an OrderComponents struct into an OrderParameters struct.
+ *
+ * @param components the OrderComponents struct to convert
+ *
+ * @custom:return _orderParameters the converted OrderParameters struct
+ */
function toOrderParameters(
OrderComponents memory components
) internal pure returns (OrderParameters memory parameters) {
diff --git a/contracts/helpers/sol/lib/OrderLib.sol b/contracts/helpers/sol/lib/OrderLib.sol
index 59dfd56a4..e7551adc9 100644
--- a/contracts/helpers/sol/lib/OrderLib.sol
+++ b/contracts/helpers/sol/lib/OrderLib.sol
@@ -2,23 +2,61 @@
pragma solidity ^0.8.17;
import {
- Order,
+ AdditionalRecipient,
AdvancedOrder,
- OrderParameters
+ BasicOrderParameters,
+ ConsiderationItem,
+ OfferItem,
+ Order,
+ OrderParameters,
+ OrderType
} from "../../../lib/ConsiderationStructs.sol";
+
+import { BasicOrderType } from "../../../lib/ConsiderationEnums.sol";
+
import { OrderParametersLib } from "./OrderParametersLib.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title AdvancedOrderLib
+ * @author James Wenzel (emo.eth)
+ * @notice AdvancedOrderLib is a library for managing AdvancedOrder
+ * structs and arrays. It allows chaining of functions to make struct
+ * creation more readable.
+ */
library OrderLib {
bytes32 private constant ORDER_MAP_POSITION =
keccak256("seaport.OrderDefaults");
bytes32 private constant ORDERS_MAP_POSITION =
keccak256("seaport.OrdersDefaults");
+ bytes32 private constant EMPTY_ORDER =
+ keccak256(
+ abi.encode(
+ Order({
+ parameters: OrderParameters({
+ offerer: address(0),
+ zone: address(0),
+ offer: new OfferItem[](0),
+ consideration: new ConsiderationItem[](0),
+ orderType: OrderType(0),
+ startTime: 0,
+ endTime: 0,
+ zoneHash: bytes32(0),
+ salt: 0,
+ conduitKey: bytes32(0),
+ totalOriginalConsiderationItems: 0
+ }),
+ signature: ""
+ })
+ )
+ );
using OrderParametersLib for OrderParameters;
/**
- * @notice clears a default Order from storage
+ * @dev Clears a default Order from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -27,12 +65,22 @@ library OrderLib {
clear(item);
}
+ /**
+ * @dev Clears all fields on an Order.
+ *
+ * @param order the Order to clear
+ */
function clear(Order storage order) internal {
// clear all fields
order.parameters.clear();
order.signature = "";
}
+ /**
+ * @dev Clears an array of Orders from storage.
+ *
+ * @param order the Orders to clear
+ */
function clear(Order[] storage order) internal {
while (order.length > 0) {
clear(order[order.length - 1]);
@@ -41,28 +89,50 @@ library OrderLib {
}
/**
- * @notice gets a default Order from storage
+ * @dev Gets a default Order from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the default Order
*/
function fromDefault(
string memory defaultName
) internal view returns (Order memory item) {
mapping(string => Order) storage orderMap = _orderMap();
item = orderMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_ORDER) {
+ revert("Empty Order selected.");
+ }
}
+ /**
+ * @dev Gets a default Order array from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the default Order array
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (Order[] memory) {
mapping(string => Order[]) storage ordersMap = _ordersMap();
Order[] memory items = ordersMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty Order array selected.");
+ }
+
return items;
}
/**
- * @notice saves an Order as a named default
+ * @dev Saves an Order as a named default.
+ *
* @param order the Order to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _order the Order saved as a default
*/
function saveDefault(
Order memory order,
@@ -73,6 +143,14 @@ library OrderLib {
return order;
}
+ /**
+ * @dev Saves an Order array as a named default.
+ *
+ * @param orders the Order array to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orders the Order array saved as a default
+ */
function saveDefaultMany(
Order[] memory orders,
string memory defaultName
@@ -83,8 +161,11 @@ library OrderLib {
}
/**
- * @notice makes a copy of an Order in-memory
+ * @dev Makes a copy of an Order in-memory.
+ *
* @param item the Order to make a copy of in-memory
+ *
+ * @custom:return copiedOrder the copied Order
*/
function copy(Order memory item) internal pure returns (Order memory) {
return
@@ -94,6 +175,13 @@ library OrderLib {
});
}
+ /**
+ * @dev Makes a copy of an Order array in-memory.
+ *
+ * @param items the Order array to make a copy of in-memory
+ *
+ * @custom:return copiedOrders the copied Order array
+ */
function copy(Order[] memory items) internal pure returns (Order[] memory) {
Order[] memory copiedItems = new Order[](items.length);
for (uint256 i = 0; i < items.length; i++) {
@@ -102,12 +190,19 @@ library OrderLib {
return copiedItems;
}
+ /**
+ * @dev Create an empty Order.
+ *
+ * @custom:return emptyOrder the empty Order
+ */
function empty() internal pure returns (Order memory) {
return Order({ parameters: OrderParametersLib.empty(), signature: "" });
}
/**
- * @notice gets the storage position of the default Order map
+ * @dev Gets the storage position of the default Order map.
+ *
+ * @return orderMap the storage position of the default Order map
*/
function _orderMap()
private
@@ -120,6 +215,11 @@ library OrderLib {
}
}
+ /**
+ * @dev Gets the storage position of the default Order array map.
+ *
+ * @return ordersMap the storage position of the default Order array map
+ */
function _ordersMap()
private
pure
@@ -131,9 +231,17 @@ library OrderLib {
}
}
- // methods for configuring a single of each of an Order's fields, which modifies the Order in-place and
- // returns it
+ // Methods for configuring a single of each of an Order's fields, which
+ // modify the Order in-place and return it.
+ /**
+ * @dev Sets the parameters of an Order.
+ *
+ * @param order the Order to set the parameters of
+ * @param parameters the parameters to set
+ *
+ * @return _order the Order with the parameters set
+ */
function withParameters(
Order memory order,
OrderParameters memory parameters
@@ -142,6 +250,14 @@ library OrderLib {
return order;
}
+ /**
+ * @dev Sets the signature of an Order.
+ *
+ * @param order the Order to set the signature of
+ * @param signature the signature to set
+ *
+ * @return _order the Order with the signature set
+ */
function withSignature(
Order memory order,
bytes memory signature
@@ -150,6 +266,16 @@ library OrderLib {
return order;
}
+ /**
+ * @dev Converts an Order to an AdvancedOrder.
+ *
+ * @param order the Order to convert
+ * @param numerator the numerator to set
+ * @param denominator the denominator to set
+ * @param extraData the extra data to set
+ *
+ * @return advancedOrder the AdvancedOrder
+ */
function toAdvancedOrder(
Order memory order,
uint120 numerator,
@@ -162,4 +288,94 @@ library OrderLib {
advancedOrder.signature = order.signature;
advancedOrder.extraData = extraData;
}
+
+ /**
+ * @dev Converts Orders to AdvancedOrders in bulk.
+ *
+ * @param orders the Orders to convert
+ * @param numerator the numerator to set for all
+ * @param denominator the denominator to set for all
+ * @param extraData the extra data to set for all
+ *
+ * @return _advancedOrders the AdvancedOrders
+ */
+ function toAdvancedOrders(
+ Order[] memory orders,
+ uint120 numerator,
+ uint120 denominator,
+ bytes memory extraData
+ ) internal pure returns (AdvancedOrder[] memory _advancedOrders) {
+ AdvancedOrder[] memory advancedOrders = new AdvancedOrder[](
+ orders.length
+ );
+ for (uint256 i = 0; i < orders.length; i++) {
+ advancedOrders[i] = toAdvancedOrder(
+ orders[i],
+ numerator,
+ denominator,
+ extraData
+ );
+ }
+ return advancedOrders;
+ }
+
+ /**
+ * @dev Converts an Order to a BasicOrderParameters.
+ *
+ * @param order the Order to convert
+ * @param basicOrderType the BasicOrderType to set
+ *
+ * @return basicOrderParameters the BasicOrderParameters
+ */
+ function toBasicOrderParameters(
+ Order memory order,
+ BasicOrderType basicOrderType
+ ) internal pure returns (BasicOrderParameters memory basicOrderParameters) {
+ basicOrderParameters.considerationToken = order
+ .parameters
+ .consideration[0]
+ .token;
+ basicOrderParameters.considerationIdentifier = order
+ .parameters
+ .consideration[0]
+ .identifierOrCriteria;
+ basicOrderParameters.considerationAmount = order
+ .parameters
+ .consideration[0]
+ .endAmount;
+ basicOrderParameters.offerer = payable(order.parameters.offerer);
+ basicOrderParameters.zone = order.parameters.zone;
+ basicOrderParameters.offerToken = order.parameters.offer[0].token;
+ basicOrderParameters.offerIdentifier = order
+ .parameters
+ .offer[0]
+ .identifierOrCriteria;
+ basicOrderParameters.offerAmount = order.parameters.offer[0].endAmount;
+ basicOrderParameters.basicOrderType = basicOrderType;
+ basicOrderParameters.startTime = order.parameters.startTime;
+ basicOrderParameters.endTime = order.parameters.endTime;
+ basicOrderParameters.zoneHash = order.parameters.zoneHash;
+ basicOrderParameters.salt = order.parameters.salt;
+ basicOrderParameters.offererConduitKey = order.parameters.conduitKey;
+ basicOrderParameters.fulfillerConduitKey = order.parameters.conduitKey;
+ basicOrderParameters.totalOriginalAdditionalRecipients =
+ order.parameters.totalOriginalConsiderationItems -
+ 1;
+
+ AdditionalRecipient[]
+ memory additionalRecipients = new AdditionalRecipient[](
+ order.parameters.consideration.length - 1
+ );
+ for (uint256 i = 1; i < order.parameters.consideration.length; i++) {
+ additionalRecipients[i - 1] = AdditionalRecipient({
+ recipient: order.parameters.consideration[i].recipient,
+ amount: order.parameters.consideration[i].startAmount
+ });
+ }
+
+ basicOrderParameters.additionalRecipients = additionalRecipients;
+ basicOrderParameters.signature = order.signature;
+
+ return basicOrderParameters;
+ }
}
diff --git a/contracts/helpers/sol/lib/OrderParametersLib.sol b/contracts/helpers/sol/lib/OrderParametersLib.sol
index 9beb886fe..1656707e1 100644
--- a/contracts/helpers/sol/lib/OrderParametersLib.sol
+++ b/contracts/helpers/sol/lib/OrderParametersLib.sol
@@ -1,23 +1,33 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
+import { ItemType, Side } from "../../../lib/ConsiderationEnums.sol";
+
import {
- BasicOrderParameters,
- OrderComponents,
ConsiderationItem,
+ CriteriaResolver,
+ OrderComponents,
OrderParameters,
OfferItem,
- AdditionalRecipient
+ ReceivedItem,
+ SpentItem
} from "../../../lib/ConsiderationStructs.sol";
-import {
- OrderType,
- ItemType,
- BasicOrderType
-} from "../../../lib/ConsiderationEnums.sol";
+
+import { OrderType } from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+
import { OfferItemLib } from "./OfferItemLib.sol";
+
import { ConsiderationItemLib } from "./ConsiderationItemLib.sol";
+/**
+ * @title OrderParametersLib
+ * @author James Wenzel (emo.eth)
+ * @notice OrderParametersLib is a library for managing OrderParameters structs
+ * and arrays. It allows chaining of functions to make struct creation
+ * more readable.
+ */
library OrderParametersLib {
using OrderParametersLib for OrderParameters;
using OfferItemLib for OfferItem[];
@@ -29,7 +39,30 @@ library OrderParametersLib {
keccak256("seaport.OrderParametersDefaults");
bytes32 private constant ORDER_PARAMETERS_ARRAY_MAP_POSITION =
keccak256("seaport.OrderParametersArrayDefaults");
+ bytes32 private constant EMPTY_ORDER_PARAMETERS =
+ keccak256(
+ abi.encode(
+ OrderParameters({
+ offerer: address(0),
+ zone: address(0),
+ offer: new OfferItem[](0),
+ consideration: new ConsiderationItem[](0),
+ orderType: OrderType(0),
+ startTime: 0,
+ endTime: 0,
+ zoneHash: bytes32(0),
+ salt: 0,
+ conduitKey: bytes32(0),
+ totalOriginalConsiderationItems: 0
+ })
+ )
+ );
+ /**
+ * @dev Clears an OrderParameters from storage.
+ *
+ * @param parameters the OrderParameters to clear
+ */
function clear(OrderParameters storage parameters) internal {
// uninitialized pointers take up no new memory (versus one word for initializing length-0)
OfferItem[] memory offer;
@@ -52,6 +85,11 @@ library OrderParametersLib {
parameters.totalOriginalConsiderationItems = 0;
}
+ /**
+ * @dev Clears an array of OrderParameters from storage.
+ *
+ * @param parameters the OrderParameters array to clear
+ */
function clear(OrderParameters[] storage parameters) internal {
while (parameters.length > 0) {
clear(parameters[parameters.length - 1]);
@@ -60,7 +98,8 @@ library OrderParametersLib {
}
/**
- * @notice clears a default OrderParameters from storage
+ * @dev Clears a default OrderParameters from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -70,6 +109,11 @@ library OrderParametersLib {
parameters.clear();
}
+ /**
+ * @dev Creates a new empty OrderParameters struct.
+ *
+ * @return item the new OrderParameters
+ */
function empty() internal pure returns (OrderParameters memory item) {
OfferItem[] memory offer;
ConsiderationItem[] memory consideration;
@@ -89,8 +133,11 @@ library OrderParametersLib {
}
/**
- * @notice gets a default OrderParameters from storage
+ * @dev Gets a default OrderParameters from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the default OrderParameters
*/
function fromDefault(
string memory defaultName
@@ -98,20 +145,38 @@ library OrderParametersLib {
mapping(string => OrderParameters)
storage orderParametersMap = _orderParametersMap();
item = orderParametersMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_ORDER_PARAMETERS) {
+ revert("Empty OrderParameters selected.");
+ }
}
+ /**
+ * @dev Gets a default OrderParameters array from storage.
+ *
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return items the default OrderParameters array
+ */
function fromDefaultMany(
string memory defaultName
) internal view returns (OrderParameters[] memory items) {
mapping(string => OrderParameters[])
storage orderParametersArrayMap = _orderParametersArrayMap();
items = orderParametersArrayMap[defaultName];
+
+ if (items.length == 0) {
+ revert("Empty OrderParameters array selected.");
+ }
}
/**
- * @notice saves an OrderParameters as a named default
+ * @dev Saves an OrderParameters as a named default.
+ *
* @param orderParameters the OrderParameters to save as a default
- * @param defaultName the name of the default for retrieval
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orderParameters the OrderParameters that was saved
*/
function saveDefault(
OrderParameters memory orderParameters,
@@ -124,6 +189,14 @@ library OrderParametersLib {
return orderParameters;
}
+ /**
+ * @dev Saves an OrderParameters array as a named default.
+ *
+ * @param orderParameters the OrderParameters array to save as a default
+ * @param defaultName the name of the default for retrieval
+ *
+ * @return _orderParameters the OrderParameters array that was saved
+ */
function saveDefaultMany(
OrderParameters[] memory orderParameters,
string memory defaultName
@@ -138,8 +211,11 @@ library OrderParametersLib {
}
/**
- * @notice makes a copy of an OrderParameters in-memory
+ * @dev Makes a copy of an OrderParameters in-memory.
+ *
* @param item the OrderParameters to make a copy of in-memory
+ *
+ * @custom:return copiedOrderParameters the copied OrderParameters
*/
function copy(
OrderParameters memory item
@@ -162,7 +238,10 @@ library OrderParametersLib {
}
/**
- * @notice gets the storage position of the default OrderParameters map
+ * @dev Gets the storage position of the default OrderParameters map.
+ *
+ * @custom:return position the storage position of the default
+ * OrderParameters map
*/
function _orderParametersMap()
private
@@ -175,6 +254,12 @@ library OrderParametersLib {
}
}
+ /**
+ * @dev Gets the storage position of the default OrderParameters array map.
+ *
+ * @custom:return position the storage position of the default
+ * OrderParameters array map
+ */
function _orderParametersArrayMap()
private
pure
@@ -188,9 +273,17 @@ library OrderParametersLib {
}
}
- // methods for configuring a single of each of an in-memory OrderParameters's fields, which modifies the
- // OrderParameters in-memory and returns it
+ // Methods for configuring a single of each of a OrderParameters's fields,
+ // which modify the OrderParameters struct in-place and return it.
+ /**
+ * @dev Sets the offerer field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param offerer the new value for the offerer field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withOfferer(
OrderParameters memory parameters,
address offerer
@@ -199,6 +292,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the zone field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param zone the new value for the zone field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withZone(
OrderParameters memory parameters,
address zone
@@ -207,6 +308,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the offer field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param offer the new value for the offer field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withOffer(
OrderParameters memory parameters,
OfferItem[] memory offer
@@ -215,6 +324,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the consideration field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param consideration the new value for the consideration field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withConsideration(
OrderParameters memory parameters,
ConsiderationItem[] memory consideration
@@ -223,6 +340,32 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the consideration field of a OrderParameters struct in-place
+ * and updates the totalOriginalConsiderationItems field accordingly.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param consideration the new value for the consideration field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
+ function withTotalConsideration(
+ OrderParameters memory parameters,
+ ConsiderationItem[] memory consideration
+ ) internal pure returns (OrderParameters memory) {
+ parameters.consideration = consideration;
+ parameters.totalOriginalConsiderationItems = consideration.length;
+ return parameters;
+ }
+
+ /**
+ * @dev Sets the orderType field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param orderType the new value for the orderType field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withOrderType(
OrderParameters memory parameters,
OrderType orderType
@@ -231,6 +374,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the startTime field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param startTime the new value for the startTime field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withStartTime(
OrderParameters memory parameters,
uint256 startTime
@@ -239,6 +390,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the endTime field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param endTime the new value for the endTime field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withEndTime(
OrderParameters memory parameters,
uint256 endTime
@@ -247,6 +406,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the zoneHash field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param zoneHash the new value for the zoneHash field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withZoneHash(
OrderParameters memory parameters,
bytes32 zoneHash
@@ -255,6 +422,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the salt field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param salt the new value for the salt field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withSalt(
OrderParameters memory parameters,
uint256 salt
@@ -263,6 +438,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the conduitKey field of a OrderParameters struct in-place.
+ *
+ * @param parameters the OrderParameters struct to modify
+ * @param conduitKey the new value for the conduitKey field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withConduitKey(
OrderParameters memory parameters,
bytes32 conduitKey
@@ -271,6 +454,18 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Sets the totalOriginalConsiderationItems field of a OrderParameters
+ * struct in-place.
+ *
+ * @param parameters the OrderParameters struct to
+ * modify
+ * @param totalOriginalConsiderationItems the new value for the
+ * totalOriginalConsiderationItems
+ * field
+ *
+ * @custom:return _parameters the modified OrderParameters struct
+ */
function withTotalOriginalConsiderationItems(
OrderParameters memory parameters,
uint256 totalOriginalConsiderationItems
@@ -280,6 +475,14 @@ library OrderParametersLib {
return parameters;
}
+ /**
+ * @dev Converts an OrderParameters struct into an OrderComponents struct.
+ *
+ * @param parameters the OrderParameters struct to convert
+ * @param counter the counter to use for the OrderComponents struct
+ *
+ * @return components the OrderComponents struct
+ */
function toOrderComponents(
OrderParameters memory parameters,
uint256 counter
@@ -296,4 +499,309 @@ library OrderParametersLib {
components.conduitKey = parameters.conduitKey;
components.counter = counter;
}
+
+ function isAvailable(
+ OrderParameters memory parameters
+ ) internal view returns (bool) {
+ return
+ block.timestamp >= parameters.startTime &&
+ block.timestamp < parameters.endTime;
+ }
+
+ function getSpentAndReceivedItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator,
+ uint256 orderIndex,
+ CriteriaResolver[] memory criteriaResolvers
+ )
+ internal
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ if (isAvailable(parameters)) {
+ spent = getSpentItems(parameters, numerator, denominator);
+ received = getReceivedItems(parameters, numerator, denominator);
+
+ applyCriteriaResolvers(
+ spent,
+ received,
+ orderIndex,
+ criteriaResolvers
+ );
+ }
+ }
+
+ function applyCriteriaResolvers(
+ SpentItem[] memory spentItems,
+ ReceivedItem[] memory receivedItems,
+ uint256 orderIndex,
+ CriteriaResolver[] memory criteriaResolvers
+ ) internal pure {
+ for (uint256 i = 0; i < criteriaResolvers.length; i++) {
+ CriteriaResolver memory resolver = criteriaResolvers[i];
+ if (resolver.orderIndex != orderIndex) {
+ continue;
+ }
+ if (resolver.side == Side.OFFER) {
+ SpentItem memory item = spentItems[resolver.index];
+ item.itemType = convertCriteriaItemType(item.itemType);
+ item.identifier = resolver.identifier;
+ } else {
+ ReceivedItem memory item = receivedItems[resolver.index];
+ item.itemType = convertCriteriaItemType(item.itemType);
+ item.identifier = resolver.identifier;
+ }
+ }
+ }
+
+ function convertCriteriaItemType(
+ ItemType itemType
+ ) internal pure returns (ItemType) {
+ if (itemType == ItemType.ERC721_WITH_CRITERIA) {
+ return ItemType.ERC721;
+ } else if (itemType == ItemType.ERC1155_WITH_CRITERIA) {
+ return ItemType.ERC1155;
+ } else {
+ revert(
+ "OrderParametersLib: amount deriver helper resolving non criteria item type"
+ );
+ }
+ }
+
+ function getSpentItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (SpentItem[] memory) {
+ return
+ getSpentItems(
+ parameters.offer,
+ parameters.startTime,
+ parameters.endTime,
+ numerator,
+ denominator
+ );
+ }
+
+ function getReceivedItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (ReceivedItem[] memory) {
+ return
+ getReceivedItems(
+ parameters.consideration,
+ parameters.startTime,
+ parameters.endTime,
+ numerator,
+ denominator
+ );
+ }
+
+ function getSpentItems(
+ OfferItem[] memory items,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (SpentItem[] memory) {
+ SpentItem[] memory spentItems = new SpentItem[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ spentItems[i] = getSpentItem(
+ items[i],
+ startTime,
+ endTime,
+ numerator,
+ denominator
+ );
+ }
+ return spentItems;
+ }
+
+ function getReceivedItems(
+ ConsiderationItem[] memory considerationItems,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ considerationItems.length
+ );
+ for (uint256 i = 0; i < considerationItems.length; i++) {
+ receivedItems[i] = getReceivedItem(
+ considerationItems[i],
+ startTime,
+ endTime,
+ numerator,
+ denominator
+ );
+ }
+ return receivedItems;
+ }
+
+ function getSpentItem(
+ OfferItem memory item,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (SpentItem memory spent) {
+ spent = SpentItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifierOrCriteria,
+ amount: _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ startAmount: item.startAmount,
+ endAmount: item.endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: false
+ })
+ });
+ }
+
+ function getReceivedItem(
+ ConsiderationItem memory considerationItem,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) internal view returns (ReceivedItem memory received) {
+ received = ReceivedItem({
+ itemType: considerationItem.itemType,
+ token: considerationItem.token,
+ identifier: considerationItem.identifierOrCriteria,
+ amount: _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ startAmount: considerationItem.startAmount,
+ endAmount: considerationItem.endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: true
+ }),
+ recipient: considerationItem.recipient
+ });
+ }
+
+ function _applyFraction(
+ uint256 startAmount,
+ uint256 endAmount,
+ uint256 numerator,
+ uint256 denominator,
+ uint256 startTime,
+ uint256 endTime,
+ bool roundUp
+ ) internal view returns (uint256 amount) {
+ // If start amount equals end amount, apply fraction to end amount.
+ if (startAmount == endAmount) {
+ // Apply fraction to end amount.
+ amount = _getFraction(numerator, denominator, endAmount);
+ } else {
+ // Otherwise, apply fraction to both and interpolated final amount.
+ amount = _locateCurrentAmount(
+ _getFraction(numerator, denominator, startAmount),
+ _getFraction(numerator, denominator, endAmount),
+ startTime,
+ endTime,
+ roundUp
+ );
+ }
+ }
+
+ function _getFraction(
+ uint256 numerator,
+ uint256 denominator,
+ uint256 value
+ ) internal pure returns (uint256 newValue) {
+ // Return value early in cases where the fraction resolves to 1.
+ if (numerator == denominator) {
+ return value;
+ }
+
+ bool failure = false;
+
+ // Ensure fraction can be applied to the value with no remainder. Note
+ // that the denominator cannot be zero.
+ assembly {
+ // Ensure new value contains no remainder via mulmod operator.
+ // Credit to @hrkrshnn + @axic for proposing this optimal solution.
+ if mulmod(value, numerator, denominator) {
+ failure := true
+ }
+ }
+
+ if (failure) {
+ revert("OrderParametersLib: bad fraction");
+ }
+
+ // Multiply the numerator by the value and ensure no overflow occurs.
+ uint256 valueTimesNumerator = value * numerator;
+
+ // Divide and check for remainder. Note that denominator cannot be zero.
+ assembly {
+ // Perform division without zero check.
+ newValue := div(valueTimesNumerator, denominator)
+ }
+ }
+
+ function _locateCurrentAmount(
+ uint256 startAmount,
+ uint256 endAmount,
+ uint256 startTime,
+ uint256 endTime,
+ bool roundUp
+ ) internal view returns (uint256 amount) {
+ // Only modify end amount if it doesn't already equal start amount.
+ if (startAmount != endAmount) {
+ // Declare variables to derive in the subsequent unchecked scope.
+ uint256 duration;
+ uint256 elapsed;
+ uint256 remaining;
+
+ // Skip underflow checks as startTime <= block.timestamp < endTime.
+ unchecked {
+ // Derive the duration for the order and place it on the stack.
+ duration = endTime - startTime;
+
+ // Derive time elapsed since the order started & place on stack.
+ elapsed = block.timestamp - startTime;
+
+ // Derive time remaining until order expires and place on stack.
+ remaining = duration - elapsed;
+ }
+
+ // Aggregate new amounts weighted by time with rounding factor.
+ uint256 totalBeforeDivision = ((startAmount * remaining) +
+ (endAmount * elapsed));
+
+ // Use assembly to combine operations and skip divide-by-zero check.
+ assembly {
+ // Multiply by iszero(iszero(totalBeforeDivision)) to ensure
+ // amount is set to zero if totalBeforeDivision is zero,
+ // as intermediate overflow can occur if it is zero.
+ amount := mul(
+ iszero(iszero(totalBeforeDivision)),
+ // Subtract 1 from the numerator and add 1 to the result if
+ // roundUp is true to get the proper rounding direction.
+ // Division is performed with no zero check as duration
+ // cannot be zero as long as startTime < endTime.
+ add(
+ div(sub(totalBeforeDivision, roundUp), duration),
+ roundUp
+ )
+ )
+ }
+
+ // Return the current amount.
+ return amount;
+ }
+
+ // Return the original amount as startAmount == endAmount.
+ return endAmount;
+ }
}
diff --git a/contracts/helpers/sol/lib/ReceivedItemLib.sol b/contracts/helpers/sol/lib/ReceivedItemLib.sol
index 49dee2fe3..ce7c72d3d 100644
--- a/contracts/helpers/sol/lib/ReceivedItemLib.sol
+++ b/contracts/helpers/sol/lib/ReceivedItemLib.sol
@@ -2,20 +2,42 @@
pragma solidity ^0.8.17;
import {
- ReceivedItem,
- ConsiderationItem
+ ConsiderationItem,
+ ReceivedItem
} from "../../../lib/ConsiderationStructs.sol";
+
import { ItemType } from "../../../lib/ConsiderationEnums.sol";
+
import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title ReceivedItemLib
+ * @author James Wenzel (emo.eth)
+ * @notice ReceivedItemLib is a library for managing ReceivedItem structs and
+ * arrays. It allows chaining of functions to make struct creation more
+ * readable.
+ */
library ReceivedItemLib {
bytes32 private constant RECEIVED_ITEM_MAP_POSITION =
keccak256("seaport.ReceivedItemDefaults");
bytes32 private constant RECEIVED_ITEMS_MAP_POSITION =
keccak256("seaport.ReceivedItemsDefaults");
+ bytes32 private constant EMPTY_RECEIVED_ITEM =
+ keccak256(
+ abi.encode(
+ ReceivedItem({
+ itemType: ItemType(0),
+ token: address(0),
+ identifier: 0,
+ amount: 0,
+ recipient: payable(address(0))
+ })
+ )
+ );
/**
- * @notice clears a default ReceivedItem from storage
+ * @dev Clears a default ReceivedItem from storage.
+ *
* @param defaultName the name of the default to clear
*/
function clear(string memory defaultName) internal {
@@ -25,6 +47,11 @@ library ReceivedItemLib {
clear(item);
}
+ /**
+ * @dev Clears all fields on a ReceivedItem.
+ *
+ * @param item the ReceivedItem to clear
+ */
function clear(ReceivedItem storage item) internal {
// clear all fields
item.itemType = ItemType.NATIVE;
@@ -34,6 +61,11 @@ library ReceivedItemLib {
item.recipient = payable(address(0));
}
+ /**
+ * @dev Clears an array of ReceivedItems from storage.
+ *
+ * @param defaultsName the name of the default to clear
+ */
function clearMany(string memory defaultsName) internal {
mapping(string => ReceivedItem[])
storage receivedItemsMap = _receivedItemsMap();
@@ -41,6 +73,11 @@ library ReceivedItemLib {
clearMany(items);
}
+ /**
+ * @dev Clears an array of ReceivedItems from storage.
+ *
+ * @param items the ReceivedItems to clear
+ */
function clearMany(ReceivedItem[] storage items) internal {
while (items.length > 0) {
clear(items[items.length - 1]);
@@ -48,6 +85,11 @@ library ReceivedItemLib {
}
}
+ /**
+ * @dev Creates an empty ReceivedItem.
+ *
+ * @return the empty ReceivedItem
+ */
function empty() internal pure returns (ReceivedItem memory) {
return
ReceivedItem({
@@ -60,8 +102,11 @@ library ReceivedItemLib {
}
/**
- * @notice gets a default ReceivedItem from storage
+ * @dev Gets a default ReceivedItem from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the default ReceivedItem
*/
function fromDefault(
string memory defaultName
@@ -69,20 +114,38 @@ library ReceivedItemLib {
mapping(string => ReceivedItem)
storage receivedItemMap = _receivedItemMap();
item = receivedItemMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_RECEIVED_ITEM) {
+ revert("Empty ReceivedItem selected.");
+ }
}
+ /**
+ * @dev Gets a default ReceivedItem from storage.
+ *
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return items the default ReceivedItem
+ */
function fromDefaultMany(
string memory defaultsName
) internal view returns (ReceivedItem[] memory items) {
mapping(string => ReceivedItem[])
storage receivedItemsMap = _receivedItemsMap();
items = receivedItemsMap[defaultsName];
+
+ if (items.length == 0) {
+ revert("Empty ReceivedItem array selected.");
+ }
}
/**
- * @notice saves an ReceivedItem as a named default
+ * @dev Saves an ReceivedItem as a named default.
+ *
* @param receivedItem the ReceivedItem to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _receivedItem the saved ReceivedItem
*/
function saveDefault(
ReceivedItem memory receivedItem,
@@ -94,6 +157,14 @@ library ReceivedItemLib {
return receivedItem;
}
+ /**
+ * @dev Saves an ReceivedItem as a named default.
+ *
+ * @param receivedItems the ReceivedItem to save as a default
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return _receivedItems the saved ReceivedItem
+ */
function saveDefaultMany(
ReceivedItem[] memory receivedItems,
string memory defaultsName
@@ -105,6 +176,14 @@ library ReceivedItemLib {
return receivedItems;
}
+ /**
+ * @dev Sets an array of in-memory ReceivedItems to an array of
+ * ReceivedItems in storage.
+ *
+ * @param items the ReceivedItems array in storage to push to
+ * @param newItems the ReceivedItems array in memory to push onto the items
+ * array
+ */
function setReceivedItems(
ReceivedItem[] storage items,
ReceivedItem[] memory newItems
@@ -116,8 +195,11 @@ library ReceivedItemLib {
}
/**
- * @notice makes a copy of an ReceivedItem in-memory
+ * @dev Makes a copy of an ReceivedItem in-memory.
+ *
* @param item the ReceivedItem to make a copy of in-memory
+ *
+ * @custom:return copiedReceivedItem the copied ReceivedItem
*/
function copy(
ReceivedItem memory item
@@ -132,6 +214,13 @@ library ReceivedItemLib {
});
}
+ /**
+ * @dev Makes a copy of an array of ReceivedItems in-memory.
+ *
+ * @param item the ReceivedItems array to make a copy of in-memory
+ *
+ * @custom:return copiedReceivedItems the copied ReceivedItems
+ */
function copy(
ReceivedItem[] memory item
) internal pure returns (ReceivedItem[] memory) {
@@ -143,7 +232,10 @@ library ReceivedItemLib {
}
/**
- * @notice gets the storage position of the default ReceivedItem map
+ * @dev Gets the storage position of the default ReceivedItem map.
+ *
+ * @custom:return receivedItemMap the storage position of the default
+ * ReceivedItem map
*/
function _receivedItemMap()
private
@@ -157,7 +249,10 @@ library ReceivedItemLib {
}
/**
- * @notice gets the storage position of the default ReceivedItem map
+ * @dev Gets the storage position of the default ReceivedItem array map.
+ *
+ * @custom:return receivedItemsMap the storage position of the default
+ * ReceivedItem array map
*/
function _receivedItemsMap()
private
@@ -170,15 +265,16 @@ library ReceivedItemLib {
}
}
- // methods for configuring a single of each of an ReceivedItem's fields, which modifies the ReceivedItem
- // in-place and
- // returns it
+ // Methods for configuring a single of each of a ReceivedItem's fields,
+ // which modify the ReceivedItem struct in-place and return it.
/**
- * @notice sets the item type
- * @param item the ReceivedItem to modify
- * @param itemType the item type to set
- * @return the modified ReceivedItem
+ * @dev Sets the itemType field of an ReceivedItem.
+ *
+ * @param item the ReceivedItem to set the itemType field of
+ * @param itemType the itemType to set the itemType field to
+ *
+ * @custom:return item the ReceivedItem with the itemType field set
*/
function withItemType(
ReceivedItem memory item,
@@ -189,10 +285,12 @@ library ReceivedItemLib {
}
/**
- * @notice sets the token address
- * @param item the ReceivedItem to modify
- * @param token the token address to set
- * @return the modified ReceivedItem
+ * @dev Sets the token field of an ReceivedItem.
+ *
+ * @param item the ReceivedItem to set the token field of
+ * @param token the token to set the token field to
+ *
+ * @custom:return item the ReceivedItem with the token field set
*/
function withToken(
ReceivedItem memory item,
@@ -203,10 +301,12 @@ library ReceivedItemLib {
}
/**
- * @notice sets the identifier or criteria
- * @param item the ReceivedItem to modify
- * @param identifier the identifier or criteria to set
- * @return the modified ReceivedItem
+ * @dev Sets the identifier field of an ReceivedItem.
+ *
+ * @param item the ReceivedItem to set the identifier field of
+ * @param identifier the identifier to set the identifier field to
+ *
+ * @custom:return item the ReceivedItem with the identifier field set
*/
function withIdentifier(
ReceivedItem memory item,
@@ -217,10 +317,12 @@ library ReceivedItemLib {
}
/**
- * @notice sets the start amount
- * @param item the ReceivedItem to modify
- * @param amount the start amount to set
- * @return the modified ReceivedItem
+ * @dev Sets the amount field of an ReceivedItem.
+ *
+ * @param item the ReceivedItem to set the amount field of
+ * @param amount the amount to set the amount field to
+ *
+ * @custom:return item the ReceivedItem with the amount field set
*/
function withAmount(
ReceivedItem memory item,
@@ -231,10 +333,12 @@ library ReceivedItemLib {
}
/**
- * @notice sets the recipient
- * @param item the ReceivedItem to modify
- * @param recipient the recipient to set
- * @return the modified ReceivedItem
+ * @dev Sets the recipient field of an ReceivedItem.
+ *
+ * @param item the ReceivedItem to set the recipient field of
+ * @param recipient the recipient to set the recipient field to
+ *
+ * @custom:return item the ReceivedItem with the recipient field set
*/
function withRecipient(
ReceivedItem memory item,
@@ -244,6 +348,13 @@ library ReceivedItemLib {
return item;
}
+ /**
+ * @dev Converts an ReceivedItem to a ConsiderationItem.
+ *
+ * @param item the ReceivedItem to convert to a ConsiderationItem
+ *
+ * @custom:return considerationItem the converted ConsiderationItem
+ */
function toConsiderationItem(
ReceivedItem memory item
) internal pure returns (ConsiderationItem memory) {
diff --git a/contracts/helpers/sol/lib/SeaportArrays.sol b/contracts/helpers/sol/lib/SeaportArrays.sol
index 40685a808..7372b2487 100644
--- a/contracts/helpers/sol/lib/SeaportArrays.sol
+++ b/contracts/helpers/sol/lib/SeaportArrays.sol
@@ -2,19 +2,19 @@
pragma solidity ^0.8.17;
import {
- OrderComponents,
- OfferItem,
- ConsiderationItem,
- SpentItem,
- ReceivedItem,
- BasicOrderParameters,
AdditionalRecipient,
- OrderParameters,
- Order,
AdvancedOrder,
+ BasicOrderParameters,
+ ConsiderationItem,
CriteriaResolver,
Fulfillment,
- FulfillmentComponent
+ FulfillmentComponent,
+ OfferItem,
+ Order,
+ OrderComponents,
+ OrderParameters,
+ ReceivedItem,
+ SpentItem
} from "../../../lib/ConsiderationStructs.sol";
library SeaportArrays {
diff --git a/contracts/helpers/sol/lib/SeaportEnumsLib.sol b/contracts/helpers/sol/lib/SeaportEnumsLib.sol
index da3159957..d53216640 100644
--- a/contracts/helpers/sol/lib/SeaportEnumsLib.sol
+++ b/contracts/helpers/sol/lib/SeaportEnumsLib.sol
@@ -2,17 +2,26 @@
pragma solidity ^0.8.17;
import {
- BasicOrderParameters,
- OrderParameters
-} from "../../../lib/ConsiderationStructs.sol";
-import {
- OrderType,
BasicOrderType,
ItemType,
- BasicOrderRouteType
+ OrderType
} from "../../../lib/ConsiderationEnums.sol";
library SeaportEnumsLib {
+ /**
+ * @dev Parses a BasicOrderType into its constituent parts.
+ *
+ * @param basicOrderType the BasicOrderType to parse
+ *
+ * @return orderType the OrderType
+ * @return offerType the ItemType of the offer
+ * @return considerationType the ItemType of the
+ * consideration
+ * @return additionalRecipientsType the ItemType of the
+ * additional recipients
+ * @return offerTypeIsAdditionalRecipientsType whether the offer type is the
+ * additional recipients type
+ */
function parseBasicOrderType(
BasicOrderType basicOrderType
)
diff --git a/contracts/helpers/sol/lib/SeaportStructLib.sol b/contracts/helpers/sol/lib/SeaportStructLib.sol
index fca841117..08cef330f 100644
--- a/contracts/helpers/sol/lib/SeaportStructLib.sol
+++ b/contracts/helpers/sol/lib/SeaportStructLib.sol
@@ -15,6 +15,7 @@ import { OrderComponentsLib } from "./OrderComponentsLib.sol";
import { OrderLib } from "./OrderLib.sol";
import { OrderParametersLib } from "./OrderParametersLib.sol";
import { ReceivedItemLib } from "./ReceivedItemLib.sol";
+import { SeaportArrays } from "./SeaportArrays.sol";
import { SpentItemLib } from "./SpentItemLib.sol";
import { StructCopier } from "./StructCopier.sol";
-import { SeaportArrays } from "./SeaportArrays.sol";
+import { ZoneParametersLib } from "./ZoneParametersLib.sol";
diff --git a/contracts/helpers/sol/lib/SpentItemLib.sol b/contracts/helpers/sol/lib/SpentItemLib.sol
index 3aa2f2da1..417d996ad 100644
--- a/contracts/helpers/sol/lib/SpentItemLib.sol
+++ b/contracts/helpers/sol/lib/SpentItemLib.sol
@@ -1,20 +1,48 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
-import { SpentItem, OfferItem } from "../../../lib/ConsiderationStructs.sol";
+import { OfferItem, SpentItem } from "../../../lib/ConsiderationStructs.sol";
+
import { ItemType } from "../../../lib/ConsiderationEnums.sol";
-import { StructCopier } from "./StructCopier.sol";
+/**
+ * @title SpentItemLib
+ * @author James Wenzel (emo.eth)
+ * @notice SpentItemLib is a library for managing SpentItem structs and arrays.
+ * It allows chaining of functions to make struct creation more
+ * readable.
+ */
library SpentItemLib {
bytes32 private constant SPENT_ITEM_MAP_POSITION =
keccak256("seaport.SpentItemDefaults");
bytes32 private constant SPENT_ITEMS_MAP_POSITION =
keccak256("seaport.SpentItemsDefaults");
+ bytes32 private constant EMPTY_SPENT_ITEM =
+ keccak256(
+ abi.encode(
+ SpentItem({
+ itemType: ItemType(0),
+ token: address(0),
+ identifier: 0,
+ amount: 0
+ })
+ )
+ );
+ /**
+ * @dev Creates an empty SpentItem.
+ *
+ * @return the empty SpentItem
+ */
function empty() internal pure returns (SpentItem memory) {
return SpentItem(ItemType(0), address(0), 0, 0);
}
+ /**
+ * @dev Clears an SpentItem from storage.
+ *
+ * @param item the item to clear
+ */
function clear(SpentItem storage item) internal {
// clear all fields
item.itemType = ItemType(0);
@@ -23,6 +51,11 @@ library SpentItemLib {
item.amount = 0;
}
+ /**
+ * @dev Clears an array of SpentItems from storage.
+ *
+ * @param items the items to clear
+ */
function clearMany(SpentItem[] storage items) internal {
while (items.length > 0) {
clear(items[items.length - 1]);
@@ -31,16 +64,21 @@ library SpentItemLib {
}
/**
- * @notice clears a default SpentItem from storage
+ * @dev Clears a default SpentItem from storage.
+ *
* @param defaultName the name of the default to clear
*/
-
function clear(string memory defaultName) internal {
mapping(string => SpentItem) storage spentItemMap = _spentItemMap();
SpentItem storage item = spentItemMap[defaultName];
clear(item);
}
+ /**
+ * @dev Clears an array of default SpentItems from storage.
+ *
+ * @param defaultsName the name of the default to clear
+ */
function clearMany(string memory defaultsName) internal {
mapping(string => SpentItem[]) storage spentItemsMap = _spentItemsMap();
SpentItem[] storage items = spentItemsMap[defaultsName];
@@ -48,27 +86,48 @@ library SpentItemLib {
}
/**
- * @notice gets a default SpentItem from storage
+ * @dev Gets a default SpentItem from storage.
+ *
* @param defaultName the name of the default for retrieval
+ *
+ * @return item the SpentItem
*/
function fromDefault(
string memory defaultName
) internal view returns (SpentItem memory item) {
mapping(string => SpentItem) storage spentItemMap = _spentItemMap();
item = spentItemMap[defaultName];
+
+ if (keccak256(abi.encode(item)) == EMPTY_SPENT_ITEM) {
+ revert("Empty SpentItem selected.");
+ }
}
+ /**
+ * @dev Gets an array of default SpentItems from storage.
+ *
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return items the SpentItems
+ */
function fromDefaultMany(
string memory defaultsName
) internal view returns (SpentItem[] memory items) {
mapping(string => SpentItem[]) storage spentItemsMap = _spentItemsMap();
items = spentItemsMap[defaultsName];
+
+ if (items.length == 0) {
+ revert("Empty SpentItem array selected.");
+ }
}
/**
- * @notice saves an SpentItem as a named default
+ * @dev Saves an SpentItem as a named default.
+ *
* @param spentItem the SpentItem to save as a default
* @param defaultName the name of the default for retrieval
+ *
+ * @return _spentItem the saved SpentItem
*/
function saveDefault(
SpentItem memory spentItem,
@@ -79,6 +138,14 @@ library SpentItemLib {
return spentItem;
}
+ /**
+ * @dev Saves an array of SpentItems as a named default.
+ *
+ * @param spentItems the SpentItems to save as a default
+ * @param defaultsName the name of the default for retrieval
+ *
+ * @return _spentItems the saved SpentItems
+ */
function saveDefaultMany(
SpentItem[] memory spentItems,
string memory defaultsName
@@ -89,6 +156,14 @@ library SpentItemLib {
return spentItems;
}
+ /**
+ * @dev Sets an array of in-memory SpentItems to an array of SpentItems in
+ * storage.
+ *
+ * @param items the SpentItem array in storage to push to
+ * @param newItems the SpentItem array in memory to push onto the items
+ * array
+ */
function setSpentItems(
SpentItem[] storage items,
SpentItem[] memory newItems
@@ -100,8 +175,11 @@ library SpentItemLib {
}
/**
- * @notice makes a copy of an SpentItem in-memory
+ * @dev Makes a copy of an SpentItem in-memory.
+ *
* @param item the SpentItem to make a copy of in-memory
+ *
+ * @custom:return copiedItem the copied SpentItem
*/
function copy(
SpentItem memory item
@@ -115,6 +193,13 @@ library SpentItemLib {
});
}
+ /**
+ * @dev Makes a copy of an array of SpentItems in-memory.
+ *
+ * @param items the SpentItems to make a copy of in-memory
+ *
+ * @custom:return copiedItems the copied SpentItems
+ */
function copy(
SpentItem[] memory items
) internal pure returns (SpentItem[] memory) {
@@ -126,7 +211,9 @@ library SpentItemLib {
}
/**
- * @notice gets the storage position of the default SpentItem map
+ * @dev Gets the storage position of the default SpentItem map.
+ *
+ * @custom:return position the storage position of the default SpentItem map
*/
function _spentItemMap()
private
@@ -139,6 +226,12 @@ library SpentItemLib {
}
}
+ /**
+ * @dev Gets the storage position of the default SpentItem array map.
+ *
+ * @custom:return position the storage position of the default SpentItem
+ * array map
+ */
function _spentItemsMap()
private
pure
@@ -150,14 +243,16 @@ library SpentItemLib {
}
}
- // methods for configuring a single of each of an SpentItem's fields, which modifies the SpentItem in-place and
- // returns it
+ // Methods for configuring a single of each of a SpentItem's fields, which
+ // modify the SpentItem struct in-place and return it.
/**
- * @notice sets the item type
- * @param item the SpentItem to modify
- * @param itemType the item type to set
- * @return the modified SpentItem
+ * @dev Sets the itemType field of a SpentItem.
+ *
+ * @param item the SpentItem to set the itemType field of
+ * @param itemType the itemType to set the itemType field to
+ *
+ * @custom:return item the SpentItem with the itemType field set
*/
function withItemType(
SpentItem memory item,
@@ -168,10 +263,12 @@ library SpentItemLib {
}
/**
- * @notice sets the token address
- * @param item the SpentItem to modify
- * @param token the token address to set
- * @return the modified SpentItem
+ * @dev Sets the token field of a SpentItem.
+ *
+ * @param item the SpentItem to set the token field of
+ * @param token the token to set the token field to
+ *
+ * @custom:return item the SpentItem with the token field set
*/
function withToken(
SpentItem memory item,
@@ -182,10 +279,12 @@ library SpentItemLib {
}
/**
- * @notice sets the identifier or criteria
- * @param item the SpentItem to modify
- * @param identifier the identifier or criteria to set
- * @return the modified SpentItem
+ * @dev Sets the identifier field of a SpentItem.
+ *
+ * @param item the SpentItem to set the identifier field of
+ * @param identifier the identifier to set the identifier field to
+ *
+ * @custom:return item the SpentItem with the identifier field set
*/
function withIdentifier(
SpentItem memory item,
@@ -196,10 +295,12 @@ library SpentItemLib {
}
/**
- * @notice sets the start amount
- * @param item the SpentItem to modify
- * @param amount the start amount to set
- * @return the modified SpentItem
+ * @dev Sets the amount field of a SpentItem.
+ *
+ * @param item the SpentItem to set the amount field of
+ * @param amount the amount to set the amount field to
+ *
+ * @custom:return item the SpentItem with the amount field set
*/
function withAmount(
SpentItem memory item,
@@ -209,6 +310,13 @@ library SpentItemLib {
return item;
}
+ /**
+ * @dev Converts a SpentItem to an OfferItem.
+ *
+ * @param item the SpentItem to convert to an OfferItem
+ *
+ * @custom:return offerItem the converted OfferItem
+ */
function toOfferItem(
SpentItem memory item
) internal pure returns (OfferItem memory) {
diff --git a/contracts/helpers/sol/lib/StructCopier.sol b/contracts/helpers/sol/lib/StructCopier.sol
index 36436af05..55bd466da 100644
--- a/contracts/helpers/sol/lib/StructCopier.sol
+++ b/contracts/helpers/sol/lib/StructCopier.sol
@@ -2,22 +2,20 @@
pragma solidity ^0.8.13;
import {
- BasicOrderParameters,
- CriteriaResolver,
- AdvancedOrder,
AdditionalRecipient,
- OfferItem,
- Order,
+ AdvancedOrder,
+ BasicOrderParameters,
ConsiderationItem,
+ CriteriaResolver,
+ Execution,
Fulfillment,
FulfillmentComponent,
- OrderParameters,
+ OfferItem,
+ Order,
OrderComponents,
- Execution
+ OrderParameters
} from "../../../lib/ConsiderationStructs.sol";
-import {
- ConsiderationInterface
-} from "../../../interfaces/ConsiderationInterface.sol";
+
import { ArrayLib } from "./ArrayLib.sol";
library StructCopier {
diff --git a/contracts/helpers/sol/lib/ZoneParametersLib.sol b/contracts/helpers/sol/lib/ZoneParametersLib.sol
new file mode 100644
index 000000000..09e88fb08
--- /dev/null
+++ b/contracts/helpers/sol/lib/ZoneParametersLib.sol
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ItemType, Side, OrderType } from "../../../lib/ConsiderationEnums.sol";
+
+import {
+ AdvancedOrder,
+ ConsiderationItem,
+ CriteriaResolver,
+ OfferItem,
+ Order,
+ OrderComponents,
+ OrderParameters,
+ SpentItem,
+ ReceivedItem,
+ ZoneParameters,
+ CriteriaResolver
+} from "../../../lib/ConsiderationStructs.sol";
+
+import { SeaportInterface } from "../SeaportInterface.sol";
+
+import { GettersAndDerivers } from "../../../lib/GettersAndDerivers.sol";
+
+import { UnavailableReason } from "../SpaceEnums.sol";
+
+import { AdvancedOrderLib } from "./AdvancedOrderLib.sol";
+
+import { ConsiderationItemLib } from "./ConsiderationItemLib.sol";
+
+import { OfferItemLib } from "./OfferItemLib.sol";
+
+import { ReceivedItemLib } from "./ReceivedItemLib.sol";
+
+import { OrderParametersLib } from "./OrderParametersLib.sol";
+
+import { StructCopier } from "./StructCopier.sol";
+
+import { AmountDeriverHelper } from "./fulfillment/AmountDeriverHelper.sol";
+
+import { OrderDetails } from "../fulfillments/lib/Structs.sol";
+
+interface FailingContractOfferer {
+ function failureReasons(bytes32) external view returns (uint256);
+}
+
+library ZoneParametersLib {
+ using AdvancedOrderLib for AdvancedOrder;
+ using AdvancedOrderLib for AdvancedOrder[];
+ using OfferItemLib for OfferItem;
+ using OfferItemLib for OfferItem[];
+ using ConsiderationItemLib for ConsiderationItem;
+ using ConsiderationItemLib for ConsiderationItem[];
+ using OrderParametersLib for OrderParameters;
+
+ struct ZoneParametersStruct {
+ AdvancedOrder[] advancedOrders;
+ address fulfiller;
+ uint256 maximumFulfilled;
+ address seaport;
+ CriteriaResolver[] criteriaResolvers;
+ }
+
+ struct ZoneDetails {
+ AdvancedOrder[] advancedOrders;
+ address fulfiller;
+ uint256 maximumFulfilled;
+ OrderDetails[] orderDetails;
+ bytes32[] orderHashes;
+ }
+
+ function getZoneParameters(
+ AdvancedOrder memory advancedOrder,
+ address fulfiller,
+ uint256 counter,
+ address seaport,
+ CriteriaResolver[] memory criteriaResolvers
+ ) internal view returns (ZoneParameters memory zoneParameters) {
+ SeaportInterface seaportInterface = SeaportInterface(seaport);
+ // Get orderParameters from advancedOrder
+ OrderParameters memory orderParameters = advancedOrder.parameters;
+
+ // Get orderHash
+ bytes32 orderHash = advancedOrder.getTipNeutralizedOrderHash(
+ seaportInterface,
+ counter
+ );
+
+ (
+ SpentItem[] memory spentItems,
+ ReceivedItem[] memory receivedItems
+ ) = orderParameters.getSpentAndReceivedItems(
+ advancedOrder.numerator,
+ advancedOrder.denominator,
+ 0,
+ criteriaResolvers
+ );
+
+ // Store orderHash in orderHashes array to pass into zoneParameters
+ bytes32[] memory orderHashes = new bytes32[](1);
+ orderHashes[0] = orderHash;
+
+ // Create ZoneParameters and add to zoneParameters array
+ zoneParameters = ZoneParameters({
+ orderHash: orderHash,
+ fulfiller: fulfiller,
+ offerer: orderParameters.offerer,
+ offer: spentItems,
+ consideration: receivedItems,
+ extraData: advancedOrder.extraData,
+ orderHashes: orderHashes,
+ startTime: orderParameters.startTime,
+ endTime: orderParameters.endTime,
+ zoneHash: orderParameters.zoneHash
+ });
+ }
+
+ function getZoneParameters(
+ AdvancedOrder[] memory advancedOrders,
+ address fulfiller,
+ uint256 maximumFulfilled,
+ address seaport,
+ CriteriaResolver[] memory criteriaResolvers,
+ UnavailableReason[] memory unavailableReasons
+ ) internal view returns (ZoneParameters[] memory) {
+ return
+ _getZoneParametersFromStruct(
+ _getZoneParametersStruct(
+ advancedOrders,
+ fulfiller,
+ maximumFulfilled,
+ seaport,
+ criteriaResolvers
+ ), unavailableReasons
+ );
+ }
+
+ function _getZoneParametersStruct(
+ AdvancedOrder[] memory advancedOrders,
+ address fulfiller,
+ uint256 maximumFulfilled,
+ address seaport,
+ CriteriaResolver[] memory criteriaResolvers
+ ) internal pure returns (ZoneParametersStruct memory) {
+ return
+ ZoneParametersStruct(
+ advancedOrders,
+ fulfiller,
+ maximumFulfilled,
+ seaport,
+ criteriaResolvers
+ );
+ }
+
+ function _getZoneParametersFromStruct(
+ ZoneParametersStruct memory zoneParametersStruct,
+ UnavailableReason[] memory unavailableReasons
+ ) internal view returns (ZoneParameters[] memory) {
+ // TODO: use testHelpers pattern to use single amount deriver helper
+ ZoneDetails memory details = _getZoneDetails(zoneParametersStruct);
+
+ // Convert offer + consideration to spent + received
+ _applyOrderDetails(details, zoneParametersStruct, unavailableReasons);
+
+ // Iterate over advanced orders to calculate orderHashes
+ _applyOrderHashes(details, zoneParametersStruct.seaport);
+
+ return _finalizeZoneParameters(details);
+ }
+
+ function _getZoneDetails(
+ ZoneParametersStruct memory zoneParametersStruct
+ ) internal pure returns (ZoneDetails memory) {
+ return
+ ZoneDetails({
+ advancedOrders: zoneParametersStruct.advancedOrders,
+ fulfiller: zoneParametersStruct.fulfiller,
+ maximumFulfilled: zoneParametersStruct.maximumFulfilled,
+ orderDetails: new OrderDetails[](
+ zoneParametersStruct.advancedOrders.length
+ ),
+ orderHashes: new bytes32[](
+ zoneParametersStruct.advancedOrders.length
+ )
+ });
+ }
+
+ function _applyOrderDetails(
+ ZoneDetails memory details,
+ ZoneParametersStruct memory zoneParametersStruct,
+ UnavailableReason[] memory unavailableReasons
+ ) internal view {
+ bytes32[] memory orderHashes = details.advancedOrders.getOrderHashes(
+ zoneParametersStruct.seaport
+ );
+
+ details.orderDetails = zoneParametersStruct
+ .advancedOrders
+ .getOrderDetails(
+ zoneParametersStruct.criteriaResolvers,
+ orderHashes,
+ unavailableReasons
+ );
+ }
+
+ function _applyOrderHashes(
+ ZoneDetails memory details,
+ address seaport
+ ) internal view {
+ bytes32[] memory orderHashes = details.advancedOrders.getOrderHashes(
+ seaport
+ );
+
+ uint256 totalFulfilled = 0;
+ // Iterate over advanced orders to calculate orderHashes
+ for (uint256 i = 0; i < details.advancedOrders.length; i++) {
+ bytes32 orderHash = orderHashes[i];
+
+ if (
+ totalFulfilled >= details.maximumFulfilled ||
+ _isUnavailable(
+ details.advancedOrders[i].parameters,
+ orderHash,
+ SeaportInterface(seaport)
+ )
+ ) {
+ // Set orderHash to 0 if order index exceeds maximumFulfilled
+ details.orderHashes[i] = bytes32(0);
+ } else {
+ // Add orderHash to orderHashes and increment totalFulfilled/
+ details.orderHashes[i] = orderHash;
+ ++totalFulfilled;
+ }
+ }
+ }
+
+ function _isUnavailable(
+ OrderParameters memory order,
+ bytes32 orderHash,
+ SeaportInterface seaport
+ ) internal view returns (bool) {
+ (, bool isCancelled, uint256 totalFilled, uint256 totalSize) = seaport
+ .getOrderStatus(orderHash);
+
+ bool isRevertingContractOrder = false;
+ if (order.orderType == OrderType.CONTRACT) {
+ isRevertingContractOrder =
+ FailingContractOfferer(order.offerer).failureReasons(
+ orderHash
+ ) !=
+ 0;
+ }
+
+ return (block.timestamp >= order.endTime ||
+ block.timestamp < order.startTime ||
+ isCancelled ||
+ isRevertingContractOrder ||
+ (totalFilled >= totalSize && totalSize > 0));
+ }
+
+ function _finalizeZoneParameters(
+ ZoneDetails memory zoneDetails
+ ) internal pure returns (ZoneParameters[] memory zoneParameters) {
+ zoneParameters = new ZoneParameters[](
+ zoneDetails.advancedOrders.length
+ );
+
+ // Iterate through advanced orders to create zoneParameters
+ uint256 totalFulfilled = 0;
+
+ for (uint i = 0; i < zoneDetails.advancedOrders.length; i++) {
+ if (totalFulfilled >= zoneDetails.maximumFulfilled) {
+ break;
+ }
+
+ if (zoneDetails.orderHashes[i] != bytes32(0)) {
+ // Create ZoneParameters and add to zoneParameters array
+ zoneParameters[i] = _createZoneParameters(
+ zoneDetails.orderHashes[i],
+ zoneDetails.orderDetails[i],
+ zoneDetails.advancedOrders[i],
+ zoneDetails.fulfiller,
+ zoneDetails.orderHashes
+ );
+ ++totalFulfilled;
+ }
+ }
+
+ return zoneParameters;
+ }
+
+ function _createZoneParameters(
+ bytes32 orderHash,
+ OrderDetails memory orderDetails,
+ AdvancedOrder memory advancedOrder,
+ address fulfiller,
+ bytes32[] memory orderHashes
+ ) internal pure returns (ZoneParameters memory) {
+ return
+ ZoneParameters({
+ orderHash: orderHash,
+ fulfiller: fulfiller,
+ offerer: advancedOrder.parameters.offerer,
+ offer: orderDetails.offer,
+ consideration: orderDetails.consideration,
+ extraData: advancedOrder.extraData,
+ orderHashes: orderHashes,
+ startTime: advancedOrder.parameters.startTime,
+ endTime: advancedOrder.parameters.endTime,
+ zoneHash: advancedOrder.parameters.zoneHash
+ });
+ }
+}
diff --git a/contracts/helpers/sol/lib/fulfillment/AmountDeriverHelper.sol b/contracts/helpers/sol/lib/fulfillment/AmountDeriverHelper.sol
new file mode 100644
index 000000000..9c0287b2e
--- /dev/null
+++ b/contracts/helpers/sol/lib/fulfillment/AmountDeriverHelper.sol
@@ -0,0 +1,560 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { SeaportInterface } from "../../../../interfaces/SeaportInterface.sol";
+import { AmountDeriver } from "../../../../lib/AmountDeriver.sol";
+import {
+ AdvancedOrder,
+ ConsiderationItem,
+ CriteriaResolver,
+ OfferItem,
+ Order,
+ OrderComponents,
+ OrderParameters,
+ OrderType,
+ ReceivedItem,
+ SpentItem
+} from "../../../../lib/ConsiderationStructs.sol";
+import { Side, ItemType } from "../../../../lib/ConsiderationEnums.sol";
+import { OfferItemLib } from "../OfferItemLib.sol";
+import { ConsiderationItemLib } from "../ConsiderationItemLib.sol";
+import { OrderParametersLib } from "../OrderParametersLib.sol";
+import { OrderDetails } from "../../fulfillments/lib/Structs.sol";
+import { UnavailableReason } from "../../SpaceEnums.sol";
+
+/**
+ * @notice Note that this contract relies on current block.timestamp to determine amounts.
+ */
+contract AmountDeriverHelper is AmountDeriver {
+ using OfferItemLib for OfferItem[];
+ using ConsiderationItemLib for ConsiderationItem[];
+ using OrderParametersLib for OrderParameters;
+
+ struct ContractNonceDetails {
+ bool set;
+ address offerer;
+ uint256 currentNonce;
+ }
+
+ function getSpentAndReceivedItems(
+ Order calldata order
+ )
+ external
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ return getSpentAndReceivedItems(order.parameters);
+ }
+
+ function getSpentAndReceivedItems(
+ AdvancedOrder calldata order
+ )
+ external
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ CriteriaResolver[] memory resolvers;
+ return
+ getSpentAndReceivedItems(
+ order.parameters,
+ order.numerator,
+ order.denominator,
+ 0,
+ resolvers
+ );
+ }
+
+ function getSpentAndReceivedItems(
+ AdvancedOrder calldata order,
+ uint256 orderIndex,
+ CriteriaResolver[] calldata criteriaResolvers
+ )
+ external
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ return
+ getSpentAndReceivedItems(
+ order.parameters,
+ order.numerator,
+ order.denominator,
+ orderIndex,
+ criteriaResolvers
+ );
+ }
+
+ function getSpentAndReceivedItems(
+ OrderParameters calldata parameters
+ )
+ public
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ if (parameters.isAvailable()) {
+ spent = getSpentItems(parameters);
+ received = getReceivedItems(parameters);
+ }
+ }
+
+ function toOrderDetails(
+ OrderParameters memory order,
+ bytes32 orderHash,
+ UnavailableReason unavailableReason
+ ) internal view returns (OrderDetails memory) {
+ (SpentItem[] memory offer, ReceivedItem[] memory consideration) = this
+ .getSpentAndReceivedItems(order);
+ return
+ OrderDetails({
+ offerer: order.offerer,
+ conduitKey: order.conduitKey,
+ offer: offer,
+ consideration: consideration,
+ isContract: order.orderType == OrderType.CONTRACT,
+ orderHash: orderHash,
+ unavailableReason: unavailableReason
+ });
+ }
+
+ function toOrderDetails(
+ Order[] memory order,
+ bytes32[] memory orderHashes,
+ UnavailableReason[] memory unavailableReasons
+ ) public view returns (OrderDetails[] memory) {
+ OrderDetails[] memory orderDetails = new OrderDetails[](order.length);
+ for (uint256 i = 0; i < order.length; i++) {
+ orderDetails[i] = toOrderDetails(
+ order[i].parameters,
+ orderHashes[i],
+ unavailableReasons[i]
+ );
+ }
+ return orderDetails;
+ }
+
+ function toOrderDetails(
+ AdvancedOrder[] memory orders,
+ CriteriaResolver[] memory resolvers,
+ bytes32[] memory orderHashes,
+ UnavailableReason[] memory unavailableReasons
+ ) public view returns (OrderDetails[] memory) {
+ OrderDetails[] memory orderDetails = new OrderDetails[](orders.length);
+ for (uint256 i = 0; i < orders.length; i++) {
+ orderDetails[i] = toOrderDetails(
+ orders[i],
+ i,
+ resolvers,
+ orderHashes[i],
+ unavailableReasons[i]
+ );
+ }
+ return orderDetails;
+ }
+
+ function toOrderDetails(
+ AdvancedOrder memory order,
+ uint256 orderIndex,
+ CriteriaResolver[] memory resolvers,
+ bytes32 orderHash,
+ UnavailableReason unavailableReason
+ ) internal view returns (OrderDetails memory) {
+ (SpentItem[] memory offer, ReceivedItem[] memory consideration) = this
+ .getSpentAndReceivedItems(order, orderIndex, resolvers);
+
+ return
+ OrderDetails({
+ offerer: order.parameters.offerer,
+ conduitKey: order.parameters.conduitKey,
+ offer: offer,
+ consideration: consideration,
+ isContract: order.parameters.orderType == OrderType.CONTRACT,
+ orderHash: orderHash,
+ unavailableReason: unavailableReason
+ });
+ }
+
+ function getSpentAndReceivedItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator,
+ uint256 orderIndex,
+ CriteriaResolver[] memory criteriaResolvers
+ )
+ private
+ view
+ returns (SpentItem[] memory spent, ReceivedItem[] memory received)
+ {
+ if (parameters.isAvailable()) {
+ spent = getSpentItems(parameters, numerator, denominator);
+ received = getReceivedItems(parameters, numerator, denominator);
+
+ applyCriteriaResolvers(
+ spent,
+ received,
+ orderIndex,
+ criteriaResolvers
+ );
+ }
+ }
+
+ function applyCriteriaResolvers(
+ SpentItem[] memory spentItems,
+ ReceivedItem[] memory receivedItems,
+ uint256 orderIndex,
+ CriteriaResolver[] memory criteriaResolvers
+ ) private pure {
+ for (uint256 i = 0; i < criteriaResolvers.length; i++) {
+ CriteriaResolver memory resolver = criteriaResolvers[i];
+ if (resolver.orderIndex != orderIndex) {
+ continue;
+ }
+ if (resolver.side == Side.OFFER) {
+ SpentItem memory item = spentItems[resolver.index];
+ item.itemType = convertCriteriaItemType(item.itemType);
+ item.identifier = resolver.identifier;
+ } else {
+ ReceivedItem memory item = receivedItems[resolver.index];
+ item.itemType = convertCriteriaItemType(item.itemType);
+ item.identifier = resolver.identifier;
+ }
+ }
+ }
+
+ function convertCriteriaItemType(
+ ItemType itemType
+ ) internal pure returns (ItemType) {
+ if (itemType == ItemType.ERC721_WITH_CRITERIA) {
+ return ItemType.ERC721;
+ } else if (itemType == ItemType.ERC1155_WITH_CRITERIA) {
+ return ItemType.ERC1155;
+ } else {
+ revert("amount deriver helper resolving non criteria item type");
+ }
+ }
+
+ function getSpentItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (SpentItem[] memory) {
+ return
+ getSpentItems(
+ parameters.offer,
+ parameters.startTime,
+ parameters.endTime,
+ numerator,
+ denominator
+ );
+ }
+
+ function getSpentItems(
+ OrderParameters memory parameters
+ ) private view returns (SpentItem[] memory) {
+ return
+ getSpentItems(
+ parameters.offer,
+ parameters.startTime,
+ parameters.endTime
+ );
+ }
+
+ function getSpentItems(
+ OfferItem[] memory offerItems,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (SpentItem[] memory) {
+ SpentItem[] memory spentItems = new SpentItem[](offerItems.length);
+ for (uint256 i = 0; i < offerItems.length; i++) {
+ spentItems[i] = getSpentItem(offerItems[i], startTime, endTime);
+ }
+ return spentItems;
+ }
+
+ function getSpentItems(
+ OfferItem[] memory items,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (SpentItem[] memory) {
+ SpentItem[] memory spentItems = new SpentItem[](items.length);
+ for (uint256 i = 0; i < items.length; i++) {
+ spentItems[i] = getSpentItem(
+ items[i],
+ startTime,
+ endTime,
+ numerator,
+ denominator
+ );
+ }
+ return spentItems;
+ }
+
+ function getSpentItem(
+ OfferItem memory offerItem,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (SpentItem memory spent) {
+ spent = SpentItem({
+ itemType: offerItem.itemType,
+ token: offerItem.token,
+ identifier: offerItem.identifierOrCriteria,
+ amount: _locateCurrentAmount({
+ item: offerItem,
+ startTime: startTime,
+ endTime: endTime
+ })
+ });
+ }
+
+ function getSpentItem(
+ OfferItem memory item,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (SpentItem memory spent) {
+ // Detect if the order has an invalid time;
+ // if so, set amount to zero
+ spent = SpentItem({
+ itemType: item.itemType,
+ token: item.token,
+ identifier: item.identifierOrCriteria,
+ amount: (block.timestamp < startTime || block.timestamp >= endTime)
+ ? 0
+ : _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ item: item,
+ startTime: startTime,
+ endTime: endTime
+ })
+ });
+ }
+
+ function getReceivedItems(
+ OrderParameters memory parameters
+ ) private view returns (ReceivedItem[] memory) {
+ return
+ getReceivedItems(
+ parameters.consideration,
+ parameters.startTime,
+ parameters.endTime
+ );
+ }
+
+ function getReceivedItems(
+ OrderParameters memory parameters,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (ReceivedItem[] memory) {
+ return
+ getReceivedItems(
+ parameters.consideration,
+ parameters.startTime,
+ parameters.endTime,
+ numerator,
+ denominator
+ );
+ }
+
+ function getReceivedItems(
+ ConsiderationItem[] memory considerationItems,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ considerationItems.length
+ );
+ for (uint256 i = 0; i < considerationItems.length; i++) {
+ receivedItems[i] = getReceivedItem(
+ considerationItems[i],
+ startTime,
+ endTime
+ );
+ }
+ return receivedItems;
+ }
+
+ function getReceivedItems(
+ ConsiderationItem[] memory considerationItems,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ considerationItems.length
+ );
+ for (uint256 i = 0; i < considerationItems.length; i++) {
+ receivedItems[i] = getReceivedItem(
+ considerationItems[i],
+ startTime,
+ endTime,
+ numerator,
+ denominator
+ );
+ }
+ return receivedItems;
+ }
+
+ function getReceivedItem(
+ ConsiderationItem memory considerationItem,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (ReceivedItem memory received) {
+ received = ReceivedItem({
+ itemType: considerationItem.itemType,
+ token: considerationItem.token,
+ identifier: considerationItem.identifierOrCriteria,
+ amount: _locateCurrentAmount({
+ item: considerationItem,
+ startTime: startTime,
+ endTime: endTime
+ }),
+ recipient: considerationItem.recipient
+ });
+ }
+
+ function getReceivedItem(
+ ConsiderationItem memory considerationItem,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) private view returns (ReceivedItem memory received) {
+ // Detect if the order has an invalid time;
+ // if so, set amount to zero
+ received = ReceivedItem({
+ itemType: considerationItem.itemType,
+ token: considerationItem.token,
+ identifier: considerationItem.identifierOrCriteria,
+ amount: (block.timestamp < startTime || block.timestamp >= endTime)
+ ? 0
+ : _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ item: considerationItem,
+ startTime: startTime,
+ endTime: endTime
+ }),
+ recipient: considerationItem.recipient
+ });
+ }
+
+ function _locateCurrentAmount(
+ OfferItem memory item,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (uint256) {
+ return
+ _locateCurrentAmount({
+ startAmount: item.startAmount,
+ endAmount: item.endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: false
+ });
+ }
+
+ function deriveFractionCompatibleAmounts(
+ uint256 originalStartAmount,
+ uint256 originalEndAmount,
+ uint256 startTime,
+ uint256 endTime,
+ uint256 numerator,
+ uint256 denominator
+ ) public pure returns (uint256 newStartAmount, uint256 newEndAmount) {
+ if (
+ startTime >= endTime ||
+ numerator > denominator ||
+ numerator == 0 ||
+ denominator == 0 ||
+ (originalStartAmount == 0 && originalEndAmount == 0)
+ ) {
+ revert(
+ "AmountDeriverHelper: bad inputs to deriveFractionCompatibleAmounts"
+ );
+ }
+
+ uint256 duration = endTime - startTime;
+
+ // determine if duration or numerator is more likely to overflow when multiplied by value
+ uint256 overflowBottleneck = (numerator > duration)
+ ? numerator
+ : duration;
+
+ uint256 absoluteMax = type(uint256).max / overflowBottleneck;
+ uint256 fractionCompatibleMax = (absoluteMax / denominator) *
+ denominator;
+
+ newStartAmount = originalStartAmount % fractionCompatibleMax;
+ newStartAmount = (newStartAmount / denominator) * denominator;
+ newStartAmount = (newStartAmount == 0) ? denominator : newStartAmount;
+
+ newEndAmount = originalEndAmount % fractionCompatibleMax;
+ newEndAmount = (newEndAmount / denominator) * denominator;
+ newEndAmount = (newEndAmount == 0) ? denominator : newEndAmount;
+
+ if (newStartAmount == 0 && newEndAmount == 0) {
+ revert("AmountDeriverHelper: derived amount will always be zero");
+ }
+ }
+
+ function _locateCurrentAmount(
+ ConsiderationItem memory item,
+ uint256 startTime,
+ uint256 endTime
+ ) private view returns (uint256) {
+ return
+ _locateCurrentAmount({
+ startAmount: item.startAmount,
+ endAmount: item.endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: true
+ });
+ }
+
+ function _applyFraction(
+ uint256 numerator,
+ uint256 denominator,
+ uint256 startTime,
+ uint256 endTime,
+ OfferItem memory item
+ ) internal view returns (uint256) {
+ uint256 startAmount = item.startAmount;
+ uint256 endAmount = item.endAmount;
+ return
+ _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ startAmount: startAmount,
+ endAmount: endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: false // don't round up offers
+ });
+ }
+
+ function _applyFraction(
+ uint256 numerator,
+ uint256 denominator,
+ uint256 startTime,
+ uint256 endTime,
+ ConsiderationItem memory item
+ ) internal view returns (uint256) {
+ uint256 startAmount = item.startAmount;
+ uint256 endAmount = item.endAmount;
+
+ return
+ _applyFraction({
+ numerator: numerator,
+ denominator: denominator,
+ startAmount: startAmount,
+ endAmount: endAmount,
+ startTime: startTime,
+ endTime: endTime,
+ roundUp: true // round up considerations
+ });
+ }
+}
diff --git a/contracts/helpers/sol/lib/types/MatchComponentType.sol b/contracts/helpers/sol/lib/types/MatchComponentType.sol
new file mode 100644
index 000000000..cb8ebe2ed
--- /dev/null
+++ b/contracts/helpers/sol/lib/types/MatchComponentType.sol
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { FulfillmentComponent } from "../../SeaportStructs.sol";
+
+struct MatchComponent {
+ uint256 amount;
+ uint8 orderIndex;
+ uint8 itemIndex;
+}
+
+library MatchComponentType {
+ using MatchComponentType for MatchComponent;
+
+ uint256 private constant AMOUNT_SHL_OFFSET = 16;
+ uint256 private constant ORDER_INDEX_SHL_OFFSET = 8;
+ uint256 private constant BYTE_MASK = 0xFF;
+ uint256 private constant AMOUNT_MASK =
+ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000;
+ uint256 private constant ORDER_INDEX_MASK = 0xFF00;
+ uint256 private constant ITEM_INDEX_MASK = 0xFF;
+ uint256 private constant NOT_AMOUNT_MASK = 0xFFFF;
+ uint256 private constant NOT_ORDER_INDEX_MASK =
+ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FF;
+ uint256 private constant NOT_ITEM_INDEX_MASK =
+ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00;
+
+ function createMatchComponent(
+ uint256 amount,
+ uint8 orderIndex,
+ uint8 itemIndex
+ ) internal pure returns (MatchComponent memory component) {
+ component.amount = amount;
+ component.orderIndex = orderIndex;
+ component.itemIndex = itemIndex;
+ // assembly {
+ // component := or(
+ // shl(AMOUNT_SHL_OFFSET, amount),
+ // or(shl(ORDER_INDEX_SHL_OFFSET, orderIndex), itemIndex)
+ // )
+ // }
+ }
+
+ function getAmount(
+ MatchComponent memory component
+ ) internal pure returns (uint256 amount) {
+ return component.amount;
+ }
+
+ function copy(
+ MatchComponent memory component
+ ) internal pure returns (MatchComponent memory copy_) {
+ copy_.amount = component.amount;
+ copy_.orderIndex = component.orderIndex;
+ copy_.itemIndex = component.itemIndex;
+ }
+
+ function setAmount(
+ MatchComponent memory component,
+ uint256 amount
+ ) internal pure returns (MatchComponent memory newComponent) {
+ newComponent = component.copy();
+ newComponent.amount = amount;
+ }
+
+ function getOrderIndex(
+ MatchComponent memory component
+ ) internal pure returns (uint8 orderIndex) {
+ return component.orderIndex;
+ }
+
+ function setOrderIndex(
+ MatchComponent memory component,
+ uint8 orderIndex
+ ) internal pure returns (MatchComponent memory newComponent) {
+ newComponent = component.copy();
+ newComponent.orderIndex = orderIndex;
+ }
+
+ function getItemIndex(
+ MatchComponent memory component
+ ) internal pure returns (uint8 itemIndex) {
+ return component.itemIndex;
+ }
+
+ function setItemIndex(
+ MatchComponent memory component,
+ uint8 itemIndex
+ ) internal pure returns (MatchComponent memory newComponent) {
+ newComponent = component.copy();
+ newComponent.itemIndex = itemIndex;
+ }
+
+ function unpack(
+ MatchComponent memory component
+ )
+ internal
+ pure
+ returns (uint256 amount, uint8 orderIndex, uint8 itemIndex)
+ {
+ return (component.amount, component.orderIndex, component.itemIndex);
+ }
+
+ function subtractAmount(
+ MatchComponent memory minuend,
+ MatchComponent memory subtrahend
+ ) internal pure returns (MatchComponent memory newComponent) {
+ uint256 minuendAmount = minuend.getAmount();
+ uint256 subtrahendAmount = subtrahend.getAmount();
+ uint256 newAmount = uint256(minuendAmount - subtrahendAmount);
+ return minuend.setAmount(newAmount);
+ }
+
+ function addAmount(
+ MatchComponent memory target,
+ MatchComponent memory ref
+ ) internal pure returns (MatchComponent memory) {
+ uint256 targetAmount = target.getAmount();
+ uint256 refAmount = ref.getAmount();
+ uint256 newAmount = uint256(targetAmount + refAmount);
+ return target.setAmount(newAmount);
+ }
+
+ function toFulfillmentComponent(
+ MatchComponent memory component
+ ) internal pure returns (FulfillmentComponent memory) {
+ (, uint8 orderIndex, uint8 itemIndex) = component.unpack();
+ return
+ FulfillmentComponent({
+ orderIndex: orderIndex,
+ itemIndex: itemIndex
+ });
+ }
+
+ function toFulfillmentComponents(
+ MatchComponent[] memory components
+ ) internal pure returns (FulfillmentComponent[] memory) {
+ FulfillmentComponent[]
+ memory fulfillmentComponents = new FulfillmentComponent[](
+ components.length
+ );
+ for (uint256 i = 0; i < components.length; i++) {
+ fulfillmentComponents[i] = components[i].toFulfillmentComponent();
+ }
+ return fulfillmentComponents;
+ }
+
+ function toStruct(
+ MatchComponent memory component
+ ) internal pure returns (MatchComponent memory) {
+ (uint256 amount, uint8 orderIndex, uint8 itemIndex) = component
+ .unpack();
+ return
+ MatchComponent({
+ amount: amount,
+ orderIndex: orderIndex,
+ itemIndex: itemIndex
+ });
+ }
+
+ function toStructs(
+ MatchComponent[] memory components
+ ) internal pure returns (MatchComponent[] memory) {
+ MatchComponent[] memory structs = new MatchComponent[](
+ components.length
+ );
+ for (uint256 i = 0; i < components.length; i++) {
+ structs[i] = components[i].toStruct();
+ }
+ return structs;
+ }
+
+ function equals(
+ MatchComponent memory left,
+ MatchComponent memory right
+ ) internal pure returns (bool) {
+ return
+ left.amount == right.amount &&
+ left.orderIndex == right.orderIndex &&
+ left.itemIndex == right.itemIndex;
+ }
+}
diff --git a/contracts/interfaces/AbridgedTokenInterfaces.sol b/contracts/interfaces/AbridgedTokenInterfaces.sol
index 14d1000f3..9cadced25 100644
--- a/contracts/interfaces/AbridgedTokenInterfaces.sol
+++ b/contracts/interfaces/AbridgedTokenInterfaces.sol
@@ -30,20 +30,34 @@ interface ERC20Interface {
*
* @return success True if the approval was successful.
*/
-
function approve(
address spender,
uint256 value
) external returns (bool success);
/**
- * @dev Returns the amount of tokens owned by `account`.
+ * @dev Returns the balance of a user.
*
- * @param account The address of the account to check the balance of.
+ * @param account The address of the user.
*
- * @return balance The amount of tokens owned by `account`.
+ * @return balance The balance of the user.
*/
function balanceOf(address account) external view returns (uint256);
+
+ /**
+ * @dev Returns the amount which spender is still allowed to withdraw
+ * from owner.
+ *
+ * @param owner The address of the owner.
+ * @param spender The address of the spender.
+ *
+ * @return remaining The amount of tokens that the spender is allowed to
+ * transfer on behalf of the owner.
+ */
+ function allowance(
+ address owner,
+ address spender
+ ) external view returns (uint256 remaining);
}
/**
@@ -69,6 +83,31 @@ interface ERC721Interface {
*/
function setApprovalForAll(address to, bool approved) external;
+ /**
+ * @dev Returns the account approved for tokenId token
+ *
+ * @param tokenId The tokenId to query the approval of.
+ *
+ * @return operator The approved account of the tokenId.
+ */
+ function getApproved(
+ uint256 tokenId
+ ) external view returns (address operator);
+
+ /**
+ * @dev Returns whether an operator is allowed to manage all of
+ * the assets of owner.
+ *
+ * @param owner The address of the owner.
+ * @param operator The address of the operator.
+ *
+ * @return approved True if the operator is approved by the owner.
+ */
+ function isApprovedForAll(
+ address owner,
+ address operator
+ ) external view returns (bool);
+
/**
* @dev Returns the owner of a given token ID.
*
@@ -128,16 +167,29 @@ interface ERC1155Interface {
function setApprovalForAll(address to, bool approved) external;
/**
- * @dev Returns the owner of a given token ID.
+ * @dev Returns the amount of token type id owned by account.
*
- * @param account The address of the account to check the balance of.
- * @param id The token ID.
+ * @param account The address of the account.
+ * @param id The id of the token.
*
- * @return balance The balance of the token.
+ * @return balance The amount of tokens of type id owned by account.
*/
-
function balanceOf(
address account,
uint256 id
) external view returns (uint256);
+
+ /**
+ * @dev Returns true if operator is approved to transfer account's tokens.
+ *
+ * @param account The address of the account.
+ * @param operator The address of the operator.
+ *
+ * @return approved True if the operator is approved to transfer account's
+ * tokens.
+ */
+ function isApprovedForAll(
+ address account,
+ address operator
+ ) external view returns (bool);
}
diff --git a/contracts/interfaces/ConsiderationInterface.sol b/contracts/interfaces/ConsiderationInterface.sol
index 5829952a4..3a3d07d72 100644
--- a/contracts/interfaces/ConsiderationInterface.sol
+++ b/contracts/interfaces/ConsiderationInterface.sol
@@ -15,7 +15,7 @@ import {
/**
* @title ConsiderationInterface
* @author 0age
- * @custom:version 1.4
+ * @custom:version 1.5
* @notice Consideration is a generalized native token/ERC20/ERC721/ERC1155
* marketplace. It minimizes external calls to the greatest extent
* possible and provides lightweight methods for common routes as well
diff --git a/contracts/interfaces/ContractOffererInterface.sol b/contracts/interfaces/ContractOffererInterface.sol
index e38823cfa..72b6b1ff5 100644
--- a/contracts/interfaces/ContractOffererInterface.sol
+++ b/contracts/interfaces/ContractOffererInterface.sol
@@ -6,13 +6,14 @@ import {
Schema,
SpentItem
} from "../lib/ConsiderationStructs.sol";
+import { IERC165 } from "../interfaces/IERC165.sol";
/**
* @title ContractOffererInterface
* @notice Contains the minimum interfaces needed to interact with a contract
* offerer.
*/
-interface ContractOffererInterface {
+interface ContractOffererInterface is IERC165 {
/**
* @dev Generates an order with the specified minimum and maximum spent
* items, and optional context (supplied as extraData).
@@ -97,5 +98,9 @@ interface ContractOffererInterface {
Schema[] memory schemas // map to Seaport Improvement Proposal IDs
);
+ function supportsInterface(
+ bytes4 interfaceId
+ ) external view override returns (bool);
+
// Additional functions and/or events based on implemented schemaIDs
}
diff --git a/contracts/interfaces/ERC165.sol b/contracts/interfaces/ERC165.sol
new file mode 100644
index 000000000..2f46133dd
--- /dev/null
+++ b/contracts/interfaces/ERC165.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
+
+pragma solidity ^0.8.7;
+
+import "./IERC165.sol";
+
+/**
+ * @dev Implementation of the {IERC165} interface.
+ *
+ * Contracts that want to implement ERC165 should inherit from this contract
+ * and override {supportsInterface} to check for the additional interface id
+ * that will be supported.
+ *
+ * Alternatively, {ERC165Storage} provides an easier to use but more
+ * expensive implementation.
+ */
+abstract contract ERC165 is IERC165 {
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view virtual override returns (bool) {
+ return interfaceId == type(IERC165).interfaceId;
+ }
+}
diff --git a/contracts/interfaces/IERC1271.sol b/contracts/interfaces/IERC1271.sol
new file mode 100644
index 000000000..32d694bd5
--- /dev/null
+++ b/contracts/interfaces/IERC1271.sol
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)
+
+pragma solidity ^0.8.7;
+
+/**
+ * @dev Interface of the ERC1271 standard signature validation method for
+ * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
+ *
+ * _Available since v4.1._
+ */
+interface IERC1271 {
+ /**
+ * @dev Should return whether the signature provided is valid for the
+ * provided data
+ * @param hash Hash of the data to be signed
+ * @param signature Signature byte array associated with _data
+ */
+ function isValidSignature(
+ bytes32 hash,
+ bytes memory signature
+ ) external view returns (bytes4 magicValue);
+}
diff --git a/contracts/interfaces/IERC165.sol b/contracts/interfaces/IERC165.sol
new file mode 100644
index 000000000..4c270d647
--- /dev/null
+++ b/contracts/interfaces/IERC165.sol
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
+
+pragma solidity ^0.8.7;
+
+/**
+ * @dev Interface of the ERC165 standard, as defined in the
+ * https://eips.ethereum.org/EIPS/eip-165[EIP].
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others ({ERC165Checker}).
+ *
+ * For an implementation, see {ERC165}.
+ */
+interface IERC165 {
+ /**
+ * @dev Returns true if this contract implements the interface defined by
+ * `interfaceId`.
+ *
+ * This function call must use less than 30 000 gas.
+ */
+ function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
diff --git a/contracts/interfaces/IERC2981.sol b/contracts/interfaces/IERC2981.sol
new file mode 100644
index 000000000..75e57ac9a
--- /dev/null
+++ b/contracts/interfaces/IERC2981.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)
+
+pragma solidity ^0.8.7;
+
+import "./IERC165.sol";
+
+/**
+ * @dev Interface for the NFT Royalty Standard.
+ *
+ * A standardized way to retrieve royalty payment information for
+ * non-fungible tokens (NFTs) to enable universal support for royalty payments
+ * across all NFT marketplaces and ecosystem participants.
+ *
+ * _Available since v4.5._
+ */
+interface IERC2981 is IERC165 {
+ /**
+ * @dev Returns how much royalty is owed and to whom, based on a sale price
+ * that may be denominated in any unit of exchange. The royalty amount
+ * is denominated and should be paid in that same unit of exchange.
+ */
+ function royaltyInfo(
+ uint256 tokenId,
+ uint256 salePrice
+ ) external view returns (address receiver, uint256 royaltyAmount);
+}
diff --git a/contracts/interfaces/SeaportInterface.sol b/contracts/interfaces/SeaportInterface.sol
index 515c38e5d..e510ed0cb 100644
--- a/contracts/interfaces/SeaportInterface.sol
+++ b/contracts/interfaces/SeaportInterface.sol
@@ -15,7 +15,7 @@ import {
/**
* @title SeaportInterface
* @author 0age
- * @custom:version 1.4
+ * @custom:version 1.5
* @notice Seaport is a generalized native token/ERC20/ERC721/ERC1155
* marketplace. It minimizes external calls to the greatest extent
* possible and provides lightweight methods for common routes as well
diff --git a/contracts/interfaces/SeaportRouterInterface.sol b/contracts/interfaces/SeaportRouterInterface.sol
index 108761496..67423ca31 100644
--- a/contracts/interfaces/SeaportRouterInterface.sol
+++ b/contracts/interfaces/SeaportRouterInterface.sol
@@ -17,6 +17,12 @@ import { Execution } from "../lib/ConsiderationStructs.sol";
* all consideration items across all listings are native tokens.
*/
interface SeaportRouterInterface {
+ /**
+ * @dev Revert with an error when attempting to fulfill any number of
+ * available orders when none are fulfillable.
+ */
+ error NoSpecifiedOrdersAvailable();
+
/**
* @dev Advanced order parameters for use through the
* FulfillAvailableAdvancedOrdersParams struct.
diff --git a/contracts/interfaces/ZoneInterface.sol b/contracts/interfaces/ZoneInterface.sol
index d64a5d419..04234ff20 100644
--- a/contracts/interfaces/ZoneInterface.sol
+++ b/contracts/interfaces/ZoneInterface.sol
@@ -3,11 +3,13 @@ pragma solidity ^0.8.13;
import { ZoneParameters, Schema } from "../lib/ConsiderationStructs.sol";
+import { IERC165 } from "../interfaces/IERC165.sol";
+
/**
* @title ZoneInterface
* @notice Contains functions exposed by a zone.
*/
-interface ZoneInterface {
+interface ZoneInterface is IERC165 {
/**
* @dev Validates an order.
*
@@ -34,4 +36,8 @@ interface ZoneInterface {
string memory name,
Schema[] memory schemas // map to Seaport Improvement Proposal IDs
);
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) external view override returns (bool);
}
diff --git a/contracts/interfaces/legacy/ConsiderationInterface1_1.sol b/contracts/interfaces/legacy/ConsiderationInterface1_1.sol
index 1590472bc..8c20c0c56 100644
--- a/contracts/interfaces/legacy/ConsiderationInterface1_1.sol
+++ b/contracts/interfaces/legacy/ConsiderationInterface1_1.sol
@@ -2,15 +2,14 @@
pragma solidity ^0.8.7;
import {
+ AdvancedOrder,
BasicOrderParameters,
- OrderComponents,
+ CriteriaResolver,
+ Execution,
Fulfillment,
FulfillmentComponent,
- Execution,
Order,
- AdvancedOrder,
- OrderStatus,
- CriteriaResolver
+ OrderComponents
} from "../../lib/ConsiderationStructs.sol";
/**
diff --git a/contracts/lib/Consideration.sol b/contracts/lib/Consideration.sol
index d737a1156..51b87f8f4 100644
--- a/contracts/lib/Consideration.sol
+++ b/contracts/lib/Consideration.sol
@@ -42,7 +42,7 @@ import {
* @custom:coauthor d1ll0n (d1ll0n.eth)
* @custom:coauthor transmissions11 (t11s.eth)
* @custom:coauthor James Wenzel (emo.eth)
- * @custom:version 1.4
+ * @custom:version 1.5
* @notice Consideration is a generalized native token/ERC20/ERC721/ERC1155
* marketplace that provides lightweight methods for common routes as
* well as more flexible methods for composing advanced orders or groups
diff --git a/contracts/lib/ConsiderationBase.sol b/contracts/lib/ConsiderationBase.sol
index a83a235fd..891f3ae20 100644
--- a/contracts/lib/ConsiderationBase.sol
+++ b/contracts/lib/ConsiderationBase.sol
@@ -43,13 +43,13 @@ import {
NameLengthPtr,
NameWithLength,
OneWord,
- OneWordShift,
Slot0x80,
ThreeWords,
ZeroSlot
} from "./ConsiderationConstants.sol";
import { ConsiderationDecoder } from "./ConsiderationDecoder.sol";
+
import { ConsiderationEncoder } from "./ConsiderationEncoder.sol";
/**
@@ -224,7 +224,7 @@ contract ConsiderationBase is
nameHash = keccak256(bytes(_nameString()));
// Derive hash of the version string of the contract.
- versionHash = keccak256(bytes("1.4"));
+ versionHash = keccak256(bytes("1.5"));
// Construct the OfferItem type string.
bytes memory offerItemTypeString = bytes(
diff --git a/contracts/lib/ConsiderationConstants.sol b/contracts/lib/ConsiderationConstants.sol
index 796b8d1ef..e0b127685 100644
--- a/contracts/lib/ConsiderationConstants.sol
+++ b/contracts/lib/ConsiderationConstants.sol
@@ -46,7 +46,7 @@ uint256 constant information_version_cd_offset = 0x60;
uint256 constant information_domainSeparator_offset = 0x20;
uint256 constant information_conduitController_offset = 0x40;
uint256 constant information_versionLengthPtr = 0x63;
-uint256 constant information_versionWithLength = 0x03312e34; // 1.4
+uint256 constant information_versionWithLength = 0x03312e35; // 1.5
uint256 constant information_length = 0xa0;
uint256 constant _NOT_ENTERED = 1;
diff --git a/contracts/lib/ConsiderationDecoder.sol b/contracts/lib/ConsiderationDecoder.sol
index bca09a333..76ac604c3 100644
--- a/contracts/lib/ConsiderationDecoder.sol
+++ b/contracts/lib/ConsiderationDecoder.sol
@@ -1331,21 +1331,28 @@ contract ConsiderationDecoder {
}
/**
- * @dev Converts an offer item into a received item, applying a given
- * recipient.
+ * @dev Caches the endAmount in an offer item and replaces it with
+ * a given recipient so that its memory may be reused as a temporary
+ * ReceivedItem.
*
* @param offerItem The offer item.
* @param recipient The recipient.
*
- * @return receivedItem The received item.
+ * @return originalEndAmount The original end amount.
*/
- function _fromOfferItemToReceivedItemWithRecipient(
+ function _replaceEndAmountWithRecipient(
OfferItem memory offerItem,
address recipient
- ) internal pure returns (ReceivedItem memory receivedItem) {
+ ) internal pure returns (uint256 originalEndAmount) {
assembly {
- receivedItem := offerItem
- mstore(add(receivedItem, ReceivedItem_recipient_offset), recipient)
+ // Derive the pointer to the end amount on the offer item.
+ let endAmountPtr := add(offerItem, ReceivedItem_recipient_offset)
+
+ // Retrieve the value of the end amount on the offer item.
+ originalEndAmount := mload(endAmountPtr)
+
+ // Write recipient to received item at the offer end amount pointer.
+ mstore(endAmountPtr, recipient)
}
}
}
diff --git a/contracts/lib/Executor.sol b/contracts/lib/Executor.sol
index 68b207e56..ae2803592 100644
--- a/contracts/lib/Executor.sol
+++ b/contracts/lib/Executor.sol
@@ -243,8 +243,8 @@ contract Executor is Verifiers, TokenTransferrer {
* @param token The ERC721 token to transfer.
* @param from The originator of the transfer.
* @param to The recipient of the transfer.
- * @param identifier The tokenId to transfer (must be 1 for ERC721).
- * @param amount The amount to transfer.
+ * @param identifier The tokenId to transfer.
+ * @param amount The amount to transfer (must be 1 for ERC721).
* @param conduitKey A bytes32 value indicating what corresponding conduit,
* if any, to source token approvals from. The zero hash
* signifies that no conduit should be used, with direct
@@ -480,7 +480,8 @@ contract Executor is Verifiers, TokenTransferrer {
_revertInvalidCallToConduit(conduit);
}
- // Ensure result was extracted and matches EIP-1271 magic value.
+ // Ensure result was extracted and matches the Conduit executor magic
+ // value.
if (result != ConduitInterface.execute.selector) {
_revertInvalidConduit(conduitKey, conduit);
}
diff --git a/contracts/lib/OrderCombiner.sol b/contracts/lib/OrderCombiner.sol
index d2e3b1f81..fb26f83aa 100644
--- a/contracts/lib/OrderCombiner.sol
+++ b/contracts/lib/OrderCombiner.sol
@@ -136,7 +136,7 @@ contract OrderCombiner is OrderFulfiller, FulfillmentApplier {
Execution[] memory /* executions */
)
{
- // Validate orders, apply amounts, & determine if they utilize conduits.
+ // Validate orders, apply amounts, & determine if they use conduits.
(
bytes32[] memory orderHashes,
bool containsNonOpen
@@ -800,15 +800,33 @@ contract OrderCombiner is OrderFulfiller, FulfillmentApplier {
// Note that the transfer will not be reflected in the
// executions array.
if (offerItem.startAmount != 0) {
- _transfer(
- _fromOfferItemToReceivedItemWithRecipient(
+ // Replace the endAmount parameter with the recipient to
+ // make offerItem compatible with the ReceivedItem input
+ // to _transfer and cache the original endAmount so it
+ // can be restored after the transfer.
+ uint256 originalEndAmount = _replaceEndAmountWithRecipient(
offerItem,
recipient
- ),
+ );
+
+ // Transfer excess offer item amount to recipient.
+ _toOfferItemInput(_transfer)(
+ offerItem,
parameters.offerer,
parameters.conduitKey,
accumulator
);
+
+ // Restore the original endAmount in offerItem.
+ assembly {
+ mstore(
+ add(
+ offerItem,
+ ReceivedItem_recipient_offset
+ ),
+ originalEndAmount
+ )
+ }
}
// Restore original amount on the offer item.
diff --git a/contracts/lib/OrderFulfiller.sol b/contracts/lib/OrderFulfiller.sol
index 405508355..50cc91480 100644
--- a/contracts/lib/OrderFulfiller.sol
+++ b/contracts/lib/OrderFulfiller.sol
@@ -348,7 +348,6 @@ contract OrderFulfiller is
)
}
- // Reduce available value if offer spent ETH or a native token.
if (considerationItem.itemType == ItemType.NATIVE) {
// Get the current available balance of native tokens.
assembly {
diff --git a/contracts/lib/OrderValidator.sol b/contracts/lib/OrderValidator.sol
index 22ac17326..4f9664521 100644
--- a/contracts/lib/OrderValidator.sol
+++ b/contracts/lib/OrderValidator.sol
@@ -251,6 +251,7 @@ contract OrderValidator is Executor, ZoneInteraction {
);
}
+ // Utilize assembly to determine the fraction to fill and update status.
assembly {
let orderStatusSlot := orderStatus.slot
// Read filled amount as numerator and denominator and put on stack.
@@ -260,14 +261,14 @@ contract OrderValidator is Executor, ZoneInteraction {
filledNumerator
)
- for {
-
- } 1 {
-
- } {
+ // "Loop" until the appropriate fill fraction has been determined.
+ for { } 1 { } {
+ // If no portion of the order has been filled yet...
if iszero(filledDenominator) {
+ // fill the full supplied fraction.
filledNumerator := numerator
+ // Exit the "loop" early.
break
}
@@ -279,14 +280,20 @@ contract OrderValidator is Executor, ZoneInteraction {
// If denominator of 1 supplied, fill entire remaining amount.
if eq(denominator, 1) {
+ // Set the amount to fill to the remaining amount.
numerator := sub(filledDenominator, filledNumerator)
+
+ // Set the fill size to the current size.
denominator := filledDenominator
+
+ // Set the filled amount to the current size.
filledNumerator := filledDenominator
+ // Exit the "loop" early.
break
}
- // If supplied denominator equals to the current one:
+ // If supplied denominator is equal to the current one:
if eq(denominator, filledDenominator) {
// Increment the filled numerator by the new numerator.
filledNumerator := add(numerator, filledNumerator)
@@ -298,15 +305,21 @@ contract OrderValidator is Executor, ZoneInteraction {
gt(filledNumerator, denominator)
)
+ // reduce the amount to fill by the excess.
numerator := sub(numerator, carry)
+ // Reduce the filled amount by the excess as well.
filledNumerator := sub(filledNumerator, carry)
+ // Exit the "loop" early.
break
}
// Otherwise, if supplied denominator differs from current one:
+ // Scale the filled amount up by the supplied size.
filledNumerator := mul(filledNumerator, denominator)
+
+ // Scale the supplied amount and size up by the current size.
numerator := mul(numerator, filledDenominator)
denominator := mul(denominator, filledDenominator)
@@ -320,8 +333,10 @@ contract OrderValidator is Executor, ZoneInteraction {
gt(filledNumerator, denominator)
)
+ // reduce the amount to fill by the excess.
numerator := sub(numerator, carry)
+ // Reduce the filled amount by the excess as well.
filledNumerator := sub(filledNumerator, carry)
// Check filledNumerator and denominator for uint120 overflow.
@@ -331,17 +346,23 @@ contract OrderValidator is Executor, ZoneInteraction {
) {
// Derive greatest common divisor using euclidean algorithm.
function gcd(_a, _b) -> out {
- for {
-
- } _b {
-
- } {
+ // "Loop" until only one non-zero value remains.
+ for { } _b { } {
+ // Assign the second value to a temporary variable.
let _c := _b
+
+ // Derive the modulus of the two values.
_b := mod(_a, _c)
+
+ // Set the first value to the temporary value.
_a := _c
}
+
+ // Return the remaining non-zero value.
out := _a
}
+
+ // Determine the amount to scale down the fill fractions.
let scaleDown := gcd(
numerator,
gcd(filledNumerator, denominator)
@@ -372,6 +393,7 @@ contract OrderValidator is Executor, ZoneInteraction {
}
}
+ // Exit the "loop" now that all evaluation is complete.
break
}
diff --git a/contracts/test/ERC2981.sol b/contracts/test/ERC2981.sol
new file mode 100644
index 000000000..dc05853f7
--- /dev/null
+++ b/contracts/test/ERC2981.sol
@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)
+
+pragma solidity ^0.8.0;
+
+import "../interfaces/IERC2981.sol";
+import "../interfaces/ERC165.sol";
+
+/**
+ * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
+ *
+ * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
+ * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
+ *
+ * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
+ * fee is specified in basis points by default.
+ *
+ * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
+ * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
+ * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
+ *
+ * _Available since v4.5._
+ */
+abstract contract ERC2981 is IERC2981, ERC165 {
+ struct RoyaltyInfo {
+ address receiver;
+ uint96 royaltyFraction;
+ }
+
+ RoyaltyInfo private _defaultRoyaltyInfo;
+ mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
+
+ /**
+ * @dev See {IERC165-supportsInterface}.
+ */
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view virtual override(IERC165, ERC165) returns (bool) {
+ return
+ interfaceId == type(IERC2981).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
+
+ /**
+ * @inheritdoc IERC2981
+ */
+ function royaltyInfo(
+ uint256 _tokenId,
+ uint256 _salePrice
+ ) public view virtual override returns (address, uint256) {
+ RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
+
+ if (royalty.receiver == address(0)) {
+ royalty = _defaultRoyaltyInfo;
+ }
+
+ uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) /
+ _feeDenominator();
+
+ return (royalty.receiver, royaltyAmount);
+ }
+
+ /**
+ * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
+ * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
+ * override.
+ */
+ function _feeDenominator() internal pure virtual returns (uint96) {
+ return 10000;
+ }
+
+ /**
+ * @dev Sets the royalty information that all ids in this contract will default to.
+ *
+ * Requirements:
+ *
+ * - `receiver` cannot be the zero address.
+ * - `feeNumerator` cannot be greater than the fee denominator.
+ */
+ function _setDefaultRoyalty(
+ address receiver,
+ uint96 feeNumerator
+ ) internal virtual {
+ require(
+ feeNumerator <= _feeDenominator(),
+ "ERC2981: royalty fee will exceed salePrice"
+ );
+ require(receiver != address(0), "ERC2981: invalid receiver");
+
+ _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
+ }
+
+ /**
+ * @dev Removes default royalty information.
+ */
+ function _deleteDefaultRoyalty() internal virtual {
+ delete _defaultRoyaltyInfo;
+ }
+
+ /**
+ * @dev Sets the royalty information for a specific token id, overriding the global default.
+ *
+ * Requirements:
+ *
+ * - `receiver` cannot be the zero address.
+ * - `feeNumerator` cannot be greater than the fee denominator.
+ */
+ function _setTokenRoyalty(
+ uint256 tokenId,
+ address receiver,
+ uint96 feeNumerator
+ ) internal virtual {
+ require(
+ feeNumerator <= _feeDenominator(),
+ "ERC2981: royalty fee will exceed salePrice"
+ );
+ require(receiver != address(0), "ERC2981: Invalid parameters");
+
+ _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
+ }
+
+ /**
+ * @dev Resets royalty information for the token id back to the global default.
+ */
+ function _resetTokenRoyalty(uint256 tokenId) internal virtual {
+ delete _tokenRoyaltyInfo[tokenId];
+ }
+}
diff --git a/contracts/test/HashCalldataContractOfferer.sol b/contracts/test/HashCalldataContractOfferer.sol
new file mode 100644
index 000000000..f6b452ec5
--- /dev/null
+++ b/contracts/test/HashCalldataContractOfferer.sol
@@ -0,0 +1,494 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../interfaces/AbridgedTokenInterfaces.sol";
+
+import { ItemType } from "../lib/ConsiderationEnums.sol";
+
+import {
+ ReceivedItem,
+ Schema,
+ SpentItem,
+ ZoneParameters
+} from "../lib/ConsiderationStructs.sol";
+
+import { ItemType, Side } from "../lib/ConsiderationEnums.sol";
+
+import {
+ ConsiderationInterface
+} from "../interfaces/ConsiderationInterface.sol";
+
+import {
+ ContractOffererInterface
+} from "../interfaces/ContractOffererInterface.sol";
+import { OffererZoneFailureReason } from "./OffererZoneFailureReason.sol";
+
+contract HashCalldataContractOfferer is ContractOffererInterface {
+ error HashCalldataContractOffererGenerateOrderReverts();
+ error HashCalldataContractOffererRatifyOrderReverts();
+
+ error NativeTokenTransferFailed();
+
+ event GenerateOrderDataHash(bytes32 orderHash, bytes32 dataHash);
+ event RatifyOrderDataHash(bytes32 orderHash, bytes32 dataHash);
+
+ struct ItemAmountMutation {
+ Side side;
+ uint256 index;
+ uint256 newAmount;
+ bytes32 orderHash;
+ }
+
+ struct DropItemMutation {
+ Side side;
+ uint256 index;
+ bytes32 orderHash;
+ }
+
+ struct ExtraItemMutation {
+ Side side;
+ ReceivedItem item;
+ bytes32 orderHash;
+ }
+
+ ItemAmountMutation[] public itemAmountMutations;
+ DropItemMutation[] public dropItemMutations;
+ ExtraItemMutation[] public extraItemMutations;
+
+ mapping(bytes32 => OffererZoneFailureReason) public failureReasons;
+
+ address private _SEAPORT;
+ address internal _expectedOfferRecipient;
+
+ mapping(bytes32 => bytes32) public orderHashToGenerateOrderDataHash;
+ mapping(bytes32 => bytes32) public orderHashToRatifyOrderDataHash;
+
+ function setFailureReason(
+ bytes32 orderHash,
+ OffererZoneFailureReason newFailureReason
+ ) external {
+ failureReasons[orderHash] = newFailureReason;
+ }
+
+ function addItemAmountMutation(
+ Side side,
+ uint256 index,
+ uint256 newAmount,
+ bytes32 orderHash
+ ) external {
+ // TODO: add safety checks to ensure that item is in range
+ // and that any failure-inducing mutations have the correct
+ // failure reason appropriately set
+
+ itemAmountMutations.push(
+ ItemAmountMutation(side, index, newAmount, orderHash)
+ );
+ }
+
+ function addDropItemMutation(
+ Side side,
+ uint256 index,
+ bytes32 orderHash
+ ) external {
+ // TODO: add safety checks to ensure that item is in range
+ // and that any failure-inducing mutations have the correct
+ // failure reason appropriately set; also should consider
+ // modifying existing indices in other mutations
+
+ dropItemMutations.push(DropItemMutation(side, index, orderHash));
+ }
+
+ function addExtraItemMutation(
+ Side side,
+ ReceivedItem calldata item,
+ bytes32 orderHash
+ ) external {
+ // TODO: add safety checks to ensure that a failure-inducing
+ // mutation has the correct failure reason appropriately set
+
+ extraItemMutations.push(ExtraItemMutation(side, item, orderHash));
+ }
+
+ function applyItemAmountMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ ItemAmountMutation memory mutation
+ ) internal pure returns (SpentItem[] memory, ReceivedItem[] memory) {
+ if (mutation.side == Side.OFFER && offer.length > mutation.index) {
+ offer[mutation.index].amount = mutation.newAmount;
+ } else if (consideration.length > mutation.index) {
+ consideration[mutation.index].amount = mutation.newAmount;
+ }
+ return (offer, consideration);
+ }
+
+ function applyDropItemMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ DropItemMutation memory mutation
+ )
+ internal
+ pure
+ returns (
+ SpentItem[] memory _offer,
+ ReceivedItem[] memory _consideration
+ )
+ {
+ if (mutation.side == Side.OFFER) {
+ _offer = dropIndex(offer, mutation.index);
+ _consideration = consideration;
+ } else {
+ _offer = offer;
+ _consideration = _cast(
+ dropIndex(_cast(consideration), mutation.index)
+ );
+ }
+ }
+
+ function dropIndex(
+ SpentItem[] memory items,
+ uint256 index
+ ) internal pure returns (SpentItem[] memory newItems) {
+ newItems = new SpentItem[](items.length - 1);
+ uint256 newIndex = 0;
+ uint256 originalLength = items.length;
+ for (uint256 i = 0; i < originalLength; i++) {
+ if (i != index) {
+ newItems[newIndex] = items[i];
+ newIndex++;
+ }
+ }
+ }
+
+ function _cast(
+ ReceivedItem[] memory items
+ ) internal pure returns (SpentItem[] memory _items) {
+ assembly {
+ _items := items
+ }
+ }
+
+ function _cast(
+ SpentItem[] memory items
+ ) internal pure returns (ReceivedItem[] memory _items) {
+ assembly {
+ _items := items
+ }
+ }
+
+ function applyExtraItemMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ ExtraItemMutation memory mutation
+ )
+ internal
+ pure
+ returns (
+ SpentItem[] memory _offer,
+ ReceivedItem[] memory _consideration
+ )
+ {
+ if (mutation.side == Side.OFFER) {
+ _offer = _cast(appendItem(_cast(offer), mutation.item));
+ _consideration = consideration;
+ } else {
+ _offer = offer;
+ _consideration = appendItem(consideration, mutation.item);
+ }
+ }
+
+ function appendItem(
+ ReceivedItem[] memory items,
+ ReceivedItem memory item
+ ) internal pure returns (ReceivedItem[] memory newItems) {
+ newItems = new ReceivedItem[](items.length + 1);
+ for (uint256 i = 0; i < items.length; i++) {
+ newItems[i] = items[i];
+ }
+ newItems[items.length] = item;
+ }
+
+ receive() external payable {}
+
+ constructor(address seaport) {
+ _SEAPORT = seaport;
+ }
+
+ /**
+ * @dev Generates an order with the specified minimum and maximum spent
+ * items. Validates data hash set in activate.
+ */
+ function generateOrder(
+ address fulfiller,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata c
+ )
+ external
+ virtual
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ uint256 contractOffererNonce = ConsiderationInterface(_SEAPORT)
+ .getContractOffererNonce(address(this));
+
+ bytes32 orderHash = bytes32(
+ contractOffererNonce ^ (uint256(uint160(address(this))) << 96)
+ );
+
+ if (
+ failureReasons[orderHash] ==
+ OffererZoneFailureReason.ContractOfferer_generateReverts
+ ) {
+ revert HashCalldataContractOffererGenerateOrderReverts();
+ } else if (
+ failureReasons[orderHash] ==
+ OffererZoneFailureReason
+ .ContractOfferer_generateReturnsInvalidEncoding
+ ) {
+ assembly {
+ mstore(0, 0x12345678)
+ return(0, 0x20)
+ }
+ }
+
+ {
+ // Create a variable to store msg.data in memory
+ bytes memory data = new bytes(msg.data.length);
+
+ // Copy msg.data to memory
+ assembly {
+ calldatacopy(add(data, 0x20), 0, calldatasize())
+ }
+
+ bytes32 calldataHash = keccak256(data);
+
+ // Store the hash of msg.data
+ orderHashToGenerateOrderDataHash[orderHash] = calldataHash;
+
+ emit GenerateOrderDataHash(orderHash, calldataHash);
+ }
+
+ (offer, consideration) = previewOrder(msg.sender, fulfiller, a, b, c);
+
+ (bool success, ) = payable(_SEAPORT).call{
+ value: _getOfferedNativeTokens(offer)
+ }("");
+
+ if (!success) {
+ revert NativeTokenTransferFailed();
+ }
+ }
+
+ /**
+ * @dev View function to preview an order generated in response to a minimum
+ * set of received items, maximum set of spent items, and context
+ * (supplied as extraData).
+ */
+ function previewOrder(
+ address caller,
+ address,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata
+ )
+ public
+ view
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ require(
+ caller == _SEAPORT,
+ "HashCalldataContractOfferer: caller not seaport"
+ );
+
+ uint256 contractOffererNonce = ConsiderationInterface(_SEAPORT)
+ .getContractOffererNonce(address(this));
+
+ bytes32 orderHash = bytes32(
+ contractOffererNonce ^ (uint256(uint160(address(this))) << 96)
+ );
+
+ (offer, consideration) = (a, _convertSpentToReceived(b));
+
+ for (uint256 i; i < itemAmountMutations.length; i++) {
+ if (itemAmountMutations[i].orderHash == orderHash) {
+ (offer, consideration) = applyItemAmountMutation(
+ offer,
+ consideration,
+ itemAmountMutations[i]
+ );
+ }
+ }
+ for (uint256 i; i < extraItemMutations.length; i++) {
+ if (extraItemMutations[i].orderHash == orderHash) {
+ (offer, consideration) = applyExtraItemMutation(
+ offer,
+ consideration,
+ extraItemMutations[i]
+ );
+ }
+ }
+ for (uint256 i; i < dropItemMutations.length; i++) {
+ if (dropItemMutations[i].orderHash == orderHash) {
+ (offer, consideration) = applyDropItemMutation(
+ offer,
+ consideration,
+ dropItemMutations[i]
+ );
+ }
+ }
+
+ return (offer, consideration);
+ }
+
+ /**
+ * @dev Ratifies that the parties have received the correct items.
+ *
+ * @custom:param minimumReceived The minimum items that the caller was
+ * willing to receive.
+ * @custom:param maximumSpent The maximum items that the caller was
+ * willing to spend.
+ * @custom:param context The context of the order.
+ * @custom:param orderHashes The order hashes, unused here.
+ * @custom:param contractNonce The contract nonce, unused here.
+ *
+ * @return ratifyOrderMagicValue The magic value to indicate things are OK.
+ */
+ function ratifyOrder(
+ SpentItem[] calldata /* minimumReceived */,
+ ReceivedItem[] calldata /* maximumSpent */,
+ bytes calldata /* context */,
+ bytes32[] calldata /* orderHashes */,
+ uint256 contractNonce
+ ) external override returns (bytes4 /* ratifyOrderMagicValue */) {
+ require(
+ msg.sender == _SEAPORT,
+ "HashCalldataContractOfferer: ratify caller not seaport"
+ );
+
+ bytes32 orderHash = bytes32(
+ contractNonce ^ (uint256(uint160(address(this))) << 96)
+ );
+
+ if (
+ failureReasons[orderHash] ==
+ OffererZoneFailureReason.ContractOfferer_ratifyReverts
+ ) {
+ revert HashCalldataContractOffererRatifyOrderReverts();
+ }
+
+ // Ratify the order.
+ {
+ // Create a variable to store msg.data in memory
+ bytes memory data = new bytes(msg.data.length);
+
+ // Copy msg.data to memory
+ assembly {
+ calldatacopy(add(data, 0x20), 0, calldatasize())
+ }
+
+ bytes32 calldataHash = keccak256(data);
+
+ // Store the hash of msg.data
+ orderHashToRatifyOrderDataHash[orderHash] = calldataHash;
+
+ emit RatifyOrderDataHash(orderHash, calldataHash);
+ }
+
+ if (
+ failureReasons[orderHash] ==
+ OffererZoneFailureReason.ContractOfferer_InvalidMagicValue
+ ) {
+ return bytes4(0x12345678);
+ } else {
+ // Return the selector of ratifyOrder as the magic value.
+ return this.ratifyOrder.selector;
+ }
+ }
+
+ /**
+ * @dev Allows us to set Seaport address following deployment.
+ *
+ * @param seaportAddress The Seaport address.
+ */
+ function setSeaportAddress(address seaportAddress) external {
+ _SEAPORT = seaportAddress;
+ }
+
+ function getSeaportMetadata()
+ external
+ pure
+ override(ContractOffererInterface)
+ returns (string memory name, Schema[] memory schemas)
+ {
+ // Return the metadata.
+ name = "TestCalldataHashContractOfferer";
+ schemas = new Schema[](1);
+ schemas[0].id = 1337;
+ schemas[0].metadata = new bytes(0);
+ }
+
+ function _convertSpentToReceived(
+ SpentItem[] calldata spentItems
+ ) internal view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ spentItems.length
+ );
+ for (uint256 i = 0; i < spentItems.length; ++i) {
+ receivedItems[i] = _convertSpentToReceived(spentItems[i]);
+ }
+ return receivedItems;
+ }
+
+ function _convertSpentToReceived(
+ SpentItem calldata spentItem
+ ) internal view returns (ReceivedItem memory) {
+ return
+ ReceivedItem({
+ itemType: spentItem.itemType,
+ token: spentItem.token,
+ identifier: spentItem.identifier,
+ amount: spentItem.amount,
+ recipient: payable(address(this))
+ });
+ }
+
+ function _getOfferedNativeTokens(
+ SpentItem[] memory offer
+ ) internal pure returns (uint256 amount) {
+ for (uint256 i = 0; i < offer.length; ++i) {
+ SpentItem memory item = offer[i];
+ if (item.itemType == ItemType.NATIVE) {
+ amount += item.amount;
+ }
+ }
+ }
+
+ /**
+ * @dev Enable accepting ERC1155 tokens via safeTransfer.
+ */
+ function onERC1155Received(
+ address,
+ address,
+ uint256,
+ uint256,
+ bytes calldata
+ ) external pure returns (bytes4) {
+ return this.onERC1155Received.selector;
+ }
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view virtual override(ContractOffererInterface) returns (bool) {
+ return interfaceId == type(ContractOffererInterface).interfaceId;
+ }
+
+ function setExpectedOfferRecipient(address expectedOfferRecipient) public {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
+}
diff --git a/contracts/test/HashValidationZoneOfferer.sol b/contracts/test/HashValidationZoneOfferer.sol
new file mode 100644
index 000000000..7c250ecfc
--- /dev/null
+++ b/contracts/test/HashValidationZoneOfferer.sol
@@ -0,0 +1,641 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../interfaces/AbridgedTokenInterfaces.sol";
+
+import {
+ ReceivedItem,
+ Schema,
+ SpentItem,
+ ZoneParameters
+} from "../lib/ConsiderationStructs.sol";
+
+import { ItemType, Side } from "../lib/ConsiderationEnums.sol";
+
+import {
+ ContractOffererInterface
+} from "../interfaces/ContractOffererInterface.sol";
+
+import { ZoneInterface } from "../interfaces/ZoneInterface.sol";
+import { OffererZoneFailureReason } from "./OffererZoneFailureReason.sol";
+
+/**
+ * @dev This contract is used to validate hashes. Use the
+ * TestTransferValidationZoneOfferer to validate transfers within the
+ * zone/offerer.
+ */
+contract HashValidationZoneOfferer is ContractOffererInterface, ZoneInterface {
+ error InvalidNativeTokenBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress
+ );
+ error InvalidERC20Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ error InvalidERC1155Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ // 0x38fb386a
+ error InvalidOwner(
+ address expectedOwner,
+ address actualOwner,
+ address checkedToken,
+ uint256 checkedTokenId
+ );
+ error IncorrectSeaportBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance
+ );
+ error HashValidationZoneOffererValidateOrderReverts();
+ error HashValidationZoneOffererRatifyOrderReverts();
+ event ValidateOrderDataHash(bytes32 dataHash);
+
+ struct ItemAmountMutation {
+ Side side;
+ uint256 index;
+ uint256 newAmount;
+ }
+
+ struct DropItemMutation {
+ Side side;
+ uint256 index;
+ }
+
+ struct ExtraItemMutation {
+ Side side;
+ ReceivedItem item;
+ }
+
+ ItemAmountMutation[] public itemAmountMutations;
+ DropItemMutation[] public dropItemMutations;
+ ExtraItemMutation[] public extraItemMutations;
+
+ function addItemAmountMutation(
+ Side side,
+ uint256 index,
+ uint256 newAmount
+ ) external {
+ itemAmountMutations.push(ItemAmountMutation(side, index, newAmount));
+ }
+
+ function addDropItemMutation(Side side, uint256 index) external {
+ dropItemMutations.push(DropItemMutation(side, index));
+ }
+
+ function addExtraItemMutation(
+ Side side,
+ ReceivedItem calldata item
+ ) external {
+ extraItemMutations.push(ExtraItemMutation(side, item));
+ }
+
+ function applyItemAmountMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ ItemAmountMutation memory mutation
+ ) internal pure returns (SpentItem[] memory, ReceivedItem[] memory) {
+ if (mutation.side == Side.OFFER) {
+ offer[mutation.index].amount = mutation.newAmount;
+ } else {
+ consideration[mutation.index].amount = mutation.newAmount;
+ }
+ return (offer, consideration);
+ }
+
+ function applyDropItemMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ DropItemMutation memory mutation
+ )
+ internal
+ pure
+ returns (
+ SpentItem[] memory _offer,
+ ReceivedItem[] memory _consideration
+ )
+ {
+ if (mutation.side == Side.OFFER) {
+ _offer = dropIndex(offer, mutation.index);
+ _consideration = consideration;
+ } else {
+ _offer = offer;
+ _consideration = _cast(
+ dropIndex(_cast(consideration), mutation.index)
+ );
+ }
+ }
+
+ function dropIndex(
+ SpentItem[] memory items,
+ uint256 index
+ ) internal pure returns (SpentItem[] memory newItems) {
+ newItems = new SpentItem[](items.length - 1);
+ uint256 newIndex = 0;
+ uint256 originalLength = items.length;
+ for (uint256 i = 0; i < originalLength; i++) {
+ if (i != index) {
+ newItems[newIndex] = items[i];
+ newIndex++;
+ }
+ }
+ }
+
+ function _cast(
+ ReceivedItem[] memory items
+ ) internal pure returns (SpentItem[] memory _items) {
+ assembly {
+ _items := items
+ }
+ }
+
+ function _cast(
+ SpentItem[] memory items
+ ) internal pure returns (ReceivedItem[] memory _items) {
+ assembly {
+ _items := items
+ }
+ }
+
+ function applyExtraItemMutation(
+ SpentItem[] memory offer,
+ ReceivedItem[] memory consideration,
+ ExtraItemMutation memory mutation
+ )
+ internal
+ pure
+ returns (
+ SpentItem[] memory _offer,
+ ReceivedItem[] memory _consideration
+ )
+ {
+ if (mutation.side == Side.OFFER) {
+ _offer = _cast(appendItem(_cast(offer), mutation.item));
+ _consideration = consideration;
+ } else {
+ _offer = offer;
+ _consideration = appendItem(consideration, mutation.item);
+ }
+ }
+
+ function appendItem(
+ ReceivedItem[] memory items,
+ ReceivedItem memory item
+ ) internal pure returns (ReceivedItem[] memory newItems) {
+ newItems = new ReceivedItem[](items.length + 1);
+ for (uint256 i = 0; i < items.length; i++) {
+ newItems[i] = items[i];
+ }
+ newItems[items.length] = item;
+ }
+
+ receive() external payable {}
+
+ address internal _expectedOfferRecipient;
+
+ mapping(bytes32 => bytes32) public orderHashToValidateOrderDataHash;
+
+ // Pass in the null address to expect the fulfiller.
+ constructor(address expectedOfferRecipient) {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
+
+ bool public called = false;
+ uint public callCount = 0;
+
+ mapping(bytes32 => OffererZoneFailureReason) public failureReasons;
+
+ function setFailureReason(
+ bytes32 orderHash,
+ OffererZoneFailureReason newFailureReason
+ ) external {
+ failureReasons[orderHash] = newFailureReason;
+ }
+
+ /**
+ * @dev Validates that the parties have received the correct items.
+ *
+ * @param zoneParameters The zone parameters, including the SpentItem and
+ * ReceivedItem arrays.
+ *
+ * @return validOrderMagicValue The magic value to indicate things are OK.
+ */
+ function validateOrder(
+ ZoneParameters calldata zoneParameters
+ ) external override returns (bytes4 validOrderMagicValue) {
+ // Get the orderHash from zoneParameters
+ bytes32 orderHash = zoneParameters.orderHash;
+
+ if (
+ failureReasons[orderHash] == OffererZoneFailureReason.Zone_reverts
+ ) {
+ revert HashValidationZoneOffererValidateOrderReverts();
+ }
+ // Validate the order.
+
+ // Currently assumes that the balances of all tokens of addresses are
+ // zero at the start of the transaction. Accordingly, take care to
+ // use an address in tests that is not pre-populated with tokens.
+
+ // Get the length of msg.data
+ uint256 dataLength = msg.data.length;
+
+ // Create a variable to store msg.data in memory
+ bytes memory data;
+
+ // Copy msg.data to memory
+ assembly {
+ let ptr := mload(0x40)
+ calldatacopy(add(ptr, 0x20), 0, dataLength)
+ mstore(ptr, dataLength)
+ data := ptr
+ }
+
+ // Get the hash of msg.data
+ bytes32 calldataHash = keccak256(data);
+
+ // Store callDataHash in orderHashToValidateOrderDataHash
+ orderHashToValidateOrderDataHash[orderHash] = calldataHash;
+
+ // Emit a DataHash event with the hash of msg.data
+ emit ValidateOrderDataHash(calldataHash);
+
+ // Check if Seaport is empty. This makes sure that we've transferred
+ // all native token balance out of Seaport before we do the validation.
+ uint256 seaportBalance = address(msg.sender).balance;
+
+ if (seaportBalance > 0) {
+ revert IncorrectSeaportBalance(0, seaportBalance);
+ }
+
+ // Set the global called flag to true.
+ called = true;
+ callCount++;
+
+ if (
+ failureReasons[orderHash] ==
+ OffererZoneFailureReason.Zone_InvalidMagicValue
+ ) {
+ validOrderMagicValue = bytes4(0x12345678);
+ } else {
+ // Return the selector of validateOrder as the magic value.
+ validOrderMagicValue = this.validateOrder.selector;
+ }
+ }
+
+ /**
+ * @dev Generates an order with the specified minimum and maximum spent
+ * items.
+ */
+ function generateOrder(
+ address,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata c
+ )
+ external
+ virtual
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ (offer, consideration) = previewOrder(
+ address(this),
+ address(this),
+ a,
+ b,
+ c
+ );
+
+ for (uint256 i; i < itemAmountMutations.length; i++) {
+ (offer, consideration) = applyItemAmountMutation(
+ offer,
+ consideration,
+ itemAmountMutations[i]
+ );
+ }
+ for (uint256 i; i < extraItemMutations.length; i++) {
+ (offer, consideration) = applyExtraItemMutation(
+ offer,
+ consideration,
+ extraItemMutations[i]
+ );
+ }
+ for (uint256 i; i < dropItemMutations.length; i++) {
+ (offer, consideration) = applyDropItemMutation(
+ offer,
+ consideration,
+ dropItemMutations[i]
+ );
+ }
+
+ return (offer, consideration);
+ }
+
+ /**
+ * @dev View function to preview an order generated in response to a minimum
+ * set of received items, maximum set of spent items, and context
+ * (supplied as extraData).
+ */
+ function previewOrder(
+ address,
+ address,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata
+ )
+ public
+ view
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ return (a, _convertSpentToReceived(b));
+ }
+
+ /**
+ * @dev Ratifies that the parties have received the correct items.
+ *
+ * @param minimumReceived The minimum items that the caller was willing to
+ * receive.
+ * @param maximumSpent The maximum items that the caller was willing to
+ * spend.
+ * @param context The context of the order.
+ * @ param orderHashes The order hashes, unused here.
+ * @ param contractNonce The contract nonce, unused here.
+ *
+ * @return ratifyOrderMagicValue The magic value to indicate things are OK.
+ */
+ function ratifyOrder(
+ SpentItem[] calldata minimumReceived /* offer */,
+ ReceivedItem[] calldata maximumSpent /* consideration */,
+ bytes calldata context /* context */,
+ bytes32[] calldata /* orderHashes */,
+ uint256 /* contractNonce */
+ ) external override returns (bytes4 /* ratifyOrderMagicValue */) {
+ // Ratify the order.
+ // Check if Seaport is empty. This makes sure that we've transferred
+ // all native token balance out of Seaport before we do the validation.
+ uint256 seaportBalance = address(msg.sender).balance;
+
+ if (seaportBalance > 0) {
+ revert IncorrectSeaportBalance(0, seaportBalance);
+ }
+
+ // Ensure that the offerer or recipient has received all consideration
+ // items.
+ _assertValidReceivedItems(maximumSpent);
+
+ // It's necessary to pass in either an expected offerer or an address
+ // in the context. If neither is provided, this ternary will revert
+ // with a generic, hard-to-debug revert when it tries to slice bytes
+ // from the context.
+ address expectedOfferRecipient = _expectedOfferRecipient == address(0)
+ ? address(bytes20(context[0:20]))
+ : _expectedOfferRecipient;
+
+ // Ensure that the expected recipient has received all offer items.
+ _assertValidSpentItems(expectedOfferRecipient, minimumReceived);
+
+ // Set the global called flag to true.
+ called = true;
+ callCount++;
+
+ return this.ratifyOrder.selector;
+ }
+
+ function getSeaportMetadata()
+ external
+ pure
+ override(ContractOffererInterface, ZoneInterface)
+ returns (string memory name, Schema[] memory schemas)
+ {
+ // Return the metadata.
+ name = "TestTransferValidationZoneOfferer";
+ schemas = new Schema[](1);
+ schemas[0].id = 1337;
+ schemas[0].metadata = new bytes(0);
+ }
+
+ function _convertSpentToReceived(
+ SpentItem[] calldata spentItems
+ ) internal view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ spentItems.length
+ );
+ for (uint256 i = 0; i < spentItems.length; ++i) {
+ receivedItems[i] = _convertSpentToReceived(spentItems[i]);
+ }
+ return receivedItems;
+ }
+
+ function _convertSpentToReceived(
+ SpentItem calldata spentItem
+ ) internal view returns (ReceivedItem memory) {
+ return
+ ReceivedItem({
+ itemType: spentItem.itemType,
+ token: spentItem.token,
+ identifier: spentItem.identifier,
+ amount: spentItem.amount,
+ recipient: payable(address(this))
+ });
+ }
+
+ function _assertValidReceivedItems(
+ ReceivedItem[] calldata receivedItems
+ ) internal view {
+ address recipient;
+ ItemType itemType;
+ ReceivedItem memory receivedItem;
+
+ // Iterate over all received items.
+ for (uint256 i = 0; i < receivedItems.length; i++) {
+ // Check if the consideration item has been received.
+ receivedItem = receivedItems[i];
+ // Get the recipient of the consideration item.
+ recipient = receivedItem.recipient;
+ // Get item type.
+ itemType = receivedItem.itemType;
+
+ // Check balance/ownerOf depending on item type.
+ if (itemType == ItemType.NATIVE) {
+ // NATIVE Token
+ _assertNativeTokenTransfer(receivedItem.amount, recipient);
+ } else if (itemType == ItemType.ERC20) {
+ // ERC20 Token
+ _assertERC20Transfer(
+ receivedItem.amount,
+ receivedItem.token,
+ recipient
+ );
+ } else if (itemType == ItemType.ERC721) {
+ // ERC721 Token
+ _assertERC721Transfer(
+ receivedItem.identifier,
+ receivedItem.token,
+ recipient
+ );
+ } else if (itemType == ItemType.ERC1155) {
+ // ERC1155 Token
+ _assertERC1155Transfer(
+ receivedItem.amount,
+ receivedItem.identifier,
+ receivedItem.token,
+ recipient
+ );
+ }
+ }
+ }
+
+ function _assertValidSpentItems(
+ address expectedRecipient,
+ SpentItem[] calldata spentItems
+ ) internal view {
+ SpentItem memory spentItem;
+ ItemType itemType;
+
+ // Iterate over all spent items.
+ for (uint256 i = 0; i < spentItems.length; i++) {
+ // Check if the offer item has been spent.
+ spentItem = spentItems[i];
+ // Get item type.
+ itemType = spentItem.itemType;
+
+ // Check balance/ownerOf depending on item type.
+ if (itemType == ItemType.NATIVE) {
+ // NATIVE Token
+ _assertNativeTokenTransfer(spentItem.amount, expectedRecipient);
+ } else if (itemType == ItemType.ERC20) {
+ // ERC20 Token
+ _assertERC20Transfer(
+ spentItem.amount,
+ spentItem.token,
+ expectedRecipient
+ );
+ } else if (itemType == ItemType.ERC721) {
+ // ERC721 Token
+ _assertERC721Transfer(
+ spentItem.identifier,
+ spentItem.token,
+ expectedRecipient
+ );
+ } else if (itemType == ItemType.ERC1155) {
+ // ERC1155 Token
+ _assertERC1155Transfer(
+ spentItem.amount,
+ spentItem.identifier,
+ spentItem.token,
+ expectedRecipient
+ );
+ }
+ }
+ }
+
+ function _assertNativeTokenTransfer(
+ uint256 expectedAmount,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient then revert, because that means the recipient did not
+ // receive the expected amount at the time the order was ratified or
+ // validated.
+ if (expectedAmount > address(expectedRecipient).balance) {
+ revert InvalidNativeTokenBalance(
+ expectedAmount,
+ address(expectedRecipient).balance,
+ expectedRecipient
+ );
+ }
+ }
+
+ function _assertERC20Transfer(
+ uint256 expectedAmount,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount > ERC20Interface(token).balanceOf(expectedRecipient)
+ ) {
+ revert InvalidERC20Balance(
+ expectedAmount,
+ ERC20Interface(token).balanceOf(expectedRecipient),
+ expectedRecipient,
+ token
+ );
+ }
+ }
+
+ function _assertERC721Transfer(
+ uint256 checkedTokenId,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the actual owner of the token is not the expected recipient,
+ // revert.
+ address actualOwner = ERC721Interface(token).ownerOf(checkedTokenId);
+ if (expectedRecipient != actualOwner) {
+ revert InvalidOwner(
+ expectedRecipient,
+ actualOwner,
+ token,
+ checkedTokenId
+ );
+ }
+ }
+
+ function _assertERC1155Transfer(
+ uint256 expectedAmount,
+ uint256 identifier,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount >
+ ERC1155Interface(token).balanceOf(expectedRecipient, identifier)
+ ) {
+ revert InvalidERC1155Balance(
+ expectedAmount,
+ ERC1155Interface(token).balanceOf(
+ expectedRecipient,
+ identifier
+ ),
+ expectedRecipient,
+ token
+ );
+ }
+ }
+
+ function setExpectedOfferRecipient(address expectedOfferRecipient) public {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
+
+ function supportsInterface(
+ bytes4 interfaceId
+ )
+ public
+ view
+ virtual
+ override(ContractOffererInterface, ZoneInterface)
+ returns (bool)
+ {
+ return
+ interfaceId == type(ContractOffererInterface).interfaceId ||
+ interfaceId == type(ZoneInterface).interfaceId;
+ }
+}
diff --git a/contracts/test/OffererZoneFailureReason.sol b/contracts/test/OffererZoneFailureReason.sol
new file mode 100644
index 000000000..c4ce07d7c
--- /dev/null
+++ b/contracts/test/OffererZoneFailureReason.sol
@@ -0,0 +1,16 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+enum OffererZoneFailureReason {
+ None,
+ ContractOfferer_generateReverts, // Offerer generateOrder reverts
+ ContractOfferer_generateReturnsInvalidEncoding, // Bad encoding
+ ContractOfferer_ratifyReverts, // Offerer ratifyOrder reverts
+ ContractOfferer_InsufficientMinimumReceived, // too few minimum received items
+ ContractOfferer_IncorrectMinimumReceived, // incorrect (insufficient amount, wrong token, etc.) minimum received items
+ ContractOfferer_ExcessMaximumSpent, // too many maximum spent items
+ ContractOfferer_IncorrectMaximumSpent, // incorrect (too many, wrong token, etc.) maximum spent items
+ ContractOfferer_InvalidMagicValue, // Offerer did not return correct magic value
+ Zone_reverts, // Zone validateOrder call reverts
+ Zone_InvalidMagicValue // Zone validateOrder call returns invalid magic value
+}
diff --git a/contracts/test/TestBadContractOfferer.sol b/contracts/test/TestBadContractOfferer.sol
index 8b2272eae..07c7bf1fd 100644
--- a/contracts/test/TestBadContractOfferer.sol
+++ b/contracts/test/TestBadContractOfferer.sol
@@ -122,6 +122,12 @@ contract TestBadContractOfferer is ContractOffererInterface {
return TestBadContractOfferer.ratifyOrder.selector;
}
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view virtual override(ContractOffererInterface) returns (bool) {
+ return interfaceId == type(ContractOffererInterface).interfaceId;
+ }
+
/**
* @dev Returns the metadata for this contract offerer.
*/
diff --git a/contracts/test/TestCalldataHashContractOfferer.sol b/contracts/test/TestCalldataHashContractOfferer.sol
new file mode 100644
index 000000000..679da7396
--- /dev/null
+++ b/contracts/test/TestCalldataHashContractOfferer.sol
@@ -0,0 +1,495 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../interfaces/AbridgedTokenInterfaces.sol";
+
+import {
+ ReceivedItem,
+ Schema,
+ SpentItem,
+ ZoneParameters
+} from "../lib/ConsiderationStructs.sol";
+
+import { ItemType } from "../lib/ConsiderationEnums.sol";
+
+import {
+ ConsiderationInterface
+} from "../interfaces/ConsiderationInterface.sol";
+
+import {
+ ContractOffererInterface
+} from "../interfaces/ContractOffererInterface.sol";
+
+contract TestCalldataHashContractOfferer is ContractOffererInterface {
+ error InvalidNativeTokenBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress
+ );
+ error InvalidERC20Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ error InvalidERC1155Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ // 0x38fb386a
+ error InvalidOwner(
+ address expectedOwner,
+ address actualOwner,
+ address checkedToken,
+ uint256 checkedTokenId
+ );
+ error IncorrectSeaportBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance
+ );
+ error InvalidDataHash(bytes32 expectedDataHash, bytes32 actualDataHash);
+ error InvalidEthBalance(uint256 expectedBalance, uint256 actualBalance);
+ error NativeTokenTransferFailed();
+
+ event GenerateOrderDataHash(bytes32 orderHash, bytes32 dataHash);
+ event RatifyOrderDataHash(bytes32 orderHash, bytes32 dataHash);
+
+ address private immutable _SEAPORT;
+ address internal _expectedOfferRecipient;
+
+ mapping(bytes32 => bytes32) public orderHashToGenerateOrderDataHash;
+ mapping(bytes32 => bytes32) public orderHashToRatifyOrderDataHash;
+
+ receive() external payable {}
+
+ constructor(address seaport) {
+ _SEAPORT = seaport;
+ }
+
+ /**
+ * @dev Sets approvals and transfers minimumReceived tokens to contract.
+ * Also stores the expected hash of msg.data to be sent in subsequent
+ * call to generateOrder.
+ */
+ function activate(
+ address,
+ SpentItem[] memory minimumReceived,
+ SpentItem[] memory /* maximumSpent */,
+ bytes calldata /* context */
+ ) public payable {
+ uint256 requiredEthBalance;
+ uint256 minimumReceivedLength = minimumReceived.length;
+
+ for (uint256 i = 0; i < minimumReceivedLength; i++) {
+ SpentItem memory item = minimumReceived[i];
+
+ if (item.itemType == ItemType.ERC721) {
+ ERC721Interface token = ERC721Interface(item.token);
+
+ token.transferFrom(msg.sender, address(this), item.identifier);
+
+ token.setApprovalForAll(_SEAPORT, true);
+ } else if (item.itemType == ItemType.ERC1155) {
+ ERC1155Interface token = ERC1155Interface(item.token);
+
+ token.safeTransferFrom(
+ msg.sender,
+ address(this),
+ item.identifier,
+ item.amount,
+ ""
+ );
+
+ token.setApprovalForAll(_SEAPORT, true);
+ } else if (item.itemType == ItemType.ERC20) {
+ ERC20Interface token = ERC20Interface(item.token);
+
+ token.transferFrom(msg.sender, address(this), item.amount);
+
+ token.approve(_SEAPORT, item.amount);
+ } else if (item.itemType == ItemType.NATIVE) {
+ requiredEthBalance += item.amount;
+ }
+ }
+
+ if (msg.value != requiredEthBalance) {
+ revert InvalidEthBalance(requiredEthBalance, msg.value);
+ }
+ }
+
+ /**
+ * @dev Generates an order with the specified minimum and maximum spent
+ * items. Validates data hash set in activate.
+ */
+ function generateOrder(
+ address,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata c
+ )
+ external
+ virtual
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ {
+ (bool success, ) = payable(_SEAPORT).call{
+ value: address(this).balance
+ }("");
+
+ if (!success) {
+ revert NativeTokenTransferFailed();
+ }
+
+ // Get the length of msg.data
+ uint256 dataLength = msg.data.length;
+
+ // Create a variable to store msg.data in memory
+ bytes memory data;
+
+ // Copy msg.data to memory
+ assembly {
+ let ptr := mload(0x40)
+ calldatacopy(add(ptr, 0x20), 0, dataLength)
+ mstore(ptr, dataLength)
+ data := ptr
+ }
+
+ bytes32 calldataHash = keccak256(data);
+
+ uint256 contractOffererNonce = ConsiderationInterface(_SEAPORT)
+ .getContractOffererNonce(address(this));
+
+ bytes32 orderHash = bytes32(
+ contractOffererNonce ^ (uint256(uint160(address(this))) << 96)
+ );
+
+ // Store the hash of msg.data
+ orderHashToGenerateOrderDataHash[orderHash] = calldataHash;
+
+ emit GenerateOrderDataHash(orderHash, calldataHash);
+ }
+
+ return previewOrder(address(this), address(this), a, b, c);
+ }
+
+ /**
+ * @dev View function to preview an order generated in response to a minimum
+ * set of received items, maximum set of spent items, and context
+ * (supplied as extraData).
+ */
+ function previewOrder(
+ address,
+ address,
+ SpentItem[] calldata a,
+ SpentItem[] calldata b,
+ bytes calldata
+ )
+ public
+ view
+ override
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ return (a, _convertSpentToReceived(b));
+ }
+
+ /**
+ * @dev Ratifies that the parties have received the correct items.
+ *
+ * @param minimumReceived The minimum items that the caller was willing to
+ * receive.
+ * @param maximumSpent The maximum items that the caller was willing to
+ * spend.
+ * @param context The context of the order.
+ * @ param orderHashes The order hashes, unused here.
+ * @ param contractNonce The contract nonce, unused here.
+ *
+ * @return ratifyOrderMagicValue The magic value to indicate things are OK.
+ */
+ function ratifyOrder(
+ SpentItem[] calldata minimumReceived /* offer */,
+ ReceivedItem[] calldata maximumSpent /* consideration */,
+ bytes calldata context /* context */,
+ bytes32[] calldata /* orderHashes */,
+ uint256 /* contractNonce */
+ ) external override returns (bytes4 /* ratifyOrderMagicValue */) {
+ // Ratify the order.
+ {
+ // Get the length of msg.data
+ uint256 dataLength = msg.data.length;
+
+ // Create a variable to store msg.data in memory
+ bytes memory data;
+
+ // Copy msg.data to memory
+ assembly {
+ let ptr := mload(0x40)
+ calldatacopy(add(ptr, 0x20), 0, dataLength)
+ mstore(ptr, dataLength)
+ data := ptr
+ }
+
+ bytes32 calldataHash = keccak256(data);
+
+ uint256 contractOffererNonce = ConsiderationInterface(_SEAPORT)
+ .getContractOffererNonce(address(this));
+
+ bytes32 orderHash = bytes32(
+ contractOffererNonce ^ (uint256(uint160(address(this))) << 96)
+ );
+
+ // Store the hash of msg.data
+ orderHashToRatifyOrderDataHash[orderHash] = calldataHash;
+
+ emit RatifyOrderDataHash(orderHash, calldataHash);
+ // Check if Seaport is empty. This makes sure that we've transferred
+ // all native token balance out of Seaport before we do the validation.
+ uint256 seaportBalance = address(msg.sender).balance;
+
+ if (seaportBalance > 0) {
+ revert IncorrectSeaportBalance(0, seaportBalance);
+ }
+ // Ensure that the offerer or recipient has received all consideration
+ // items.
+ _assertValidReceivedItems(maximumSpent);
+ }
+
+ // It's necessary to pass in either an expected offerer or an address
+ // in the context. If neither is provided, this ternary will revert
+ // with a generic, hard-to-debug revert when it tries to slice bytes
+ // from the context.
+ address expectedOfferRecipient = _expectedOfferRecipient == address(0)
+ ? address(bytes20(context[0:20]))
+ : _expectedOfferRecipient;
+
+ // Ensure that the expected recipient has received all offer items.
+ _assertValidSpentItems(expectedOfferRecipient, minimumReceived);
+
+ return this.ratifyOrder.selector;
+ }
+
+ function getSeaportMetadata()
+ external
+ pure
+ override(ContractOffererInterface)
+ returns (string memory name, Schema[] memory schemas)
+ {
+ // Return the metadata.
+ name = "TestCalldataHashContractOfferer";
+ schemas = new Schema[](1);
+ schemas[0].id = 1337;
+ schemas[0].metadata = new bytes(0);
+ }
+
+ function _convertSpentToReceived(
+ SpentItem[] calldata spentItems
+ ) internal view returns (ReceivedItem[] memory) {
+ ReceivedItem[] memory receivedItems = new ReceivedItem[](
+ spentItems.length
+ );
+ for (uint256 i = 0; i < spentItems.length; ++i) {
+ receivedItems[i] = _convertSpentToReceived(spentItems[i]);
+ }
+ return receivedItems;
+ }
+
+ function _convertSpentToReceived(
+ SpentItem calldata spentItem
+ ) internal view returns (ReceivedItem memory) {
+ return
+ ReceivedItem({
+ itemType: spentItem.itemType,
+ token: spentItem.token,
+ identifier: spentItem.identifier,
+ amount: spentItem.amount,
+ recipient: payable(address(this))
+ });
+ }
+
+ function _assertValidReceivedItems(
+ ReceivedItem[] calldata receivedItems
+ ) internal view {
+ address recipient;
+ ItemType itemType;
+ ReceivedItem memory receivedItem;
+
+ // Iterate over all received items.
+ for (uint256 i = 0; i < receivedItems.length; i++) {
+ // Check if the consideration item has been received.
+ receivedItem = receivedItems[i];
+ // Get the recipient of the consideration item.
+ recipient = receivedItem.recipient;
+ // Get item type.
+ itemType = receivedItem.itemType;
+
+ // Check balance/ownerOf depending on item type.
+ if (itemType == ItemType.NATIVE) {
+ // NATIVE Token
+ _assertNativeTokenTransfer(receivedItem.amount, recipient);
+ } else if (itemType == ItemType.ERC20) {
+ // ERC20 Token
+ _assertERC20Transfer(
+ receivedItem.amount,
+ receivedItem.token,
+ recipient
+ );
+ } else if (itemType == ItemType.ERC721) {
+ // ERC721 Token
+ _assertERC721Transfer(
+ receivedItem.identifier,
+ receivedItem.token,
+ recipient
+ );
+ } else if (itemType == ItemType.ERC1155) {
+ // ERC1155 Token
+ _assertERC1155Transfer(
+ receivedItem.amount,
+ receivedItem.identifier,
+ receivedItem.token,
+ recipient
+ );
+ }
+ }
+ }
+
+ function _assertValidSpentItems(
+ address expectedRecipient,
+ SpentItem[] calldata spentItems
+ ) internal view {
+ SpentItem memory spentItem;
+ ItemType itemType;
+
+ // Iterate over all spent items.
+ for (uint256 i = 0; i < spentItems.length; i++) {
+ // Check if the offer item has been spent.
+ spentItem = spentItems[i];
+ // Get item type.
+ itemType = spentItem.itemType;
+
+ // Check balance/ownerOf depending on item type.
+ if (itemType == ItemType.NATIVE) {
+ // NATIVE Token
+ _assertNativeTokenTransfer(spentItem.amount, expectedRecipient);
+ } else if (itemType == ItemType.ERC20) {
+ // ERC20 Token
+ _assertERC20Transfer(
+ spentItem.amount,
+ spentItem.token,
+ expectedRecipient
+ );
+ } else if (itemType == ItemType.ERC721) {
+ // ERC721 Token
+ _assertERC721Transfer(
+ spentItem.identifier,
+ spentItem.token,
+ expectedRecipient
+ );
+ } else if (itemType == ItemType.ERC1155) {
+ // ERC1155 Token
+ _assertERC1155Transfer(
+ spentItem.amount,
+ spentItem.identifier,
+ spentItem.token,
+ expectedRecipient
+ );
+ }
+ }
+ }
+
+ function _assertNativeTokenTransfer(
+ uint256 expectedAmount,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient then revert, because that means the recipient did not
+ // receive the expected amount at the time the order was ratified or
+ // validated.
+ if (expectedAmount > address(expectedRecipient).balance) {
+ revert InvalidNativeTokenBalance(
+ expectedAmount,
+ address(expectedRecipient).balance,
+ expectedRecipient
+ );
+ }
+ }
+
+ function _assertERC20Transfer(
+ uint256 expectedAmount,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount > ERC20Interface(token).balanceOf(expectedRecipient)
+ ) {
+ revert InvalidERC20Balance(
+ expectedAmount,
+ ERC20Interface(token).balanceOf(expectedRecipient),
+ expectedRecipient,
+ token
+ );
+ }
+ }
+
+ function _assertERC721Transfer(
+ uint256 checkedTokenId,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the actual owner of the token is not the expected recipient,
+ // revert.
+ address actualOwner = ERC721Interface(token).ownerOf(checkedTokenId);
+ if (expectedRecipient != actualOwner) {
+ revert InvalidOwner(
+ expectedRecipient,
+ actualOwner,
+ token,
+ checkedTokenId
+ );
+ }
+ }
+
+ function _assertERC1155Transfer(
+ uint256 expectedAmount,
+ uint256 identifier,
+ address token,
+ address expectedRecipient
+ ) internal view {
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount >
+ ERC1155Interface(token).balanceOf(expectedRecipient, identifier)
+ ) {
+ revert InvalidERC1155Balance(
+ expectedAmount,
+ ERC1155Interface(token).balanceOf(
+ expectedRecipient,
+ identifier
+ ),
+ expectedRecipient,
+ token
+ );
+ }
+ }
+
+ function setExpectedOfferRecipient(address expectedOfferRecipient) public {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view virtual override(ContractOffererInterface) returns (bool) {
+ return interfaceId == type(ContractOffererInterface).interfaceId;
+ }
+}
diff --git a/contracts/test/TestContractOfferer.sol b/contracts/test/TestContractOfferer.sol
index 4840b16e8..a3f135a0a 100644
--- a/contracts/test/TestContractOfferer.sol
+++ b/contracts/test/TestContractOfferer.sol
@@ -11,6 +11,8 @@ import {
ContractOffererInterface
} from "../interfaces/ContractOffererInterface.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import { ItemType } from "../lib/ConsiderationEnums.sol";
import {
@@ -28,7 +30,7 @@ import {
* an order. The offered item is placed into this contract as part of
* deployment and the corresponding token approvals are set for Seaport.
*/
-contract TestContractOfferer is ContractOffererInterface {
+contract TestContractOfferer is ERC165, ContractOffererInterface {
error OrderUnavailable();
address private immutable _SEAPORT;
@@ -53,6 +55,20 @@ contract TestContractOfferer is ContractOffererInterface {
receive() external payable {}
+ function supportsInterface(
+ bytes4 interfaceId
+ )
+ public
+ view
+ virtual
+ override(ERC165, ContractOffererInterface)
+ returns (bool)
+ {
+ return
+ interfaceId == type(ContractOffererInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
+
/// In case of criteria based orders and non-wildcard items, the member
/// `available.identifier` would correspond to the `identifierOrCriteria`
/// i.e., the merkle-root.
diff --git a/contracts/test/TestContractOffererNativeToken.sol b/contracts/test/TestContractOffererNativeToken.sol
index b1955fc6b..760eac52b 100644
--- a/contracts/test/TestContractOffererNativeToken.sol
+++ b/contracts/test/TestContractOffererNativeToken.sol
@@ -10,6 +10,8 @@ import {
ContractOffererInterface
} from "../interfaces/ContractOffererInterface.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import { ItemType } from "../lib/ConsiderationEnums.sol";
import {
@@ -21,7 +23,7 @@ import {
/**
* @title TestContractOffererNativeToken
*/
-contract TestContractOffererNativeToken is ContractOffererInterface {
+contract TestContractOffererNativeToken is ContractOffererInterface, ERC165 {
error OrderUnavailable();
address private immutable _SEAPORT;
@@ -246,6 +248,20 @@ contract TestContractOffererNativeToken is ContractOffererInterface {
return bytes4(0xf23a6e61);
}
+ function supportsInterface(
+ bytes4 interfaceId
+ )
+ public
+ view
+ virtual
+ override(ERC165, ContractOffererInterface)
+ returns (bool)
+ {
+ return
+ interfaceId == type(ContractOffererInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
+
/**
* @dev Returns the metadata for this contract offerer.
*/
diff --git a/contracts/test/TestERC1271.sol b/contracts/test/TestERC1271.sol
new file mode 100644
index 000000000..ed510e441
--- /dev/null
+++ b/contracts/test/TestERC1271.sol
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import { IERC1271 } from "../interfaces/IERC1271.sol";
+
+contract TestERC1271 is IERC1271 {
+ address public immutable owner;
+
+ constructor(address owner_) {
+ owner = owner_;
+ }
+
+ function isValidSignature(
+ bytes32 digest,
+ bytes memory signature
+ ) external view returns (bytes4) {
+ bytes32 r;
+ bytes32 s;
+ uint8 v;
+
+ assembly {
+ r := mload(add(signature, 0x20))
+ s := mload(add(signature, 0x40))
+ v := byte(0, mload(add(signature, 0x60)))
+ }
+
+ if (
+ uint256(s) >
+ 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
+ ) {
+ revert();
+ }
+
+ if (v != 27 && v != 28) {
+ revert();
+ }
+
+ address signer = ecrecover(digest, v, r, s);
+
+ if (signer == address(0)) {
+ revert();
+ }
+
+ if (signer != owner) {
+ revert();
+ }
+
+ return IERC1271.isValidSignature.selector;
+ }
+}
diff --git a/contracts/test/TestERC20.sol b/contracts/test/TestERC20.sol
index ea4abd901..fc3e5f0e7 100644
--- a/contracts/test/TestERC20.sol
+++ b/contracts/test/TestERC20.sol
@@ -36,6 +36,12 @@ contract TestERC20 is ERC20("Test20", "TST20", 18) {
return false;
}
+ uint256 allowed = allowance[from][msg.sender];
+
+ if (amount > allowed) {
+ revert("NOT_AUTHORIZED");
+ }
+
super.transferFrom(from, to, amount);
if (noReturnData) {
@@ -46,4 +52,17 @@ contract TestERC20 is ERC20("Test20", "TST20", 18) {
ok = true;
}
+
+ function increaseAllowance(
+ address spender,
+ uint256 amount
+ ) external returns (bool) {
+ uint256 current = allowance[msg.sender][spender];
+ uint256 remaining = type(uint256).max - current;
+ if (amount > remaining) {
+ amount = remaining;
+ }
+ approve(spender, current + amount);
+ return true;
+ }
}
diff --git a/contracts/test/TestERC721Fee.sol b/contracts/test/TestERC721Fee.sol
new file mode 100644
index 000000000..952e9e482
--- /dev/null
+++ b/contracts/test/TestERC721Fee.sol
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import { ERC721 } from "@rari-capital/solmate/src/tokens/ERC721.sol";
+import { ERC2981 } from "./ERC2981.sol";
+
+contract TestERC721Fee is ERC721, ERC2981 {
+ /// @notice When set to false, `royaltyInfo` reverts
+ bool creatorFeeEnabled = false;
+ /// @notice Below the min transaction price, `royaltyInfo` reverts
+ uint256 minTransactionPrice = 0;
+
+ constructor() ERC721("Fee", "FEE") {}
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view override(ERC721, ERC2981) returns (bool) {
+ return
+ ERC721.supportsInterface(interfaceId) ||
+ ERC2981.supportsInterface(interfaceId);
+ }
+
+ function mint(address to, uint256 id) external {
+ _mint(to, id);
+ }
+
+ function burn(uint256 id) external {
+ _burn(id);
+ }
+
+ function tokenURI(uint256) public pure override returns (string memory) {
+ return "tokenURI";
+ }
+
+ function royaltyInfo(
+ uint256,
+ uint256 _salePrice
+ ) public view override returns (address, uint256) {
+ if (!creatorFeeEnabled) {
+ revert("creator fee disabled");
+ }
+ if (_salePrice < minTransactionPrice) {
+ revert("sale price too low");
+ }
+
+ return (
+ 0x000000000000000000000000000000000000fEE2,
+ (_salePrice * (creatorFeeEnabled ? 250 : 0)) / 10000
+ ); // 2.5% fee to 0xFEE2
+ }
+
+ function setCreatorFeeEnabled(bool enabled) public {
+ creatorFeeEnabled = enabled;
+ }
+
+ function setMinTransactionPrice(uint256 minTransactionPrice_) public {
+ minTransactionPrice = minTransactionPrice_;
+ }
+}
diff --git a/contracts/test/TestERC721Funky.sol b/contracts/test/TestERC721Funky.sol
new file mode 100644
index 000000000..ea2b082b5
--- /dev/null
+++ b/contracts/test/TestERC721Funky.sol
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import { ERC721 } from "@rari-capital/solmate/src/tokens/ERC721.sol";
+
+/**
+ * @notice TestERC721Funky is an ERC721 that implements ERC2981 with an incorrect return type.
+ */
+contract TestERC721Funky is ERC721("TestERC721Funky", "TST721FUNKY") {
+ function mint(address to, uint256 id) external {
+ _mint(to, id);
+ }
+
+ function burn(uint256 id) external {
+ _burn(id);
+ }
+
+ function tokenURI(uint256) public pure override returns (string memory) {
+ return "tokenURI";
+ }
+
+ function royaltyInfo(uint256, uint256) public pure returns (address) {
+ return (0x000000000000000000000000000000000000fEE2); // 2.5% fee to 0xFEE2
+ }
+}
diff --git a/contracts/test/TestERC721Revert.sol b/contracts/test/TestERC721Revert.sol
index 8d820122f..e0e897183 100644
--- a/contracts/test/TestERC721Revert.sol
+++ b/contracts/test/TestERC721Revert.sol
@@ -1,12 +1,14 @@
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
-contract TestERC721Revert {
+import { TestERC721 } from "./TestERC721.sol";
+
+contract TestERC721Revert is TestERC721 {
function transferFrom(
address /* from */,
address /* to */,
uint256 /* amount */
- ) public pure {
+ ) public pure override {
revert(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
);
diff --git a/contracts/test/TestInvalidContractOfferer165.sol b/contracts/test/TestInvalidContractOfferer165.sol
new file mode 100644
index 000000000..2661ae0f2
--- /dev/null
+++ b/contracts/test/TestInvalidContractOfferer165.sol
@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {
+ ERC20Interface,
+ ERC721Interface,
+ ERC1155Interface
+} from "../interfaces/AbridgedTokenInterfaces.sol";
+
+import {
+ ContractOffererInterface
+} from "../interfaces/ContractOffererInterface.sol";
+
+import { ERC165 } from "../interfaces/ERC165.sol";
+
+import { ItemType } from "../lib/ConsiderationEnums.sol";
+
+import {
+ ReceivedItem,
+ Schema,
+ SpentItem
+} from "../lib/ConsiderationStructs.sol";
+
+contract TestInvalidContractOfferer165 {
+ error OrderUnavailable();
+
+ address private immutable _SEAPORT;
+
+ SpentItem private _available;
+ SpentItem private _required;
+
+ bool public ready;
+ bool public fulfilled;
+
+ uint256 public extraAvailable;
+ uint256 public extraRequired;
+
+ constructor(address seaport) {
+ // Set immutable values and storage variables.
+ _SEAPORT = seaport;
+ fulfilled = false;
+ ready = false;
+ extraAvailable = 0;
+ extraRequired = 0;
+ }
+
+ receive() external payable {}
+
+ /// In case of criteria based orders and non-wildcard items, the member
+ /// `available.identifier` would correspond to the `identifierOrCriteria`
+ /// i.e., the merkle-root.
+ /// @param identifier corresponds to the actual token-id that gets transferred.
+ function activateWithCriteria(
+ SpentItem memory available,
+ SpentItem memory required,
+ uint256 identifier
+ ) public {
+ if (ready || fulfilled) {
+ revert OrderUnavailable();
+ }
+
+ if (available.itemType == ItemType.ERC721_WITH_CRITERIA) {
+ ERC721Interface token = ERC721Interface(available.token);
+
+ token.transferFrom(msg.sender, address(this), identifier);
+
+ token.setApprovalForAll(_SEAPORT, true);
+ } else if (available.itemType == ItemType.ERC1155_WITH_CRITERIA) {
+ ERC1155Interface token = ERC1155Interface(available.token);
+
+ token.safeTransferFrom(
+ msg.sender,
+ address(this),
+ identifier,
+ available.amount,
+ ""
+ );
+
+ token.setApprovalForAll(_SEAPORT, true);
+ }
+
+ // Set storage variables.
+ _available = available;
+ _required = required;
+ ready = true;
+ }
+
+ function activate(
+ SpentItem memory available,
+ SpentItem memory required
+ ) public payable {
+ if (ready || fulfilled) {
+ revert OrderUnavailable();
+ }
+
+ // Retrieve the offered item and set associated approvals.
+ if (available.itemType == ItemType.NATIVE) {
+ available.amount = address(this).balance;
+ } else if (available.itemType == ItemType.ERC20) {
+ ERC20Interface token = ERC20Interface(available.token);
+
+ token.transferFrom(msg.sender, address(this), available.amount);
+
+ token.approve(_SEAPORT, available.amount);
+ } else if (available.itemType == ItemType.ERC721) {
+ ERC721Interface token = ERC721Interface(available.token);
+
+ token.transferFrom(msg.sender, address(this), available.identifier);
+
+ token.setApprovalForAll(_SEAPORT, true);
+ } else if (available.itemType == ItemType.ERC1155) {
+ ERC1155Interface token = ERC1155Interface(available.token);
+
+ token.safeTransferFrom(
+ msg.sender,
+ address(this),
+ available.identifier,
+ available.amount,
+ ""
+ );
+
+ token.setApprovalForAll(_SEAPORT, true);
+ }
+
+ // Set storage variables.
+ _available = available;
+ _required = required;
+ ready = true;
+ }
+
+ function extendAvailable() public {
+ if (!ready || fulfilled) {
+ revert OrderUnavailable();
+ }
+
+ extraAvailable++;
+
+ _available.amount /= 2;
+ }
+
+ function extendRequired() public {
+ if (!ready || fulfilled) {
+ revert OrderUnavailable();
+ }
+
+ extraRequired++;
+ }
+
+ function generateOrder(
+ address,
+ SpentItem[] calldata,
+ SpentItem[] calldata,
+ bytes calldata context
+ )
+ external
+ virtual
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ // Ensure the caller is Seaport & the order has not yet been fulfilled.
+ if (
+ !ready ||
+ fulfilled ||
+ msg.sender != _SEAPORT ||
+ context.length % 32 != 0
+ ) {
+ revert OrderUnavailable();
+ }
+
+ // Set the offer and consideration that were supplied during deployment.
+ offer = new SpentItem[](1 + extraAvailable);
+ consideration = new ReceivedItem[](1 + extraRequired);
+
+ for (uint256 i = 0; i < 1 + extraAvailable; ++i) {
+ offer[i] = _available;
+ }
+
+ for (uint256 i = 0; i < 1 + extraRequired; ++i) {
+ consideration[i] = ReceivedItem({
+ itemType: _required.itemType,
+ token: _required.token,
+ identifier: _required.identifier,
+ amount: _required.amount,
+ recipient: payable(address(this))
+ });
+ }
+
+ // Update storage to reflect that the order has been fulfilled.
+ fulfilled = true;
+ }
+
+ function previewOrder(
+ address caller,
+ address,
+ SpentItem[] calldata,
+ SpentItem[] calldata,
+ bytes calldata context
+ )
+ external
+ view
+ returns (SpentItem[] memory offer, ReceivedItem[] memory consideration)
+ {
+ // Ensure the caller is Seaport & the order has not yet been fulfilled.
+ if (
+ !ready ||
+ fulfilled ||
+ caller != _SEAPORT ||
+ context.length % 32 != 0
+ ) {
+ revert OrderUnavailable();
+ }
+
+ // Set the offer and consideration that were supplied during deployment.
+ offer = new SpentItem[](1 + extraAvailable);
+ consideration = new ReceivedItem[](1 + extraRequired);
+
+ for (uint256 i = 0; i < 1 + extraAvailable; ++i) {
+ offer[i] = _available;
+ }
+
+ for (uint256 i = 0; i < 1 + extraRequired; ++i) {
+ consideration[i] = ReceivedItem({
+ itemType: _required.itemType,
+ token: _required.token,
+ identifier: _required.identifier,
+ amount: _required.amount,
+ recipient: payable(address(this))
+ });
+ }
+ }
+
+ function getInventory()
+ external
+ view
+ returns (SpentItem[] memory offerable, SpentItem[] memory receivable)
+ {
+ // Set offerable and receivable supplied at deployment if unfulfilled.
+ if (!ready || fulfilled) {
+ offerable = new SpentItem[](0);
+
+ receivable = new SpentItem[](0);
+ } else {
+ offerable = new SpentItem[](1 + extraAvailable);
+ for (uint256 i = 0; i < 1 + extraAvailable; ++i) {
+ offerable[i] = _available;
+ }
+
+ receivable = new SpentItem[](1 + extraRequired);
+ for (uint256 i = 0; i < 1 + extraRequired; ++i) {
+ receivable[i] = _required;
+ }
+ }
+ }
+
+ function ratifyOrder(
+ SpentItem[] calldata /* offer */,
+ ReceivedItem[] calldata /* consideration */,
+ bytes calldata context,
+ bytes32[] calldata orderHashes,
+ uint256 /* contractNonce */
+ ) external pure virtual returns (bytes4 /* ratifyOrderMagicValue */) {
+ if (context.length > 32 && context.length % 32 == 0) {
+ bytes32[] memory expectedOrderHashes = abi.decode(
+ context,
+ (bytes32[])
+ );
+
+ uint256 expectedLength = expectedOrderHashes.length;
+
+ if (expectedLength != orderHashes.length) {
+ revert("Revert on unexpected order hashes length");
+ }
+
+ for (uint256 i = 0; i < expectedLength; ++i) {
+ if (expectedOrderHashes[i] != orderHashes[i]) {
+ revert("Revert on unexpected order hash");
+ }
+ }
+ }
+
+ return ContractOffererInterface.ratifyOrder.selector;
+ }
+
+ function onERC1155Received(
+ address,
+ address,
+ uint256,
+ uint256,
+ bytes calldata
+ ) external pure returns (bytes4) {
+ return bytes4(0xf23a6e61);
+ }
+
+ /**
+ * @dev Returns the metadata for this contract offerer.
+ */
+ function getSeaportMetadata()
+ external
+ pure
+ returns (
+ string memory name,
+ Schema[] memory schemas // map to Seaport Improvement Proposal IDs
+ )
+ {
+ schemas = new Schema[](1);
+ schemas[0].id = 1337;
+ schemas[0].metadata = new bytes(0);
+
+ return ("TestContractOfferer", schemas);
+ }
+}
diff --git a/contracts/test/TestInvalidZone.sol b/contracts/test/TestInvalidZone.sol
new file mode 100644
index 000000000..50c54cd85
--- /dev/null
+++ b/contracts/test/TestInvalidZone.sol
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import { ZoneParameters, Schema } from "../lib/ConsiderationStructs.sol";
+
+import { ERC165 } from "../interfaces/ERC165.sol";
+
+import { ZoneInterface } from "../interfaces/ZoneInterface.sol";
+
+contract TestInvalidZone is ERC165, ZoneInterface {
+ // Returns invalid magic value
+ function validateOrder(
+ ZoneParameters calldata
+ ) external pure returns (bytes4 validOrderMagicValue) {
+ return ZoneInterface.getSeaportMetadata.selector;
+ }
+
+ /**
+ * @dev Returns the metadata for this zone.
+ */
+ function getSeaportMetadata()
+ external
+ pure
+ override
+ returns (
+ string memory name,
+ Schema[] memory schemas // map to Seaport Improvement Proposal IDs
+ )
+ {
+ schemas = new Schema[](1);
+ schemas[0].id = 3003;
+ schemas[0].metadata = new bytes(0);
+
+ return ("TestZone", schemas);
+ }
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view override(ERC165, ZoneInterface) returns (bool) {
+ return
+ interfaceId == type(ZoneInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
+}
diff --git a/contracts/test/TestPostExecution.sol b/contracts/test/TestPostExecution.sol
index 34dd469ce..f5669b84a 100644
--- a/contracts/test/TestPostExecution.sol
+++ b/contracts/test/TestPostExecution.sol
@@ -3,6 +3,8 @@ pragma solidity ^0.8.13;
import { ZoneInterface } from "../interfaces/ZoneInterface.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import { ERC721Interface } from "../interfaces/AbridgedTokenInterfaces.sol";
import { ItemType } from "../lib/ConsiderationEnums.sol";
@@ -13,7 +15,7 @@ import {
ZoneParameters
} from "../lib/ConsiderationStructs.sol";
-contract TestPostExecution is ZoneInterface {
+contract TestPostExecution is ERC165, ZoneInterface {
function validateOrder(
ZoneParameters calldata zoneParameters
) external view override returns (bytes4 validOrderMagicValue) {
@@ -68,4 +70,12 @@ contract TestPostExecution is ZoneInterface {
return ("TestPostExecution", schemas);
}
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view override(ERC165, ZoneInterface) returns (bool) {
+ return
+ interfaceId == type(ZoneInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
}
diff --git a/contracts/test/TestTransferValidationZoneOfferer.sol b/contracts/test/TestTransferValidationZoneOfferer.sol
index 25f45460a..9427c5c19 100644
--- a/contracts/test/TestTransferValidationZoneOfferer.sol
+++ b/contracts/test/TestTransferValidationZoneOfferer.sol
@@ -7,6 +7,8 @@ import {
ERC1155Interface
} from "../interfaces/AbridgedTokenInterfaces.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import {
ReceivedItem,
Schema,
@@ -22,14 +24,58 @@ import {
import { ZoneInterface } from "../interfaces/ZoneInterface.sol";
+/**
+ * @dev This contract is used to validate transfer within the zone/offerer. Use
+ * the HashValidationZoneOfferer to validate calldata via hashes.
+ */
contract TestTransferValidationZoneOfferer is
ContractOffererInterface,
- ZoneInterface
+ ZoneInterface,
+ ERC165
{
- error InvalidBalance();
- error InvalidOwner();
+ error InvalidNativeTokenBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress
+ );
+ error InvalidERC20Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ error InvalidERC1155Balance(
+ uint256 expectedBalance,
+ uint256 actualBalance,
+ address checkedAddress,
+ address checkedToken
+ );
+ // 0x38fb386a
+ error InvalidOwner(
+ address expectedOwner,
+ address actualOwner,
+ address checkedToken,
+ uint256 checkedTokenId
+ );
+ error IncorrectSeaportBalance(
+ uint256 expectedBalance,
+ uint256 actualBalance
+ );
+ event ValidateOrderDataHash(bytes32 dataHash);
+
+ receive() external payable {}
+
+ address internal _expectedOfferRecipient;
+
+ mapping(bytes32 => bytes32) public orderHashToValidateOrderDataHash;
+
+ // Pass in the null address to expect the fulfiller.
+ constructor(address expectedOfferRecipient) {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
- constructor() {}
+ bool public called = false;
+ uint public callCount = 0;
/**
* @dev Validates that the parties have received the correct items.
@@ -39,22 +85,66 @@ contract TestTransferValidationZoneOfferer is
*
* @return validOrderMagicValue The magic value to indicate things are OK.
*/
-
function validateOrder(
ZoneParameters calldata zoneParameters
- ) external view override returns (bytes4 validOrderMagicValue) {
+ ) external override returns (bytes4 validOrderMagicValue) {
// Validate the order.
+
// Currently assumes that the balances of all tokens of addresses are
- // zero at the start of the transaction.
+ // zero at the start of the transaction. Accordingly, take care to
+ // use an address in tests that is not pre-populated with tokens.
+
+ // Get the length of msg.data
+ uint256 dataLength = msg.data.length;
+
+ // Create a variable to store msg.data in memory
+ bytes memory data;
+
+ // Copy msg.data to memory
+ assembly {
+ let ptr := mload(0x40)
+ calldatacopy(add(ptr, 0x20), 0, dataLength)
+ mstore(ptr, dataLength)
+ data := ptr
+ }
+
+ // Get the hash of msg.data
+ bytes32 calldataHash = keccak256(data);
- // Check if all consideration items have been received.
+ // Get the orderHash from zoneParameters
+ bytes32 orderHash = zoneParameters.orderHash;
+
+ // Store callDataHash in orderHashToValidateOrderDataHash
+ orderHashToValidateOrderDataHash[orderHash] = calldataHash;
+
+ // Emit a DataHash event with the hash of msg.data
+ emit ValidateOrderDataHash(calldataHash);
+
+ // Check if Seaport is empty. This makes sure that we've transferred
+ // all native token balance out of Seaport before we do the validation.
+ uint256 seaportBalance = address(msg.sender).balance;
+
+ if (seaportBalance > 0) {
+ revert IncorrectSeaportBalance(0, seaportBalance);
+ }
+
+ // Ensure that the offerer or recipient has received all consideration
+ // items.
_assertValidReceivedItems(zoneParameters.consideration);
- // Check if all offer items have been spent.
- _assertValidSpentItems(zoneParameters.fulfiller, zoneParameters.offer);
+ address expectedOfferRecipient = _expectedOfferRecipient == address(0)
+ ? zoneParameters.fulfiller
+ : _expectedOfferRecipient;
+
+ // Ensure that the expected recipient has received all offer items.
+ _assertValidSpentItems(expectedOfferRecipient, zoneParameters.offer);
+
+ // Set the global called flag to true.
+ called = true;
+ callCount++;
// Return the selector of validateOrder as the magic value.
- validOrderMagicValue = ZoneInterface.validateOrder.selector;
+ validOrderMagicValue = this.validateOrder.selector;
}
/**
@@ -114,18 +204,34 @@ contract TestTransferValidationZoneOfferer is
bytes calldata context /* context */,
bytes32[] calldata /* orderHashes */,
uint256 /* contractNonce */
- ) external view override returns (bytes4 /* ratifyOrderMagicValue */) {
+ ) external override returns (bytes4 /* ratifyOrderMagicValue */) {
// Ratify the order.
+ // Check if Seaport is empty. This makes sure that we've transferred
+ // all native token balance out of Seaport before we do the validation.
+ uint256 seaportBalance = address(msg.sender).balance;
+
+ if (seaportBalance > 0) {
+ revert IncorrectSeaportBalance(0, seaportBalance);
+ }
// Ensure that the offerer or recipient has received all consideration
// items.
_assertValidReceivedItems(maximumSpent);
- // Get the fulfiller address from the context.
- address fulfiller = address(bytes20(context[0:20]));
+ // It's necessary to pass in either an expected offerer or an address
+ // in the context. If neither is provided, this ternary will revert
+ // with a generic, hard-to-debug revert when it tries to slice bytes
+ // from the context.
+ address expectedOfferRecipient = _expectedOfferRecipient == address(0)
+ ? address(bytes20(context[0:20]))
+ : _expectedOfferRecipient;
- // Ensure that the fulfiller has received all offer items.
- _assertValidSpentItems(fulfiller, minimumReceived);
+ // Ensure that the expected recipient has received all offer items.
+ _assertValidSpentItems(expectedOfferRecipient, minimumReceived);
+
+ // Set the global called flag to true.
+ called = true;
+ callCount++;
return this.ratifyOrder.selector;
}
@@ -174,13 +280,13 @@ contract TestTransferValidationZoneOfferer is
address recipient;
ItemType itemType;
ReceivedItem memory receivedItem;
- // Check if all consideration items have been received.
+
+ // Iterate over all received items.
for (uint256 i = 0; i < receivedItems.length; i++) {
// Check if the consideration item has been received.
receivedItem = receivedItems[i];
// Get the recipient of the consideration item.
recipient = receivedItem.recipient;
-
// Get item type.
itemType = receivedItem.itemType;
@@ -215,13 +321,13 @@ contract TestTransferValidationZoneOfferer is
}
function _assertValidSpentItems(
- address fulfiller,
+ address expectedRecipient,
SpentItem[] calldata spentItems
) internal view {
SpentItem memory spentItem;
ItemType itemType;
- // Check if all offer items have been spent.
+ // Iterate over all spent items.
for (uint256 i = 0; i < spentItems.length; i++) {
// Check if the offer item has been spent.
spentItem = spentItems[i];
@@ -231,20 +337,20 @@ contract TestTransferValidationZoneOfferer is
// Check balance/ownerOf depending on item type.
if (itemType == ItemType.NATIVE) {
// NATIVE Token
- _assertNativeTokenTransfer(spentItem.amount, fulfiller);
+ _assertNativeTokenTransfer(spentItem.amount, expectedRecipient);
} else if (itemType == ItemType.ERC20) {
// ERC20 Token
_assertERC20Transfer(
spentItem.amount,
spentItem.token,
- fulfiller
+ expectedRecipient
);
} else if (itemType == ItemType.ERC721) {
// ERC721 Token
_assertERC721Transfer(
spentItem.identifier,
spentItem.token,
- fulfiller
+ expectedRecipient
);
} else if (itemType == ItemType.ERC1155) {
// ERC1155 Token
@@ -252,49 +358,109 @@ contract TestTransferValidationZoneOfferer is
spentItem.amount,
spentItem.identifier,
spentItem.token,
- fulfiller
+ expectedRecipient
);
}
}
}
function _assertNativeTokenTransfer(
- uint256 amount,
- address recipient
+ uint256 expectedAmount,
+ address expectedRecipient
) internal view {
- if (amount > address(recipient).balance) {
- revert InvalidBalance();
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient then revert, because that means the recipient did not
+ // receive the expected amount at the time the order was ratified or
+ // validated.
+ if (expectedAmount > address(expectedRecipient).balance) {
+ revert InvalidNativeTokenBalance(
+ expectedAmount,
+ address(expectedRecipient).balance,
+ expectedRecipient
+ );
}
}
function _assertERC20Transfer(
- uint256 amount,
+ uint256 expectedAmount,
address token,
- address recipient
+ address expectedRecipient
) internal view {
- if (amount > ERC20Interface(token).balanceOf(recipient)) {
- revert InvalidBalance();
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount > ERC20Interface(token).balanceOf(expectedRecipient)
+ ) {
+ revert InvalidERC20Balance(
+ expectedAmount,
+ ERC20Interface(token).balanceOf(expectedRecipient),
+ expectedRecipient,
+ token
+ );
}
}
function _assertERC721Transfer(
- uint256 identifier,
+ uint256 checkedTokenId,
address token,
- address recipient
+ address expectedRecipient
) internal view {
- if (recipient != ERC721Interface(token).ownerOf(identifier)) {
- revert InvalidOwner();
+ // If the actual owner of the token is not the expected recipient,
+ // revert.
+ address actualOwner = ERC721Interface(token).ownerOf(checkedTokenId);
+ if (expectedRecipient != actualOwner) {
+ revert InvalidOwner(
+ expectedRecipient,
+ actualOwner,
+ token,
+ checkedTokenId
+ );
}
}
function _assertERC1155Transfer(
- uint256 amount,
+ uint256 expectedAmount,
uint256 identifier,
address token,
- address recipient
+ address expectedRecipient
) internal view {
- if (amount > ERC1155Interface(token).balanceOf(recipient, identifier)) {
- revert InvalidBalance();
+ // If the amount we read from the spent item or received item (the
+ // expected transfer value) is greater than the balance of the expected
+ // recipient, revert.
+ if (
+ expectedAmount >
+ ERC1155Interface(token).balanceOf(expectedRecipient, identifier)
+ ) {
+ revert InvalidERC1155Balance(
+ expectedAmount,
+ ERC1155Interface(token).balanceOf(
+ expectedRecipient,
+ identifier
+ ),
+ expectedRecipient,
+ token
+ );
}
}
+
+ function setExpectedOfferRecipient(address expectedOfferRecipient) public {
+ _expectedOfferRecipient = expectedOfferRecipient;
+ }
+
+ function supportsInterface(
+ bytes4 interfaceId
+ )
+ public
+ view
+ virtual
+ override(ERC165, ContractOffererInterface, ZoneInterface)
+ returns (bool)
+ {
+ return
+ interfaceId == type(ContractOffererInterface).interfaceId ||
+ interfaceId == type(ZoneInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
}
diff --git a/contracts/test/TestZone.sol b/contracts/test/TestZone.sol
index ca78521fc..27db79584 100644
--- a/contracts/test/TestZone.sol
+++ b/contracts/test/TestZone.sol
@@ -3,9 +3,11 @@ pragma solidity ^0.8.13;
import { ZoneInterface } from "../interfaces/ZoneInterface.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import { Schema, ZoneParameters } from "../lib/ConsiderationStructs.sol";
-contract TestZone is ZoneInterface {
+contract TestZone is ERC165, ZoneInterface {
function validateOrder(
ZoneParameters calldata zoneParameters
) external pure override returns (bytes4 validOrderMagicValue) {
@@ -68,4 +70,12 @@ contract TestZone is ZoneInterface {
return ("TestZone", schemas);
}
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view override(ERC165, ZoneInterface) returns (bool) {
+ return
+ interfaceId == type(ZoneInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
}
diff --git a/contracts/test/TypehashDirectory.sol b/contracts/test/TypehashDirectory.sol
index 9fd733109..c37eac131 100644
--- a/contracts/test/TypehashDirectory.sol
+++ b/contracts/test/TypehashDirectory.sol
@@ -134,43 +134,43 @@ contract TypehashDirectory {
function getTreeSubTypes() internal pure returns (bytes memory) {
// Construct the OfferItem type string.
bytes memory offerItemTypeString = bytes(
- "OfferItem("
- "uint8 itemType,"
- "address token,"
- "uint256 identifierOrCriteria,"
- "uint256 startAmount,"
- "uint256 endAmount"
- ")"
- );
+ "OfferItem("
+ "uint8 itemType,"
+ "address token,"
+ "uint256 identifierOrCriteria,"
+ "uint256 startAmount,"
+ "uint256 endAmount"
+ ")"
+ );
// Construct the ConsiderationItem type string.
bytes memory considerationItemTypeString = bytes(
- "ConsiderationItem("
- "uint8 itemType,"
- "address token,"
- "uint256 identifierOrCriteria,"
- "uint256 startAmount,"
- "uint256 endAmount,"
- "address recipient"
- ")"
- );
+ "ConsiderationItem("
+ "uint8 itemType,"
+ "address token,"
+ "uint256 identifierOrCriteria,"
+ "uint256 startAmount,"
+ "uint256 endAmount,"
+ "address recipient"
+ ")"
+ );
// Construct the OrderComponents type string, not including the above.
bytes memory orderComponentsPartialTypeString = bytes(
- "OrderComponents("
- "address offerer,"
- "address zone,"
- "OfferItem[] offer,"
- "ConsiderationItem[] consideration,"
- "uint8 orderType,"
- "uint256 startTime,"
- "uint256 endTime,"
- "bytes32 zoneHash,"
- "uint256 salt,"
- "bytes32 conduitKey,"
- "uint256 counter"
- ")"
- );
+ "OrderComponents("
+ "address offerer,"
+ "address zone,"
+ "OfferItem[] offer,"
+ "ConsiderationItem[] consideration,"
+ "uint8 orderType,"
+ "uint256 startTime,"
+ "uint256 endTime,"
+ "bytes32 zoneHash,"
+ "uint256 salt,"
+ "bytes32 conduitKey,"
+ "uint256 counter"
+ ")"
+ );
// Return the combined string.
return
diff --git a/contracts/zones/PausableZone.sol b/contracts/zones/PausableZone.sol
index 6abf08d1d..c6dd084b7 100644
--- a/contracts/zones/PausableZone.sol
+++ b/contracts/zones/PausableZone.sol
@@ -7,6 +7,8 @@ import {
PausableZoneEventsAndErrors
} from "./interfaces/PausableZoneEventsAndErrors.sol";
+import { ERC165 } from "../interfaces/ERC165.sol";
+
import { SeaportInterface } from "../interfaces/SeaportInterface.sol";
import {
@@ -31,6 +33,7 @@ import { PausableZoneInterface } from "./interfaces/PausableZoneInterface.sol";
* cannot execute orders that return native tokens to the fulfiller.
*/
contract PausableZone is
+ ERC165,
PausableZoneEventsAndErrors,
ZoneInterface,
PausableZoneInterface
@@ -252,4 +255,12 @@ contract PausableZone is
return ("PausableZone", schemas);
}
+
+ function supportsInterface(
+ bytes4 interfaceId
+ ) public view override(ERC165, ZoneInterface) returns (bool) {
+ return
+ interfaceId == type(ZoneInterface).interfaceId ||
+ super.supportsInterface(interfaceId);
+ }
}
diff --git a/contracts/zones/PausableZoneController.sol b/contracts/zones/PausableZoneController.sol
index 14662e518..1e731ca95 100644
--- a/contracts/zones/PausableZoneController.sol
+++ b/contracts/zones/PausableZoneController.sol
@@ -240,7 +240,7 @@ contract PausableZoneController is
/**
* @notice Initiate Zone ownership transfer by assigning a new potential
- * owner this contract. Once set, the new potential owner
+ * owner of this contract. Once set, the new potential owner
* may call `acceptOwnership` to claim ownership.
* Only the owner in question may call this function.
*
@@ -360,7 +360,7 @@ contract PausableZoneController is
}
/**
- * @notice An external view function that return the potential owner.
+ * @notice An external view function that returns the potential owner.
*
* @return The address of the potential owner.
*/
diff --git a/contracts/zones/interfaces/PausableZoneControllerInterface.sol b/contracts/zones/interfaces/PausableZoneControllerInterface.sol
index 8c115556c..fb661b395 100644
--- a/contracts/zones/interfaces/PausableZoneControllerInterface.sol
+++ b/contracts/zones/interfaces/PausableZoneControllerInterface.sol
@@ -104,7 +104,7 @@ interface PausableZoneControllerInterface {
/**
* @notice Initiate Zone ownership transfer by assigning a new potential
- * owner this contract. Once set, the new potential owner
+ * owner of this contract. Once set, the new potential owner
* may call `acceptOwnership` to claim ownership.
* Only the owner in question may call this function.
*
@@ -153,7 +153,7 @@ interface PausableZoneControllerInterface {
function owner() external view returns (address);
/**
- * @notice An external view function that return the potential owner.
+ * @notice An external view function that returns the potential owner.
*
* @return The address of the potential owner.
*/
diff --git a/contracts/zones/interfaces/PausableZoneEventsAndErrors.sol b/contracts/zones/interfaces/PausableZoneEventsAndErrors.sol
index 459343631..bb80f9402 100644
--- a/contracts/zones/interfaces/PausableZoneEventsAndErrors.sol
+++ b/contracts/zones/interfaces/PausableZoneEventsAndErrors.sol
@@ -43,7 +43,7 @@ interface PausableZoneEventsAndErrors {
/**
* @dev Emit an event whenever a zone owner assigns a new pauser
*
- * @param newPauser The new pausear of the zone.
+ * @param newPauser The new pauser of the zone.
*/
event PauserUpdated(address newPauser);
diff --git a/docs/Deployment.md b/docs/Deployment.md
index 4226d2711..b2c6c68d9 100644
--- a/docs/Deployment.md
+++ b/docs/Deployment.md
@@ -1,6 +1,8 @@
# Deploying Seaport
-Seaport 1.1, 1.2, and the ConduitController can each be deployed to their respective canonical deployment address on all EVM chains using the CREATE2 Factory.
+Seaport 1.5 and the ConduitController can each be deployed to their respective canonical deployment address on all EVM chains using the CREATE2 Factory. Note that a pre-155 transaction with a gas price of 100 gwei (or a manual workaround) is required as part of the deployment process (subsequent transactions can be submitted without these constraints), and that EVM equivalence (particularly consistent CREATE2 address derivation) is required in order to deploy to the canonical cross-chain deployment addresses.
+
+If you are deploying a fork of Seaport, it is *highly* advised that you **supply the canonical conduit controller** as its constructor argument; this allows the Seaport fork to use conduits that are fully interoperable with the canonical Seaport instance. (Better yet, deploy the canonical Seaport instance and use a distinct conduit if needed!)
## Relevant Addresses
@@ -30,12 +32,8 @@ Seaport 1.1, 1.2, and the ConduitController can each be deployed to their respec