From 2b284d527e3ca4a744c07816f35a6ca078665e7f Mon Sep 17 00:00:00 2001 From: James Wenzel Date: Fri, 10 Jun 2022 18:41:49 -0700 Subject: [PATCH 1/2] test fulfills revert with native offer items --- test/foundry/FulfillAdvancedOrder.t.sol | 58 ++++++++++++ .../FulfillAvailableAdvancedOrder.t.sol | 94 +++++++++++++++++++ test/foundry/FulfillOrderTest.t.sol | 48 ++++++++++ test/foundry/FullfillAvailableOrder.t.sol | 92 ++++++++++++++++++ 4 files changed, 292 insertions(+) diff --git a/test/foundry/FulfillAdvancedOrder.t.sol b/test/foundry/FulfillAdvancedOrder.t.sol index 08eb4dc33..d606d6f46 100644 --- a/test/foundry/FulfillAdvancedOrder.t.sol +++ b/test/foundry/FulfillAdvancedOrder.t.sol @@ -82,6 +82,64 @@ contract FulfillAdvancedOrder is BaseOrderTest { } } + function testNoNativeOffersFulfillAdvanced(uint8[8] memory itemTypes) + public + { + uint256 tokenId; + for (uint256 i; i < 8; i++) { + ItemType itemType = ItemType(itemTypes[i] % 4); + if (itemType == ItemType.NATIVE) { + addEthOfferItem(1); + } else if (itemType == ItemType.ERC20) { + addErc20OfferItem(1); + } else if (itemType == ItemType.ERC1155) { + test1155_1.mint(alice, tokenId, 1); + addErc1155OfferItem(tokenId, 1); + } else { + test721_1.mint(alice, tokenId); + addErc721OfferItem(tokenId); + } + tokenId++; + } + addEthOfferItem(1); + + addEthConsiderationItem(alice, 1); + + test( + this.noNativeOfferItemsFulfillAdvanced, + Context(consideration, empty, 0, 0) + ); + test( + this.noNativeOfferItemsFulfillAdvanced, + Context(referenceConsideration, empty, 0, 0) + ); + } + + function noNativeOfferItemsFulfillAdvanced(Context memory context) + external + stateless + { + configureOrderParameters(alice); + uint256 counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature = signOrder( + context.consideration, + alicePk, + orderHash + ); + + vm.expectRevert(abi.encodeWithSignature("InvalidNativeOfferItem()")); + context.consideration.fulfillAdvancedOrder( + AdvancedOrder(baseOrderParameters, 1, 1, signature, ""), + new CriteriaResolver[](0), + bytes32(0), + address(0) + ); + } + function testAdvancedPartialAscendingOfferAmount1155( FuzzInputs memory args, uint128 tokenAmount, diff --git a/test/foundry/FulfillAvailableAdvancedOrder.t.sol b/test/foundry/FulfillAvailableAdvancedOrder.t.sol index be0fbbbf6..ebed17425 100644 --- a/test/foundry/FulfillAvailableAdvancedOrder.t.sol +++ b/test/foundry/FulfillAvailableAdvancedOrder.t.sol @@ -81,6 +81,100 @@ contract FulfillAvailableAdvancedOrder is BaseOrderTest { } } + function testNoNativeOffersFulfillAvailableAdvanced( + uint8[8] memory itemTypes + ) public { + uint256 tokenId; + for (uint256 i; i < 8; i++) { + ItemType itemType = ItemType(itemTypes[i] % 4); + if (itemType == ItemType.NATIVE) { + addEthOfferItem(1); + } else if (itemType == ItemType.ERC20) { + addErc20OfferItem(1); + } else if (itemType == ItemType.ERC1155) { + test1155_1.mint(alice, tokenId, 1); + addErc1155OfferItem(tokenId, 1); + } else { + test721_1.mint(alice, tokenId); + addErc721OfferItem(tokenId); + } + tokenId++; + offerComponents.push(FulfillmentComponent(1, i)); + } + addEthOfferItem(1); + + addEthConsiderationItem(alice, 1); + considerationComponents.push(FulfillmentComponent(1, 0)); + + test( + this.noNativeOfferItemsFulfillAvailableAdvanced, + Context(consideration, empty, ItemType(0)) + ); + test( + this.noNativeOfferItemsFulfillAvailableAdvanced, + Context(referenceConsideration, empty, ItemType(0)) + ); + } + + function noNativeOfferItemsFulfillAvailableAdvanced(Context memory context) + external + stateless + { + configureOrderParameters(alice); + uint256 counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature = signOrder( + context.consideration, + alicePk, + orderHash + ); + + AdvancedOrder[] memory orders = new AdvancedOrder[](2); + orders[1] = AdvancedOrder(baseOrderParameters, 1, 1, signature, ""); + offerComponentsArray.push(offerComponents); + considerationComponentsArray.push(considerationComponents); + + delete offerItems; + delete considerationItems; + delete offerComponents; + delete considerationComponents; + + token1.mint(alice, 100); + addErc20OfferItem(100); + addEthConsiderationItem(alice, 1); + configureOrderParameters(alice); + counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash2 = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature2 = signOrder( + context.consideration, + alicePk, + orderHash2 + ); + offerComponents.push(FulfillmentComponent(0, 0)); + considerationComponents.push(FulfillmentComponent(0, 0)); + offerComponentsArray.push(offerComponents); + considerationComponentsArray.push(considerationComponents); + + orders[0] = AdvancedOrder(baseOrderParameters, 1, 1, signature2, ""); + + vm.expectRevert(abi.encodeWithSignature("InvalidNativeOfferItem()")); + context.consideration.fulfillAvailableAdvancedOrders{ value: 2 }( + orders, + new CriteriaResolver[](0), + offerComponentsArray, + considerationComponentsArray, + bytes32(0), + address(0), + 2 + ); + } + function testFulfillAvailableAdvancedOrderOverflow() public { for (uint256 i; i < 4; ++i) { // skip 721s diff --git a/test/foundry/FulfillOrderTest.t.sol b/test/foundry/FulfillOrderTest.t.sol index eeed488ee..3ecc2ba40 100644 --- a/test/foundry/FulfillOrderTest.t.sol +++ b/test/foundry/FulfillOrderTest.t.sol @@ -107,6 +107,54 @@ contract FulfillOrderTest is BaseOrderTest { _; } + function testNoNativeOffers(uint8[8] memory itemTypes) public { + uint256 tokenId; + for (uint256 i; i < 8; i++) { + ItemType itemType = ItemType(itemTypes[i] % 4); + if (itemType == ItemType.NATIVE) { + addEthOfferItem(1); + } else if (itemType == ItemType.ERC20) { + addErc20OfferItem(1); + } else if (itemType == ItemType.ERC1155) { + test1155_1.mint(alice, tokenId, 1); + addErc1155OfferItem(tokenId, 1); + } else { + test721_1.mint(alice, tokenId); + addErc721OfferItem(tokenId); + } + tokenId++; + } + addEthOfferItem(1); + + addEthConsiderationItem(alice, 1); + + test(this.noNativeOfferItems, Context(consideration, empty, 0, 0, 0)); + test( + this.noNativeOfferItems, + Context(referenceConsideration, empty, 0, 0, 0) + ); + } + + function noNativeOfferItems(Context memory context) external stateless { + configureOrderParameters(alice); + uint256 counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature = signOrder( + context.consideration, + alicePk, + orderHash + ); + + vm.expectRevert(abi.encodeWithSignature("InvalidNativeOfferItem()")); + context.consideration.fulfillOrder( + Order(baseOrderParameters, signature), + bytes32(0) + ); + } + function testFulfillAscendingDescendingOffer(FuzzInputsCommon memory inputs) public validateInputs(inputs) diff --git a/test/foundry/FullfillAvailableOrder.t.sol b/test/foundry/FullfillAvailableOrder.t.sol index 8fee6c59e..8b8f67127 100644 --- a/test/foundry/FullfillAvailableOrder.t.sol +++ b/test/foundry/FullfillAvailableOrder.t.sol @@ -57,6 +57,98 @@ contract FulfillAvailableOrder is BaseOrderTest { } } + function testNoNativeOffersFulfillAvailable(uint8[8] memory itemTypes) + public + { + uint256 tokenId; + for (uint256 i; i < 8; i++) { + ItemType itemType = ItemType(itemTypes[i] % 4); + if (itemType == ItemType.NATIVE) { + addEthOfferItem(1); + } else if (itemType == ItemType.ERC20) { + addErc20OfferItem(1); + } else if (itemType == ItemType.ERC1155) { + test1155_1.mint(alice, tokenId, 1); + addErc1155OfferItem(tokenId, 1); + } else { + test721_1.mint(alice, tokenId); + addErc721OfferItem(tokenId); + } + tokenId++; + offerComponents.push(FulfillmentComponent(1, i)); + } + addEthOfferItem(1); + + addEthConsiderationItem(alice, 1); + considerationComponents.push(FulfillmentComponent(1, 0)); + + test( + this.noNativeOfferItemsFulfillAvailable, + Context(consideration, empty, ItemType(0)) + ); + test( + this.noNativeOfferItemsFulfillAvailable, + Context(referenceConsideration, empty, ItemType(0)) + ); + } + + function noNativeOfferItemsFulfillAvailable(Context memory context) + external + stateless + { + configureOrderParameters(alice); + uint256 counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature = signOrder( + context.consideration, + alicePk, + orderHash + ); + + Order[] memory orders = new Order[](2); + orders[1] = Order(baseOrderParameters, signature); + offerComponentsArray.push(offerComponents); + considerationComponentsArray.push(considerationComponents); + + delete offerItems; + delete considerationItems; + delete offerComponents; + delete considerationComponents; + + token1.mint(alice, 100); + addErc20OfferItem(100); + addEthConsiderationItem(alice, 1); + configureOrderParameters(alice); + counter = context.consideration.getCounter(alice); + _configureOrderComponents(counter); + bytes32 orderHash2 = context.consideration.getOrderHash( + baseOrderComponents + ); + bytes memory signature2 = signOrder( + context.consideration, + alicePk, + orderHash2 + ); + offerComponents.push(FulfillmentComponent(0, 0)); + considerationComponents.push(FulfillmentComponent(0, 0)); + offerComponentsArray.push(offerComponents); + considerationComponentsArray.push(considerationComponents); + + orders[0] = Order(baseOrderParameters, signature2); + + vm.expectRevert(abi.encodeWithSignature("InvalidNativeOfferItem()")); + context.consideration.fulfillAvailableOrders{ value: 2 }( + orders, + offerComponentsArray, + considerationComponentsArray, + bytes32(0), + 2 + ); + } + function testFulfillAvailableOrdersOverflowOfferSide() public { // skip eth for (uint256 i = 1; i < 4; ++i) { From ebee871783bd8b19f0c5cb813a1f6283dc50c63a Mon Sep 17 00:00:00 2001 From: 0age <0age@protonmail.com> Date: Fri, 10 Jun 2022 20:13:17 -0700 Subject: [PATCH 2/2] run linter --- test/foundry/FulfillOrderTest.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/foundry/FulfillOrderTest.t.sol b/test/foundry/FulfillOrderTest.t.sol index 1cdcd16e8..3d05a820a 100644 --- a/test/foundry/FulfillOrderTest.t.sol +++ b/test/foundry/FulfillOrderTest.t.sol @@ -151,7 +151,7 @@ contract FulfillOrderTest is BaseOrderTest { ); vm.expectRevert(abi.encodeWithSignature("InvalidNativeOfferItem()")); - + context.consideration.fulfillOrder( Order(baseOrderParameters, signature), bytes32(0)