diff --git a/.gas-snapshot b/.gas-snapshot index c772413518..0a27955b47 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,251 +1,260 @@ -GenericPoolOrderBookV5ArbOrderTakerExpressionTest:testGenericPoolTakeOrdersExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256[],uint256[]) (runs: 14, μ: 366679, ~: 365222) -GenericPoolOrderBookV5ArbOrderTakerExpressionTest:testGenericPoolTakeOrdersWrongExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,address,bytes)) (runs: 14, μ: 122321, ~: 131929) -GenericPoolOrderBookV5ArbOrderTakerSenderTest:testGenericPoolTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 14, μ: 263941, ~: 264237) -GenericPoolOrderBookV5FlashBorrowerTest:testGenericPoolOrderBookV5FlashBorrowerTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 14, μ: 449655, ~: 450556) -LibOrderTest:testHashEqual((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 104, μ: 161508, ~: 159096) -LibOrderTest:testHashNotEqual((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 104, μ: 221910, ~: 222700) -OrderBookAddOrderEnactTest:testAddLiveOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 772021, ~: 749287) -OrderBookAddOrderEnactTest:testAddLiveOrderRevertNoAdd(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 596650, ~: 579514) -OrderBookAddOrderEnactTest:testAddOrderContext(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 899088, ~: 880983) -OrderBookAddOrderEnactTest:testAddOrderEmptyNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 528094, ~: 512116) -OrderBookAddOrderEnactTest:testAddOrderOneReadState(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 588947, ~: 572963) -OrderBookAddOrderEnactTest:testAddOrderOneStateless(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 574304, ~: 558320) -OrderBookAddOrderEnactTest:testAddOrderWriteStateDifferentOwnersNamespaced(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 2820243, ~: 2736604) -OrderBookAddOrderEnactTest:testAddOrderWriteStateSequential(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 821998, ~: 805992) -OrderBookAddOrderEnactTest:testAddOrderWriteStateSingle(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 1116008, ~: 1087303) -OrderBookAddOrderMockTest:testAddOrderSameAccountWithDifferentConfig(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,bytes) (runs: 104, μ: 2060830, ~: 2013048) -OrderBookAddOrderMockTest:testAddOrderTwoAccountsWithDifferentConfig(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,bytes) (runs: 104, μ: 1867647, ~: 1822361) -OrderBookAddOrderMockTest:testAddOrderTwoAccountsWithSameConfig(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 1809469, ~: 1852418) -OrderBookAddOrderMockTest:testAddOrderWithCalculationsInputsAndOutputsSucceeds(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 955008, ~: 927360) -OrderBookAddOrderMockTest:testAddOrderWithNonEmptyMetaEmitsMetaV1(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 964588, ~: 937624) -OrderBookAddOrderMockTest:testAddOrderWithNonEmptyMetaReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 528259, ~: 514367) -OrderBookAddOrderMockTest:testAddOrderWithoutCalculationsDeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 476253, ~: 460344) -OrderBookAddOrderMockTest:testAddOrderWithoutInputsReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 124188, ~: 117428) -OrderBookAddOrderMockTest:testAddOrderWithoutOutputsReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 122474, ~: 110164) -OrderBookAddOrderNonceTest:testAddOrderNonceDifferentNonceStateChange(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes32) (runs: 104, μ: 871414, ~: 821474) -OrderBookAddOrderNonceTest:testAddOrderNonceSameNonceDifferentOrderStateChange(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1072167, ~: 1068698) -OrderBookAddOrderNonceTest:testAddOrderNonceSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 687817, ~: 663900) -OrderBookAddOrderOwnerTest:testAddOrderOwnerDifferentOwnerStateChange(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 104, μ: 974422, ~: 953785) -OrderBookAddOrderOwnerTest:testAddOrderOwnerSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 687892, ~: 663975) -OrderBookAddOrderTest:testAddOrderRealCalculateInputsReverts1(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 473326, ~: 458439) -OrderBookAddOrderTest:testAddOrderRealCalculateInputsReverts2(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 475086, ~: 460199) -OrderBookAddOrderTest:testAddOrderRealCalculateInputsRevertsPreference(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 474627, ~: 459740) -OrderBookAddOrderTest:testAddOrderRealNoHandleIODeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 465363, ~: 450476) -OrderBookAddOrderTest:testAddOrderRealNoSourcesDeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 443204, ~: 428321) -OrderBookAddOrderTest:testAddOrderRealOneStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 477635, ~: 462748) -OrderBookAddOrderTest:testAddOrderRealThreeStackCalculate(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 490213, ~: 475326) -OrderBookAddOrderTest:testAddOrderRealTwoStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 483854, ~: 468967) -OrderBookAddOrderTest:testAddOrderRealZeroStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 471957, ~: 457070) -OrderBookClearHandleIORevertTest:testClearOrderAliceNoHandleIORevert() (gas: 773649) -OrderBookClearHandleIORevertTest:testClearOrderBobNoHandleIORevert() (gas: 773671) -OrderBookClearHandleIORevertTest:testClearOrderBothNoHandleIORevert() (gas: 752404) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO0() (gas: 812656) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO1() (gas: 805491) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO2() (gas: 805677) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO3() (gas: 812700) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO4() (gas: 697687) -OrderBookClearHandleIORevertTest:testClearOrderHandleIO5() (gas: 655913) -OrderBookClearOrderBadStackTest:testClearOrderBadStackEmptyStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1728751, ~: 1735658) -OrderBookClearOrderBadStackTest:testClearOrderBadStackOneEmpty(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1805222, ~: 1817818) -OrderBookClearOrderBadStackTest:testClearOrderBadStackOneOne(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1812803, ~: 1825399) -OrderBookClearOrderBadStackTest:testClearOrderBadStackOneOtherOne(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1749580, ~: 1756489) -OrderBookClearOrderBadStackTest:testClearOrderBadStackOneStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1743253, ~: 1750162) -OrderBookClearOrderBadStackTest:testClearOrderBadStackOtherEmpty(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1741999, ~: 1748911) -OrderBookClearOrderContextTest:testContextEmptyStack(address,address,bytes32,bytes32,bytes32,bytes32) (runs: 14, μ: 2314399, ~: 2344891) -OrderBookClearSameTokenTest:testClearSameToken(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 1405089, ~: 1374250) -OrderBookClearTest:testClear2ZeroRatioAliceAndBob(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 104, μ: 3595082, ~: 3682682) -OrderBookClearTest:testClear2ZeroRatioAliceOnly(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 104, μ: 3635624, ~: 3723224) -OrderBookClearTest:testClear2ZeroRatioBobOnly(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 104, μ: 3637357, ~: 3724957) -OrderBookClearTest:testClearFuzzIoRatioError(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32,uint256,uint256) (runs: 104, μ: 3598879, ~: 3630032) -OrderBookClearTest:testClearFuzzIoRatioHappy(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32,uint256,uint256) (runs: 104, μ: 3673882, ~: 3704548) -OrderBookClearTest:testClearSimple(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 104, μ: 3678413, ~: 3765995) -OrderBookClearTest:testFlashLoanToNonReceiver(uint256,bytes,bytes32,bytes) (runs: 5100, μ: 28389, ~: 28287) -OrderBookDepositEnactTest:testDepositRevertInAction(address,bytes32,uint256) (runs: 14, μ: 126920, ~: 126811) -OrderBookDepositEnactTest:testOrderBookDepositEnactEmptyNoop(address,bytes32,uint256) (runs: 14, μ: 100114, ~: 100005) -OrderBookDepositEnactTest:testOrderBookDepositEnactOneReadState(address,bytes32,uint256) (runs: 14, μ: 162287, ~: 162178) -OrderBookDepositEnactTest:testOrderBookDepositEnactOneStateless(address,bytes32,uint256) (runs: 14, μ: 147601, ~: 147492) -OrderBookDepositEnactTest:testOrderBookDepositEvalWriteStateDifferentOwnersNamespaced(address,address,bytes32,uint256) (runs: 14, μ: 1037467, ~: 1037444) -OrderBookDepositEnactTest:testOrderBookDepositEvalWriteStateSequential(address,bytes32,uint256) (runs: 14, μ: 656494, ~: 656502) -OrderBookDepositEnactTest:testOrderBookDepositEvalWriteStateSingle(address,bytes32,uint256) (runs: 14, μ: 274620, ~: 274628) -OrderBookDepositEnactTest:testOrderDepositContext(address,bytes32,uint256,uint256) (runs: 14, μ: 744692, ~: 757106) -OrderBookDepositTest:testDepositEvent(address,bytes32,uint256) (runs: 104, μ: 69204, ~: 69107) -OrderBookDepositTest:testDepositFail(address,bytes32,uint256) (runs: 104, μ: 1040464862, ~: 1040464742) -OrderBookDepositTest:testDepositGas00() (gas: 14374) -OrderBookDepositTest:testDepositGas01() (gas: 61493) -OrderBookDepositTest:testDepositMany((address,address,bytes32,uint256,bytes32)[]) (runs: 104, μ: 9214718, ~: 8084088) -OrderBookDepositTest:testDepositReentrancy(address,bytes32,uint256,address,bytes32,uint256) (runs: 104, μ: 653938, ~: 654163) -OrderBookDepositTest:testDepositSimple(address,bytes32,uint256) (runs: 104, μ: 68905, ~: 68808) -OrderBookDepositTest:testDepositZero(address,bytes32) (runs: 104, μ: 13768, ~: 13768) -OrderBookEnactTest:testOrderBookEvalEmptyNoop(address) (runs: 104, μ: 14140, ~: 14140) -OrderBookEnactTest:testOrderBookEvalOneReadState(address) (runs: 104, μ: 73699, ~: 73699) -OrderBookEnactTest:testOrderBookEvalOneStateless(address) (runs: 104, μ: 59038, ~: 59038) -OrderBookEnactTest:testOrderBookEvalWriteStateDifferentOwnersNamespaced(address,address) (runs: 104, μ: 866761, ~: 866761) -OrderBookEnactTest:testOrderBookEvalWriteStateSequential() (gas: 542558) -OrderBookEnactTest:testOrderBookEvalWriteStateSingle(address) (runs: 104, μ: 170937, ~: 170937) -OrderBookQuoteSameTokenTest:testQuoteSameToken(((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)[])) (runs: 14, μ: 7638263, ~: 7910018) -OrderBookQuoteTest:testQuoteContextSender(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 104, μ: 7590767, ~: 8008843) -OrderBookQuoteTest:testQuoteDeadOrder(((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)[])) (runs: 104, μ: 6432027, ~: 5597087) -OrderBookQuoteTest:testQuoteMaxOutput(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 104, μ: 853370, ~: 899969) -OrderBookQuoteTest:testQuoteSimple(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 104, μ: 846979, ~: 893506) -OrderBookRemoveOrderEnactTest:testRemoveOrderContext(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 559522, ~: 549546) -OrderBookRemoveOrderEnactTest:testRemoveOrderDeadOrder(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 278309, ~: 269901) -OrderBookRemoveOrderEnactTest:testRemoveOrderEmptyNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 752025, ~: 725507) -OrderBookRemoveOrderEnactTest:testRemoveOrderOneReadState(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 813215, ~: 786690) -OrderBookRemoveOrderEnactTest:testRemoveOrderOneStateless(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 798595, ~: 772070) -OrderBookRemoveOrderEnactTest:testRemoveOrderRevertInAction(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 906062, ~: 876706) -OrderBookRemoveOrderEnactTest:testRemoveOrderWriteStateDifferentOwnersNamespaced(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 3860489, ~: 3787923) -OrderBookRemoveOrderEnactTest:testRemoveOrderWriteStateSequential(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1047466, ~: 1020910) -OrderBookRemoveOrderEnactTest:testRemoveOrderWriteStateSingle(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 1575201, ~: 1525294) -OrderBookRemoveOrderMockTest:testRemoveOrderAddRemoveMulti(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 5193484, ~: 5011091) -OrderBookRemoveOrderMockTest:testRemoveOrderDifferent(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 3598202, ~: 3497472) -OrderBookRemoveOrderMockTest:testRemoveOrderDifferentOwners(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 3484795, ~: 3563204) -OrderBookRemoveOrderMockTest:testRemoveOrderDifferentOwnersDifferent(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 7115574, ~: 7071857) -OrderBookRemoveOrderMockTest:testRemoveOrderDoesNotExist(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 301988, ~: 292762) -OrderBookRemoveOrderMockTest:testRemoveOrderOnlyOwner(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 104, μ: 1888673, ~: 1933097) -OrderBookRemoveOrderOwnerTest:testRemoveOrderOwnerDifferentOwnerStateChange(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 104, μ: 4460769, ~: 4322581) -OrderBookRemoveOrderOwnerTest:testRemoveOrderOwnerSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 2369198, ~: 2277730) -OrderBookRemoveOrderOwnerTest:testRemoveOrderWrongOwner(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 104, μ: 613119, ~: 600036) -OrderBookSubParserContextCalculatedIORatioTest:testSubParserContextHappy() (gas: 2277259) -OrderBookSubParserContextCalculatedIORatioTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254112) -OrderBookSubParserContextCalculatedIORatioTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239776) -OrderBookSubParserContextCalculatedMaxOutputTest:testSubParserContextHappy() (gas: 2277586) -OrderBookSubParserContextCalculatedMaxOutputTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254436) -OrderBookSubParserContextCalculatedMaxOutputTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2240103) -OrderBookSubParserContextInputTokenDecimalsTest:testSubParserContextHappy() (gas: 2277424) -OrderBookSubParserContextInputTokenDecimalsTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254274) -OrderBookSubParserContextInputTokenDecimalsTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239941) -OrderBookSubParserContextInputTokenTest:testSubParserContextHappy() (gas: 2275963) -OrderBookSubParserContextInputTokenTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2252813) -OrderBookSubParserContextInputTokenTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238480) -OrderBookSubParserContextInputVaultBalanceIncreaseTest:testSubParserContextHappy() (gas: 2277424) -OrderBookSubParserContextInputVaultBalanceIncreaseTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254274) -OrderBookSubParserContextInputVaultBalanceIncreaseTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239941) -OrderBookSubParserContextOrderBookTest:testSubParserContextHappy() (gas: 2275639) -OrderBookSubParserContextOrderBookTest:testSubParserContextHappy() (gas: 2276449) -OrderBookSubParserContextOrderBookTest:testSubParserContextHappy() (gas: 2276611) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2252489) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2253299) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2253461) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238156) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238966) -OrderBookSubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239128) -OrderBookSubParserContextOrderClearerTest:testSubParserContextHappy() (gas: 2276287) -OrderBookSubParserContextOrderClearerTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2253137) -OrderBookSubParserContextOrderClearerTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238804) -OrderBookSubParserContextOrderCounterpartyTest:testSubParserContextHappy() (gas: 2277097) -OrderBookSubParserContextOrderCounterpartyTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2253950) -OrderBookSubParserContextOrderCounterpartyTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239614) -OrderBookSubParserContextOrderHashTest:testSubParserContextHappy() (gas: 2275801) -OrderBookSubParserContextOrderHashTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2252651) -OrderBookSubParserContextOrderHashTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238318) -OrderBookSubParserContextOrderOwnerTest:testSubParserContextHappy() (gas: 2275963) -OrderBookSubParserContextOrderOwnerTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2252813) -OrderBookSubParserContextOrderOwnerTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238480) -OrderBookSubParserContextOutputTokenDecimalsTest:testSubParserContextHappy() (gas: 2277586) -OrderBookSubParserContextOutputTokenDecimalsTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254436) -OrderBookSubParserContextOutputTokenDecimalsTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2240103) -OrderBookSubParserContextOutputTokenTest:testSubParserContextHappy() (gas: 2276125) -OrderBookSubParserContextOutputTokenTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2252975) -OrderBookSubParserContextOutputTokenTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2238642) -OrderBookSubParserContextOutputVaultBalanceBeforeTest:testSubParserContextHappy() (gas: 2277259) -OrderBookSubParserContextOutputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254112) -OrderBookSubParserContextOutputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239776) -OrderBookSubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextHappy() (gas: 2277586) -OrderBookSubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2254436) -OrderBookSubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2240103) -OrderBookSubParserContextVaultBalanceBeforeTest:testSubParserContextHappy() (gas: 2277097) -OrderBookSubParserContextVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2253950) -OrderBookSubParserContextVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2239614) -OrderBookSubParserDescribedByMetaV1Test:testOrderBookSubParserDescribedByMetaV1Happy() (gas: 2193079) -OrderBookSubParserIERC165Test:testOrderBookSubParserIERC165(bytes4) (runs: 5100, μ: 2196789, ~: 2196789) -OrderBookSubParserPointersTest:testSubParserFunctionPointers() (gas: 2204101) -OrderBookSubParserPointersTest:testSubParserOperandParsers() (gas: 2204123) -OrderBookSubParserPointersTest:testSubParserParseMeta() (gas: 121568) -OrderBookSubParserPointersTest:testWordOperandLengthEquivalence() (gas: 4076) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextHappy0() (gas: 2283066) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextHappy1() (gas: 2283136) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextHappy2() (gas: 2283137) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextHappy3() (gas: 2283295) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextUnhappyInput() (gas: 2259802) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextUnhappyNoOperand() (gas: 2235704) -OrderBookSubParserSignedContextTest:testSubParserContextSignedContextUnhappyTooManyOperands() (gas: 2244797) -OrderBookSubParserSignersTest:testSubParserContextSignerHappy0() (gas: 2278291) -OrderBookSubParserSignersTest:testSubParserContextSignerHappy1() (gas: 2278383) -OrderBookSubParserSignersTest:testSubParserContextSignerUnhappyInput() (gas: 2255024) -OrderBookSubParserSignersTest:testSubParserContextSignerUnhappyNoOperand() (gas: 2234381) -OrderBookSubParserSignersTest:testSubParserContextSignerUnhappyTooManyOperands() (gas: 2240433) -OrderBookTakeOrderBadStackTest:testTakeOrderBadStackEmptyStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 763780, ~: 746951) -OrderBookTakeOrderBadStackTest:testTakeOrderBadStackOneStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 770994, ~: 754162) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO00() (gas: 323225) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO1() (gas: 476691) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO10(uint256) (runs: 104, μ: 711614, ~: 666396) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO2() (gas: 491057) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO3() (gas: 642990) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO4() (gas: 662182) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO5() (gas: 662183) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO6() (gas: 647829) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO7(uint256) (runs: 104, μ: 915933, ~: 915565) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO8(uint256) (runs: 104, μ: 1082847, ~: 1082312) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderHandleIO9(uint256) (runs: 104, μ: 793122, ~: 719899) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert0() (gas: 296417) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert1() (gas: 463534) -OrderBookTakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert2() (gas: 449148) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputMultipleOrdersMultipleOwners(uint256,uint256,uint256) (runs: 104, μ: 563472, ~: 569596) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputMultipleOrdersSingleOwner(uint256,uint256) (runs: 104, μ: 491574, ~: 508195) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleAnyDeposit(uint256,uint256) (runs: 104, μ: 334680, ~: 335769) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderLessThanMaximumInput(uint256,uint256) (runs: 104, μ: 331614, ~: 331614) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderLessThanMaximumOutput(uint256) (runs: 104, μ: 332552, ~: 332519) -OrderBookTakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderUnlimitedMax(uint256) (runs: 104, μ: 324945, ~: 325177) -OrderBookTakeOrderMaximumInputTest:testTakeOrderNoopZeroMaxTakerInput((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,bytes32[],bytes)) (runs: 104, μ: 155544, ~: 151840) -OrderBookTakeOrderNoopTest:testTakeOrderNoopNonLiveOrderOne((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)) (runs: 104, μ: 406525, ~: 416556) -OrderBookTakeOrderNoopTest:testTakeOrderNoopNonLiveOrderTwo((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256,(address,bytes32[],bytes),(address,bytes32[],bytes)) (runs: 104, μ: 730208, ~: 729680) -OrderBookTakeOrderNoopTest:testTakeOrderNoopZeroOrders() (gas: 13028) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad01() (gas: 327840) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad02() (gas: 327861) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad03() (gas: 329546) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad04() (gas: 329590) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad05() (gas: 329547) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad06() (gas: 329568) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad07() (gas: 328485) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad08() (gas: 328462) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad09() (gas: 328442) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad10() (gas: 328486) -OrderBookTakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad11() (gas: 328935) -OrderBookTakeOrderSameTokenTest:testTakeOrderSameToken(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 14, μ: 641097, ~: 620874) -OrderBookTakeOrderTokenMismatchTest:testTokenDecimalMismatchOutputs((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256) (runs: 14, μ: 518147, ~: 537052) -OrderBookTakeOrderTokenMismatchTest:testTokenMismatchInputs((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256) (runs: 14, μ: 516873, ~: 535778) -OrderBookV4FlashLenderFeeTest:testFlashFee(address,uint256) (runs: 5100, μ: 6558, ~: 6558) -OrderBookV4FlashLenderIERC165Test:testOrderBookV4FlashLenderIERC165(bytes4) (runs: 5100, μ: 580452, ~: 580452) -OrderBookV4FlashLenderMaxFlashLoanTest:testFlashMaxLoan(uint256) (runs: 5100, μ: 7937, ~: 7937) -OrderBookV4FlashLenderMockSuccessTest:testFlashLoanToReceiver(uint256,bytes) (runs: 5100, μ: 14874, ~: 14820) -OrderBookV4FlashLenderReentrant:testReenterAddOrder(uint256,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 12614489, ~: 12848303) -OrderBookV4FlashLenderReentrant:testReenterCheckOrderExists(bytes32,uint256) (runs: 104, μ: 553989, ~: 553989) -OrderBookV4FlashLenderReentrant:testReenterClear(uint256,address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 26849038, ~: 27248245) -OrderBookV4FlashLenderReentrant:testReenterDeposit(uint256,uint256,uint256) (runs: 104, μ: 681999, ~: 681876) -OrderBookV4FlashLenderReentrant:testReenterReadVaultBalances(uint256,uint256) (runs: 104, μ: 598701, ~: 599276) -OrderBookV4FlashLenderReentrant:testReenterRemoveOrder(uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 104, μ: 11750818, ~: 11341552) -OrderBookV4FlashLenderReentrant:testReenterTakeOrder(uint256,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 104, μ: 13160932, ~: 13389240) -OrderBookV4FlashLenderReentrant:testReenterWithdraw(uint256,uint256,uint256) (runs: 104, μ: 661658, ~: 661726) -OrderBookV4FlashLenderTransferTest:testFlashLoanTransferFail(uint256,uint256,bool) (runs: 104, μ: 1345715, ~: 1347575) -OrderBookV4FlashLenderTransferTest:testFlashLoanTransferSuccess(uint256,bool) (runs: 104, μ: 1297673, ~: 1303638) -OrderBookV5ArbOrderTakerContextTest:testOrderBookV5ArbOrderTakerContext() (gas: 2791400) -OrderBookV5ArbOrderTakerIERC165Test:testOrderBookV5ArbOrderTakerIERC165(bytes4) (runs: 5100, μ: 2465382, ~: 2465382) -OrderBookV5FlashBorrowerIERC165Test:testOrderBookV5FlashBorrowerIERC165(bytes4) (runs: 5100, μ: 3059081, ~: 3059081) -OrderBookVaultBalanceTest:testVaultBalanceNoDeposits(address,bytes32) (runs: 5100, μ: 8973, ~: 8973) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalEmptyNoop(address,bytes32,uint256,uint256) (runs: 104, μ: 96903, ~: 97007) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalOneReadState(address,bytes32,uint256,uint256) (runs: 104, μ: 159254, ~: 159358) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalOneStateless(address,bytes32,uint256,uint256) (runs: 104, μ: 144548, ~: 144652) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalWriteStateDifferentOwnersNamespaced(address,address,bytes32,uint256,uint256) (runs: 104, μ: 1088904, ~: 1089005) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalWriteStateSequential(address,bytes32,uint256,uint256) (runs: 104, μ: 672738, ~: 672673) -OrderBookWithdrawEvalTest:testOrderBookWithdrawEvalWriteStateSingle(address,bytes32,uint256,uint256) (runs: 104, μ: 290031, ~: 289966) -OrderBookWithdrawEvalTest:testOrderBookWithdrawalEvalRevertInAction(address,bytes32,uint256,uint256) (runs: 104, μ: 142920, ~: 143024) -OrderBookWithdrawEvalTest:testOrderWithdrawContext(address,bytes32,uint256,uint256) (runs: 104, μ: 797181, ~: 804047) -OrderBookWithdrawTest:testWithdrawEmptyVault(address,bytes32,uint256) (runs: 104, μ: 54679, ~: 54609) -OrderBookWithdrawTest:testWithdrawFailure(address,bytes32,uint256,uint256) (runs: 104, μ: 1040442512, ~: 1040442374) -OrderBookWithdrawTest:testWithdrawFullVault(address,bytes32,uint256,uint256) (runs: 104, μ: 89055, ~: 89040) -OrderBookWithdrawTest:testWithdrawMany((bool,address,address,bytes32,uint256,bytes32,uint256,bool)[]) (runs: 104, μ: 7426228, ~: 7098996) -OrderBookWithdrawTest:testWithdrawPartialVault(address,bytes32,uint256,uint256) (runs: 104, μ: 90990, ~: 90902) -OrderBookWithdrawTest:testWithdrawZero(address,address,bytes32) (runs: 104, μ: 13536, ~: 13536) -RouteProcessorOrderBookV5ArbOrderTakerExpressionTest:testRouteProcessorTakeOrdersExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256[],uint256[]) (runs: 104, μ: 365297, ~: 357866) -RouteProcessorOrderBookV5ArbOrderTakerExpressionTest:testRouteProcessorTakeOrdersWrongExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,address,bytes)) (runs: 104, μ: 131845, ~: 130810) -RouteProcessorOrderBookV5ArbOrderTakerSenderTest:testRouteProcessorTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 104, μ: 257195, ~: 248039) \ No newline at end of file +GenericPoolOrderBookV6ArbOrderTakerExpressionTest:testGenericPoolTakeOrdersExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256[],uint256[]) (runs: 10, μ: 365709, ~: 355253) +GenericPoolOrderBookV6ArbOrderTakerExpressionTest:testGenericPoolTakeOrdersWrongExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,address,bytes)) (runs: 10, μ: 145680, ~: 146004) +GenericPoolOrderBookV6ArbOrderTakerSenderTest:testGenericPoolTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 10, μ: 285056, ~: 278113) +GenericPoolOrderBookV6FlashBorrowerTest:testGenericPoolOrderBookV6FlashBorrowerTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 10, μ: 443482, ~: 430924) +LibOrderTest:testHashEqual((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 100, μ: 157994, ~: 155100) +LibOrderTest:testHashNotEqual((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 100, μ: 232153, ~: 235696) +OrderBookV5FlashBorrowerIERC165Test:testOrderBookV5FlashBorrowerIERC165(bytes4) (runs: 5089, μ: 2289436, ~: 2289436) +OrderBookV6AddOrderEnactTest:testAddLiveOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 778545, ~: 769325) +OrderBookV6AddOrderEnactTest:testAddLiveOrderRevertNoAdd(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 641517, ~: 651456) +OrderBookV6AddOrderEnactTest:testAddOrderContext(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 890745, ~: 891708) +OrderBookV6AddOrderEnactTest:testAddOrderEmptyNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 541692, ~: 525924) +OrderBookV6AddOrderEnactTest:testAddOrderOneReadState(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 634476, ~: 637979) +OrderBookV6AddOrderEnactTest:testAddOrderOneStateless(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 617752, ~: 623360) +OrderBookV6AddOrderEnactTest:testAddOrderWriteStateDifferentOwnersNamespaced(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 2748354, ~: 2893563) +OrderBookV6AddOrderEnactTest:testAddOrderWriteStateSequential(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 801286, ~: 810163) +OrderBookV6AddOrderEnactTest:testAddOrderWriteStateSingle(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 1146735, ~: 1168083) +OrderBookV6AddOrderMockTest:testAddOrderSameAccountWithDifferentConfig(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,bytes) (runs: 100, μ: 2014735, ~: 1971244) +OrderBookV6AddOrderMockTest:testAddOrderTwoAccountsWithDifferentConfig(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,bytes) (runs: 100, μ: 1901246, ~: 1895450) +OrderBookV6AddOrderMockTest:testAddOrderTwoAccountsWithSameConfig(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 1860058, ~: 1817782) +OrderBookV6AddOrderMockTest:testAddOrderWithCalculationsInputsAndOutputsSucceeds(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 99, μ: 886798, ~: 887134) +OrderBookV6AddOrderMockTest:testAddOrderWithNonEmptyMetaEmitsMetaV1(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 98, μ: 898605, ~: 895499) +OrderBookV6AddOrderMockTest:testAddOrderWithNonEmptyMetaReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 98, μ: 513779, ~: 512812) +OrderBookV6AddOrderMockTest:testAddOrderWithoutCalculationsDeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 527792, ~: 519989) +OrderBookV6AddOrderMockTest:testAddOrderWithoutInputsReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 135150, ~: 131542) +OrderBookV6AddOrderMockTest:testAddOrderWithoutOutputsReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 138886, ~: 136657) +OrderBookV6AddOrderNonceTest:testAddOrderNonceDifferentNonceStateChange(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes32) (runs: 100, μ: 942742, ~: 945176) +OrderBookV6AddOrderNonceTest:testAddOrderNonceSameNonceDifferentOrderStateChange(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 1102817, ~: 1110297) +OrderBookV6AddOrderNonceTest:testAddOrderNonceSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 767284, ~: 755438) +OrderBookV6AddOrderOwnerTest:testAddOrderOwnerDifferentOwnerStateChange(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 100, μ: 941851, ~: 938978) +OrderBookV6AddOrderOwnerTest:testAddOrderOwnerSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 767387, ~: 755541) +OrderBookV6AddOrderTest:testAddOrderRealCalculateInputsReverts1(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 517823, ~: 510479) +OrderBookV6AddOrderTest:testAddOrderRealCalculateInputsReverts2(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 519602, ~: 512258) +OrderBookV6AddOrderTest:testAddOrderRealCalculateInputsRevertsPreference(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 519187, ~: 511843) +OrderBookV6AddOrderTest:testAddOrderRealNoHandleIODeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 510115, ~: 502771) +OrderBookV6AddOrderTest:testAddOrderRealNoSourcesDeploys(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 489560, ~: 482218) +OrderBookV6AddOrderTest:testAddOrderRealOneStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 520830, ~: 513086) +OrderBookV6AddOrderTest:testAddOrderRealThreeStackCalculate(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 534618, ~: 529057) +OrderBookV6AddOrderTest:testAddOrderRealTwoStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 526983, ~: 519219) +OrderBookV6AddOrderTest:testAddOrderRealZeroStackCalculateReverts(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 516545, ~: 509201) +OrderBookV6ArbOrderTakerContextTest:testOrderBookV6ArbOrderTakerContext() (gas: 2043846) +OrderBookV6ArbOrderTakerIERC165Test:testOrderBookV6ArbOrderTakerIERC165(bytes4) (runs: 5090, μ: 1772793, ~: 1772793) +OrderBookV6ClearHandleIORevertTest:testClearOrderAliceNoHandleIORevert() (gas: 623848) +OrderBookV6ClearHandleIORevertTest:testClearOrderBobNoHandleIORevert() (gas: 623783) +OrderBookV6ClearHandleIORevertTest:testClearOrderBothNoHandleIORevert() (gas: 602969) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO0() (gas: 655599) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO1() (gas: 651939) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO2() (gas: 652081) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO3() (gas: 655555) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO4() (gas: 715306) +OrderBookV6ClearHandleIORevertTest:testClearOrderHandleIO5() (gas: 679426) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackEmptyStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 1806689, ~: 1758069) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackOneEmpty(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1894994, ~: 1845177) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackOneOne(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1890852, ~: 1843520) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackOneOtherOne(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1826490, ~: 1780301) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackOneStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1825157, ~: 1774124) +OrderBookV6ClearOrderBadStackTest:testClearOrderBadStackOtherEmpty(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1825813, ~: 1773505) +OrderBookV6ClearOrderContextTest:testContextEmptyStack(address,address,bytes32,bytes32,bytes32,bytes32) (runs: 11, μ: 2206208, ~: 2244135) +OrderBookV6ClearSameTokenTest:testClearSameToken(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 10, μ: 1315140, ~: 1195390) +OrderBookV6ClearTest:testClear2ZeroRatioAliceAndBob(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 99, μ: 3477778, ~: 3549397) +OrderBookV6ClearTest:testClear2ZeroRatioAliceOnly(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 99, μ: 3499036, ~: 3570655) +OrderBookV6ClearTest:testClear2ZeroRatioBobOnly(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 99, μ: 3502584, ~: 3574203) +OrderBookV6ClearTest:testClearFuzzIoRatioError(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32,uint256,uint256) (runs: 98, μ: 3654074, ~: 3623829) +OrderBookV6ClearTest:testClearFuzzIoRatioHappy(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32,uint256,uint256) (runs: 98, μ: 3694181, ~: 3664485) +OrderBookV6ClearTest:testClearSimple(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,address,bytes32,bytes32) (runs: 99, μ: 3567410, ~: 3639016) +OrderBookV6ClearZeroAmountTest:testClearZeroAmount(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 11, μ: 2110583, ~: 1890456) +OrderBookV6DepositEnactTest:testDepositRevertInAction(address,bytes32,uint256) (runs: 11, μ: 126109, ~: 125985) +OrderBookV6DepositEnactTest:testOrderBookDepositEnactEmptyNoop(address,bytes32,uint256) (runs: 11, μ: 75151, ~: 74965) +OrderBookV6DepositEnactTest:testOrderBookDepositEnactOneReadState(address,bytes32,uint256) (runs: 11, μ: 135348, ~: 135224) +OrderBookV6DepositEnactTest:testOrderBookDepositEnactOneStateless(address,bytes32,uint256) (runs: 11, μ: 120752, ~: 120628) +OrderBookV6DepositEnactTest:testOrderBookDepositEvalWriteStateDifferentOwnersNamespaced(address,address,bytes32,uint256) (runs: 11, μ: 974597, ~: 974647) +OrderBookV6DepositEnactTest:testOrderBookDepositEvalWriteStateSequential(address,bytes32,uint256) (runs: 11, μ: 610097, ~: 609989) +OrderBookV6DepositEnactTest:testOrderBookDepositEvalWriteStateSingle(address,bytes32,uint256) (runs: 11, μ: 242694, ~: 242551) +OrderBookV6DepositEnactTest:testOrderDepositContext(address,bytes32,uint256,uint256) (runs: 11, μ: 706936, ~: 719978) +OrderBookV6DepositTest:testDepositEvent(address,bytes32,uint256) (runs: 100, μ: 71230, ~: 71175) +OrderBookV6DepositTest:testDepositFail(address,bytes32,uint256) (runs: 101, μ: 1040466584, ~: 1040466446) +OrderBookV6DepositTest:testDepositGas00() (gas: 15667) +OrderBookV6DepositTest:testDepositGas01() (gas: 63981) +OrderBookV6DepositTest:testDepositMany((address,address,bytes32,uint256,bytes32)[]) (runs: 0, μ: 0, ~: 0) +OrderBookV6DepositTest:testDepositReentrancy(address,bytes32,uint256,address,bytes32,uint256) (runs: 101, μ: 544564, ~: 544628) +OrderBookV6DepositTest:testDepositSimple(address,bytes32,uint256) (runs: 100, μ: 70592, ~: 70537) +OrderBookV6DepositTest:testDepositZero(address,bytes32) (runs: 100, μ: 13582, ~: 13582) +OrderBookV6EnactTest:testOrderBookEvalEmptyNoop(address) (runs: 101, μ: 14260, ~: 14260) +OrderBookV6EnactTest:testOrderBookEvalOneReadState(address) (runs: 101, μ: 71892, ~: 71892) +OrderBookV6EnactTest:testOrderBookEvalOneStateless(address) (runs: 101, μ: 57276, ~: 57276) +OrderBookV6EnactTest:testOrderBookEvalWriteStateDifferentOwnersNamespaced(address,address) (runs: 101, μ: 837360, ~: 837360) +OrderBookV6EnactTest:testOrderBookEvalWriteStateSequential() (gas: 523537) +OrderBookV6EnactTest:testOrderBookEvalWriteStateSingle(address) (runs: 101, μ: 166224, ~: 166224) +OrderBookV6FlashLenderFeeTest:testFlashFee(address,uint256) (runs: 5096, μ: 3798, ~: 3798) +OrderBookV6FlashLenderGriefRecipientTest:testFlashLoanToNonReceiver(uint256,bytes,bytes32,bytes) (runs: 5096, μ: 24274, ~: 24264) +OrderBookV6FlashLenderIERC165Test:testOrderBookV6FlashLenderIERC165(bytes4) (runs: 5085, μ: 366649, ~: 366649) +OrderBookV6FlashLenderMaxFlashLoanTest:testFlashMaxLoan(uint256) (runs: 5096, μ: 7448, ~: 7448) +OrderBookV6FlashLenderMockSuccessTest:testFlashLoanToReceiver(uint256,bytes) (runs: 5096, μ: 11830, ~: 11823) +OrderBookV6FlashLenderReentrant:testReenterAddOrder(uint256,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 12356843, ~: 12191772) +OrderBookV6FlashLenderReentrant:testReenterCheckOrderExists(bytes32,uint256) (runs: 100, μ: 439869, ~: 439869) +OrderBookV6FlashLenderReentrant:testReenterClear(uint256,address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 26815315, ~: 25608494) +OrderBookV6FlashLenderReentrant:testReenterDeposit(uint256,uint256,uint256) (runs: 100, μ: 569254, ~: 569171) +OrderBookV6FlashLenderReentrant:testReenterReadVaultBalances(uint256,uint256) (runs: 100, μ: 484501, ~: 484899) +OrderBookV6FlashLenderReentrant:testReenterRemoveOrder(uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32)) (runs: 100, μ: 10984818, ~: 10328391) +OrderBookV6FlashLenderReentrant:testReenterTakeOrder(uint256,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 12909723, ~: 12738871) +OrderBookV6FlashLenderReentrant:testReenterWithdraw(uint256,uint256,uint256) (runs: 100, μ: 550171, ~: 550287) +OrderBookV6FlashLenderTransferTest:testFlashLoanTransferFail(uint256,uint256,bool) (runs: 101, μ: 946603, ~: 947862) +OrderBookV6FlashLenderTransferTest:testFlashLoanTransferSuccess(uint256,bool) (runs: 100, μ: 888708, ~: 881839) +OrderBookV6QuoteSameTokenTest:testQuoteSameToken(((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)[])) (runs: 10, μ: 4383724, ~: 3853491) +OrderBookV6QuoteTest:testQuoteContextSender(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 101, μ: 9052764, ~: 8974784) +OrderBookV6QuoteTest:testQuoteDeadOrder(((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)[])) (runs: 100, μ: 6616370, ~: 5519007) +OrderBookV6QuoteTest:testQuoteMaxOutput(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 101, μ: 1004469, ~: 985427) +OrderBookV6QuoteTest:testQuoteSimple(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),uint256) (runs: 101, μ: 1003772, ~: 992621) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderContext(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 586855, ~: 581786) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderDeadOrder(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 305555, ~: 302011) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderEmptyNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 839425, ~: 828004) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderOneReadState(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 898543, ~: 887213) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderOneStateless(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 881027, ~: 866414) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderRevertInAction(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1000798, ~: 988859) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderWriteStateDifferentOwnersNamespaced(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 3987411, ~: 4061923) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderWriteStateSequential(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1120959, ~: 1107094) +OrderBookV6RemoveOrderEnactTest:testRemoveOrderWriteStateSingle(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 1725218, ~: 1702436) +OrderBookV6RemoveOrderMockTest:testRemoveOrderAddRemoveMulti(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 4833398, ~: 4806513) +OrderBookV6RemoveOrderMockTest:testRemoveOrderDifferent(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 3466182, ~: 3451921) +OrderBookV6RemoveOrderMockTest:testRemoveOrderDifferentOwners(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 3597923, ~: 3507749) +OrderBookV6RemoveOrderMockTest:testRemoveOrderDifferentOwnersDifferent(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 7174741, ~: 7149373) +OrderBookV6RemoveOrderMockTest:testRemoveOrderDoesNotExist(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 297737, ~: 297233) +OrderBookV6RemoveOrderMockTest:testRemoveOrderOnlyOwner(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),bytes) (runs: 100, μ: 1961225, ~: 1914802) +OrderBookV6RemoveOrderOwnerTest:testRemoveOrderOwnerDifferentOwnerStateChange(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 100, μ: 4325716, ~: 4275239) +OrderBookV6RemoveOrderOwnerTest:testRemoveOrderOwnerSameOrderNoop(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 2666586, ~: 2619432) +OrderBookV6RemoveOrderOwnerTest:testRemoveOrderWrongOwner(((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes),address,address) (runs: 100, μ: 595981, ~: 594043) +OrderBookV6SubParserContextCalculatedIORatioTest:testSubParserContextHappy() (gas: 2065358) +OrderBookV6SubParserContextCalculatedIORatioTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042454) +OrderBookV6SubParserContextCalculatedIORatioTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028887) +OrderBookV6SubParserContextCalculatedMaxOutputTest:testSubParserContextHappy() (gas: 2065685) +OrderBookV6SubParserContextCalculatedMaxOutputTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042777) +OrderBookV6SubParserContextCalculatedMaxOutputTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2029215) +OrderBookV6SubParserContextInputTokenDecimalsTest:testSubParserContextHappy() (gas: 2065524) +OrderBookV6SubParserContextInputTokenDecimalsTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042616) +OrderBookV6SubParserContextInputTokenDecimalsTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2029053) +OrderBookV6SubParserContextInputTokenTest:testSubParserContextHappy() (gas: 2064061) +OrderBookV6SubParserContextInputTokenTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041154) +OrderBookV6SubParserContextInputTokenTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027591) +OrderBookV6SubParserContextInputVaultBalanceBeforeTest:testSubParserContextHappy() (gas: 2065196) +OrderBookV6SubParserContextInputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042292) +OrderBookV6SubParserContextInputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028725) +OrderBookV6SubParserContextInputVaultBalanceIncreaseTest:testSubParserContextHappy() (gas: 2065524) +OrderBookV6SubParserContextInputVaultBalanceIncreaseTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042616) +OrderBookV6SubParserContextInputVaultBalanceIncreaseTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2029053) +OrderBookV6SubParserContextInputVaultIdTest:testSubParserContextHappy() (gas: 2064548) +OrderBookV6SubParserContextInputVaultIdTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041641) +OrderBookV6SubParserContextInputVaultIdTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028077) +OrderBookV6SubParserContextOrderBookTest:testSubParserContextHappy() (gas: 2063737) +OrderBookV6SubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2040830) +OrderBookV6SubParserContextOrderBookTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027267) +OrderBookV6SubParserContextOrderClearerTest:testSubParserContextHappy() (gas: 2064385) +OrderBookV6SubParserContextOrderClearerTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041478) +OrderBookV6SubParserContextOrderClearerTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027915) +OrderBookV6SubParserContextOrderCounterpartyTest:testSubParserContextHappy() (gas: 2065196) +OrderBookV6SubParserContextOrderCounterpartyTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042292) +OrderBookV6SubParserContextOrderCounterpartyTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028725) +OrderBookV6SubParserContextOrderHashTest:testSubParserContextHappy() (gas: 2063899) +OrderBookV6SubParserContextOrderHashTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2040992) +OrderBookV6SubParserContextOrderHashTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027429) +OrderBookV6SubParserContextOrderOwnerTest:testSubParserContextHappy() (gas: 2064062) +OrderBookV6SubParserContextOrderOwnerTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041155) +OrderBookV6SubParserContextOrderOwnerTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027591) +OrderBookV6SubParserContextOutputTokenDecimalsTest:testSubParserContextHappy() (gas: 2065686) +OrderBookV6SubParserContextOutputTokenDecimalsTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042778) +OrderBookV6SubParserContextOutputTokenDecimalsTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2029215) +OrderBookV6SubParserContextOutputTokenTest:testSubParserContextHappy() (gas: 2064223) +OrderBookV6SubParserContextOutputTokenTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041316) +OrderBookV6SubParserContextOutputTokenTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2027753) +OrderBookV6SubParserContextOutputVaultBalanceBeforeTest:testSubParserContextHappy() (gas: 2065358) +OrderBookV6SubParserContextOutputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042454) +OrderBookV6SubParserContextOutputVaultBalanceBeforeTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028887) +OrderBookV6SubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextHappy() (gas: 2065686) +OrderBookV6SubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2042778) +OrderBookV6SubParserContextOutputVaultBalanceDecreaseTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2029215) +OrderBookV6SubParserContextOutputVaultIdTest:testSubParserContextHappy() (gas: 2064710) +OrderBookV6SubParserContextOutputVaultIdTest:testSubParserContextUnhappyDisallowedInputs() (gas: 2041803) +OrderBookV6SubParserContextOutputVaultIdTest:testSubParserContextUnhappyDisallowedOperand() (gas: 2028239) +OrderBookV6SubParserDescribedByMetaV1Test:testOrderBookV6SubParserDescribedByMetaV1Happy() (gas: 1978249) +OrderBookV6SubParserIERC165Test:testOrderBookV6SubParserIERC165(bytes4) (runs: 5073, μ: 1984624, ~: 1984624) +OrderBookV6SubParserPointersTest:testSubParserFunctionPointers() (gas: 1990810) +OrderBookV6SubParserPointersTest:testSubParserOperandParsers() (gas: 1990832) +OrderBookV6SubParserPointersTest:testSubParserParseMeta() (gas: 102268) +OrderBookV6SubParserPointersTest:testWordOperandLengthEquivalence() (gas: 880) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextHappy0() (gas: 2070733) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextHappy1() (gas: 2070844) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextHappy2() (gas: 2070845) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextHappy3() (gas: 2071044) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextUnhappyInput() (gas: 2047674) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextUnhappyNoOperand() (gas: 2025115) +OrderBookV6SubParserSignedContextTest:testSubParserContextSignedContextUnhappyTooManyOperands() (gas: 2033428) +OrderBookV6SubParserSignersTest:testSubParserContextSignerHappy0() (gas: 2066224) +OrderBookV6SubParserSignersTest:testSubParserContextSignerHappy1() (gas: 2066357) +OrderBookV6SubParserSignersTest:testSubParserContextSignerUnhappyInput() (gas: 2043150) +OrderBookV6SubParserSignersTest:testSubParserContextSignerUnhappyNoOperand() (gas: 2023791) +OrderBookV6SubParserSignersTest:testSubParserContextSignerUnhappyTooManyOperands() (gas: 2029364) +OrderBookV6TakeOrderBadStackTest:testTakeOrderBadStackEmptyStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 100, μ: 806856, ~: 823194) +OrderBookV6TakeOrderBadStackTest:testTakeOrderBadStackOneStack(address,address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 101, μ: 812021, ~: 826018) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO00() (gas: 300224) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO1() (gas: 476549) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO10(uint256) (runs: 101, μ: 677222, ~: 644240) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO2() (gas: 490690) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO3() (gas: 647053) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO4() (gas: 663684) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO5() (gas: 663669) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO6() (gas: 649497) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO7(uint256) (runs: 101, μ: 916926, ~: 917177) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO8(uint256) (runs: 101, μ: 1088161, ~: 1088383) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderHandleIO9(uint256) (runs: 101, μ: 757536, ~: 693883) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert0() (gas: 295996) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert1() (gas: 465921) +OrderBookV6TakeOrderHandleIORevertTest:testTakeOrderNoHandleIORevert2() (gas: 451760) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputMultipleOrdersMultipleOwners(uint256,uint256,uint256) (runs: 101, μ: 546173, ~: 560404) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputMultipleOrdersSingleOwner(uint256,uint256) (runs: 101, μ: 488266, ~: 503279) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleAnyDeposit(uint256,uint256) (runs: 101, μ: 326143, ~: 328452) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderLessThanMaximumInput(uint256,uint256) (runs: 101, μ: 303204, ~: 303978) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderLessThanMaximumOutput(uint256) (runs: 101, μ: 305119, ~: 305068) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderMaximumInputSingleOrderUnlimitedMax(uint256) (runs: 101, μ: 298033, ~: 297848) +OrderBookV6TakeOrderMaximumInputTest:testTakeOrderNoopZeroMaxTakerInput((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,bytes32[],bytes)) (runs: 99, μ: 164912, ~: 164415) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputMultipleOrders(uint256,uint256) (runs: 101, μ: 496897, ~: 517345) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputMultipleOrdersDifferentOwners(uint256,uint256,uint256) (runs: 101, μ: 562968, ~: 586913) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputSingleAnyDeposit(uint256,uint256) (runs: 101, μ: 335533, ~: 337859) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputSingleOrderLimitedByVault(uint256,uint256) (runs: 101, μ: 310417, ~: 311177) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputSingleOrderLimitedMax(uint256) (runs: 101, μ: 309612, ~: 309877) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputSingleOrderUnlimitedMax(uint256) (runs: 101, μ: 305478, ~: 305311) +OrderBookV6TakeOrderMaximumOutputTest:testTakeOrderMaximumOutputZero((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,bytes32[],bytes)) (runs: 5055, μ: 161923, ~: 160642) +OrderBookV6TakeOrderNoopTest:testTakeOrderNoopNonLiveOrderOne((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,bytes32[],bytes)) (runs: 100, μ: 404220, ~: 394510) +OrderBookV6TakeOrderNoopTest:testTakeOrderNoopNonLiveOrderTwo((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256,(address,bytes32[],bytes),(address,bytes32[],bytes)) (runs: 98, μ: 734399, ~: 730801) +OrderBookV6TakeOrderNoopTest:testTakeOrderNoopZeroOrders() (gas: 13193) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad01() (gas: 303214) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad02() (gas: 303192) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad03() (gas: 304957) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad04() (gas: 304935) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad05() (gas: 304914) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad06() (gas: 304979) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad07() (gas: 303892) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad08() (gas: 303869) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad09() (gas: 303915) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad10() (gas: 303870) +OrderBookV6TakeOrderPrecisionTest:testTakeOrderPrecisionKnownBad11() (gas: 304334) +OrderBookV6TakeOrderSameTokenTest:testTakeOrderSameToken(address,((address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32,bytes32,bytes)) (runs: 10, μ: 667019, ~: 674510) +OrderBookV6TakeOrderTokenMismatchTest:testTokenDecimalMismatchOutputs((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256) (runs: 10, μ: 522616, ~: 532407) +OrderBookV6TakeOrderTokenMismatchTest:testTokenMismatchInputs((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256,uint256) (runs: 10, μ: 522449, ~: 532240) +OrderBookV6VaultBalanceTest:testVaultBalanceNoDeposits(address,bytes32) (runs: 5096, μ: 6238, ~: 6238) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalEmptyNoop(address,bytes32,uint256,uint256) (runs: 101, μ: 97532, ~: 98423) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalOneReadState(address,bytes32,uint256,uint256) (runs: 101, μ: 158004, ~: 158910) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalOneStateless(address,bytes32,uint256,uint256) (runs: 101, μ: 143369, ~: 144273) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalWriteStateDifferentOwnersNamespaced(address,address,bytes32,uint256,uint256) (runs: 101, μ: 1059991, ~: 1061709) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalWriteStateSequential(address,bytes32,uint256,uint256) (runs: 101, μ: 655090, ~: 655961) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawEvalWriteStateSingle(address,bytes32,uint256,uint256) (runs: 101, μ: 286888, ~: 287796) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawalEvalRevertInAction(address,bytes32,uint256,uint256) (runs: 101, μ: 142162, ~: 143061) +OrderBookV6WithdrawEvalTest:testOrderBookWithdrawalEvalZeroAmountEvalNoop(address,bytes32,uint256) (runs: 101, μ: 110325, ~: 110101) +OrderBookV6WithdrawEvalTest:testOrderWithdrawContext(address,bytes32,uint256,uint256) (runs: 101, μ: 776368, ~: 768958) +OrderBookV6WithdrawTest:testWithdrawEmptyVault(address,bytes32,uint256) (runs: 100, μ: 56637, ~: 56561) +OrderBookV6WithdrawTest:testWithdrawFailure(address,bytes32,uint256,uint256) (runs: 101, μ: 1040424480, ~: 1040442736) +OrderBookV6WithdrawTest:testWithdrawFullVault(address,bytes32,uint256,uint256) (runs: 100, μ: 72648, ~: 72588) +OrderBookV6WithdrawTest:testWithdrawMany((bool,address,address,bytes32,uint256,bytes32,uint256,bool)[]) (runs: 99, μ: 7225147, ~: 7601753) +OrderBookV6WithdrawTest:testWithdrawPartialVault(address,bytes32,uint256,uint256) (runs: 100, μ: 94456, ~: 94374) +OrderBookV6WithdrawTest:testWithdrawZero(address,address,bytes32) (runs: 100, μ: 13481, ~: 13481) +RouteProcessorOrderBookV6ArbOrderTakerExpressionTest:testRouteProcessorTakeOrdersExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,uint256[],uint256[]) (runs: 100, μ: 341600, ~: 341997) +RouteProcessorOrderBookV6ArbOrderTakerExpressionTest:testRouteProcessorTakeOrdersWrongExpression((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256,(address,address,bytes)) (runs: 100, μ: 137266, ~: 137223) +RouteProcessorOrderBookV6ArbOrderTakerSenderTest:testRouteProcessorTakeOrdersSender((address,(address,address,bytes),(address,bytes32)[],(address,bytes32)[],bytes32),uint256,uint256) (runs: 100, μ: 269362, ~: 259694) \ No newline at end of file diff --git a/.github/workflows/deploy-subgraph.yaml b/.github/workflows/deploy-subgraph.yaml index d754fadddf..6a588e531b 100644 --- a/.github/workflows/deploy-subgraph.yaml +++ b/.github/workflows/deploy-subgraph.yaml @@ -33,6 +33,9 @@ jobs: submodules: recursive fetch-depth: 0 + - name: Free disk space + uses: jlumbroso/free-disk-space@v1.3.1 + - uses: nixbuild/nix-quick-install-action@v30 with: nix_conf: | diff --git a/crates/bindings/ARCHITECTURE.md b/crates/bindings/ARCHITECTURE.md index f3e3f61539..1cb8c4c4f9 100644 --- a/crates/bindings/ARCHITECTURE.md +++ b/crates/bindings/ARCHITECTURE.md @@ -70,7 +70,7 @@ WASM and JS Interop - `EvaluableV4`: `{ interpreter: string; store: string; bytecode: string; }` - `SignedContextV1`: `{ signer: string; context: string[]; signature: string; }` - `TakeOrderConfigV4`: `{ order: OrderV4; inputIOIndex: string; outputIOIndex: string; signedContext: SignedContextV1[]; }` - - `TakeOrdersConfigV4`: `{ minimumInput: string; maximumInput: string; maximumIORatio: string; orders: TakeOrderConfigV4[]; data: string; }` + - `TakeOrdersConfigV5`: `{ minimumIO: string; maximumIO: string; maximumIORatio: string; IOIsInput: string; orders: TakeOrderConfigV4[]; data: string; }` - Why many fields are `string` in TS - Large numeric values (e.g., `U256`) are represented as strings to avoid precision issues and to keep interop predictable across JS runtimes. Hex strings are used for byte data. This matches how the rest of the workspace serializes on the boundary. diff --git a/crates/bindings/src/js_api.rs b/crates/bindings/src/js_api.rs index 4f41094bec..570b0b1ac6 100644 --- a/crates/bindings/src/js_api.rs +++ b/crates/bindings/src/js_api.rs @@ -1,5 +1,5 @@ -use crate::IOrderBookV5::{ - EvaluableV4, OrderV4, QuoteV2, SignedContextV1, TakeOrderConfigV4, TakeOrdersConfigV4, IOV2, +use crate::IOrderBookV6::{ + EvaluableV4, OrderV4, QuoteV2, SignedContextV1, TakeOrderConfigV4, TakeOrdersConfigV5, IOV2, }; use wasm_bindgen_utils::{impl_custom_tsify, impl_wasm_traits, prelude::*}; @@ -9,7 +9,7 @@ impl_wasm_traits!(OrderV4); impl_wasm_traits!(EvaluableV4); impl_wasm_traits!(SignedContextV1); impl_wasm_traits!(TakeOrderConfigV4); -impl_wasm_traits!(TakeOrdersConfigV4); +impl_wasm_traits!(TakeOrdersConfigV5); impl_custom_tsify!( IOV2, @@ -63,11 +63,12 @@ impl_custom_tsify!( }" ); impl_custom_tsify!( - TakeOrdersConfigV4, - "export interface TakeOrdersConfigV4 { - minimumInput: string; - maximumInput: string; + TakeOrdersConfigV5, + "export interface TakeOrdersConfigV5 { + minimumIO: string; + maximumIO: string; maximumIORatio: string; + IOIsInput: string; orders: TakeOrderConfigV4[]; data: string; }" @@ -159,17 +160,20 @@ mod tests { #[wasm_bindgen_test] fn test_take_orders_config_v4_tsify() { - let js_take_orders_config = to_js_value(&TakeOrdersConfigV4::default()).unwrap(); + let js_take_orders_config = to_js_value(&TakeOrdersConfigV5::default()).unwrap(); // validate serialized props match the tsify definition - assert!(JsString::from_str("minimumInput") + assert!(JsString::from_str("minimumIO") .unwrap() .js_in(&js_take_orders_config)); - assert!(JsString::from_str("maximumInput") + assert!(JsString::from_str("maximumIO") .unwrap() .js_in(&js_take_orders_config)); assert!(JsString::from_str("maximumIORatio") .unwrap() .js_in(&js_take_orders_config)); + assert!(JsString::from_str("IOIsInput") + .unwrap() + .js_in(&js_take_orders_config)); assert!(JsString::from_str("orders") .unwrap() .js_in(&js_take_orders_config)); diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index aaa32c93fc..b3d232009c 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -3,13 +3,13 @@ use alloy::sol; sol!( #![sol(all_derives = true, rpc)] #![sol(extra_derives(serde::Serialize, serde::Deserialize))] - IOrderBookV5, "../../out/IOrderBookV5.sol/IOrderBookV5.json" + IOrderBookV6, "../../out/IOrderBookV6.sol/IOrderBookV6.json" ); sol!( #![sol(all_derives = true)] #![sol(extra_derives(serde::Serialize, serde::Deserialize))] - OrderBook, "../../out/OrderBook.sol/OrderBook.json" + OrderBook, "../../out/OrderBookV6.sol/OrderBookV6.json" ); sol!( @@ -39,7 +39,7 @@ pub mod wasm_traits; pub mod topics { use crate::{ IInterpreterStoreV3::Set, - IOrderBookV5::{ + IOrderBookV6::{ AddOrderV3, AfterClearV2, ClearV3, DepositV2, RemoveOrderV3, TakeOrderV3, WithdrawV2, }, OrderBook::MetaV1_2, diff --git a/crates/cli/src/commands/order/add.rs b/crates/cli/src/commands/order/add.rs index ea86820607..049488064c 100644 --- a/crates/cli/src/commands/order/add.rs +++ b/crates/cli/src/commands/order/add.rs @@ -80,7 +80,7 @@ mod tests { use super::*; use alloy::primitives::{address, Address, B256, U256}; use rain_orderbook_app_settings::spec_version::SpecVersion; - use rain_orderbook_bindings::IOrderBookV5::IOV2; + use rain_orderbook_bindings::IOrderBookV6::IOV2; use std::{collections::HashMap, str::FromStr}; use tempfile::NamedTempFile; diff --git a/crates/cli/src/commands/order/detail.rs b/crates/cli/src/commands/order/detail.rs index bc62096bcb..c101ceb5db 100644 --- a/crates/cli/src/commands/order/detail.rs +++ b/crates/cli/src/commands/order/detail.rs @@ -32,7 +32,7 @@ mod tests { use super::*; use alloy::{hex::encode_prefixed, primitives::B256, sol_types::SolValue}; use httpmock::MockServer; - use rain_orderbook_bindings::IOrderBookV5::{OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{OrderV4, IOV2}; use serde_json::{json, Value}; #[tokio::test] diff --git a/crates/cli/src/commands/order/list.rs b/crates/cli/src/commands/order/list.rs index 86c7dc82ca..fac089e32d 100644 --- a/crates/cli/src/commands/order/list.rs +++ b/crates/cli/src/commands/order/list.rs @@ -99,7 +99,7 @@ mod tests { use super::*; use alloy::{hex::encode_prefixed, primitives::B256, sol_types::SolValue}; use httpmock::MockServer; - use rain_orderbook_bindings::IOrderBookV5::{OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{OrderV4, IOV2}; use serde_json::{json, Value}; #[tokio::test] diff --git a/crates/common/src/add_order.rs b/crates/common/src/add_order.rs index f2ef81f3e8..49fd1433c1 100644 --- a/crates/common/src/add_order.rs +++ b/crates/common/src/add_order.rs @@ -27,8 +27,8 @@ use rain_metadata::{ }; use rain_metadata_bindings::MetaBoard::emitMetaCall; use rain_orderbook_app_settings::deployment::DeploymentCfg; -use rain_orderbook_bindings::IOrderBookV5::{ - addOrder3Call, EvaluableV4, OrderConfigV4, TaskV2, IOV2, +use rain_orderbook_bindings::IOrderBookV6::{ + addOrder4Call, EvaluableV4, OrderConfigV4, TaskV2, IOV2, }; use serde::{Deserialize, Serialize}; use serde_bytes::ByteBuf; @@ -212,7 +212,7 @@ impl AddOrderArgs { pub async fn try_into_call( &self, rpcs: Vec, - ) -> Result { + ) -> Result { let rainlang = self.compose_to_rainlang()?; let bytecode = self .try_parse_rainlang(rpcs.clone(), rainlang.clone()) @@ -242,7 +242,7 @@ impl AddOrderArgs { signedContext: vec![], }; - Ok(addOrder3Call { + Ok(addOrder4Call { config: OrderConfigV4 { validInputs: self.inputs.clone(), validOutputs: self.outputs.clone(), @@ -295,7 +295,7 @@ impl AddOrderArgs { pub async fn get_add_order_call_parameters( &self, transaction_args: TransactionArgs, - ) -> Result, AddOrderArgsError> { + ) -> Result, AddOrderArgsError> { let add_order_call = self.try_into_call(transaction_args.clone().rpcs).await?; let params = transaction_args.try_into_write_contract_parameters( add_order_call, @@ -305,7 +305,7 @@ impl AddOrderArgs { } #[cfg(not(target_family = "wasm"))] - pub async fn execute)>( + pub async fn execute)>( &self, transaction_args: TransactionArgs, transaction_status_changed: S, @@ -1610,7 +1610,7 @@ _ _: 0 0; additional_meta: None, }; - let add_order_call = addOrder3Call { + let add_order_call = addOrder4Call { config: OrderConfigV4 { evaluable: EvaluableV4 { interpreter: *local_evm.interpreter.address(), @@ -1700,7 +1700,7 @@ _ _: 0 0; .unwrap() .into(); - let expected_bytes: Bytes = addOrder3Call { + let expected_bytes: Bytes = addOrder4Call { config: OrderConfigV4 { evaluable: EvaluableV4 { interpreter: *local_evm.interpreter.address(), diff --git a/crates/common/src/deposit.rs b/crates/common/src/deposit.rs index 7e24cf9025..abd395f938 100644 --- a/crates/common/src/deposit.rs +++ b/crates/common/src/deposit.rs @@ -9,7 +9,7 @@ use alloy_ethers_typecast::{WriteTransaction, WriteTransactionStatus}; use rain_math_float::{Float, FloatError}; #[cfg(not(target_family = "wasm"))] use rain_orderbook_bindings::IERC20::approveCall; -use rain_orderbook_bindings::{IOrderBookV5::deposit3Call, IERC20::allowanceCall}; +use rain_orderbook_bindings::{IOrderBookV6::deposit4Call, IERC20::allowanceCall}; use serde::{Deserialize, Serialize}; use thiserror::Error; @@ -42,11 +42,11 @@ pub struct DepositArgs { pub decimals: u8, } -impl TryFrom for deposit3Call { +impl TryFrom for deposit4Call { type Error = FloatError; fn try_from(val: DepositArgs) -> Result { - let call = deposit3Call { + let call = deposit4Call { token: val.token, vaultId: val.vault_id, depositAmount: val.amount.get_inner(), @@ -111,14 +111,14 @@ impl DepositArgs { /// Execute OrderbookV3 deposit call #[cfg(not(target_family = "wasm"))] - pub async fn execute_deposit)>( + pub async fn execute_deposit)>( &self, transaction_args: TransactionArgs, transaction_status_changed: S, ) -> Result<(), DepositError> { let (ledger_client, _) = transaction_args.clone().try_into_ledger_client().await?; - let deposit_call: deposit3Call = self.clone().try_into()?; + let deposit_call: deposit4Call = self.clone().try_into()?; let params = transaction_args .try_into_write_contract_parameters(deposit_call, transaction_args.orderbook_address)?; @@ -147,7 +147,7 @@ mod tests { decimals: 6, }; - let deposit_call: deposit3Call = args.try_into().unwrap(); + let deposit_call: deposit4Call = args.try_into().unwrap(); assert_eq!( deposit_call.token, @@ -205,7 +205,7 @@ mod tests { }; let amount = Float::parse("100".to_string()).unwrap().get_inner(); - let deposit_call = deposit3Call { + let deposit_call = deposit4Call { token: Address::ZERO, vaultId: B256::from(U256::from(42)), depositAmount: amount, diff --git a/crates/common/src/local_db/address_collectors.rs b/crates/common/src/local_db/address_collectors.rs index 029cc32399..498f0c90e6 100644 --- a/crates/common/src/local_db/address_collectors.rs +++ b/crates/common/src/local_db/address_collectors.rs @@ -1,6 +1,6 @@ use super::decode::{DecodedEvent, DecodedEventData}; use alloy::primitives::Address; -use rain_orderbook_bindings::IOrderBookV5::OrderV4; +use rain_orderbook_bindings::IOrderBookV6::OrderV4; use std::collections::BTreeSet; pub fn collect_token_addresses( @@ -68,7 +68,7 @@ mod tests { use super::*; use alloy::primitives::{b256, Address, Bytes, FixedBytes, U256}; use rain_orderbook_bindings::IInterpreterStoreV3::Set; - use rain_orderbook_bindings::IOrderBookV5::{ + use rain_orderbook_bindings::IOrderBookV6::{ AddOrderV3, DepositV2, OrderV4, RemoveOrderV3, SignedContextV1, TakeOrderConfigV4, TakeOrderV3, WithdrawV2, IOV2, }; @@ -90,7 +90,7 @@ mod tests { OrderV4 { owner: Address::from([1u8; 20]), nonce: U256::from(1).into(), - evaluable: rain_orderbook_bindings::IOrderBookV5::EvaluableV4 { + evaluable: rain_orderbook_bindings::IOrderBookV6::EvaluableV4 { interpreter: Address::from([2u8; 20]), store: Address::from([3u8; 20]), bytecode: alloy::primitives::Bytes::from(vec![]), @@ -172,11 +172,11 @@ mod tests { vaultId: U256::from(0).into(), }); - let clear = rain_orderbook_bindings::IOrderBookV5::ClearV3 { + let clear = rain_orderbook_bindings::IOrderBookV6::ClearV3 { sender: Address::from([0u8; 20]), alice, bob, - clearConfig: rain_orderbook_bindings::IOrderBookV5::ClearConfigV2 { + clearConfig: rain_orderbook_bindings::IOrderBookV6::ClearConfigV2 { aliceInputIOIndex: U256::from(0), aliceOutputIOIndex: U256::from(0), bobInputIOIndex: U256::from(0), diff --git a/crates/common/src/local_db/decode.rs b/crates/common/src/local_db/decode.rs index 2f0e234648..634dce6e6e 100644 --- a/crates/common/src/local_db/decode.rs +++ b/crates/common/src/local_db/decode.rs @@ -7,7 +7,7 @@ use alloy::{ use core::convert::TryFrom; use rain_orderbook_bindings::{ IInterpreterStoreV3::Set, - IOrderBookV5::{ + IOrderBookV6::{ AddOrderV3, AfterClearV2, ClearV3, DepositV2, RemoveOrderV3, TakeOrderV3, WithdrawV2, }, OrderBook::MetaV1_2, @@ -210,11 +210,11 @@ mod test_helpers { use alloy::hex; use alloy::primitives::{address, b256, Address, Bytes, FixedBytes, B256, U256}; use rain_orderbook_bindings::{ - IOrderBookV5::{ + IOrderBookV6::{ AddOrderV3, AfterClearV2, ClearConfigV2, ClearStateChangeV2, ClearV3, DepositV2, RemoveOrderV3, SignedContextV1, TakeOrderConfigV4, TakeOrderV3, WithdrawV2, }, - IOrderBookV5::{EvaluableV4, OrderV4, IOV2}, + IOrderBookV6::{EvaluableV4, OrderV4, IOV2}, OrderBook::MetaV1_2, }; use serde_json::Value; diff --git a/crates/common/src/local_db/fetch.rs b/crates/common/src/local_db/fetch.rs index 469ec1f9a9..7ab923b903 100644 --- a/crates/common/src/local_db/fetch.rs +++ b/crates/common/src/local_db/fetch.rs @@ -391,7 +391,7 @@ mod tests { use alloy::rpc::types::FilterBlockError; use alloy::sol_types::SolEvent; use httpmock::prelude::*; - use rain_orderbook_bindings::{IInterpreterStoreV3::Set, IOrderBookV5::AddOrderV3}; + use rain_orderbook_bindings::{IInterpreterStoreV3::Set, IOrderBookV6::AddOrderV3}; use serde_json::json; use std::str::FromStr; use std::sync::atomic::{AtomicUsize, Ordering}; diff --git a/crates/common/src/local_db/insert.rs b/crates/common/src/local_db/insert.rs index d035ed4668..a784abe651 100644 --- a/crates/common/src/local_db/insert.rs +++ b/crates/common/src/local_db/insert.rs @@ -10,7 +10,7 @@ use alloy::{ }; use itertools::Itertools; use rain_math_float::Float; -use rain_orderbook_bindings::IOrderBookV5::{ +use rain_orderbook_bindings::IOrderBookV6::{ AddOrderV3, AfterClearV2, ClearV3, DepositV2, OrderV4, RemoveOrderV3, TakeOrderV3, WithdrawV2, IOV2, }; @@ -968,7 +968,7 @@ mod tests { use alloy::hex; use alloy::primitives::{address, b256, Address, Bytes, FixedBytes, B256, U256}; use rain_orderbook_bindings::IInterpreterStoreV3::Set; - use rain_orderbook_bindings::IOrderBookV5::{ + use rain_orderbook_bindings::IOrderBookV6::{ ClearConfigV2, ClearStateChangeV2, EvaluableV4, SignedContextV1, TakeOrderConfigV4, }; use std::collections::HashMap; diff --git a/crates/common/src/local_db/pipeline/adapters/apply.rs b/crates/common/src/local_db/pipeline/adapters/apply.rs index c5ff683c4e..e644528c11 100644 --- a/crates/common/src/local_db/pipeline/adapters/apply.rs +++ b/crates/common/src/local_db/pipeline/adapters/apply.rs @@ -225,7 +225,7 @@ mod tests { fn deposit_event(addr: Address) -> DecodedEventData { use crate::local_db::decode::EventType; - use rain_orderbook_bindings::IOrderBookV5::DepositV2; + use rain_orderbook_bindings::IOrderBookV6::DepositV2; DecodedEventData { event_type: EventType::DepositV2, block_number: U256::from(1), @@ -245,7 +245,7 @@ mod tests { fn withdraw_event(addr: Address) -> DecodedEventData { use crate::local_db::decode::EventType; - use rain_orderbook_bindings::IOrderBookV5::WithdrawV2; + use rain_orderbook_bindings::IOrderBookV6::WithdrawV2; DecodedEventData { event_type: EventType::WithdrawV2, block_number: U256::from(0x10), diff --git a/crates/common/src/local_db/pipeline/engine.rs b/crates/common/src/local_db/pipeline/engine.rs index 3bc3417a23..4a0e2b0056 100644 --- a/crates/common/src/local_db/pipeline/engine.rs +++ b/crates/common/src/local_db/pipeline/engine.rs @@ -409,7 +409,7 @@ mod tests { token: Address, tx: u8, ) -> DecodedEventData { - use rain_orderbook_bindings::IOrderBookV5::DepositV2; + use rain_orderbook_bindings::IOrderBookV6::DepositV2; DecodedEventData { event_type: EventType::DepositV2, block_number: U256::from(block), @@ -433,7 +433,7 @@ mod tests { output_token: Address, tx: u8, ) -> DecodedEventData { - use rain_orderbook_bindings::IOrderBookV5::{AddOrderV3, EvaluableV4, OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{AddOrderV3, EvaluableV4, OrderV4, IOV2}; DecodedEventData { event_type: EventType::AddOrderV3, block_number: U256::from(block), diff --git a/crates/common/src/raindex_client/remove_orders.rs b/crates/common/src/raindex_client/remove_orders.rs index 2da4a3e908..ebd91610a5 100644 --- a/crates/common/src/raindex_client/remove_orders.rs +++ b/crates/common/src/raindex_client/remove_orders.rs @@ -6,7 +6,7 @@ use crate::raindex_client::orders::{fetch_orders_dotrain_sources, RaindexOrder}; use crate::retry::{retry_with_constant_interval, RetryError}; use alloy::primitives::{hex::decode, Bytes, B256}; use alloy::sol_types::{SolCall, SolValue}; -use rain_orderbook_bindings::IOrderBookV5::{removeOrder3Call, OrderV4}; +use rain_orderbook_bindings::IOrderBookV6::{removeOrder3Call, OrderV4}; use rain_orderbook_subgraph_client::types::order_detail_traits::OrderDetailError; use std::rc::Rc; diff --git a/crates/common/src/raindex_client/vaults.rs b/crates/common/src/raindex_client/vaults.rs index abb6618af6..375177afaa 100644 --- a/crates/common/src/raindex_client/vaults.rs +++ b/crates/common/src/raindex_client/vaults.rs @@ -23,7 +23,7 @@ use alloy::{ }; use async_trait::async_trait; use rain_math_float::Float; -use rain_orderbook_bindings::{IOrderBookV5::deposit3Call, IERC20::approveCall}; +use rain_orderbook_bindings::{IOrderBookV6::deposit4Call, IERC20::approveCall}; use rain_orderbook_subgraph_client::{ performance::vol::{VaultVolume, VolumeDetails}, types::{ @@ -411,7 +411,7 @@ impl RaindexVault { ) -> Result { self.validate_amount(amount)?; let (deposit_args, _) = self.get_deposit_and_transaction_args(amount).await?; - let call = deposit3Call::try_from(deposit_args)?; + let call = deposit4Call::try_from(deposit_args)?; Ok(Bytes::copy_from_slice(&call.abi_encode())) } @@ -2148,7 +2148,7 @@ mod tests { use httpmock::MockServer; use rain_orderbook_bindings::IERC20::decimalsCall; use rain_orderbook_bindings::{ - IOrderBookV5::{deposit3Call, withdraw3Call}, + IOrderBookV6::{deposit4Call, withdraw4Call}, IERC20::approveCall, }; use rain_orderbook_subgraph_client::utils::float::*; @@ -2995,7 +2995,7 @@ mod tests { assert_eq!( result, Bytes::copy_from_slice( - &deposit3Call { + &deposit4Call { token: Address::from_str("0x1d80c49bbbcd1c0911346656b529df9e5c2f783d") .unwrap(), vaultId: B256::from(U256::from_str("0x0123").unwrap()), @@ -3060,7 +3060,7 @@ mod tests { assert_eq!( result, Bytes::copy_from_slice( - &withdraw3Call { + &withdraw4Call { token: Address::from_str("0x1d80c49bbbcd1c0911346656b529df9e5c2f783d") .unwrap(), vaultId: B256::from(U256::from_str("0x0123").unwrap()), diff --git a/crates/common/src/remove_order.rs b/crates/common/src/remove_order.rs index 6d35b5ce3b..504e7954b8 100644 --- a/crates/common/src/remove_order.rs +++ b/crates/common/src/remove_order.rs @@ -6,7 +6,7 @@ use alloy::sol_types::SolCall; use alloy_ethers_typecast::WritableClientError; #[cfg(not(target_family = "wasm"))] use alloy_ethers_typecast::{WriteTransaction, WriteTransactionStatus}; -use rain_orderbook_bindings::IOrderBookV5::removeOrder3Call; +use rain_orderbook_bindings::IOrderBookV6::removeOrder3Call; use rain_orderbook_subgraph_client::types::{ common::SgOrder, order_detail_traits::OrderDetailError, }; @@ -79,7 +79,7 @@ impl RemoveOrderArgs { mod tests { use super::*; use alloy::primitives::Address; - use rain_orderbook_bindings::IOrderBookV5::removeOrder3Call; + use rain_orderbook_bindings::IOrderBookV6::removeOrder3Call; use rain_orderbook_subgraph_client::types::common::{ SgBigInt, SgBytes, SgErc20, SgOrderbook, SgVault, }; diff --git a/crates/common/src/replays.rs b/crates/common/src/replays.rs index 2ca3942d26..434dc97167 100644 --- a/crates/common/src/replays.rs +++ b/crates/common/src/replays.rs @@ -188,7 +188,7 @@ amount price: 2 1; let amount = Float::parse("10".to_string()).unwrap().get_inner(); let tx_req = orderbook - .deposit3( + .deposit4( *token1.address(), B256::from(U256::from(0x01)), amount, @@ -214,7 +214,7 @@ amount price: 2 1; .unwrap() .get_inner(); let one_float = Float::parse("1".to_string()).unwrap().get_inner(); - let config = Orderbook::TakeOrdersConfigV4 { + let config = Orderbook::TakeOrdersConfigV5 { orders: vec![Orderbook::TakeOrderConfigV4 { order, inputIOIndex: U256::from(0), @@ -222,13 +222,14 @@ amount price: 2 1; signedContext: vec![], }], maximumIORatio: max_float, - maximumInput: max_float, - minimumInput: one_float, + maximumIO: max_float, + minimumIO: one_float, + IOIsInput: true, data: Bytes::new(), }; let tx_req = orderbook - .takeOrders3(config) + .takeOrders4(config) .from(token2_holder) .into_transaction_request(); diff --git a/crates/common/src/take_orders.rs b/crates/common/src/take_orders.rs index c6a2fb3952..33797b73bd 100644 --- a/crates/common/src/take_orders.rs +++ b/crates/common/src/take_orders.rs @@ -4,7 +4,7 @@ use crate::raindex_client::RaindexError; use alloy::primitives::Address; use futures::StreamExt; use rain_math_float::Float; -use rain_orderbook_bindings::IOrderBookV5::OrderV4; +use rain_orderbook_bindings::IOrderBookV6::OrderV4; const DEFAULT_QUOTE_CONCURRENCY: usize = 5; @@ -143,7 +143,7 @@ mod tests { use alloy::sol_types::{SolCall, SolValue}; use rain_math_float::Float; use rain_orderbook_app_settings::spec_version::SpecVersion; - use rain_orderbook_bindings::IOrderBookV5::{EvaluableV4, OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{EvaluableV4, OrderV4, IOV2}; use rain_orderbook_quote::Pair; use rain_orderbook_subgraph_client::types::common::{ SgBigInt, SgBytes, SgErc20, SgOrder, SgOrderbook, SgVault, diff --git a/crates/common/src/transaction.rs b/crates/common/src/transaction.rs index a01528b30b..e4650fdb80 100644 --- a/crates/common/src/transaction.rs +++ b/crates/common/src/transaction.rs @@ -139,7 +139,7 @@ mod tests { use httpmock::MockServer; use super::*; - use rain_orderbook_bindings::IOrderBookV5::vaultBalance2Call; + use rain_orderbook_bindings::IOrderBookV6::vaultBalance2Call; #[test] fn test_try_into_write_contract_parameters_ok() { diff --git a/crates/common/src/types/orders_list_flattened.rs b/crates/common/src/types/orders_list_flattened.rs index 44c920d9e8..d671607415 100644 --- a/crates/common/src/types/orders_list_flattened.rs +++ b/crates/common/src/types/orders_list_flattened.rs @@ -2,7 +2,7 @@ use crate::types::vault::NO_SYMBOL; use crate::{csv::TryIntoCsv, utils::timestamp::format_bigint_timestamp_display}; use alloy::dyn_abi::SolType; use alloy::primitives::hex::{decode, encode}; -use rain_orderbook_bindings::IOrderBookV5::OrderV4; +use rain_orderbook_bindings::IOrderBookV6::OrderV4; use rain_orderbook_subgraph_client::types::common::*; use serde::{Deserialize, Serialize}; @@ -90,7 +90,7 @@ mod tests { primitives::{Address, Bytes, FixedBytes, B256, U256}, sol_types::SolValue, }; - use rain_orderbook_bindings::IOrderBookV5::{EvaluableV4, OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{EvaluableV4, OrderV4, IOV2}; use rain_orderbook_subgraph_client::types::common::{ SgAddOrder, SgBigInt, SgBytes, SgErc20, SgOrderStructPartialTrade, SgOrderbook, SgTransaction, SgVault, diff --git a/crates/common/src/withdraw.rs b/crates/common/src/withdraw.rs index 328617a71d..72c36296c2 100644 --- a/crates/common/src/withdraw.rs +++ b/crates/common/src/withdraw.rs @@ -8,7 +8,7 @@ use alloy_ethers_typecast::{WriteTransaction, WriteTransactionStatus}; use serde::{Deserialize, Serialize}; use rain_math_float::Float; -use rain_orderbook_bindings::IOrderBookV5::withdraw3Call; +use rain_orderbook_bindings::IOrderBookV6::withdraw4Call; #[derive(Clone, Deserialize, Serialize, Debug)] pub struct WithdrawArgs { @@ -17,9 +17,9 @@ pub struct WithdrawArgs { pub target_amount: Float, } -impl From for withdraw3Call { +impl From for withdraw4Call { fn from(val: WithdrawArgs) -> Self { - withdraw3Call { + withdraw4Call { token: val.token, vaultId: val.vault_id, targetAmount: val.target_amount.get_inner(), @@ -31,14 +31,14 @@ impl From for withdraw3Call { impl WithdrawArgs { /// Execute OrderbookV3 withdraw call #[cfg(not(target_family = "wasm"))] - pub async fn execute)>( + pub async fn execute)>( &self, transaction_args: TransactionArgs, transaction_status_changed: S, ) -> Result<(), WritableTransactionExecuteError> { let (ledger_client, _) = transaction_args.clone().try_into_ledger_client().await?; - let withdraw_call: withdraw3Call = self.clone().into(); + let withdraw_call: withdraw4Call = self.clone().into(); let params = transaction_args.try_into_write_contract_parameters( withdraw_call, transaction_args.orderbook_address, @@ -52,7 +52,7 @@ impl WithdrawArgs { } pub async fn get_withdraw_calldata(&self) -> Result, WritableTransactionExecuteError> { - let withdraw_call: withdraw3Call = self.clone().into(); + let withdraw_call: withdraw4Call = self.clone().into(); Ok(withdraw_call.abi_encode()) } } @@ -74,7 +74,7 @@ mod tests { target_amount: amount, }; - let withdraw_call: withdraw3Call = args.into(); + let withdraw_call: withdraw4Call = args.into(); assert_eq!( withdraw_call.token, address!("1234567890abcdef1234567890abcdef12345678") @@ -93,7 +93,7 @@ mod tests { }; let calldata = args.get_withdraw_calldata().await.unwrap(); - let expected_calldata = withdraw3Call { + let expected_calldata = withdraw4Call { token: Address::from_str("0x1234567890abcdef1234567890abcdef12345678").unwrap(), vaultId: B256::from(U256::from(42)), targetAmount: amount.get_inner(), @@ -117,7 +117,7 @@ mod tests { }; let amount = Float::parse("456".to_string()).unwrap().get_inner(); - let withdraw_call = withdraw3Call { + let withdraw_call = withdraw4Call { token: Address::from_str("0x1234567890abcdef1234567890abcdef12345678").unwrap(), vaultId: B256::from(U256::from(123)), targetAmount: amount, diff --git a/crates/js_api/ARCHITECTURE.md b/crates/js_api/ARCHITECTURE.md index b41058fed8..9ff1ed82d6 100644 --- a/crates/js_api/ARCHITECTURE.md +++ b/crates/js_api/ARCHITECTURE.md @@ -28,7 +28,7 @@ - Key types and exports: - `TakeOrdersCalldata(Bytes)` as an opaque JS type for encoded calldata. - `getOrderHash(order: OrderV4) -> string`: ABI-encodes `OrderV4` and returns `keccak256` with `0x` prefix. - - `getTakeOrders3Calldata(config: TakeOrdersConfigV4) -> TakeOrdersCalldata`: ABI-encodes a `takeOrders3` call for the on-chain OrderBook. + - `getTakeOrders4Calldata(config: TakeOrdersConfigV5) -> TakeOrdersCalldata`: ABI-encodes a `takeOrders4` call for the on-chain OrderBook. - `keccak256(bytes: Uint8Array) -> string` and `keccak256HexString(hex: string) -> string`. - Errors: `Error::FromHexError` mapped to JS with human-readable message. diff --git a/crates/js_api/src/bindings/mod.rs b/crates/js_api/src/bindings/mod.rs index 4c4c2fabba..57d7805710 100644 --- a/crates/js_api/src/bindings/mod.rs +++ b/crates/js_api/src/bindings/mod.rs @@ -8,7 +8,7 @@ use alloy::{ }, sol_types::SolCall, }; -use rain_orderbook_bindings::IOrderBookV5::{takeOrders3Call, OrderV4, TakeOrdersConfigV4}; +use rain_orderbook_bindings::IOrderBookV6::{takeOrders4Call, OrderV4, TakeOrdersConfigV5}; use serde::{Deserialize, Serialize}; use wasm_bindgen_utils::{impl_wasm_traits, prelude::*}; @@ -60,13 +60,13 @@ pub fn get_order_hash( unchecked_return_type = "TakeOrdersCalldata", return_description = "Encoded calldata ready for blockchain submission" )] -pub fn get_take_orders3_calldata( +pub fn get_take_orders4_calldata( #[wasm_export( - param_description = "Complete configuration for order execution including minimumInput, maximumInput, maximumIORatio, orders array, and additional data" + param_description = "Complete configuration for order execution including minimumIO, maximumIO, maximumIORatio, orders array, IOIsInput, and additional data" )] - take_orders_config: TakeOrdersConfigV4, + take_orders_config: TakeOrdersConfigV5, ) -> Result { - let calldata = takeOrders3Call { + let calldata = takeOrders4Call { config: take_orders_config, } .abi_encode(); @@ -169,9 +169,9 @@ mod tests { #[wasm_bindgen_test] fn test_take_orders_calldata() { - let take_orders_config = TakeOrdersConfigV4::default(); - let result = get_take_orders3_calldata(take_orders_config.clone()).unwrap(); - let expected = takeOrders3Call { + let take_orders_config = TakeOrdersConfigV5::default(); + let result = get_take_orders4_calldata(take_orders_config.clone()).unwrap(); + let expected = takeOrders4Call { config: take_orders_config, } .abi_encode(); diff --git a/crates/js_api/src/gui/order_operations.rs b/crates/js_api/src/gui/order_operations.rs index 057b2a44a3..8b85db10d9 100644 --- a/crates/js_api/src/gui/order_operations.rs +++ b/crates/js_api/src/gui/order_operations.rs @@ -14,7 +14,7 @@ use rain_orderbook_app_settings::{ orderbook::OrderbookCfg, }; use rain_orderbook_bindings::{ - IOrderBookV5::deposit3Call, OrderBook::multicallCall, IERC20::approveCall, + IOrderBookV6::deposit4Call, OrderBook::multicallCall, IERC20::approveCall, }; use rain_orderbook_common::{ add_order::AddOrderArgs, deposit::DepositArgs, erc20::ERC20, transaction::TransactionArgs, @@ -486,7 +486,7 @@ impl DotrainOrderGui { vault_id: vault_id.into(), decimals, }; - let calldata = deposit3Call::try_from(deposit_args) + let calldata = deposit4Call::try_from(deposit_args) .map_err(rain_orderbook_common::deposit::DepositError::from)? .abi_encode(); calldatas.push(Bytes::copy_from_slice(&calldata)); diff --git a/crates/quote/src/cli/input.rs b/crates/quote/src/cli/input.rs index da959c388e..722b5830e9 100644 --- a/crates/quote/src/cli/input.rs +++ b/crates/quote/src/cli/input.rs @@ -5,7 +5,7 @@ use alloy::primitives::{ }; use alloy::sol_types::SolType; use clap::Args; -use rain_orderbook_bindings::IOrderBookV5::{OrderV4, QuoteV2}; +use rain_orderbook_bindings::IOrderBookV6::{OrderV4, QuoteV2}; use std::str::FromStr; /// Group of valid input formats @@ -202,7 +202,7 @@ mod tests { use super::*; use alloy::primitives::hex::encode_prefixed; use alloy::sol_types::SolValue; - use rain_orderbook_bindings::IOrderBookV5::{EvaluableV4, OrderV4}; + use rain_orderbook_bindings::IOrderBookV6::{EvaluableV4, OrderV4}; #[test] fn test_parse_input() { diff --git a/crates/quote/src/cli/mod.rs b/crates/quote/src/cli/mod.rs index f5332f648d..1dd18a2afc 100644 --- a/crates/quote/src/cli/mod.rs +++ b/crates/quote/src/cli/mod.rs @@ -153,7 +153,7 @@ mod tests { use clap::CommandFactory; use httpmock::{Method::POST, MockServer}; use rain_math_float::Float; - use rain_orderbook_bindings::IOrderBookV5::{quote2Call, quote2Return, OrderV4, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{quote2Call, quote2Return, OrderV4, IOV2}; use serde_json::json; use std::{fs::read_to_string, str::FromStr}; use tempfile::NamedTempFile; diff --git a/crates/quote/src/order_quotes.rs b/crates/quote/src/order_quotes.rs index 25f8b4c3df..29a71d69fe 100644 --- a/crates/quote/src/order_quotes.rs +++ b/crates/quote/src/order_quotes.rs @@ -5,7 +5,7 @@ use crate::{ }; use alloy::primitives::{Address, U256}; use alloy_ethers_typecast::ReadableClient; -use rain_orderbook_bindings::IOrderBookV5::{OrderV4, QuoteV2}; +use rain_orderbook_bindings::IOrderBookV6::{OrderV4, QuoteV2}; use rain_orderbook_subgraph_client::types::common::SgOrder; use serde::{Deserialize, Serialize}; use std::str::FromStr; diff --git a/crates/quote/src/quote.rs b/crates/quote/src/quote.rs index 4ca63670a4..4119827f36 100644 --- a/crates/quote/src/quote.rs +++ b/crates/quote/src/quote.rs @@ -13,7 +13,7 @@ use url::Url; use wasm_bindgen_utils::{add_ts_content, impl_wasm_traits, prelude::*}; use rain_math_float::Float; -use rain_orderbook_bindings::IOrderBookV5::{quote2Return, OrderV4, QuoteV2, SignedContextV1}; +use rain_orderbook_bindings::IOrderBookV6::{quote2Return, OrderV4, QuoteV2, SignedContextV1}; use rain_orderbook_subgraph_client::{ types::{common::SgBytes, Id}, utils::make_order_id, @@ -319,7 +319,7 @@ mod tests { use alloy::transports::TransportError; use httpmock::{Method::POST, MockServer}; use rain_error_decoding::AbiDecodedErrorType; - use rain_orderbook_bindings::IOrderBookV5::{quote2Call, QuoteV2, IOV2}; + use rain_orderbook_bindings::IOrderBookV6::{quote2Call, QuoteV2, IOV2}; use rain_orderbook_subgraph_client::OrderbookSubgraphClientError; use serde_json::{json, Value}; diff --git a/crates/quote/src/quote_debug.rs b/crates/quote/src/quote_debug.rs index a989aa7e8c..ebfcf91dc4 100644 --- a/crates/quote/src/quote_debug.rs +++ b/crates/quote/src/quote_debug.rs @@ -7,7 +7,7 @@ use rain_interpreter_eval::{ fork::{Forker, NewForkedEvm}, trace::{RainEvalResult, RainEvalResultFromRawCallResultError}, }; -use rain_orderbook_bindings::IOrderBookV5::quote2Call; +use rain_orderbook_bindings::IOrderBookV6::quote2Call; use url::Url; pub struct NewQuoteDebugger { @@ -89,7 +89,7 @@ mod tests { use alloy::sol_types::{SolCall, SolValue}; use httpmock::MockServer; use rain_orderbook_app_settings::spec_version::SpecVersion; - use rain_orderbook_bindings::IOrderBookV5::{OrderV4, QuoteV2}; + use rain_orderbook_bindings::IOrderBookV6::{OrderV4, QuoteV2}; use rain_orderbook_common::add_order::AddOrderArgs; use rain_orderbook_common::dotrain_order::DotrainOrder; use rain_orderbook_test_fixtures::LocalEvm; diff --git a/crates/quote/src/rpc.rs b/crates/quote/src/rpc.rs index cde53669e8..95f0799947 100644 --- a/crates/quote/src/rpc.rs +++ b/crates/quote/src/rpc.rs @@ -9,7 +9,7 @@ use alloy::{ }; use rain_error_decoding::{AbiDecodedErrorType, ErrorRegistry}; use rain_orderbook_bindings::provider::mk_read_provider; -use rain_orderbook_bindings::IOrderBookV5::{quote2Call, quote2Return, IOrderBookV5Instance}; +use rain_orderbook_bindings::IOrderBookV6::{quote2Call, quote2Return, IOrderBookV6Instance}; use url::Url; /// Quotes array of given quote targets using the given rpc url @@ -39,7 +39,7 @@ pub async fn batch_quote( } for quote_target in quote_targets { - let ob_instance = IOrderBookV5Instance::new(quote_target.orderbook, provider.clone()); + let ob_instance = IOrderBookV6Instance::new(quote_target.orderbook, provider.clone()); let call = ob_instance .quote2(quote_target.quote_config.clone()) .into_call(true); @@ -113,7 +113,7 @@ mod tests { use httpmock::{Method::POST, MockServer}; use rain_error_decoding::ErrorRegistry; use rain_math_float::Float; - use rain_orderbook_bindings::IOrderBookV5::{quote2Call, quote2Return}; + use rain_orderbook_bindings::IOrderBookV6::{quote2Call, quote2Return}; use serde_json::json; #[tokio::test] diff --git a/crates/settings/src/remote_tokens.rs b/crates/settings/src/remote_tokens.rs index 6715c776d1..1f9f51e731 100644 --- a/crates/settings/src/remote_tokens.rs +++ b/crates/settings/src/remote_tokens.rs @@ -48,9 +48,10 @@ impl RemoteTokensCfg { } for token in unique_tokens.values() { - if let Some(token_cfg) = token + // skip tokens that error on parse as the list might include invalid records + if let Ok(Some(token_cfg)) = token .clone() - .try_into_token_cfg(networks, remote_tokens.document.clone())? + .try_into_token_cfg(networks, remote_tokens.document.clone()) { if tokens.contains_key(&token_cfg.key) { return Err(ParseRemoteTokensError::ConflictingTokens( diff --git a/crates/subgraph/src/types/order_detail_traits.rs b/crates/subgraph/src/types/order_detail_traits.rs index fd52678ff1..4608817eeb 100644 --- a/crates/subgraph/src/types/order_detail_traits.rs +++ b/crates/subgraph/src/types/order_detail_traits.rs @@ -5,7 +5,7 @@ use alloy::primitives::{ Address, B256, }; use alloy::sol_types::SolValue; -use rain_orderbook_bindings::IOrderBookV5::{OrderV4, IOV2}; +use rain_orderbook_bindings::IOrderBookV6::{OrderV4, IOV2}; use std::{num::TryFromIntError, str::FromStr}; use thiserror::Error; @@ -49,7 +49,7 @@ impl TryFrom for OrderV4 { mod tests { use alloy::hex; use alloy::primitives::{bytes, B256}; - use rain_orderbook_bindings::IOrderBookV5::EvaluableV4; + use rain_orderbook_bindings::IOrderBookV6::EvaluableV4; use std::vec; use super::*; diff --git a/crates/test_fixtures/src/lib.rs b/crates/test_fixtures/src/lib.rs index 2229f89692..30d832aa2e 100644 --- a/crates/test_fixtures/src/lib.rs +++ b/crates/test_fixtures/src/lib.rs @@ -21,12 +21,12 @@ use rain_math_float::Float; sol!( #![sol(all_derives = true, rpc = true)] - Orderbook, "../../out/OrderBook.sol/OrderBook.json" + Orderbook, "../../out/OrderBookV6.sol/OrderBookV6.json" ); sol!( #![sol(all_derives = true, rpc = true)] - OrderbookSubParser, "../../out/OrderBookSubParser.sol/OrderBookSubParser.json" + OrderbookSubParser, "../../out/OrderBookV6SubParser.sol/OrderBookV6SubParser.json" ); sol!( @@ -331,7 +331,7 @@ impl LocalEvm { let tx = self .orderbook - .deposit3(token, vault_id, raw_deposit_amount, vec![]) + .deposit4(token, vault_id, raw_deposit_amount, vec![]) .from(from) .into_transaction_request(); @@ -351,4 +351,4 @@ impl LocalEvm { const MULTICALL3_ADDRESS: Address = address!("cA11bde05977b3631167028862bE2a173976CA11"); const MULTICALL3_BYTECODE: &str = "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"; -const TOFU_TOKEN_DECIMALS_ADDRESS: Address = address!("4f1C29FAAB7EDdF8D7794695d8259996734Cc665"); +const TOFU_TOKEN_DECIMALS_ADDRESS: Address = address!("0xF66761F6b5F58202998D6Cd944C81b22Dc6d4f1E"); diff --git a/flake.nix b/flake.nix index bda380e818..748cfc6a21 100644 --- a/flake.nix +++ b/flake.nix @@ -23,12 +23,12 @@ mkdir -p meta; forge script --silent ./script/BuildAuthoringMeta.sol; rain meta build \ - -i <(cat ./meta/OrderBookSubParserAuthoringMeta.rain.meta) \ + -i <(cat ./meta/OrderBookV6SubParserAuthoringMeta.rain.meta) \ -m authoring-meta-v2 \ -t cbor \ -e deflate \ -l none \ - -o meta/OrderBookSubParser.rain.meta \ + -o meta/OrderBookV6SubParser.rain.meta \ ; ''; }; diff --git a/foundry.lock b/foundry.lock index 55989f8d99..34531f94be 100644 --- a/foundry.lock +++ b/foundry.lock @@ -1,12 +1,12 @@ { "lib/rain.interpreter": { - "rev": "d1fee1b9c4a427ebd529b9c0b0e17718c1a4a99a" + "rev": "22479b75c0ff6101fcb20a184eb89b62388383f6" }, "lib/rain.orderbook.interface": { - "rev": "dae86d795b32cb88005d9c47cbbbff9a5eef940a" + "rev": "24bc3bdf9be3d4bdd4061dba862a29e3a9feaf1b" }, "lib/rain.tofu.erc20-decimals": { - "rev": "ca8e8bacf6c6cb3b9938a6961efb9f93cc1754f9" + "rev": "db41950b70dae3c6ff38e50da96d04763a15c00a" }, "lib/sushixswap-v2": { "rev": "ca38c64cf7c3042f6427414d7bff61c54293da51" diff --git a/foundry.toml b/foundry.toml index 869fc60ad2..7c3baab0ae 100644 --- a/foundry.toml +++ b/foundry.toml @@ -6,7 +6,7 @@ libs = ['lib'] # See more config options https://github.com/foundry-rs/foundry/tree/master/config solc = "0.8.25" -evm_version = "paris" +evm_version = "cancun" # optimizer settings for debugging # via_ir = false @@ -31,7 +31,7 @@ fs_permissions = [ { access = "read", path = "./lib/rain.interpreter/deployments/latest/RainterpreterStoreNPE2" }, { access = "read", path = "./lib/rain.interpreter/deployments/latest/RainterpreterNPE2" }, { access = "read", path = "./lib/rain.interpreter/deployments/latest/RainterpreterExpressionDeployerNPE2" }, - { access = "read-write", path = "./meta/OrderBookSubParserAuthoringMeta.rain.meta"}, + { access = "read-write", path = "./meta/OrderBookV6SubParserAuthoringMeta.rain.meta"}, { access = "read-write", path = "src/generated" }, ] diff --git a/lib/rain.interpreter b/lib/rain.interpreter index 18827b5afe..22479b75c0 160000 --- a/lib/rain.interpreter +++ b/lib/rain.interpreter @@ -1 +1 @@ -Subproject commit 18827b5afedbe4fb0feaff9a392474fa4de39446 +Subproject commit 22479b75c0ff6101fcb20a184eb89b62388383f6 diff --git a/lib/rain.orderbook.interface b/lib/rain.orderbook.interface index dae86d795b..24bc3bdf9b 160000 --- a/lib/rain.orderbook.interface +++ b/lib/rain.orderbook.interface @@ -1 +1 @@ -Subproject commit dae86d795b32cb88005d9c47cbbbff9a5eef940a +Subproject commit 24bc3bdf9be3d4bdd4061dba862a29e3a9feaf1b diff --git a/lib/rain.tofu.erc20-decimals b/lib/rain.tofu.erc20-decimals index ca8e8bacf6..db41950b70 160000 --- a/lib/rain.tofu.erc20-decimals +++ b/lib/rain.tofu.erc20-decimals @@ -1 +1 @@ -Subproject commit ca8e8bacf6c6cb3b9938a6961efb9f93cc1754f9 +Subproject commit db41950b70dae3c6ff38e50da96d04763a15c00a diff --git a/packages/orderbook/test/js_api/gui.test.ts b/packages/orderbook/test/js_api/gui.test.ts index 66f07ededd..de4235921a 100644 --- a/packages/orderbook/test/js_api/gui.test.ts +++ b/packages/orderbook/test/js_api/gui.test.ts @@ -1367,7 +1367,7 @@ ${dotrain}`; assert.equal( // @ts-expect-error - result is valid result.Calldatas[0], - '0x7921a9620000000000000000000000008f3cf7ad23cd3cadbd9735aff958023239c6a0630000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000138800000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000' + '0x2fbc4ba00000000000000000000000008f3cf7ad23cd3cadbd9735aff958023239c6a0630000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000138800000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000' ); // Test no deposits case diff --git a/script/BuildAuthoringMeta.sol b/script/BuildAuthoringMeta.sol index 564be3412b..3db5476c8d 100644 --- a/script/BuildAuthoringMeta.sol +++ b/script/BuildAuthoringMeta.sol @@ -10,6 +10,6 @@ import {LibOrderBookSubParser} from "../src/lib/LibOrderBookSubParser.sol"; /// wrapped in CBOR and emitted on metaboard. contract BuildAuthoringMeta is Script { function run() external { - vm.writeFileBinary("meta/OrderBookSubParserAuthoringMeta.rain.meta", LibOrderBookSubParser.authoringMetaV2()); + vm.writeFileBinary("meta/OrderBookV6SubParserAuthoringMeta.rain.meta", LibOrderBookSubParser.authoringMetaV2()); } } diff --git a/script/BuildPointers.sol b/script/BuildPointers.sol index 88912b140f..8501740138 100644 --- a/script/BuildPointers.sol +++ b/script/BuildPointers.sol @@ -5,15 +5,15 @@ pragma solidity =0.8.25; import {Script} from "forge-std/Script.sol"; import {LibCodeGen} from "rain.sol.codegen/lib/LibCodeGen.sol"; import {LibFs} from "rain.sol.codegen/lib/LibFs.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {LibOrderBookSubParser, EXTERN_PARSE_META_BUILD_DEPTH} from "src/lib/LibOrderBookSubParser.sol"; import {LibGenParseMeta} from "rain.interpreter.interface/lib/codegen/LibGenParseMeta.sol"; contract BuildPointers is Script { function buildOrderBookSubParserPointers() internal { - OrderBookSubParser subParser = new OrderBookSubParser(); + OrderBookV6SubParser subParser = new OrderBookV6SubParser(); - string memory name = "OrderBookSubParser"; + string memory name = "OrderBookV6SubParser"; LibFs.buildFileForContract( vm, diff --git a/script/Deploy.sol b/script/Deploy.sol index e4040d9fff..9d0aa1eba2 100644 --- a/script/Deploy.sol +++ b/script/Deploy.sol @@ -3,12 +3,12 @@ pragma solidity =0.8.25; import {Script} from "forge-std/Script.sol"; -import {OrderBook, EvaluableV4, TaskV2, SignedContextV1} from "src/concrete/ob/OrderBook.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; -import {GenericPoolOrderBookV5ArbOrderTaker} from "src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol"; -import {RouteProcessorOrderBookV5ArbOrderTaker} from "src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol"; -import {GenericPoolOrderBookV5FlashBorrower} from "src/concrete/arb/GenericPoolOrderBookV5FlashBorrower.sol"; -import {OrderBookV5ArbConfig} from "src/abstract/OrderBookV5ArbCommon.sol"; +import {OrderBookV6, EvaluableV4, TaskV2, SignedContextV1} from "src/concrete/ob/OrderBookV6.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; +import {GenericPoolOrderBookV6ArbOrderTaker} from "src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol"; +import {RouteProcessorOrderBookV6ArbOrderTaker} from "src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol"; +import {GenericPoolOrderBookV6FlashBorrower} from "src/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sol"; +import {OrderBookV6ArbConfig} from "src/abstract/OrderBookV6ArbCommon.sol"; import {IMetaBoardV1_2} from "rain.metadata/interface/unstable/IMetaBoardV1_2.sol"; import {LibDescribedByMeta} from "rain.metadata/lib/LibDescribedByMeta.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; @@ -40,13 +40,13 @@ error BadRouteProcessor(bytes32 expected, bytes32 actual); /// @notice A script that deploys all contracts. This is intended to be run on /// every commit by CI to a testnet such as mumbai. contract Deploy is Script { - function deployRaindex() internal returns (OrderBook) { - return new OrderBook(); + function deployRaindex() internal returns (OrderBookV6) { + return new OrderBookV6(); } function deploySubParser(IMetaBoardV1_2 metaboard) internal { - OrderBookSubParser subParser = new OrderBookSubParser(); - bytes memory subParserDescribedByMeta = vm.readFileBinary("meta/OrderBookSubParser.rain.meta"); + OrderBookV6SubParser subParser = new OrderBookV6SubParser(); + bytes memory subParserDescribedByMeta = vm.readFileBinary("meta/OrderBookV6SubParser.rain.meta"); LibDescribedByMeta.emitForDescribedAddress(metaboard, subParser, subParserDescribedByMeta); } @@ -97,8 +97,8 @@ contract Deploy is Script { if (suite == DEPLOYMENT_SUITE_ARB || suite == DEPLOYMENT_SUITE_ALL) { // Order takers. - new GenericPoolOrderBookV5ArbOrderTaker( - OrderBookV5ArbConfig( + new GenericPoolOrderBookV6ArbOrderTaker( + OrderBookV6ArbConfig( address(raindex), TaskV2({ evaluable: EvaluableV4(IInterpreterV4(address(0)), IInterpreterStoreV3(address(0)), hex""), @@ -108,8 +108,8 @@ contract Deploy is Script { ) ); - new RouteProcessorOrderBookV5ArbOrderTaker( - OrderBookV5ArbConfig( + new RouteProcessorOrderBookV6ArbOrderTaker( + OrderBookV6ArbConfig( address(raindex), TaskV2({ evaluable: EvaluableV4(IInterpreterV4(address(0)), IInterpreterStoreV3(address(0)), hex""), @@ -120,8 +120,8 @@ contract Deploy is Script { ); // Flash borrowers. - new GenericPoolOrderBookV5FlashBorrower( - OrderBookV5ArbConfig( + new GenericPoolOrderBookV6FlashBorrower( + OrderBookV6ArbConfig( raindex, TaskV2({ evaluable: EvaluableV4(IInterpreterV4(address(0)), IInterpreterStoreV3(address(0)), hex""), diff --git a/src/abstract/OrderBookV5ArbCommon.sol b/src/abstract/OrderBookV6ArbCommon.sol similarity index 86% rename from src/abstract/OrderBookV5ArbCommon.sol rename to src/abstract/OrderBookV6ArbCommon.sol index fc12eb37ab..53b0184560 100644 --- a/src/abstract/OrderBookV5ArbCommon.sol +++ b/src/abstract/OrderBookV6ArbCommon.sol @@ -8,7 +8,7 @@ import { SourceIndexV2, DEFAULT_STATE_NAMESPACE } from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; -import {IOrderBookV5, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {IOrderBookV6, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol"; import {LibNamespace} from "rain.interpreter.interface/lib/ns/LibNamespace.sol"; import {LibEvaluable} from "rain.interpreter.interface/lib/caller/LibEvaluable.sol"; @@ -18,7 +18,7 @@ import {LibEvaluable} from "rain.interpreter.interface/lib/caller/LibEvaluable.s /// @param tasks The tasks to use as post for each arb. /// @param implementationData The constructor data for the specific /// implementation of the arb contract. -struct OrderBookV5ArbConfig { +struct OrderBookV6ArbConfig { address orderBook; TaskV2 task; bytes implementationData; @@ -31,14 +31,14 @@ error WrongTask(); /// allows for some kind of access control to the arb. SourceIndexV2 constant BEFORE_ARB_SOURCE_INDEX = SourceIndexV2.wrap(0); -abstract contract OrderBookV5ArbCommon { +abstract contract OrderBookV6ArbCommon { using LibEvaluable for EvaluableV4; - event Construct(address sender, OrderBookV5ArbConfig config); + event Construct(address sender, OrderBookV6ArbConfig config); bytes32 public immutable iTaskHash = 0; - constructor(OrderBookV5ArbConfig memory config) { + constructor(OrderBookV6ArbConfig memory config) { // Emit events before any external calls are made. emit Construct(msg.sender, config); diff --git a/src/abstract/OrderBookV5ArbOrderTaker.sol b/src/abstract/OrderBookV6ArbOrderTaker.sol similarity index 66% rename from src/abstract/OrderBookV5ArbOrderTaker.sol rename to src/abstract/OrderBookV6ArbOrderTaker.sol index 330440e9e0..a00351300b 100644 --- a/src/abstract/OrderBookV5ArbOrderTaker.sol +++ b/src/abstract/OrderBookV6ArbOrderTaker.sol @@ -3,9 +3,8 @@ pragma solidity ^0.8.19; import {ERC165, IERC165} from "openzeppelin-contracts/contracts/utils/introspection/ERC165.sol"; -import {ReentrancyGuard} from "openzeppelin-contracts/contracts/security/ReentrancyGuard.sol"; -import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; +import {ReentrancyGuard} from "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol"; +import {IERC20, SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol"; import {SourceIndexV2} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import { @@ -13,22 +12,22 @@ import { LibEncodedDispatch } from "rain.interpreter.interface/lib/deprecated/caller/LibEncodedDispatch.sol"; import {LibNamespace} from "rain.interpreter.interface/lib/ns/LibNamespace.sol"; -import {IOrderBookV5, NoOrders} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {IOrderBookV6} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import { - IOrderBookV5ArbOrderTaker, + IOrderBookV6ArbOrderTaker, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5ArbOrderTaker.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6ArbOrderTaker.sol"; import { IInterpreterV4, DEFAULT_STATE_NAMESPACE } from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; -import {TakeOrdersConfigV4, Float} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {OrderBookV5ArbConfig, EvaluableV4, OrderBookV5ArbCommon, SignedContextV1} from "./OrderBookV5ArbCommon.sol"; +import {TakeOrdersConfigV5, Float} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {OrderBookV6ArbConfig, EvaluableV4, OrderBookV6ArbCommon, SignedContextV1} from "./OrderBookV6ArbCommon.sol"; import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol"; import {LibBytecode} from "rain.interpreter.interface/lib/bytecode/LibBytecode.sol"; import {LibOrderBook} from "../lib/LibOrderBook.sol"; import {LibOrderBookArb, NonZeroBeforeArbStack, BadLender} from "../lib/LibOrderBookArb.sol"; -import {IOrderBookV5OrderTaker} from "rain.orderbook.interface/interface/unstable/IOrderBookV5OrderTaker.sol"; +import {IOrderBookV6OrderTaker} from "rain.orderbook.interface/interface/unstable/IOrderBookV6OrderTaker.sol"; import {LibTOFUTokenDecimals} from "rain.tofu.erc20-decimals/lib/LibTOFUTokenDecimals.sol"; /// Thrown when "before arb" wants inputs that we don't have. @@ -38,25 +37,25 @@ error NonZeroBeforeArbInputs(uint256 inputs); /// is to allow for access control to the arb, the return values are ignored. SourceIndexV2 constant BEFORE_ARB_SOURCE_INDEX = SourceIndexV2.wrap(0); -abstract contract OrderBookV5ArbOrderTaker is - IOrderBookV5OrderTaker, - IOrderBookV5ArbOrderTaker, +abstract contract OrderBookV6ArbOrderTaker is + IOrderBookV6OrderTaker, + IOrderBookV6ArbOrderTaker, ReentrancyGuard, ERC165, - OrderBookV5ArbCommon + OrderBookV6ArbCommon { using SafeERC20 for IERC20; - constructor(OrderBookV5ArbConfig memory config) OrderBookV5ArbCommon(config) {} + constructor(OrderBookV6ArbConfig memory config) OrderBookV6ArbCommon(config) {} /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { - return (interfaceId == type(IOrderBookV5OrderTaker).interfaceId) - || (interfaceId == type(IOrderBookV5ArbOrderTaker).interfaceId) || super.supportsInterface(interfaceId); + return (interfaceId == type(IOrderBookV6OrderTaker).interfaceId) + || (interfaceId == type(IOrderBookV6ArbOrderTaker).interfaceId) || super.supportsInterface(interfaceId); } - /// @inheritdoc IOrderBookV5ArbOrderTaker - function arb4(IOrderBookV5 orderBook, TakeOrdersConfigV4 calldata takeOrders, TaskV2 calldata task) + /// @inheritdoc IOrderBookV6ArbOrderTaker + function arb5(IOrderBookV6 orderBook, TakeOrdersConfigV5 calldata takeOrders, TaskV2 calldata task) external payable nonReentrant @@ -64,17 +63,16 @@ abstract contract OrderBookV5ArbOrderTaker is { // Mimic what OB would do anyway if called with zero orders. if (takeOrders.orders.length == 0) { - revert NoOrders(); + revert IOrderBookV6.NoOrders(); } address ordersInputToken = takeOrders.orders[0].order.validInputs[takeOrders.orders[0].inputIOIndex].token; address ordersOutputToken = takeOrders.orders[0].order.validOutputs[takeOrders.orders[0].outputIOIndex].token; - IERC20(ordersInputToken).safeApprove(address(orderBook), 0); - IERC20(ordersInputToken).safeApprove(address(orderBook), type(uint256).max); - (Float totalTakerInput, Float totalTakerOutput) = orderBook.takeOrders3(takeOrders); + IERC20(ordersInputToken).forceApprove(address(orderBook), type(uint256).max); + (Float totalTakerInput, Float totalTakerOutput) = orderBook.takeOrders4(takeOrders); (totalTakerInput, totalTakerOutput); - IERC20(ordersInputToken).safeApprove(address(orderBook), 0); + IERC20(ordersInputToken).forceApprove(address(orderBook), 0); LibOrderBookArb.finalizeArb( task, @@ -85,6 +83,6 @@ abstract contract OrderBookV5ArbOrderTaker is ); } - /// @inheritdoc IOrderBookV5OrderTaker + /// @inheritdoc IOrderBookV6OrderTaker function onTakeOrders2(address, address, Float, Float, bytes calldata) public virtual override {} } diff --git a/src/abstract/OrderBookV5FlashBorrower.sol b/src/abstract/OrderBookV6FlashBorrower.sol similarity index 87% rename from src/abstract/OrderBookV5FlashBorrower.sol rename to src/abstract/OrderBookV6FlashBorrower.sol index ac65ef63ad..b16b84e076 100644 --- a/src/abstract/OrderBookV5FlashBorrower.sol +++ b/src/abstract/OrderBookV6FlashBorrower.sol @@ -6,7 +6,7 @@ import {ERC165, IERC165} from "openzeppelin-contracts/contracts/utils/introspect import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -import {ReentrancyGuard} from "openzeppelin-contracts/contracts/security/ReentrancyGuard.sol"; +import {ReentrancyGuard} from "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol"; import { LibEncodedDispatch, EncodedDispatch @@ -14,15 +14,14 @@ import { import {LibBytecode} from "rain.interpreter.interface/lib/bytecode/LibBytecode.sol"; import {ON_FLASH_LOAN_CALLBACK_SUCCESS} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import { - IOrderBookV5, - TakeOrdersConfigV4, - NoOrders, + IOrderBookV6, + TakeOrdersConfigV5, TaskV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC3156FlashBorrower} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; -import {OrderBookV5ArbConfig, OrderBookV5ArbCommon} from "./OrderBookV5ArbCommon.sol"; +import {OrderBookV6ArbConfig, OrderBookV6ArbCommon} from "./OrderBookV6ArbCommon.sol"; import {EvaluableV4, SignedContextV1} from "rain.interpreter.interface/interface/unstable/IInterpreterCallerV4.sol"; import {LibOrderBook} from "../lib/LibOrderBook.sol"; import {LibOrderBookArb, NonZeroBeforeArbStack, BadLender} from "../lib/LibOrderBookArb.sol"; @@ -69,11 +68,11 @@ error SwapFailed(); /// - The arb operator wants to attempt to prevent front running by other bots. /// - The arb operator may prefer a dedicated instance of the contract to make /// it easier to track profits, etc. -abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyGuard, ERC165, OrderBookV5ArbCommon { +abstract contract OrderBookV6FlashBorrower is IERC3156FlashBorrower, ReentrancyGuard, ERC165, OrderBookV6ArbCommon { using Address for address; using SafeERC20 for IERC20; - constructor(OrderBookV5ArbConfig memory config) OrderBookV5ArbCommon(config) {} + constructor(OrderBookV6ArbConfig memory config) OrderBookV6ArbCommon(config) {} /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { @@ -89,7 +88,7 @@ abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyG /// @param takeOrders As per `arb`. /// @param exchangeData As per `arb`. //slither-disable-next-line dead-code - function _exchange(TakeOrdersConfigV4 memory takeOrders, bytes memory exchangeData) internal virtual {} + function _exchange(TakeOrdersConfigV5 memory takeOrders, bytes memory exchangeData) internal virtual {} /// @inheritdoc IERC3156FlashBorrower function onFlashLoan(address initiator, address, uint256, uint256, bytes calldata data) @@ -101,8 +100,8 @@ abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyG revert BadInitiator(initiator); } - (TakeOrdersConfigV4 memory takeOrders, bytes memory exchangeData) = - abi.decode(data, (TakeOrdersConfigV4, bytes)); + (TakeOrdersConfigV5 memory takeOrders, bytes memory exchangeData) = + abi.decode(data, (TakeOrdersConfigV5, bytes)); // Dispatch the `_exchange` hook to ensure we have the correct asset // type and amount to fill the orders. @@ -113,7 +112,7 @@ abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyG // We don't do anything with the total input/output amounts here because // the flash loan itself will take back what it needs, and we simply // keep anything left over according to active balances. - (Float totalInput, Float totalOutput) = IOrderBookV5(msg.sender).takeOrders3(takeOrders); + (Float totalInput, Float totalOutput) = IOrderBookV6(msg.sender).takeOrders4(takeOrders); (totalInput, totalOutput); return ON_FLASH_LOAN_CALLBACK_SUCCESS; @@ -140,15 +139,15 @@ abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyG /// for decoding this data and defining how it controls interactions with /// the external liquidity. For example, `GenericPoolOrderBookV5FlashBorrower` /// uses this data as a literal encoded external call. - function arb3( - IOrderBookV5 orderBook, - TakeOrdersConfigV4 calldata takeOrders, + function arb4( + IOrderBookV6 orderBook, + TakeOrdersConfigV5 calldata takeOrders, bytes calldata exchangeData, TaskV2 calldata task ) external payable nonReentrant onlyValidTask(task) { // Mimic what OB would do anyway if called with zero orders. if (takeOrders.orders.length == 0) { - revert NoOrders(); + revert IOrderBookV6.NoOrders(); } // Encode everything that will be used by the flash loan callback. @@ -163,17 +162,16 @@ abstract contract OrderBookV5FlashBorrower is IERC3156FlashBorrower, ReentrancyG // We can't repay more than the minimum that the orders are going to // give us and there's no reason to borrow less. - uint256 flashLoanAmount = LibDecimalFloat.toFixedDecimalLossless(takeOrders.minimumInput, inputDecimals); + uint256 flashLoanAmount = LibDecimalFloat.toFixedDecimalLossless(takeOrders.minimumIO, inputDecimals); // Take the flash loan, which will in turn call `onFlashLoan`, which is // expected to process an exchange against external liq to pay back the // flash loan, cover the orders and remain in profit. - IERC20(ordersInputToken).safeApprove(address(orderBook), 0); - IERC20(ordersInputToken).safeApprove(address(orderBook), type(uint256).max); + IERC20(ordersInputToken).forceApprove(address(orderBook), type(uint256).max); if (!orderBook.flashLoan(this, ordersOutputToken, flashLoanAmount, data)) { revert FlashLoanFailed(); } - IERC20(ordersInputToken).safeApprove(address(orderBook), 0); + IERC20(ordersInputToken).forceApprove(address(orderBook), 0); LibOrderBookArb.finalizeArb(task, ordersInputToken, inputDecimals, ordersOutputToken, outputDecimals); } diff --git a/src/abstract/OrderBookV4FlashLender.sol b/src/abstract/OrderBookV6FlashLender.sol similarity index 97% rename from src/abstract/OrderBookV4FlashLender.sol rename to src/abstract/OrderBookV6FlashLender.sol index e8b962d007..849498987d 100644 --- a/src/abstract/OrderBookV4FlashLender.sol +++ b/src/abstract/OrderBookV6FlashLender.sol @@ -22,11 +22,11 @@ error FlashLenderCallbackFailed(bytes32 result); /// to connect external liquidity to live orders via arbitrage. uint256 constant FLASH_FEE = 0; -/// @title OrderBookV4FlashLender +/// @title OrderBookV6FlashLender /// @notice Implements `IERC3156FlashLender` for `OrderBook`. Based on the /// reference implementation by Alberto Cuesta Cañada found at /// https://eips.ethereum.org/EIPS/eip-3156#flash-loan-reference-implementation -abstract contract OrderBookV4FlashLender is IERC3156FlashLender, ERC165 { +abstract contract OrderBookV6FlashLender is IERC3156FlashLender, ERC165 { using SafeERC20 for IERC20; /// @inheritdoc IERC165 diff --git a/src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol b/src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol similarity index 73% rename from src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol rename to src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol index e6da3308de..e2206b8d18 100644 --- a/src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol +++ b/src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol @@ -6,15 +6,15 @@ import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol"; -import {OrderBookV5ArbOrderTaker, OrderBookV5ArbConfig, Float} from "../../abstract/OrderBookV5ArbOrderTaker.sol"; +import {OrderBookV6ArbOrderTaker, OrderBookV6ArbConfig, Float} from "../../abstract/OrderBookV6ArbOrderTaker.sol"; -contract GenericPoolOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { +contract GenericPoolOrderBookV6ArbOrderTaker is OrderBookV6ArbOrderTaker { using SafeERC20 for IERC20; using Address for address; - constructor(OrderBookV5ArbConfig memory config) OrderBookV5ArbOrderTaker(config) {} + constructor(OrderBookV6ArbConfig memory config) OrderBookV6ArbOrderTaker(config) {} - /// @inheritdoc OrderBookV5ArbOrderTaker + /// @inheritdoc OrderBookV6ArbOrderTaker function onTakeOrders2( address inputToken, address outputToken, @@ -26,13 +26,12 @@ contract GenericPoolOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { (address spender, address pool, bytes memory encodedFunctionCall) = abi.decode(takeOrdersData, (address, address, bytes)); - IERC20(inputToken).safeApprove(spender, 0); - IERC20(inputToken).safeApprove(spender, type(uint256).max); + IERC20(inputToken).forceApprove(spender, type(uint256).max); bytes memory returnData = pool.functionCallWithValue(encodedFunctionCall, address(this).balance); // Nothing can be done with returnData as `takeOrders` does not support // it. (returnData); - IERC20(inputToken).safeApprove(spender, 0); + IERC20(inputToken).forceApprove(spender, 0); } /// Allow receiving gas. diff --git a/src/concrete/arb/GenericPoolOrderBookV5FlashBorrower.sol b/src/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sol similarity index 71% rename from src/concrete/arb/GenericPoolOrderBookV5FlashBorrower.sol rename to src/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sol index eff836a3b7..401983d06e 100644 --- a/src/concrete/arb/GenericPoolOrderBookV5FlashBorrower.sol +++ b/src/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sol @@ -6,16 +6,16 @@ import {IERC3156FlashLender} from "rain.orderbook.interface/interface/ierc3156/I import {IERC3156FlashBorrower} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import { - OrderBookV5FlashBorrower, + OrderBookV6FlashBorrower, SafeERC20, IERC20, Address, - TakeOrdersConfigV4, - OrderBookV5ArbConfig -} from "../../abstract/OrderBookV5FlashBorrower.sol"; + TakeOrdersConfigV5, + OrderBookV6ArbConfig +} from "../../abstract/OrderBookV6FlashBorrower.sol"; -/// @title GenericPoolOrderBookV5FlashBorrower -/// Implements the OrderBookV5FlashBorrower interface for an external liquidity +/// @title GenericPoolOrderBookV6FlashBorrower +/// Implements the OrderBookV6FlashBorrower interface for an external liquidity /// source that behaves vaguely like a standard AMM. The `exchangeData` from /// `arb` is decoded into a spender, pool and callData. The `callData` is /// literally the encoded function call to the pool. This allows the `arb` @@ -24,25 +24,24 @@ import { /// The `spender` is the address that will be approved to spend the input token /// on `takeOrders`, which is almost always going to be the pool itself. If you /// are unsure, simply set it to the pool address. -contract GenericPoolOrderBookV5FlashBorrower is OrderBookV5FlashBorrower { +contract GenericPoolOrderBookV6FlashBorrower is OrderBookV6FlashBorrower { using SafeERC20 for IERC20; using Address for address; - constructor(OrderBookV5ArbConfig memory config) OrderBookV5FlashBorrower(config) {} + constructor(OrderBookV6ArbConfig memory config) OrderBookV6FlashBorrower(config) {} - /// @inheritdoc OrderBookV5FlashBorrower - function _exchange(TakeOrdersConfigV4 memory takeOrders, bytes memory exchangeData) internal virtual override { + /// @inheritdoc OrderBookV6FlashBorrower + function _exchange(TakeOrdersConfigV5 memory takeOrders, bytes memory exchangeData) internal virtual override { (address spender, address pool, bytes memory encodedFunctionCall) = abi.decode(exchangeData, (address, address, bytes)); address borrowedToken = takeOrders.orders[0].order.validOutputs[takeOrders.orders[0].outputIOIndex].token; - IERC20(borrowedToken).safeApprove(spender, 0); - IERC20(borrowedToken).safeApprove(spender, type(uint256).max); + IERC20(borrowedToken).forceApprove(spender, type(uint256).max); bytes memory returnData = pool.functionCallWithValue(encodedFunctionCall, address(this).balance); // Nothing can be done with returnData as 3156 does not support it. (returnData); - IERC20(borrowedToken).safeApprove(spender, 0); + IERC20(borrowedToken).forceApprove(spender, 0); } /// Allow receiving gas. diff --git a/src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol b/src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol similarity index 79% rename from src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol rename to src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol index 9726eb05d4..0d44ab1a2b 100644 --- a/src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol +++ b/src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol @@ -7,22 +7,22 @@ import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol"; -import {OrderBookV5ArbOrderTaker, OrderBookV5ArbConfig, Float} from "../../abstract/OrderBookV5ArbOrderTaker.sol"; +import {OrderBookV6ArbOrderTaker, OrderBookV6ArbConfig, Float} from "../../abstract/OrderBookV6ArbOrderTaker.sol"; import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -contract RouteProcessorOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { +contract RouteProcessorOrderBookV6ArbOrderTaker is OrderBookV6ArbOrderTaker { using SafeERC20 for IERC20; using Address for address; IRouteProcessor public immutable iRouteProcessor; - constructor(OrderBookV5ArbConfig memory config) OrderBookV5ArbOrderTaker(config) { + constructor(OrderBookV6ArbConfig memory config) OrderBookV6ArbOrderTaker(config) { (address routeProcessor) = abi.decode(config.implementationData, (address)); iRouteProcessor = IRouteProcessor(routeProcessor); } - /// @inheritdoc OrderBookV5ArbOrderTaker + /// @inheritdoc OrderBookV6ArbOrderTaker function onTakeOrders2( address inputToken, address outputToken, @@ -31,8 +31,7 @@ contract RouteProcessorOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { bytes calldata takeOrdersData ) public virtual override { super.onTakeOrders2(inputToken, outputToken, inputAmountSent, totalOutputAmount, takeOrdersData); - IERC20(inputToken).safeApprove(address(iRouteProcessor), 0); - IERC20(inputToken).safeApprove(address(iRouteProcessor), type(uint256).max); + IERC20(inputToken).forceApprove(address(iRouteProcessor), type(uint256).max); bytes memory route = abi.decode(takeOrdersData, (bytes)); (uint256 inputTokenAmount, bool losslessInputAmount) = LibDecimalFloat.toFixedDecimalLossy(inputAmountSent, IERC20Metadata(inputToken).decimals()); @@ -45,7 +44,7 @@ contract RouteProcessorOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { (uint256 amountOut) = iRouteProcessor.processRoute( inputToken, inputTokenAmount, outputToken, outputTokenAmount, address(this), route ); - IERC20(inputToken).safeApprove(address(iRouteProcessor), 0); + IERC20(inputToken).forceApprove(address(iRouteProcessor), 0); (amountOut); } diff --git a/src/concrete/ob/OrderBook.sol b/src/concrete/ob/OrderBookV6.sol similarity index 92% rename from src/concrete/ob/OrderBook.sol rename to src/concrete/ob/OrderBookV6.sol index 490fe7b68d..7a39733598 100644 --- a/src/concrete/ob/OrderBook.sol +++ b/src/concrete/ob/OrderBookV6.sol @@ -6,7 +6,7 @@ import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol"; import {Multicall} from "openzeppelin-contracts/contracts/utils/Multicall.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; -import {ReentrancyGuard} from "openzeppelin-contracts/contracts/security/ReentrancyGuard.sol"; +import {ReentrancyGuard} from "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { @@ -25,7 +25,6 @@ import { import {LibUint256Array} from "rain.solmem/lib/LibUint256Array.sol"; import {LibUint256Matrix} from "rain.solmem/lib/LibUint256Matrix.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; -import {IExpressionDeployerV3} from "rain.interpreter.interface/interface/deprecated/IExpressionDeployerV3.sol"; import {LibNamespace} from "rain.interpreter.interface/lib/ns/LibNamespace.sol"; import {LibMeta} from "rain.metadata/lib/LibMeta.sol"; import {IMetaV1_2} from "rain.metadata/interface/unstable/IMetaV1_2.sol"; @@ -38,35 +37,33 @@ import { } from "rain.tofu.erc20-decimals/lib/LibTOFUTokenDecimals.sol"; import { - IOrderBookV5, - NoOrders, + IOrderBookV6, OrderV4, OrderConfigV4, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, ClearConfigV2, ClearStateChangeV2, - ZeroMaximumInput, SignedContextV1, + //forge-lint: disable-next-line(unused-import) EvaluableV4, TaskV2, QuoteV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {IOrderBookV5OrderTaker} from "rain.orderbook.interface/interface/unstable/IOrderBookV5OrderTaker.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {IOrderBookV6OrderTaker} from "rain.orderbook.interface/interface/unstable/IOrderBookV6OrderTaker.sol"; import {LibOrder} from "../../lib/LibOrder.sol"; import { CALLING_CONTEXT_COLUMNS, CONTEXT_CALLING_CONTEXT_COLUMN, CONTEXT_CALCULATIONS_COLUMN, CONTEXT_VAULT_IO_BALANCE_DIFF, - CONTEXT_VAULT_IO_TOKEN_DECIMALS, CONTEXT_VAULT_INPUTS_COLUMN, CONTEXT_VAULT_IO_TOKEN, CONTEXT_VAULT_OUTPUTS_COLUMN, CONTEXT_VAULT_IO_VAULT_ID } from "../../lib/LibOrderBook.sol"; -import {OrderBookV4FlashLender} from "../../abstract/OrderBookV4FlashLender.sol"; +import {OrderBookV6FlashLender} from "../../abstract/OrderBookV6FlashLender.sol"; import {LibBytes32Array} from "rain.solmem/lib/LibBytes32Array.sol"; import {LibBytes32Matrix} from "rain.solmem/lib/LibBytes32Matrix.sol"; @@ -90,9 +87,9 @@ error TokenSelfTrade(); error TokenDecimalsMismatch(); /// Thrown when the minimum input is not met. -/// @param minimumInput The minimum input required. -/// @param input The input that was achieved. -error MinimumInput(Float minimumInput, Float input); +/// @param minimumIO The minimum io required. +/// @param actualIO The io that was achieved. +error MinimumIO(Float minimumIO, Float actualIO); /// Thrown when two orders have the same owner during clear. error SameOwner(); @@ -200,9 +197,9 @@ type Output18Amount is uint256; type Input18Amount is uint256; -/// @title OrderBook -/// See `IOrderBookV1` for more documentation. -contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, OrderBookV4FlashLender { +/// @title OrderBookV6 +/// See `IOrderBookV6` for more documentation. +contract OrderBookV6 is IOrderBookV6, IMetaV1_2, ReentrancyGuard, Multicall, OrderBookV6FlashLender { using LibUint256Array for uint256[]; using SafeERC20 for IERC20; using LibOrder for OrderV4; @@ -229,23 +226,23 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order mapping(address owner => mapping(address token => mapping(bytes32 vaultId => Float balance))) internal sVaultBalances; - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function vaultBalance2(address owner, address token, bytes32 vaultId) external view override returns (Float) { return sVaultBalances[owner][token][vaultId]; } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function orderExists(bytes32 orderHash) external view override returns (bool) { return sOrders[orderHash] == ORDER_LIVE; } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function entask2(TaskV2[] calldata post) external nonReentrant { LibOrderBook.doPost(new bytes32[][](0), post); } - /// @inheritdoc IOrderBookV5 - function deposit3(address token, bytes32 vaultId, Float depositAmount, TaskV2[] calldata post) + /// @inheritdoc IOrderBookV6 + function deposit4(address token, bytes32 vaultId, Float depositAmount, TaskV2[] calldata post) external nonReentrant { @@ -278,8 +275,8 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } } - /// @inheritdoc IOrderBookV5 - function withdraw3(address token, bytes32 vaultId, Float targetAmount, TaskV2[] calldata post) + /// @inheritdoc IOrderBookV6 + function withdraw4(address token, bytes32 vaultId, Float targetAmount, TaskV2[] calldata post) external nonReentrant { @@ -313,8 +310,8 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } } - /// @inheritdoc IOrderBookV5 - function addOrder3(OrderConfigV4 calldata orderConfig, TaskV2[] calldata post) + /// @inheritdoc IOrderBookV6 + function addOrder4(OrderConfigV4 calldata orderConfig, TaskV2[] calldata post) external nonReentrant returns (bool) @@ -361,7 +358,7 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order return stateChange; } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function removeOrder3(OrderV4 calldata order, TaskV2[] calldata post) external nonReentrant @@ -389,7 +386,7 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function quote2(QuoteV2 calldata quoteConfig) external view returns (bool, Float, Float) { bytes32 orderHash = quoteConfig.order.hash(); @@ -409,11 +406,11 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order return (true, orderIOCalculation.outputMax, orderIOCalculation.IORatio); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 // Most of the cyclomatic complexity here is due to the error handling within // the loop. The actual logic is fairly linear. //slither-disable-next-line cyclomatic-complexity - function takeOrders3(TakeOrdersConfigV4 calldata config) + function takeOrders4(TakeOrdersConfigV5 calldata config) external nonReentrant returns (Float totalTakerInput, Float totalTakerOutput) @@ -444,13 +441,13 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } { - Float remainingTakerInput = config.maximumInput; - if (!remainingTakerInput.gt(Float.wrap(0))) { - revert ZeroMaximumInput(); + Float remainingTakerIO = config.maximumIO; + if (!remainingTakerIO.gt(Float.wrap(0))) { + revert ZeroMaximumIO(); } uint256 i = 0; - while (i < config.orders.length && remainingTakerInput.gt(Float.wrap(0))) { + while (i < config.orders.length && remainingTakerIO.gt(Float.wrap(0))) { takeOrderConfig = config.orders[i]; order = takeOrderConfig.order; // Every order needs the same input token. @@ -485,13 +482,32 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } else if (orderIOCalculation.outputMax.isZero()) { emit OrderZeroAmount(msg.sender, order.owner, orderHash); } else { - // Taker is just "market buying" the order output max. - // Can't exceed the remaining taker input. - Float takerInput = orderIOCalculation.outputMax.min(remainingTakerInput); - - Float takerOutput = orderIOCalculation.IORatio.mul(takerInput); - - remainingTakerInput = remainingTakerInput.sub(takerInput); + Float takerInput; + Float takerOutput; + if (config.IOIsInput) { + // Taker is just "market buying" the order output max. + // Can't exceed the remaining taker input. + takerInput = orderIOCalculation.outputMax.min(remainingTakerIO); + + // Slither false positive because it sees the div on + // the else branch and triggers a + // divide-before-multiply warning. In this case the + // IOIsInput on the config is always the same for + // every order in the loop so we always take the same + // branch, whether this or the else. + //slither-disable-next-line divide-before-multiply + takerOutput = orderIOCalculation.IORatio.mul(takerInput); + + remainingTakerIO = remainingTakerIO.sub(takerInput); + } else { + // Taker is "market selling" up to the order output max. + Float orderMaxInput = orderIOCalculation.IORatio.mul(orderIOCalculation.outputMax); + takerOutput = orderMaxInput.min(remainingTakerIO); + // This rounds down which favours the order/dex. + takerInput = takerOutput.div(orderIOCalculation.IORatio); + + remainingTakerIO = remainingTakerIO.sub(takerOutput); + } totalTakerOutput = totalTakerOutput.add(takerOutput); totalTakerInput = totalTakerInput.add(takerInput); @@ -519,8 +535,11 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } } - if (totalTakerInput.lt(config.minimumInput)) { - revert MinimumInput(config.minimumInput, totalTakerInput); + { + Float actualRelevantTakerIO = config.IOIsInput ? totalTakerInput : totalTakerOutput; + if (actualRelevantTakerIO.lt(config.minimumIO)) { + revert MinimumIO(config.minimumIO, actualRelevantTakerIO); + } } // We send the tokens to `msg.sender` first adopting a similar pattern to @@ -537,7 +556,7 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order pushTokens(orderOutputToken, totalTakerInput); if (config.data.length > 0) { - IOrderBookV5OrderTaker(msg.sender).onTakeOrders2( + IOrderBookV6OrderTaker(msg.sender).onTakeOrders2( orderOutputToken, orderInputToken, totalTakerInput, totalTakerOutput, config.data ); } @@ -551,7 +570,7 @@ contract OrderBook is IOrderBookV5, IMetaV1_2, ReentrancyGuard, Multicall, Order } } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function clear3( OrderV4 memory aliceOrder, OrderV4 memory bobOrder, diff --git a/src/concrete/parser/OrderBookSubParser.sol b/src/concrete/parser/OrderBookV6SubParser.sol similarity index 99% rename from src/concrete/parser/OrderBookSubParser.sol rename to src/concrete/parser/OrderBookV6SubParser.sol index 4e8d9539fb..463dd4cd03 100644 --- a/src/concrete/parser/OrderBookSubParser.sol +++ b/src/concrete/parser/OrderBookV6SubParser.sol @@ -65,10 +65,10 @@ import { PARSE_META as SUB_PARSER_PARSE_META, SUB_PARSER_WORD_PARSERS, OPERAND_HANDLER_FUNCTION_POINTERS as SUB_PARSER_OPERAND_HANDLERS -} from "../../generated/OrderBookSubParser.pointers.sol"; +} from "../../generated/OrderBookV6SubParser.pointers.sol"; import {IDescribedByMetaV1} from "rain.metadata/interface/IDescribedByMetaV1.sol"; -contract OrderBookSubParser is BaseRainterpreterSubParserNPE2 { +contract OrderBookV6SubParser is BaseRainterpreterSubParserNPE2 { using LibUint256Matrix for uint256[][]; /// @inheritdoc IDescribedByMetaV1 diff --git a/src/generated/OrderBookSubParser.pointers.sol b/src/generated/OrderBookV6SubParser.pointers.sol similarity index 89% rename from src/generated/OrderBookSubParser.pointers.sol rename to src/generated/OrderBookV6SubParser.pointers.sol index 1c131c8a94..e61ee0079f 100644 --- a/src/generated/OrderBookSubParser.pointers.sol +++ b/src/generated/OrderBookV6SubParser.pointers.sol @@ -10,7 +10,7 @@ pragma solidity ^0.8.25; // file needs the contract to exist so that it can be compiled. /// @dev Hash of the known bytecode. -bytes32 constant BYTECODE_HASH = bytes32(0x7c8b8c827e772690a58491ad0b064e4eadf31c95511023abfea56990fef5d847); +bytes32 constant BYTECODE_HASH = bytes32(0xcce0acb013106679d66b3ab3a941fead9ccec6e43d8a3cb06161fb158384ef61); /// @dev The hash of the meta that describes the contract. bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x3457291434660c589b0e6c287e12b513e5194a5129c75fa47d01ce03fbc52178); @@ -44,13 +44,13 @@ uint8 constant PARSE_META_BUILD_DEPTH = 1; /// to things that happen entirely on the interpreter such as well known /// constants and references to the context grid. bytes constant SUB_PARSER_WORD_PARSERS = - hex"166a1689169a16ab16bb16cc16dd16ee16ff17101721173117421753176417751786179617a6166a169a16ab16bb17dc166a169a16ab16bb17dc17ed"; + hex"162e164b165a166916781688169716a716b616c616d616e516f5170417141724173417431752162e165a166916781787162e165a1669167817871797"; /// @dev Every two bytes is a function pointer for an operand handler. /// These positional indexes all map to the same indexes looked up in the parse /// meta. bytes constant OPERAND_HANDLER_FUNCTION_POINTERS = - hex"1c191c191c191c191c191c191c191c191c191c191c191c191c191c191c191c191c191c5e1d161c191c191c191c191c191c191c191c191c191c191c19"; + hex"1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1bd11c861b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f1b8f"; /// @dev Every two bytes is a function pointer for a literal parser. /// Literal dispatches are determined by the first byte(s) of the literal diff --git a/src/lib/LibOrder.sol b/src/lib/LibOrder.sol index 3b9678ae7c..26ae04abba 100644 --- a/src/lib/LibOrder.sol +++ b/src/lib/LibOrder.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity ^0.8.18; -import {OrderV4} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {OrderV4} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; /// @title LibOrder /// @notice Consistent handling of `OrderV4` for where it matters w.r.t. diff --git a/src/lib/LibOrderBook.sol b/src/lib/LibOrderBook.sol index 0836a33a5e..6e51a58dd4 100644 --- a/src/lib/LibOrderBook.sol +++ b/src/lib/LibOrderBook.sol @@ -8,7 +8,7 @@ import { CONTEXT_BASE_ROW_CALLING_CONTRACT, CONTEXT_BASE_COLUMN } from "rain.interpreter.interface/lib/caller/LibContext.sol"; -import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import { SourceIndexV2, StateNamespace, diff --git a/src/lib/LibOrderBookArb.sol b/src/lib/LibOrderBookArb.sol index 675536031a..289dcfaf01 100644 --- a/src/lib/LibOrderBookArb.sol +++ b/src/lib/LibOrderBookArb.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity ^0.8.19; -import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {LibOrderBook} from "./LibOrderBook.sol"; import {Address} from "openzeppelin-contracts/contracts/utils/Address.sol"; diff --git a/subgraph/networks.json b/subgraph/networks.json index ec998ca08f..e3690d3313 100644 --- a/subgraph/networks.json +++ b/subgraph/networks.json @@ -13,8 +13,8 @@ }, "base": { "OrderBook": { - "address": "0x52CEB8eBEf648744fFDDE89F7Bc9C3aC35944775", - "startBlock": 36667253 + "address": "0x77Ca4947dce161e122Eb690D475448f092a7d7EB", + "startBlock": 40754388 } }, "flare": { diff --git a/subgraph/subgraph.yaml b/subgraph/subgraph.yaml index 1cebb33820..f627ea243d 100644 --- a/subgraph/subgraph.yaml +++ b/subgraph/subgraph.yaml @@ -19,7 +19,7 @@ dataSources: - Transaction abis: - name: OrderBook - file: ../out/OrderBook.sol/OrderBook.json + file: ../out/OrderBookV6.sol/OrderBookV6.json - name: ERC20 file: ../out/ERC20.sol/ERC20.json - name: DecimalFloat diff --git a/test/abstract/OrderBookV4FlashLender.fee.t.sol b/test/abstract/OrderBookV4FlashLender.fee.t.sol deleted file mode 100644 index 71f3874ed5..0000000000 --- a/test/abstract/OrderBookV4FlashLender.fee.t.sol +++ /dev/null @@ -1,14 +0,0 @@ -// SPDX-License-Identifier: LicenseRef-DCL-1.0 -// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd -pragma solidity =0.8.25; - -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; - -/// @title OrderBookV4FlashLenderFeeTest -/// Tests the fee charged by `OrderBookV4FlashLender`. -contract OrderBookV4FlashLenderFeeTest is OrderBookExternalMockTest { - /// Tests that the fee charged by `OrderBookV4FlashLender` is 0. - function testFlashFee(address token, uint256 amount) public view { - assertEq(iOrderbook.flashFee(token, amount), 0); - } -} diff --git a/test/abstract/OrderBookV5ArbOrderTaker.context.t.sol b/test/abstract/OrderBookV6ArbOrderTaker.context.t.sol similarity index 82% rename from test/abstract/OrderBookV5ArbOrderTaker.context.t.sol rename to test/abstract/OrderBookV6ArbOrderTaker.context.t.sol index a3ac9166b9..db6c22d0e7 100644 --- a/test/abstract/OrderBookV5ArbOrderTaker.context.t.sol +++ b/test/abstract/OrderBookV6ArbOrderTaker.context.t.sol @@ -3,31 +3,30 @@ pragma solidity =0.8.25; import { - ChildOrderBookV5ArbOrderTaker, + ChildOrderBookV6ArbOrderTaker, TaskV2, SignedContextV1, EvaluableV4 -} from "../util/concrete/ChildOrderBookV5ArbOrderTaker.sol"; -import {OrderBookExternalRealTest} from "../util/abstract/OrderBookExternalRealTest.sol"; +} from "../util/concrete/ChildOrderBookV6ArbOrderTaker.sol"; +import {OrderBookV6ExternalRealTest} from "../util/abstract/OrderBookV6ExternalRealTest.sol"; import { - TakeOrdersConfigV4, + TakeOrdersConfigV5, TakeOrderConfigV4, IOV2, OrderConfigV4, OrderV4, IInterpreterV4 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -import {StateNamespace, LibNamespace} from "src/concrete/ob/OrderBook.sol"; +import {StateNamespace, LibNamespace} from "src/concrete/ob/OrderBookV6.sol"; import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract OrderBookV5ArbOrderTakerContextTest is OrderBookExternalRealTest { - function testOrderBookV5ArbOrderTakerContext() external { +contract OrderBookV6ArbOrderTakerContextTest is OrderBookV6ExternalRealTest { + function testOrderBookV6ArbOrderTakerContext() external { address alice = address(999999); address bob = address(999998); - ChildOrderBookV5ArbOrderTaker arbOrderTaker = new ChildOrderBookV5ArbOrderTaker(); - + ChildOrderBookV6ArbOrderTaker arbOrderTaker = new ChildOrderBookV6ArbOrderTaker(); OrderConfigV4 memory aliceOrderConfig; { IOV2[] memory aliceValidInputs = new IOV2[](1); @@ -63,10 +62,11 @@ contract OrderBookV5ArbOrderTakerContextTest is OrderBookExternalRealTest { TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](1); orders[0] = aliceTakeOrderConfig; - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4({ - minimumInput: LibDecimalFloat.packLossless(0, 0), - maximumInput: LibDecimalFloat.packLossless(type(int224).max, 0), + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, orders: orders, data: "" }); @@ -108,6 +108,6 @@ contract OrderBookV5ArbOrderTakerContextTest is OrderBookExternalRealTest { // 5e18 is 5 eth as wei is 18 decimals. vm.deal(address(arbOrderTaker), 5e18); vm.prank(bob); - arbOrderTaker.arb4(iOrderbook, takeOrdersConfig, task); + arbOrderTaker.arb5(iOrderbook, takeOrdersConfig, task); } } diff --git a/test/abstract/OrderBookV5ArbOrderTaker.ierc165.t.sol b/test/abstract/OrderBookV6ArbOrderTaker.ierc165.t.sol similarity index 57% rename from test/abstract/OrderBookV5ArbOrderTaker.ierc165.t.sol rename to test/abstract/OrderBookV6ArbOrderTaker.ierc165.t.sol index caad0db455..3d20b75af1 100644 --- a/test/abstract/OrderBookV5ArbOrderTaker.ierc165.t.sol +++ b/test/abstract/OrderBookV6ArbOrderTaker.ierc165.t.sol @@ -5,30 +5,30 @@ pragma solidity =0.8.25; import {Test} from "forge-std/Test.sol"; import {IERC165} from "openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"; import { - OrderBookV5ArbOrderTaker, - IOrderBookV5ArbOrderTaker, + OrderBookV6ArbOrderTaker, + IOrderBookV6ArbOrderTaker, EvaluableV4, - OrderBookV5ArbConfig, - IOrderBookV5OrderTaker, + OrderBookV6ArbConfig, + IOrderBookV6OrderTaker, TaskV2, SignedContextV1 -} from "src/abstract/OrderBookV5ArbOrderTaker.sol"; +} from "src/abstract/OrderBookV6ArbOrderTaker.sol"; import {IInterpreterV4} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; -import {ChildOrderBookV5ArbOrderTaker} from "../util/concrete/ChildOrderBookV5ArbOrderTaker.sol"; +import {ChildOrderBookV6ArbOrderTaker} from "../util/concrete/ChildOrderBookV6ArbOrderTaker.sol"; -contract OrderBookV5ArbOrderTakerIERC165Test is Test { - /// Test that ERC165 and IOrderBookV5ArbOrderTaker are supported interfaces +contract OrderBookV6ArbOrderTakerIERC165Test is Test { + /// Test that ERC165 and IOrderBookV6ArbOrderTaker are supported interfaces /// as per ERC165. - function testOrderBookV5ArbOrderTakerIERC165(bytes4 badInterfaceId) external { + function testOrderBookV6ArbOrderTakerIERC165(bytes4 badInterfaceId) external { vm.assume(badInterfaceId != type(IERC165).interfaceId); - vm.assume(badInterfaceId != type(IOrderBookV5ArbOrderTaker).interfaceId); - vm.assume(badInterfaceId != type(IOrderBookV5OrderTaker).interfaceId); + vm.assume(badInterfaceId != type(IOrderBookV6ArbOrderTaker).interfaceId); + vm.assume(badInterfaceId != type(IOrderBookV6OrderTaker).interfaceId); - ChildOrderBookV5ArbOrderTaker arbOrderTaker = new ChildOrderBookV5ArbOrderTaker(); + ChildOrderBookV6ArbOrderTaker arbOrderTaker = new ChildOrderBookV6ArbOrderTaker(); assertTrue(arbOrderTaker.supportsInterface(type(IERC165).interfaceId)); - assertTrue(arbOrderTaker.supportsInterface(type(IOrderBookV5ArbOrderTaker).interfaceId)); - assertTrue(arbOrderTaker.supportsInterface(type(IOrderBookV5OrderTaker).interfaceId)); + assertTrue(arbOrderTaker.supportsInterface(type(IOrderBookV6ArbOrderTaker).interfaceId)); + assertTrue(arbOrderTaker.supportsInterface(type(IOrderBookV6OrderTaker).interfaceId)); assertFalse(arbOrderTaker.supportsInterface(badInterfaceId)); } } diff --git a/test/abstract/OrderBookV5FlashBorrower.ierc165.t.sol b/test/abstract/OrderBookV6FlashBorrower.ierc165.t.sol similarity index 83% rename from test/abstract/OrderBookV5FlashBorrower.ierc165.t.sol rename to test/abstract/OrderBookV6FlashBorrower.ierc165.t.sol index 61990572d8..b8875d15a7 100644 --- a/test/abstract/OrderBookV5FlashBorrower.ierc165.t.sol +++ b/test/abstract/OrderBookV6FlashBorrower.ierc165.t.sol @@ -5,22 +5,22 @@ pragma solidity =0.8.25; import {Test} from "forge-std/Test.sol"; import {IERC165} from "openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"; import { - OrderBookV5FlashBorrower, + OrderBookV6FlashBorrower, IERC3156FlashBorrower, - OrderBookV5ArbConfig, + OrderBookV6ArbConfig, TaskV2, SignedContextV1, EvaluableV4 -} from "src/abstract/OrderBookV5FlashBorrower.sol"; +} from "src/abstract/OrderBookV6FlashBorrower.sol"; import {IInterpreterV4} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; /// @dev We need a contract that is deployable in order to test the abstract /// base contract. -contract ChildOrderBookV5FlashBorrower is OrderBookV5FlashBorrower { +contract ChildOrderBookV6FlashBorrower is OrderBookV6FlashBorrower { constructor() - OrderBookV5FlashBorrower( - OrderBookV5ArbConfig( + OrderBookV6FlashBorrower( + OrderBookV6ArbConfig( address(0), TaskV2({ evaluable: EvaluableV4(IInterpreterV4(address(0)), IInterpreterStoreV3(address(0)), hex""), @@ -39,7 +39,7 @@ contract OrderBookV5FlashBorrowerIERC165Test is Test { vm.assume(badInterfaceId != type(IERC165).interfaceId); vm.assume(badInterfaceId != type(IERC3156FlashBorrower).interfaceId); - ChildOrderBookV5FlashBorrower flashBorrower = new ChildOrderBookV5FlashBorrower(); + ChildOrderBookV6FlashBorrower flashBorrower = new ChildOrderBookV6FlashBorrower(); assertTrue(flashBorrower.supportsInterface(type(IERC165).interfaceId)); assertTrue(flashBorrower.supportsInterface(type(IERC3156FlashBorrower).interfaceId)); assertFalse(flashBorrower.supportsInterface(badInterfaceId)); diff --git a/test/abstract/OrderBookV6FlashLender.fee.t.sol b/test/abstract/OrderBookV6FlashLender.fee.t.sol new file mode 100644 index 0000000000..7d5e57be45 --- /dev/null +++ b/test/abstract/OrderBookV6FlashLender.fee.t.sol @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: LicenseRef-DCL-1.0 +// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd +pragma solidity =0.8.25; + +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; + +/// @title OrderBookV6FlashLenderFeeTest +/// Tests the fee charged by `OrderBookV6FlashLender`. +contract OrderBookV6FlashLenderFeeTest is OrderBookV6ExternalMockTest { + /// Tests that the fee charged by `OrderBookV6FlashLender` is 0. + function testFlashFee(address token, uint256 amount) public view { + assertEq(iOrderbook.flashFee(token, amount), 0); + } +} diff --git a/test/abstract/OrderBookV4FlashLender.griefRecipient.t.sol b/test/abstract/OrderBookV6FlashLender.griefRecipient.t.sol similarity index 89% rename from test/abstract/OrderBookV4FlashLender.griefRecipient.t.sol rename to test/abstract/OrderBookV6FlashLender.griefRecipient.t.sol index 5710379309..e4f2d552ff 100644 --- a/test/abstract/OrderBookV4FlashLender.griefRecipient.t.sol +++ b/test/abstract/OrderBookV6FlashLender.griefRecipient.t.sol @@ -2,20 +2,20 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import { IERC3156FlashBorrower, ON_FLASH_LOAN_CALLBACK_SUCCESS } from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -import {FlashLenderCallbackFailed} from "src/abstract/OrderBookV4FlashLender.sol"; +import {FlashLenderCallbackFailed} from "src/abstract/OrderBookV6FlashLender.sol"; -/// @title OrderBookV4FlashLenderGriefRecipientTest +/// @title OrderBookV6FlashLenderGriefRecipientTest /// Try to grief the recipient of the flash loan. -contract OrderBookClearTest is OrderBookExternalMockTest { +contract OrderBookV6FlashLenderGriefRecipientTest is OrderBookV6ExternalMockTest { /// Tests that no matter who the receiver is, and no matter what happens with /// the tokens, the flash loan will revert if the receiver is not - /// `OrderBookV4FlashBorrower`. + /// `OrderBookV6FlashBorrower`. function testFlashLoanToNonReceiver( uint256 amount, bytes memory data, diff --git a/test/abstract/OrderBookV4FlashLender.ierc165.t.sol b/test/abstract/OrderBookV6FlashLender.ierc165.t.sol similarity index 68% rename from test/abstract/OrderBookV4FlashLender.ierc165.t.sol rename to test/abstract/OrderBookV6FlashLender.ierc165.t.sol index 02581b1e5e..b22ce8e73e 100644 --- a/test/abstract/OrderBookV4FlashLender.ierc165.t.sol +++ b/test/abstract/OrderBookV6FlashLender.ierc165.t.sol @@ -4,22 +4,22 @@ pragma solidity =0.8.25; import {Test} from "forge-std/Test.sol"; import {IERC165} from "openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"; -import {OrderBookV4FlashLender, IERC3156FlashLender} from "src/abstract/OrderBookV4FlashLender.sol"; +import {OrderBookV6FlashLender, IERC3156FlashLender} from "src/abstract/OrderBookV6FlashLender.sol"; /// @dev We need a contract that is deployable in order to test the abstract /// base contract. -contract ChildOrderBookV4FlashLender is OrderBookV4FlashLender { - constructor() OrderBookV4FlashLender() {} +contract ChildOrderBookV6FlashLender is OrderBookV6FlashLender { + constructor() OrderBookV6FlashLender() {} } -contract OrderBookV4FlashLenderIERC165Test is Test { +contract OrderBookV6FlashLenderIERC165Test is Test { /// Test that ERC165 and IERC3156FlashLender are supported interfaces /// as per ERC165. - function testOrderBookV4FlashLenderIERC165(bytes4 badInterfaceId) external { + function testOrderBookV6FlashLenderIERC165(bytes4 badInterfaceId) external { vm.assume(badInterfaceId != type(IERC165).interfaceId); vm.assume(badInterfaceId != type(IERC3156FlashLender).interfaceId); - ChildOrderBookV4FlashLender flashLender = new ChildOrderBookV4FlashLender(); + ChildOrderBookV6FlashLender flashLender = new ChildOrderBookV6FlashLender(); assertTrue(flashLender.supportsInterface(type(IERC165).interfaceId)); assertTrue(flashLender.supportsInterface(type(IERC3156FlashLender).interfaceId)); assertFalse(flashLender.supportsInterface(badInterfaceId)); diff --git a/test/abstract/OrderBookV4FlashLender.maxFlashLoan.t.sol b/test/abstract/OrderBookV6FlashLender.maxFlashLoan.t.sol similarity index 67% rename from test/abstract/OrderBookV4FlashLender.maxFlashLoan.t.sol rename to test/abstract/OrderBookV6FlashLender.maxFlashLoan.t.sol index c8262076dc..a7fd76e14f 100644 --- a/test/abstract/OrderBookV4FlashLender.maxFlashLoan.t.sol +++ b/test/abstract/OrderBookV6FlashLender.maxFlashLoan.t.sol @@ -2,13 +2,13 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -/// @title OrderBookV4FlashLenderMaxFlashLoanTest -/// Tests the maximum flash loan amount for `OrderBookV4FlashLender`. -contract OrderBookV4FlashLenderMaxFlashLoanTest is OrderBookExternalMockTest { - /// Tests that the maximum flash loan amount for `OrderBookV4FlashLender` is +/// @title OrderBookV6FlashLenderMaxFlashLoanTest +/// Tests the maximum flash loan amount for `OrderBookV6FlashLender`. +contract OrderBookV6FlashLenderMaxFlashLoanTest is OrderBookV6ExternalMockTest { + /// Tests that the maximum flash loan amount for `OrderBookV6FlashLender` is /// the balance of the token in the order book. function testFlashMaxLoan(uint256 amount) public { vm.mockCall( diff --git a/test/abstract/OrderBookV4FlashLender.mockSuccess.t.sol b/test/abstract/OrderBookV6FlashLender.mockSuccess.t.sol similarity index 80% rename from test/abstract/OrderBookV4FlashLender.mockSuccess.t.sol rename to test/abstract/OrderBookV6FlashLender.mockSuccess.t.sol index 0861da1303..d23a5bc5b5 100644 --- a/test/abstract/OrderBookV4FlashLender.mockSuccess.t.sol +++ b/test/abstract/OrderBookV6FlashLender.mockSuccess.t.sol @@ -2,18 +2,18 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import { IERC3156FlashBorrower, ON_FLASH_LOAN_CALLBACK_SUCCESS } from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -/// @title OrderBookV4FlashLenderMockSuccessTest -/// Show that if the receiver is `OrderBookV4FlashBorrower` and the token +/// @title OrderBookV6FlashLenderMockSuccessTest +/// Show that if the receiver is `OrderBookV6FlashBorrower` and the token /// movements do not error, then the flash loan will succeed. -contract OrderBookV4FlashLenderMockSuccessTest is OrderBookExternalMockTest { - /// Tests that if the receiver is `OrderBookV4FlashBorrower` and the token +contract OrderBookV6FlashLenderMockSuccessTest is OrderBookV6ExternalMockTest { + /// Tests that if the receiver is `OrderBookV6FlashBorrower` and the token /// movements do not error, then the flash loan will succeed. function testFlashLoanToReceiver(uint256 amount, bytes memory data) public { // Return true for all transfers. diff --git a/test/abstract/OrderBookV4FlashLender.reentrant.t.sol b/test/abstract/OrderBookV6FlashLender.reentrant.t.sol similarity index 85% rename from test/abstract/OrderBookV4FlashLender.reentrant.t.sol rename to test/abstract/OrderBookV6FlashLender.reentrant.t.sol index e97ca2daaf..fd216432c5 100644 --- a/test/abstract/OrderBookV4FlashLender.reentrant.t.sol +++ b/test/abstract/OrderBookV6FlashLender.reentrant.t.sol @@ -3,17 +3,17 @@ pragma solidity =0.8.25; import {Vm} from "forge-std/Vm.sol"; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import {Reenteroor} from "test/util/concrete/Reenteroor.sol"; import { - IOrderBookV5, + IOrderBookV6, OrderConfigV4, OrderV4, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, ClearConfigV2, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IParserV2} from "rain.interpreter.interface/interface/IParserV2.sol"; import {IERC3156FlashBorrower} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; @@ -22,10 +22,10 @@ import {EvaluableV4, SignedContextV1} from "rain.interpreter.interface/interface import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -/// @title OrderBookV4FlashLenderReentrant +/// @title OrderBookV6FlashLenderReentrant /// Test that flash borrowers can reenter the orderbook, which is necessary for /// trading etc. against it while the loan is active. -contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { +contract OrderBookV6FlashLenderReentrant is OrderBookV6ExternalRealTest { function checkFlashLoanNotRevert(Reenteroor borrower, bytes memory encodedCall, uint256 loanAmount) internal { borrower.reenterWith(encodedCall); vm.mockCall( @@ -55,7 +55,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { Reenteroor borrower = new Reenteroor(); checkFlashLoanNotRevert( borrower, - abi.encodeWithSelector(IOrderBookV5.vaultBalance2.selector, address(borrower), address(iToken0), vaultId), + abi.encodeWithSelector(IOrderBookV6.vaultBalance2.selector, address(borrower), address(iToken0), vaultId), loanAmount ); } @@ -66,7 +66,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { // Create a flash borrower. Reenteroor borrower = new Reenteroor(); checkFlashLoanNotRevert( - borrower, abi.encodeWithSelector(IOrderBookV5.orderExists.selector, orderHash), loanAmount + borrower, abi.encodeWithSelector(IOrderBookV6.orderExists.selector, orderHash), loanAmount ); } @@ -85,7 +85,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { checkFlashLoanNotRevert( borrower, abi.encodeWithSelector( - IOrderBookV5.deposit3.selector, address(iToken0), vaultId, depositAmount, new EvaluableV4[](0) + IOrderBookV6.deposit4.selector, address(iToken0), vaultId, depositAmount, new EvaluableV4[](0) ), loanAmount ); @@ -106,7 +106,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { checkFlashLoanNotRevert( borrower, abi.encodeWithSelector( - IOrderBookV5.withdraw3.selector, address(iToken0), vaultId, withdrawAmount, new TaskV2[](0) + IOrderBookV6.withdraw4.selector, address(iToken0), vaultId, withdrawAmount, new TaskV2[](0) ), loanAmount ); @@ -121,7 +121,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { // Create a flash borrower. Reenteroor borrower = new Reenteroor(); checkFlashLoanNotRevert( - borrower, abi.encodeWithSelector(IOrderBookV5.addOrder3.selector, config, new TaskV2[](0)), loanAmount + borrower, abi.encodeWithSelector(IOrderBookV6.addOrder4.selector, config, new TaskV2[](0)), loanAmount ); } @@ -132,7 +132,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { Reenteroor borrower = new Reenteroor(); order.owner = address(borrower); checkFlashLoanNotRevert( - borrower, abi.encodeWithSelector(IOrderBookV5.removeOrder3.selector, order, new TaskV2[](0)), loanAmount + borrower, abi.encodeWithSelector(IOrderBookV6.removeOrder3.selector, order, new TaskV2[](0)), loanAmount ); } @@ -145,24 +145,25 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { config.evaluable.bytecode = iParserV2.parse2("_ _:max-positive-value() 1;:;"); vm.recordLogs(); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); (,, OrderV4 memory order) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](1); orders[0] = TakeOrderConfigV4(order, 0, 0, new SignedContextV1[](0)); - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ); + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); // Create a flash borrower. Reenteroor borrower = new Reenteroor(); checkFlashLoanNotRevert( - borrower, abi.encodeWithSelector(IOrderBookV5.takeOrders3.selector, takeOrdersConfig), loanAmount + borrower, abi.encodeWithSelector(IOrderBookV6.takeOrders4.selector, takeOrdersConfig), loanAmount ); } @@ -191,13 +192,13 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { vm.recordLogs(); vm.prank(alice); - iOrderbook.addOrder3(aliceConfig, new TaskV2[](0)); + iOrderbook.addOrder4(aliceConfig, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); (,, OrderV4 memory aliceOrder) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); vm.recordLogs(); vm.prank(bob); - iOrderbook.addOrder3(bobConfig, new TaskV2[](0)); + iOrderbook.addOrder4(bobConfig, new TaskV2[](0)); entries = vm.getRecordedLogs(); (,, OrderV4 memory bobOrder) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); @@ -205,7 +206,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { vm.mockCall(aliceOrder.validOutputs[0].token, bytes(""), abi.encode(true)); vm.prank(aliceOrder.owner); - iOrderbook.deposit3( + iOrderbook.deposit4( aliceOrder.validOutputs[0].token, aliceOrder.validOutputs[0].vaultId, LibDecimalFloat.packLossless(type(int64).max, 0), @@ -213,7 +214,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { ); vm.mockCall(bobOrder.validOutputs[0].token, bytes(""), abi.encode(true)); vm.prank(bobOrder.owner); - iOrderbook.deposit3( + iOrderbook.deposit4( bobOrder.validOutputs[0].token, bobOrder.validOutputs[0].vaultId, LibDecimalFloat.packLossless(type(int64).max, 0), @@ -225,7 +226,7 @@ contract OrderBookV4FlashLenderReentrant is OrderBookExternalRealTest { checkFlashLoanNotRevert( borrower, abi.encodeWithSelector( - IOrderBookV5.clear3.selector, + IOrderBookV6.clear3.selector, aliceOrder, bobOrder, clearConfig, diff --git a/test/abstract/OrderBookV4FlashLender.transfers.t.sol b/test/abstract/OrderBookV6FlashLender.transfers.t.sol similarity index 84% rename from test/abstract/OrderBookV4FlashLender.transfers.t.sol rename to test/abstract/OrderBookV6FlashLender.transfers.t.sol index c5e713edcb..2063eab1fc 100644 --- a/test/abstract/OrderBookV4FlashLender.transfers.t.sol +++ b/test/abstract/OrderBookV6FlashLender.transfers.t.sol @@ -3,8 +3,8 @@ pragma solidity =0.8.25; import {stdError} from "forge-std/Test.sol"; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; -import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; +import {ERC20, IERC20Errors} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -13,7 +13,7 @@ import { ON_FLASH_LOAN_CALLBACK_SUCCESS } from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; import {IERC3156FlashLender} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashLender.sol"; -import {FlashLenderCallbackFailed} from "src/abstract/OrderBookV4FlashLender.sol"; +import {FlashLenderCallbackFailed} from "src/abstract/OrderBookV6FlashLender.sol"; contract TKN is ERC20 { constructor(address recipient, uint256 supply) ERC20("TKN", "TKN") { @@ -79,9 +79,9 @@ contract Carol is IPull { } } -/// @title OrderBookV4FlashLenderTransferTest -/// Tests the `OrderBookV4FlashLender` transfer functions. -contract OrderBookV4FlashLenderTransferTest is OrderBookExternalMockTest { +/// @title OrderBookV6FlashLenderTransferTest +/// Tests the `OrderBookV6FlashLender` transfer functions. +contract OrderBookV6FlashLenderTransferTest is OrderBookV6ExternalMockTest { /// Alice can send tokens to Bob, who will return them and then the loan will /// be repaid. /// forge-config: default.fuzz.runs = 100 @@ -100,8 +100,8 @@ contract OrderBookV4FlashLenderTransferTest is OrderBookExternalMockTest { } } - /// Alice can send tokens to Carol, who will return all but one of them and - /// then the loan will fail. + /// Alice can send tokens to Carol, who will return not all of them and then + /// the loan will fail. /// forge-config: default.fuzz.runs = 100 function testFlashLoanTransferFail(uint256 amount, uint256 amountWithheld, bool success) public { amount = bound(amount, 1, type(uint256).max); @@ -114,7 +114,11 @@ contract OrderBookV4FlashLenderTransferTest is OrderBookExternalMockTest { if (!success) { vm.expectRevert(abi.encodeWithSelector(FlashLenderCallbackFailed.selector, bytes32(0))); } else { - vm.expectRevert("ERC20: transfer amount exceeds balance"); + vm.expectRevert( + abi.encodeWithSelector( + IERC20Errors.ERC20InsufficientBalance.selector, address(alice), amount - amountWithheld, amount + ) + ); } iOrderbook.flashLoan(IERC3156FlashBorrower(address(alice)), address(tkn), amount, ""); } diff --git a/test/concrete/arb/GenericPoolOrderBookV4ArbOrderTaker.sender.t.sol b/test/concrete/arb/GenericPoolOrderBookV4ArbOrderTaker.sender.t.sol deleted file mode 100644 index ec8179cfc4..0000000000 --- a/test/concrete/arb/GenericPoolOrderBookV4ArbOrderTaker.sender.t.sol +++ /dev/null @@ -1,45 +0,0 @@ -// SPDX-License-Identifier: LicenseRef-DCL-1.0 -// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd -pragma solidity =0.8.25; - -import {GenericPoolOrderBookV5ArbOrderTakerTest} from "test/util/abstract/GenericPoolOrderBookV5ArbOrderTakerTest.sol"; - -import { - GenericPoolOrderBookV5ArbOrderTaker, - OrderBookV5ArbConfig -} from "src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol"; -import { - OrderV4, - EvaluableV4, - TakeOrderConfigV4, - TakeOrdersConfigV4, - IInterpreterV4, - IInterpreterStoreV3, - TaskV2, - SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; - -contract GenericPoolOrderBookV5ArbOrderTakerSenderTest is GenericPoolOrderBookV5ArbOrderTakerTest { - /// forge-config: default.fuzz.runs = 10 - function testGenericPoolTakeOrdersSender(OrderV4 memory order, uint256 inputIOIndex, uint256 outputIOIndex) - public - { - TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); - - GenericPoolOrderBookV5ArbOrderTaker(iArb).arb4( - iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(iRefundoor, iRefundoor, "") - ), - TaskV2({ - evaluable: EvaluableV4(iInterpreter, iInterpreterStore, ""), - signedContext: new SignedContextV1[](0) - }) - ); - } -} diff --git a/test/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.expression.t.sol b/test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.expression.t.sol similarity index 67% rename from test/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.expression.t.sol rename to test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.expression.t.sol index 7a7ca71e8d..93129ac88d 100644 --- a/test/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.expression.t.sol +++ b/test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.expression.t.sol @@ -2,35 +2,35 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {GenericPoolOrderBookV5ArbOrderTakerTest} from "test/util/abstract/GenericPoolOrderBookV5ArbOrderTakerTest.sol"; +import {GenericPoolOrderBookV6ArbOrderTakerTest} from "test/util/abstract/GenericPoolOrderBookV6ArbOrderTakerTest.sol"; import { - GenericPoolOrderBookV5ArbOrderTaker, - OrderBookV5ArbConfig -} from "src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol"; + GenericPoolOrderBookV6ArbOrderTaker, + OrderBookV6ArbConfig +} from "src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol"; import { OrderV4, EvaluableV4, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, IInterpreterV4, IInterpreterStoreV3, SignedContextV1, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol"; import { LibNamespace, DEFAULT_STATE_NAMESPACE, BEFORE_ARB_SOURCE_INDEX, WrongTask -} from "src/abstract/OrderBookV5ArbCommon.sol"; -import {CALCULATE_ORDER_ENTRYPOINT} from "src/concrete/ob/OrderBook.sol"; +} from "src/abstract/OrderBookV6ArbCommon.sol"; +import {CALCULATE_ORDER_ENTRYPOINT} from "src/concrete/ob/OrderBookV6.sol"; import { StateNamespace, FullyQualifiedNamespace } from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract GenericPoolOrderBookV5ArbOrderTakerExpressionTest is GenericPoolOrderBookV5ArbOrderTakerTest { +contract GenericPoolOrderBookV6ArbOrderTakerExpressionTest is GenericPoolOrderBookV6ArbOrderTakerTest { function expression() internal virtual override returns (bytes memory) { // We're going to test with a mock so it doesn't matter what the expression is. return hex"deadbeef"; @@ -50,15 +50,16 @@ contract GenericPoolOrderBookV5ArbOrderTakerExpressionTest is GenericPoolOrderBo TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); vm.expectRevert(abi.encodeWithSelector(WrongTask.selector)); - GenericPoolOrderBookV5ArbOrderTaker(iArb).arb4( + GenericPoolOrderBookV6ArbOrderTaker(iArb).arb5( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(iRefundoor, iRefundoor, "") - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(iRefundoor, iRefundoor, "") + }), TaskV2({evaluable: evaluable, signedContext: new SignedContextV1[](0)}) ); } @@ -89,15 +90,16 @@ contract GenericPoolOrderBookV5ArbOrderTakerExpressionTest is GenericPoolOrderBo vm.expectCall(address(iInterpreterStore), abi.encodeWithSelector(IInterpreterStoreV3.set.selector, ns, kvs)); } - GenericPoolOrderBookV5ArbOrderTaker(iArb).arb4( + GenericPoolOrderBookV6ArbOrderTaker(iArb).arb5( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(iRefundoor, iRefundoor, "") - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(iRefundoor, iRefundoor, "") + }), TaskV2({ evaluable: EvaluableV4(iInterpreter, iInterpreterStore, expression()), signedContext: new SignedContextV1[](0) diff --git a/test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sender.t.sol b/test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sender.t.sol new file mode 100644 index 0000000000..bf5c7c2155 --- /dev/null +++ b/test/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sender.t.sol @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: LicenseRef-DCL-1.0 +// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd +pragma solidity =0.8.25; + +import {GenericPoolOrderBookV6ArbOrderTakerTest} from "test/util/abstract/GenericPoolOrderBookV6ArbOrderTakerTest.sol"; + +import { + GenericPoolOrderBookV6ArbOrderTaker, + OrderBookV6ArbConfig +} from "src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol"; +import { + OrderV4, + EvaluableV4, + TakeOrderConfigV4, + TakeOrdersConfigV5, + IInterpreterV4, + IInterpreterStoreV3, + TaskV2, + SignedContextV1 +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; + +contract GenericPoolOrderBookV6ArbOrderTakerSenderTest is GenericPoolOrderBookV6ArbOrderTakerTest { + /// forge-config: default.fuzz.runs = 10 + function testGenericPoolTakeOrdersSender(OrderV4 memory order, uint256 inputIOIndex, uint256 outputIOIndex) + public + { + TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); + + GenericPoolOrderBookV6ArbOrderTaker(iArb).arb5( + iOrderBook, + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(iRefundoor, iRefundoor, "") + }), + TaskV2({ + evaluable: EvaluableV4(iInterpreter, iInterpreterStore, ""), + signedContext: new SignedContextV1[](0) + }) + ); + } +} diff --git a/test/concrete/arb/GenericPoolOrderBookV4FlashBorrower.sender.t.sol b/test/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sender.t.sol similarity index 54% rename from test/concrete/arb/GenericPoolOrderBookV4FlashBorrower.sender.t.sol rename to test/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sender.t.sol index d0c48d69ca..23c74daff8 100644 --- a/test/concrete/arb/GenericPoolOrderBookV4FlashBorrower.sender.t.sol +++ b/test/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sender.t.sol @@ -5,45 +5,46 @@ pragma solidity =0.8.25; import {ArbTest} from "test/util/abstract/ArbTest.sol"; import { - GenericPoolOrderBookV5FlashBorrower, - OrderBookV5ArbConfig -} from "src/concrete/arb/GenericPoolOrderBookV5FlashBorrower.sol"; + GenericPoolOrderBookV6FlashBorrower, + OrderBookV6ArbConfig +} from "src/concrete/arb/GenericPoolOrderBookV6FlashBorrower.sol"; import { OrderV4, TakeOrderConfigV4, EvaluableV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, IInterpreterV4, IInterpreterStoreV3, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract GenericPoolOrderBookV5FlashBorrowerTest is ArbTest { - function buildArb(OrderBookV5ArbConfig memory config) internal override returns (address) { - return address(new GenericPoolOrderBookV5FlashBorrower(config)); +contract GenericPoolOrderBookV6FlashBorrowerTest is ArbTest { + function buildArb(OrderBookV6ArbConfig memory config) internal override returns (address) { + return address(new GenericPoolOrderBookV6FlashBorrower(config)); } constructor() ArbTest() {} /// forge-config: default.fuzz.runs = 10 - function testGenericPoolOrderBookV5FlashBorrowerTakeOrdersSender( + function testGenericPoolOrderBookV6FlashBorrowerTakeOrdersSender( OrderV4 memory order, uint256 inputIOIndex, uint256 outputIOIndex ) public { TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); - GenericPoolOrderBookV5FlashBorrower(iArb).arb3( + GenericPoolOrderBookV6FlashBorrower(iArb).arb4( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }), abi.encode(iRefundoor, iRefundoor, ""), TaskV2({ evaluable: EvaluableV4(iInterpreter, iInterpreterStore, ""), diff --git a/test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.expression.t.sol b/test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.expression.t.sol similarity index 65% rename from test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.expression.t.sol rename to test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.expression.t.sol index bf1963a419..a1940baa91 100644 --- a/test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.expression.t.sol +++ b/test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.expression.t.sol @@ -2,26 +2,26 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {RouteProcessorOrderBookV5ArbOrderTakerTest} from - "test/util/abstract/RouteProcessorOrderBookV5ArbOrderTakerTest.sol"; +import {RouteProcessorOrderBookV6ArbOrderTakerTest} from + "test/util/abstract/RouteProcessorOrderBookV6ArbOrderTakerTest.sol"; import { OrderV4, EvaluableV4, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, IInterpreterV4, IInterpreterStoreV3, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {WrongTask} from "src/abstract/OrderBookV5ArbCommon.sol"; -import {RouteProcessorOrderBookV5ArbOrderTaker} from "src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {WrongTask} from "src/abstract/OrderBookV6ArbCommon.sol"; +import {RouteProcessorOrderBookV6ArbOrderTaker} from "src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol"; import { StateNamespace, FullyQualifiedNamespace } from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract RouteProcessorOrderBookV5ArbOrderTakerExpressionTest is RouteProcessorOrderBookV5ArbOrderTakerTest { +contract RouteProcessorOrderBookV6ArbOrderTakerExpressionTest is RouteProcessorOrderBookV6ArbOrderTakerTest { function expression() internal virtual override returns (bytes memory) { // We're going to test with a mock so it doesn't matter what the expression is. return hex"deadbeef"; @@ -41,15 +41,16 @@ contract RouteProcessorOrderBookV5ArbOrderTakerExpressionTest is RouteProcessorO TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); vm.expectRevert(abi.encodeWithSelector(WrongTask.selector)); - RouteProcessorOrderBookV5ArbOrderTaker(iArb).arb4( + RouteProcessorOrderBookV6ArbOrderTaker(iArb).arb5( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(iRefundoor, iRefundoor, "") - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(iRefundoor, iRefundoor, "") + }), TaskV2({evaluable: evaluable, signedContext: new SignedContextV1[](0)}) ); } @@ -78,15 +79,16 @@ contract RouteProcessorOrderBookV5ArbOrderTakerExpressionTest is RouteProcessorO vm.expectCall(address(iInterpreterStore), abi.encodeWithSelector(IInterpreterStoreV3.set.selector, ns)); } - RouteProcessorOrderBookV5ArbOrderTaker(iArb).arb4( + RouteProcessorOrderBookV6ArbOrderTaker(iArb).arb5( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(iRefundoor, iRefundoor, "") - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(iRefundoor, iRefundoor, "") + }), TaskV2({ evaluable: EvaluableV4(iInterpreter, iInterpreterStore, expression()), signedContext: new SignedContextV1[](0) diff --git a/test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.sender.t.sol b/test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sender.t.sol similarity index 50% rename from test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.sender.t.sol rename to test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sender.t.sol index 0dbb689712..de31acd922 100644 --- a/test/concrete/arb/RouteProcessorOrderBookV4ArbOrderTaker.sender.t.sol +++ b/test/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sender.t.sol @@ -2,40 +2,41 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {RouteProcessorOrderBookV5ArbOrderTakerTest} from - "test/util/abstract/RouteProcessorOrderBookV5ArbOrderTakerTest.sol"; +import {RouteProcessorOrderBookV6ArbOrderTakerTest} from + "test/util/abstract/RouteProcessorOrderBookV6ArbOrderTakerTest.sol"; import { OrderV4, EvaluableV4, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, IInterpreterV4, IInterpreterStoreV3, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import { - RouteProcessorOrderBookV5ArbOrderTaker, - OrderBookV5ArbConfig -} from "src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol"; + RouteProcessorOrderBookV6ArbOrderTaker, + OrderBookV6ArbConfig +} from "src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract RouteProcessorOrderBookV5ArbOrderTakerSenderTest is RouteProcessorOrderBookV5ArbOrderTakerTest { +contract RouteProcessorOrderBookV6ArbOrderTakerSenderTest is RouteProcessorOrderBookV6ArbOrderTakerTest { /// forge-config: default.fuzz.runs = 100 function testRouteProcessorTakeOrdersSender(OrderV4 memory order, uint256 inputIOIndex, uint256 outputIOIndex) public { TakeOrderConfigV4[] memory orders = buildTakeOrderConfig(order, inputIOIndex, outputIOIndex); - RouteProcessorOrderBookV5ArbOrderTaker(iArb).arb4( + RouteProcessorOrderBookV6ArbOrderTaker(iArb).arb5( iOrderBook, - TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - abi.encode(bytes("0x00")) - ), + TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: abi.encode(bytes("0x00")) + }), TaskV2({ evaluable: EvaluableV4(iInterpreter, iInterpreterStore, ""), signedContext: new SignedContextV1[](0) diff --git a/test/concrete/ob/OrderBook.addOrder.entask.t.sol b/test/concrete/ob/OrderBookV6.addOrder.entask.t.sol similarity index 90% rename from test/concrete/ob/OrderBook.addOrder.entask.t.sol rename to test/concrete/ob/OrderBookV6.addOrder.entask.t.sol index ea431d074c..facf9af4ff 100644 --- a/test/concrete/ob/OrderBook.addOrder.entask.t.sol +++ b/test/concrete/ob/OrderBookV6.addOrder.entask.t.sol @@ -2,20 +2,20 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, EvaluableV4, TaskV2, OrderV4, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; -contract OrderBookAddOrderEnactTest is OrderBookExternalRealTest { +contract OrderBookV6AddOrderEnactTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; using Strings for address; using Strings for uint256; @@ -24,17 +24,19 @@ contract OrderBookAddOrderEnactTest is OrderBookExternalRealTest { function checkReentrancyRW(uint256 expectedReads, uint256 expectedWrites) internal { (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); + // ReentrancyGuard.REENTRANCY_GUARD_STORAGE + bytes32 reentrancyGuardStorage = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; // 3 reads for reentrancy guard. // 1 reads for add order. assert(reads.length == expectedReads); - assert(reads[0] == bytes32(uint256(0))); - assert(reads[1] == bytes32(uint256(0))); - assert(reads[reads.length - 1] == bytes32(uint256(0))); + assert(reads[0] == reentrancyGuardStorage); + assert(reads[1] == reentrancyGuardStorage); + assert(reads[reads.length - 1] == reentrancyGuardStorage); // 2 writes for reentrancy guard. // 1 write for add order. assert(writes.length == expectedWrites); - assert(writes[0] == bytes32(uint256(0))); - assert(writes[writes.length - 1] == bytes32(uint256(0))); + assert(writes[0] == reentrancyGuardStorage); + assert(writes[writes.length - 1] == reentrancyGuardStorage); } function checkAddOrder( @@ -48,7 +50,7 @@ contract OrderBookAddOrderEnactTest is OrderBookExternalRealTest { vm.startPrank(owner); TaskV2[] memory actions = evalsToActions(evalStrings); vm.record(); - bool stateChanged = iOrderbook.addOrder3(config, actions); + bool stateChanged = iOrderbook.addOrder4(config, actions); assert(stateChanged != nonces[config.nonce]); checkReentrancyRW(nonces[config.nonce] ? 4 : 5, nonces[config.nonce] ? 2 : 3); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iStore)); @@ -161,7 +163,7 @@ contract OrderBookAddOrderEnactTest is OrderBookExternalRealTest { vm.startPrank(alice); TaskV2[] memory actions = evalsToActions(evals0); vm.expectRevert("always revert"); - bool stateChanged = iOrderbook.addOrder3(config, actions); + bool stateChanged = iOrderbook.addOrder4(config, actions); assert(!stateChanged); OrderV4 memory order = OrderV4(alice, config.evaluable, config.validInputs, config.validOutputs, config.nonce); diff --git a/test/concrete/ob/OrderBook.addOrder.mock.t.sol b/test/concrete/ob/OrderBookV6.addOrder.mock.t.sol similarity index 93% rename from test/concrete/ob/OrderBook.addOrder.mock.t.sol rename to test/concrete/ob/OrderBookV6.addOrder.mock.t.sol index a30f32737c..c4b4039418 100644 --- a/test/concrete/ob/OrderBook.addOrder.mock.t.sol +++ b/test/concrete/ob/OrderBookV6.addOrder.mock.t.sol @@ -2,22 +2,22 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import { OrderConfigV4, OrderV4, IOV2, EvaluableV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {NotRainMetaV1, META_MAGIC_NUMBER_V1} from "rain.metadata/interface/unstable/IMetaV1_2.sol"; import {LibMeta} from "rain.metadata/lib/LibMeta.sol"; import {IExpressionDeployerV3} from "rain.interpreter.interface/interface/deprecated/IExpressionDeployerV3.sol"; -/// @title OrderBookAddOrderMockTest -/// @notice Tests the addOrder function of the OrderBook contract. -contract OrderBookAddOrderMockTest is OrderBookExternalMockTest { +/// @title OrderBookV6AddOrderMockTest +/// @notice Tests the addOrder function of the OrderBookV6 contract. +contract OrderBookV6AddOrderMockTest is OrderBookV6ExternalMockTest { /// Adding an order without calculations does not revert. /// This is a runtime error. /// forge-config: default.fuzz.runs = 100 @@ -25,7 +25,7 @@ contract OrderBookAddOrderMockTest is OrderBookExternalMockTest { vm.prank(owner); LibTestAddOrder.conformConfig(config, iInterpreter, iStore); config.evaluable.bytecode = ""; - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); (OrderV4 memory order, bytes32 orderHash) = LibTestAddOrder.expectedOrder(owner, config); (order); assertTrue(iOrderbook.orderExists(orderHash)); @@ -38,7 +38,7 @@ contract OrderBookAddOrderMockTest is OrderBookExternalMockTest { config.evaluable.bytecode = hex"02000000040000000000000000"; config.validInputs = new IOV2[](0); vm.expectRevert(abi.encodeWithSelector(OrderNoInputs.selector)); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); (OrderV4 memory order, bytes32 orderHash) = LibTestAddOrder.expectedOrder(owner, config); (order); assertTrue(!iOrderbook.orderExists(orderHash)); @@ -52,7 +52,7 @@ contract OrderBookAddOrderMockTest is OrderBookExternalMockTest { vm.assume(config.validInputs.length > 0); config.validOutputs = new IOV2[](0); vm.expectRevert(abi.encodeWithSelector(OrderNoOutputs.selector)); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); (OrderV4 memory order, bytes32 orderHash) = LibTestAddOrder.expectedOrder(owner, config); (order); assertTrue(!iOrderbook.orderExists(orderHash)); @@ -88,7 +88,7 @@ contract OrderBookAddOrderMockTest is OrderBookExternalMockTest { vm.assume(config.meta.length > 0); vm.expectRevert(abi.encodeWithSelector(NotRainMetaV1.selector, config.meta)); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); (OrderV4 memory order, bytes32 orderHash) = LibTestAddOrder.expectedOrder(owner, config); (order); diff --git a/test/concrete/ob/OrderBook.addOrder.nonce.t.sol b/test/concrete/ob/OrderBookV6.addOrder.nonce.t.sol similarity index 81% rename from test/concrete/ob/OrderBook.addOrder.nonce.t.sol rename to test/concrete/ob/OrderBookV6.addOrder.nonce.t.sol index 0097499e7a..2c7b174b08 100644 --- a/test/concrete/ob/OrderBook.addOrder.nonce.t.sol +++ b/test/concrete/ob/OrderBookV6.addOrder.nonce.t.sol @@ -2,14 +2,14 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, EvaluableV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { +contract OrderBookV6AddOrderNonceTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; /// forge-config: default.fuzz.runs = 100 @@ -18,12 +18,12 @@ contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { OrderV4 memory order = OrderV4(owner, config.evaluable, config.validInputs, config.validOutputs, config.nonce); vm.prank(owner); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(order.hash())); vm.prank(owner); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(!stateChange); assert(iOrderbook.orderExists(order.hash())); } @@ -35,7 +35,7 @@ contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { LibTestAddOrder.conformConfig(config, iInterpreter, iStore); vm.assume(config.nonce != otherNonce); vm.prank(owner); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert( iOrderbook.orderExists( @@ -45,7 +45,7 @@ contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { config.nonce = otherNonce; vm.prank(owner); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert( iOrderbook.orderExists( @@ -66,7 +66,7 @@ contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { config1.nonce = config0.nonce; vm.assume(keccak256(abi.encode(config0)) != keccak256(abi.encode(config1))); vm.prank(owner); - bool stateChange = iOrderbook.addOrder3(config0, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config0, new TaskV2[](0)); assert(stateChange); assert( iOrderbook.orderExists( @@ -75,7 +75,7 @@ contract OrderBookAddOrderNonceTest is OrderBookExternalRealTest { ); vm.prank(owner); - stateChange = iOrderbook.addOrder3(config1, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config1, new TaskV2[](0)); assert(stateChange); assert( iOrderbook.orderExists( diff --git a/test/concrete/ob/OrderBook.addOrder.owner.t.sol b/test/concrete/ob/OrderBookV6.addOrder.owner.t.sol similarity index 77% rename from test/concrete/ob/OrderBook.addOrder.owner.t.sol rename to test/concrete/ob/OrderBookV6.addOrder.owner.t.sol index e6cac265b6..59a885a13b 100644 --- a/test/concrete/ob/OrderBook.addOrder.owner.t.sol +++ b/test/concrete/ob/OrderBookV6.addOrder.owner.t.sol @@ -2,14 +2,14 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, EvaluableV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -contract OrderBookAddOrderOwnerTest is OrderBookExternalRealTest { +contract OrderBookV6AddOrderOwnerTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; /// forge-config: default.fuzz.runs = 100 @@ -19,12 +19,12 @@ contract OrderBookAddOrderOwnerTest is OrderBookExternalRealTest { OrderV4 memory order = OrderV4(owner, config.evaluable, config.validInputs, config.validOutputs, config.nonce); vm.prank(owner); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(order.hash())); vm.prank(owner); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(!stateChange); assert(iOrderbook.orderExists(order.hash())); } @@ -41,12 +41,12 @@ contract OrderBookAddOrderOwnerTest is OrderBookExternalRealTest { OrderV4 memory orderBob = OrderV4(bob, config.evaluable, config.validInputs, config.validOutputs, config.nonce); vm.prank(alice); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderAlice.hash())); vm.prank(bob); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderBob.hash())); } diff --git a/test/concrete/ob/OrderBook.addOrder.t.sol b/test/concrete/ob/OrderBookV6.addOrder.t.sol similarity index 83% rename from test/concrete/ob/OrderBook.addOrder.t.sol rename to test/concrete/ob/OrderBookV6.addOrder.t.sol index 0dd6faa951..070148b82a 100644 --- a/test/concrete/ob/OrderBook.addOrder.t.sol +++ b/test/concrete/ob/OrderBookV6.addOrder.t.sol @@ -2,22 +2,22 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {OrderConfigV4, EvaluableV4, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {OrderConfigV4, EvaluableV4, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IParserV2} from "rain.interpreter.interface/interface/IParserV2.sol"; -import {UnsupportedCalculateOutputs, UnsupportedCalculateInputs} from "src/concrete/ob/OrderBook.sol"; +import {UnsupportedCalculateOutputs, UnsupportedCalculateInputs} from "src/concrete/ob/OrderBookV6.sol"; -/// @title OrderBookAddOrderTest -/// @notice A test harness for testing the OrderBook addOrder function. -contract OrderBookAddOrderTest is OrderBookExternalRealTest { +/// @title OrderBookV6AddOrderTest +/// @notice A test harness for testing the OrderBookV6 addOrder function. +contract OrderBookV6AddOrderTest is OrderBookV6ExternalRealTest { /// No sources deploys as we let this be a runtime check. /// forge-config: default.fuzz.runs = 100 function testAddOrderRealNoSourcesDeploys(address owner, OrderConfigV4 memory config) public { LibTestAddOrder.conformConfig(config, iInterpreter, iStore); config.evaluable.bytecode = hex""; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// No handle IO reverts. @@ -28,7 +28,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2(":;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// A stack of 0 for calculate order deploys. @@ -39,7 +39,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2(":;:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// A stack of 1 for calculate order reverts. @@ -50,7 +50,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("_:block-timestamp();:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// A stack of 2 for calculate order deploys. @@ -60,7 +60,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("_ _:block-timestamp() chain-id();:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// A stack of 3 for calculate order deploys. @@ -70,7 +70,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("_ _ _:block-timestamp() chain-id() block-number();:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// Inputs for calculate order. Tests one input. @@ -81,7 +81,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("i:;:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// Inputs for calculate order errors. Tests two inputs. @@ -92,7 +92,7 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("i0 i1:;:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } /// Inputs for calculate order errors. This takes precedent over the same @@ -104,6 +104,6 @@ contract OrderBookAddOrderTest is OrderBookExternalRealTest { bytes memory bytecode = iParserV2.parse2("i:;i:;"); config.evaluable.bytecode = bytecode; vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } } diff --git a/test/concrete/ob/OrderBook.clear.badStack.t.sol b/test/concrete/ob/OrderBookV6.clear.badStack.t.sol similarity index 91% rename from test/concrete/ob/OrderBook.clear.badStack.t.sol rename to test/concrete/ob/OrderBookV6.clear.badStack.t.sol index 7cdf8b41a8..8a2dec3f63 100644 --- a/test/concrete/ob/OrderBook.clear.badStack.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.badStack.t.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import { OrderConfigV4, @@ -11,11 +11,11 @@ import { ClearConfigV2, SignedContextV1, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {UnsupportedCalculateOutputs} from "src/concrete/ob/OrderBook.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {UnsupportedCalculateOutputs} from "src/concrete/ob/OrderBookV6.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -contract OrderBookClearOrderBadStackTest is OrderBookExternalRealTest { +contract OrderBookV6ClearOrderBadStackTest is OrderBookV6ExternalRealTest { function checkBadStack( address alice, address bob, @@ -43,10 +43,10 @@ contract OrderBookClearOrderBadStackTest is OrderBookExternalRealTest { OrderV4(bob, configBob.evaluable, configBob.validInputs, configBob.validOutputs, configBob.nonce); vm.prank(alice); - iOrderbook.addOrder3(configAlice, new TaskV2[](0)); + iOrderbook.addOrder4(configAlice, new TaskV2[](0)); vm.prank(bob); - iOrderbook.addOrder3(configBob, new TaskV2[](0)); + iOrderbook.addOrder4(configBob, new TaskV2[](0)); vm.expectRevert(abi.encodeWithSelector(UnsupportedCalculateOutputs.selector, badStackHeight)); iOrderbook.clear3( diff --git a/test/concrete/ob/OrderBook.clear.context.t.sol b/test/concrete/ob/OrderBookV6.clear.context.t.sol similarity index 95% rename from test/concrete/ob/OrderBook.clear.context.t.sol rename to test/concrete/ob/OrderBookV6.clear.context.t.sol index 2f3283059d..5e588217ec 100644 --- a/test/concrete/ob/OrderBook.clear.context.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.context.t.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import { OrderConfigV4, @@ -12,7 +12,7 @@ import { SignedContextV1, IOV2, EvaluableV4 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {REVERTING_MOCK_BYTECODE} from "test/util/lib/LibTestConstants.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; @@ -20,7 +20,7 @@ import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -contract OrderBookClearOrderContextTest is OrderBookExternalRealTest { +contract OrderBookV6ClearOrderContextTest is OrderBookV6ExternalRealTest { using Strings for address; using Strings for uint256; @@ -184,10 +184,10 @@ contract OrderBookClearOrderContextTest is OrderBookExternalRealTest { OrderV4(bob, configBob.evaluable, configBob.validInputs, configBob.validOutputs, configBob.nonce); vm.prank(alice); - iOrderbook.addOrder3(configAlice, new TaskV2[](0)); + iOrderbook.addOrder4(configAlice, new TaskV2[](0)); vm.prank(alice); - iOrderbook.deposit3( + iOrderbook.deposit4( configAlice.validOutputs[0].token, configAlice.validOutputs[0].vaultId, LibDecimalFloat.packLossless(100e6, -6), @@ -195,10 +195,10 @@ contract OrderBookClearOrderContextTest is OrderBookExternalRealTest { ); vm.prank(bob); - iOrderbook.addOrder3(configBob, new TaskV2[](0)); + iOrderbook.addOrder4(configBob, new TaskV2[](0)); vm.prank(bob); - iOrderbook.deposit3( + iOrderbook.deposit4( configBob.validOutputs[0].token, configBob.validOutputs[0].vaultId, LibDecimalFloat.packLossless(100e12, -12), diff --git a/test/concrete/ob/OrderBook.clear.handleIO.revert.t.sol b/test/concrete/ob/OrderBookV6.clear.handleIO.revert.t.sol similarity index 95% rename from test/concrete/ob/OrderBook.clear.handleIO.revert.t.sol rename to test/concrete/ob/OrderBookV6.clear.handleIO.revert.t.sol index e68dee82b7..c8cfeb5bff 100644 --- a/test/concrete/ob/OrderBook.clear.handleIO.revert.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.handleIO.revert.t.sol @@ -3,7 +3,7 @@ pragma solidity =0.8.25; import {Vm} from "forge-std/Vm.sol"; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { ClearConfigV2, OrderV4, @@ -14,14 +14,14 @@ import { SignedContextV1, TaskV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {SourceIndexOutOfBounds} from "rain.interpreter.interface/error/ErrBytecode.sol"; import {LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; -/// @title OrderBookClearHandleIORevertTest +/// @title OrderBookV6ClearHandleIORevertTest /// @notice A test harness for testing the OrderBook clear function will run /// handle IO and revert if it fails. -contract OrderBookClearHandleIORevertTest is OrderBookExternalRealTest { +contract OrderBookV6ClearHandleIORevertTest is OrderBookV6ExternalRealTest { using LibDecimalFloat for Float; function userDeposit(bytes memory rainString, address owner, address inputToken, address outputToken) @@ -48,7 +48,7 @@ contract OrderBookClearHandleIORevertTest is OrderBookExternalRealTest { } vm.prank(owner); - iOrderbook.deposit3(outputToken, vaultId, LibDecimalFloat.packLossless(type(int224).max, 0), new TaskV2[](0)); + iOrderbook.deposit4(outputToken, vaultId, LibDecimalFloat.packLossless(type(int224).max, 0), new TaskV2[](0)); Float balance = iOrderbook.vaultBalance2(owner, outputToken, vaultId); assertTrue(balance.eq(LibDecimalFloat.packLossless(type(int224).max, 0))); @@ -58,7 +58,7 @@ contract OrderBookClearHandleIORevertTest is OrderBookExternalRealTest { vm.prank(owner); vm.recordLogs(); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); assertEq(entries.length, 1); (,, OrderV4 memory order) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); diff --git a/test/concrete/ob/OrderBook.clear.mock.t.sol b/test/concrete/ob/OrderBookV6.clear.mock.t.sol similarity index 98% rename from test/concrete/ob/OrderBook.clear.mock.t.sol rename to test/concrete/ob/OrderBookV6.clear.mock.t.sol index ff0011e0e9..a8b1b15ae8 100644 --- a/test/concrete/ob/OrderBook.clear.mock.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.mock.t.sol @@ -5,7 +5,7 @@ pragma solidity =0.8.25; import {Test, stdError} from "forge-std/Test.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import { OrderConfigV4, OrderV4, @@ -16,9 +16,9 @@ import { IInterpreterV4, TaskV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {NotOrderOwner, StackItem, NegativeBounty} from "src/concrete/ob/OrderBook.sol"; +import {NotOrderOwner, StackItem, NegativeBounty} from "src/concrete/ob/OrderBookV6.sol"; import {LibNamespace} from "rain.interpreter.interface/lib/ns/LibNamespace.sol"; import {StateNamespace, EvalV4, SourceIndexV2} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {LibFixedPointDecimalArithmeticOpenZeppelin} from @@ -38,9 +38,9 @@ contract MockInterpreter { } } -/// @title OrderBookClearTest +/// @title OrderBookV6ClearTest /// Tests clearing an order. -contract OrderBookClearTest is OrderBookExternalMockTest { +contract OrderBookV6ClearTest is OrderBookV6ExternalMockTest { using LibFixedPointDecimalArithmeticOpenZeppelin for uint256; using Math for uint256; using LibDecimalFloat for Float; @@ -54,7 +54,7 @@ contract OrderBookClearTest is OrderBookExternalMockTest { abi.encodeWithSelector(IERC20.transferFrom.selector, depositor, address(iOrderbook), amount18), abi.encode(true) ); - iOrderbook.deposit3(address(token), vaultId, amount, new TaskV2[](0)); + iOrderbook.deposit4(address(token), vaultId, amount, new TaskV2[](0)); Float balance = iOrderbook.vaultBalance2(depositor, token, vaultId); @@ -297,7 +297,7 @@ contract OrderBookClearTest is OrderBookExternalMockTest { ) external { // 0 tested separately. aliceIORatio18 = bound(aliceIORatio18, 1, 1e18); - bobIORatio18 = bound(bobIORatio18, 1e18, uint256(1e18).fixedPointDiv(aliceIORatio18, Math.Rounding.Down)); + bobIORatio18 = bound(bobIORatio18, 1e18, uint256(1e18).fixedPointDiv(aliceIORatio18, Math.Rounding.Floor)); Float aliceIORatio = LibDecimalFloat.fromFixedDecimalLosslessPacked(aliceIORatio18, 18); Float bobIORatio = LibDecimalFloat.fromFixedDecimalLosslessPacked(bobIORatio18, 18); diff --git a/test/concrete/ob/OrderBook.clear.sameToken.t.sol b/test/concrete/ob/OrderBookV6.clear.sameToken.t.sol similarity index 78% rename from test/concrete/ob/OrderBook.clear.sameToken.t.sol rename to test/concrete/ob/OrderBookV6.clear.sameToken.t.sol index 1b079bd50f..f5a6cfb248 100644 --- a/test/concrete/ob/OrderBook.clear.sameToken.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.sameToken.t.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, @@ -10,11 +10,11 @@ import { ClearConfigV2, SignedContextV1, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {TokenSelfTrade} from "src/concrete/ob/OrderBook.sol"; +import {TokenSelfTrade} from "src/concrete/ob/OrderBookV6.sol"; -contract OrderBookClearSameTokenTest is OrderBookExternalRealTest { +contract OrderBookV6ClearSameTokenTest is OrderBookV6ExternalRealTest { /// forge-config: default.fuzz.runs = 10 function testClearSameToken( address alice, @@ -37,10 +37,10 @@ contract OrderBookClearSameTokenTest is OrderBookExternalRealTest { OrderV4(bob, configBob.evaluable, configBob.validInputs, configBob.validOutputs, configBob.nonce); vm.prank(alice); - iOrderbook.addOrder3(configAlice, new TaskV2[](0)); + iOrderbook.addOrder4(configAlice, new TaskV2[](0)); vm.prank(bob); - iOrderbook.addOrder3(configBob, new TaskV2[](0)); + iOrderbook.addOrder4(configBob, new TaskV2[](0)); vm.expectRevert(abi.encodeWithSelector(TokenSelfTrade.selector)); iOrderbook.clear3( diff --git a/test/concrete/ob/OrderBook.clear.zeroAmount.t.sol b/test/concrete/ob/OrderBookV6.clear.zeroAmount.t.sol similarity index 81% rename from test/concrete/ob/OrderBook.clear.zeroAmount.t.sol rename to test/concrete/ob/OrderBookV6.clear.zeroAmount.t.sol index 6e71f4bec9..cf3d5d0ea6 100644 --- a/test/concrete/ob/OrderBook.clear.zeroAmount.t.sol +++ b/test/concrete/ob/OrderBookV6.clear.zeroAmount.t.sol @@ -2,18 +2,18 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, TaskV2, SignedContextV1, ClearConfigV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {ClearZeroAmount} from "src/concrete/ob/OrderBook.sol"; +import {ClearZeroAmount} from "src/concrete/ob/OrderBookV6.sol"; -contract OrderBookClearZeroAmountTest is OrderBookExternalRealTest { +contract OrderBookV6ClearZeroAmountTest is OrderBookV6ExternalRealTest { /// forge-config: default.fuzz.runs = 10 function testClearZeroAmount( address alice, @@ -41,9 +41,9 @@ contract OrderBookClearZeroAmountTest is OrderBookExternalRealTest { OrderV4(bob, configBob.evaluable, configBob.validInputs, configBob.validOutputs, configBob.nonce); vm.prank(alice); - iOrderbook.addOrder3(configAlice, new TaskV2[](0)); + iOrderbook.addOrder4(configAlice, new TaskV2[](0)); vm.prank(bob); - iOrderbook.addOrder3(configBob, new TaskV2[](0)); + iOrderbook.addOrder4(configBob, new TaskV2[](0)); vm.expectRevert(ClearZeroAmount.selector); iOrderbook.clear3( diff --git a/test/concrete/ob/OrderBook.deposit.entask.t.sol b/test/concrete/ob/OrderBookV6.deposit.entask.t.sol similarity index 92% rename from test/concrete/ob/OrderBook.deposit.entask.t.sol rename to test/concrete/ob/OrderBookV6.deposit.entask.t.sol index bb183f8ff3..2426495ffa 100644 --- a/test/concrete/ob/OrderBook.deposit.entask.t.sol +++ b/test/concrete/ob/OrderBookV6.deposit.entask.t.sol @@ -2,20 +2,20 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest, LibDecimalFloat, Float} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest, LibDecimalFloat, Float} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, EvaluableV4, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {LibFormatDecimalFloat} from "rain.math.float/lib/format/LibFormatDecimalFloat.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; -contract OrderBookDepositEnactTest is OrderBookExternalRealTest { +contract OrderBookV6DepositEnactTest is OrderBookV6ExternalRealTest { using Strings for address; using Strings for uint256; using LibDecimalFloat for Float; @@ -23,17 +23,17 @@ contract OrderBookDepositEnactTest is OrderBookExternalRealTest { function checkReentrancyRW() internal view { (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); - // 3 reads for reentrancy guard. - // 5 reads for deposit. + // ReentrancyGuard.REENTRANCY_GUARD_STORAGE + bytes32 reentrancyGuardStorage = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; + assertEq(reads.length, 5); - assertEq(reads[0], bytes32(uint256(0))); - assertEq(reads[1], bytes32(uint256(0))); - assertEq(reads[reads.length - 1], bytes32(uint256(0))); - // 2 writes for reentrancy guard. - // 2 write for deposit. + assertEq(reads[0], reentrancyGuardStorage); + assertEq(reads[1], reentrancyGuardStorage); + assertEq(reads[reads.length - 1], reentrancyGuardStorage); + assertEq(writes.length, 3); - assertEq(writes[0], bytes32(uint256(0))); - assertEq(writes[writes.length - 1], bytes32(uint256(0))); + assertEq(writes[0], reentrancyGuardStorage); + assertEq(writes[writes.length - 1], reentrancyGuardStorage); } function checkDeposit( @@ -59,7 +59,7 @@ contract OrderBookDepositEnactTest is OrderBookExternalRealTest { TaskV2(EvaluableV4(iInterpreter, iStore, iParserV2.parse2(evalStrings[i])), new SignedContextV1[](0)); } vm.record(); - iOrderbook.deposit3(address(iToken0), vaultId, amount, actions); + iOrderbook.deposit4(address(iToken0), vaultId, amount, actions); checkReentrancyRW(); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iStore)); assert(reads.length == expectedReads); @@ -259,7 +259,7 @@ contract OrderBookDepositEnactTest is OrderBookExternalRealTest { assertTrue(iOrderbook.vaultBalance2(alice, address(iToken0), vaultId).isZero()); vm.expectRevert("revert in action"); - iOrderbook.deposit3(address(iToken0), vaultId, amount, actions); + iOrderbook.deposit4(address(iToken0), vaultId, amount, actions); assertTrue(iOrderbook.vaultBalance2(alice, address(iToken0), vaultId).isZero()); } diff --git a/test/concrete/ob/OrderBook.deposit.t.sol b/test/concrete/ob/OrderBookV6.deposit.t.sol similarity index 84% rename from test/concrete/ob/OrderBook.deposit.t.sol rename to test/concrete/ob/OrderBookV6.deposit.t.sol index fe44ff2a1f..9aad5afc34 100644 --- a/test/concrete/ob/OrderBook.deposit.t.sol +++ b/test/concrete/ob/OrderBookV6.deposit.t.sol @@ -4,16 +4,18 @@ pragma solidity =0.8.25; import {stdError} from "forge-std/Test.sol"; import {REVERTING_MOCK_BYTECODE, CONSOLE_ADDRESS} from "test/util/lib/LibTestConstants.sol"; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; -import {TaskV2, EvaluableV4, IOrderBookV5} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; +import {TaskV2, EvaluableV4, IOrderBookV6} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {Reenteroor} from "test/util/concrete/Reenteroor.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; +import {ReentrancyGuard} from "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol"; +import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; -/// @title OrderBookDepositTest +/// @title OrderBookV6DepositTest /// Tests depositing to an order book. -contract OrderBookDepositTest is OrderBookExternalMockTest { +contract OrderBookV6DepositTest is OrderBookV6ExternalMockTest { using LibDecimalFloat for Float; /// Tests that we can deposit some amount and view the new vault balance. @@ -29,7 +31,7 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { Float amount = LibDecimalFloat.fromFixedDecimalLosslessPacked(amount18, 18); - iOrderbook.deposit3(address(iToken0), vaultId, amount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, amount, new TaskV2[](0)); assertTrue(iOrderbook.vaultBalance2(depositor, address(iToken0), vaultId).eq(amount)); } @@ -39,10 +41,10 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { vm.prank(depositor); vm.expectRevert( abi.encodeWithSelector( - IOrderBookV5.ZeroDepositAmount.selector, address(depositor), address(iToken0), vaultId + IOrderBookV6.ZeroDepositAmount.selector, address(depositor), address(iToken0), vaultId ) ); - iOrderbook.deposit3(address(iToken0), vaultId, LibDecimalFloat.packLossless(0, 0), new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, LibDecimalFloat.packLossless(0, 0), new TaskV2[](0)); } /// Test a warm deposit, which is the best case scenario for gas. In this @@ -56,14 +58,14 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { abi.encodeWithSelector(IERC20.transferFrom.selector, address(this), address(iOrderbook), 1), abi.encode(true) ); - iOrderbook.deposit3(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); vm.mockCall( address(iToken0), abi.encodeWithSelector(IERC20.transferFrom.selector, address(this), address(iOrderbook), 1), abi.encode(true) ); vm.resumeGasMetering(); - iOrderbook.deposit3(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); } /// Test a cold deposit, which is the worst case scenario for gas. In this @@ -78,7 +80,7 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { abi.encode(true) ); vm.resumeGasMetering(); - iOrderbook.deposit3(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), 0, LibDecimalFloat.packLossless(1, -18), new TaskV2[](0)); } /// Any failure in the deposit should revert the entire transaction. @@ -89,8 +91,8 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { // The token contract always reverts when not mocked. vm.prank(depositor); - vm.expectRevert(bytes("SafeERC20: low-level call failed")); - iOrderbook.deposit3(address(iToken0), vaultId, amount, new TaskV2[](0)); + vm.expectRevert(); + iOrderbook.deposit4(address(iToken0), vaultId, amount, new TaskV2[](0)); // Mocking the token to return false should also revert. vm.prank(depositor); @@ -100,8 +102,8 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { abi.encode(false) ); // This error string appears when the call completes but returns false. - vm.expectRevert(bytes("SafeERC20: ERC20 operation did not succeed")); - iOrderbook.deposit3(address(iToken0), vaultId, amount, new TaskV2[](0)); + vm.expectRevert(abi.encodeWithSelector(SafeERC20.SafeERC20FailedOperation.selector, address(iToken0))); + iOrderbook.deposit4(address(iToken0), vaultId, amount, new TaskV2[](0)); } /// Defines a deposit to be used in testDepositMany. @@ -128,11 +130,7 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { actions[i].amount = LibDecimalFloat.fromFixedDecimalLosslessPacked(actions[i].amount18, 18); // Avoid errors from attempting to etch precompiles. vm.assume(uint160(actions[i].token) < 1 || 10 < uint160(actions[i].token)); - // Avoid errors from attempting to etch the orderbook. - vm.assume(actions[i].token != address(iOrderbook)); - // Avoid errors from attempting to etch test harness internals. - vm.assume(actions[i].token != address(CONSOLE_ADDRESS)); - vm.assume(actions[i].token != address(vm)); + vm.assume(actions[i].token.code.length != 0); } for (uint256 i = 0; i < actions.length; i++) { @@ -157,7 +155,7 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { emit DepositV2(actions[i].depositor, actions[i].token, actions[i].vaultId, actions[i].amount18); vm.record(); vm.recordLogs(); - iOrderbook.deposit3(actions[i].token, actions[i].vaultId, actions[i].amount, new TaskV2[](0)); + iOrderbook.deposit4(actions[i].token, actions[i].vaultId, actions[i].amount, new TaskV2[](0)); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); assertEq(vm.getRecordedLogs().length, 1, "logs"); // - reentrancy guard x3 @@ -189,7 +187,7 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { vm.expectEmit(false, false, false, true); emit DepositV2(depositor, address(iToken0), vaultId, amount18); Float amount = LibDecimalFloat.fromFixedDecimalLosslessPacked(amount18, 18); - iOrderbook.deposit3(address(iToken0), vaultId, amount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, amount, new TaskV2[](0)); } /// Depositing should NOT allow reentrancy. @@ -213,9 +211,9 @@ contract OrderBookDepositTest is OrderBookExternalMockTest { address(reenteroor), abi.encodeWithSelector(IERC20Metadata.decimals.selector), abi.encode(uint8(18)) ); reenteroor.reenterWith( - abi.encodeWithSelector(IOrderBookV5.deposit3.selector, reToken, reVaultId, reAmount, new TaskV2[](0)) + abi.encodeWithSelector(IOrderBookV6.deposit4.selector, reToken, reVaultId, reAmount, new TaskV2[](0)) ); - vm.expectRevert(bytes("ReentrancyGuard: reentrant call")); - iOrderbook.deposit3(address(reenteroor), vaultId, amount, new TaskV2[](0)); + vm.expectRevert(abi.encodeWithSelector(ReentrancyGuard.ReentrancyGuardReentrantCall.selector)); + iOrderbook.deposit4(address(reenteroor), vaultId, amount, new TaskV2[](0)); } } diff --git a/test/concrete/ob/OrderBook.entask.t.sol b/test/concrete/ob/OrderBookV6.entask.t.sol similarity index 86% rename from test/concrete/ob/OrderBook.entask.t.sol rename to test/concrete/ob/OrderBookV6.entask.t.sol index 3b1d1f216c..86befa5201 100644 --- a/test/concrete/ob/OrderBook.entask.t.sol +++ b/test/concrete/ob/OrderBookV6.entask.t.sol @@ -2,25 +2,27 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, EvaluableV4, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; -contract OrderBookEnactTest is OrderBookExternalRealTest { - function checkReentrancyRW() internal { +contract OrderBookV6EnactTest is OrderBookV6ExternalRealTest { + function checkReentrancyRW() internal view { (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); // reads/writes for reentrancy guard. + // ReentrancyGuard.REENTRANCY_GUARD_STORAGE + bytes32 reentrancyGuardStorage = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; assert(reads.length == 3); - assert(reads[0] == bytes32(uint256(0))); - assert(reads[1] == bytes32(uint256(0))); - assert(reads[2] == bytes32(uint256(0))); + assert(reads[0] == reentrancyGuardStorage); + assert(reads[1] == reentrancyGuardStorage); + assert(reads[2] == reentrancyGuardStorage); assert(writes.length == 2); - assert(writes[0] == bytes32(uint256(0))); - assert(writes[1] == bytes32(uint256(0))); + assert(writes[0] == reentrancyGuardStorage); + assert(writes[1] == reentrancyGuardStorage); } function checkEntask(address owner, bytes[] memory evalStrings, uint256 expectedReads, uint256 expectedWrites) diff --git a/test/concrete/ob/OrderBook.quote.sameToken.t.sol b/test/concrete/ob/OrderBookV6.quote.sameToken.t.sol similarity index 79% rename from test/concrete/ob/OrderBook.quote.sameToken.t.sol rename to test/concrete/ob/OrderBookV6.quote.sameToken.t.sol index 9e4f3f0584..8b7697273c 100644 --- a/test/concrete/ob/OrderBook.quote.sameToken.t.sol +++ b/test/concrete/ob/OrderBookV6.quote.sameToken.t.sol @@ -2,13 +2,13 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; -import {QuoteV2, OrderConfigV4, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {TokenSelfTrade} from "src/concrete/ob/OrderBook.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; +import {QuoteV2, OrderConfigV4, TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {TokenSelfTrade} from "src/concrete/ob/OrderBookV6.sol"; import {Float} from "rain.math.float/lib/LibDecimalFloat.sol"; -/// @title OrderBookQuoteSameTokenTest -contract OrderBookQuoteSameTokenTest is OrderBookExternalRealTest { +/// @title OrderBookV6QuoteSameTokenTest +contract OrderBookV6QuoteSameTokenTest is OrderBookV6ExternalRealTest { /// Same token for input and output is error. /// forge-config: default.fuzz.runs = 10 function testQuoteSameToken(QuoteV2 memory quoteConfig) external { @@ -18,7 +18,7 @@ contract OrderBookQuoteSameTokenTest is OrderBookExternalRealTest { quoteConfig.inputIOIndex = 0; quoteConfig.outputIOIndex = 0; vm.prank(quoteConfig.order.owner); - iOrderbook.addOrder3( + iOrderbook.addOrder4( OrderConfigV4({ evaluable: quoteConfig.order.evaluable, validInputs: quoteConfig.order.validInputs, diff --git a/test/concrete/ob/OrderBook.quote.t.sol b/test/concrete/ob/OrderBookV6.quote.t.sol similarity index 95% rename from test/concrete/ob/OrderBook.quote.t.sol rename to test/concrete/ob/OrderBookV6.quote.t.sol index 68a521bdae..2dea9f11e6 100644 --- a/test/concrete/ob/OrderBook.quote.t.sol +++ b/test/concrete/ob/OrderBookV6.quote.t.sol @@ -2,27 +2,27 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest, console2} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest, console2} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { - IOrderBookV5, + IOrderBookV6, QuoteV2, OrderConfigV4, EvaluableV4, TaskV2, OrderV4, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -import {TokenSelfTrade} from "src/concrete/ob/OrderBook.sol"; +import {TokenSelfTrade} from "src/concrete/ob/OrderBookV6.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; import {LibFormatDecimalFloat} from "rain.math.float/lib/format/LibFormatDecimalFloat.sol"; -/// @title OrderBookQuoteTest -contract OrderBookQuoteTest is OrderBookExternalRealTest { +/// @title OrderBookV6QuoteTest +contract OrderBookV6QuoteTest is OrderBookV6ExternalRealTest { using Strings for address; using Strings for uint256; @@ -64,14 +64,14 @@ contract OrderBookQuoteTest is OrderBookExternalRealTest { abi.encode(true) ); vm.prank(owner); - iOrderbook.deposit3( + iOrderbook.deposit4( config.validOutputs[0].token, config.validOutputs[0].vaultId, depositAmount, new TaskV2[](0) ); for (uint256 i = 0; i < rainlang.length; i++) { config.evaluable.bytecode = iParserV2.parse2(rainlang[i]); vm.prank(owner); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); OrderV4 memory order = OrderV4({ owner: owner, diff --git a/test/concrete/ob/OrderBook.removeOrder.entask.t.sol b/test/concrete/ob/OrderBookV6.removeOrder.entask.t.sol similarity index 90% rename from test/concrete/ob/OrderBook.removeOrder.entask.t.sol rename to test/concrete/ob/OrderBookV6.removeOrder.entask.t.sol index 68e34185a8..3165e34ed6 100644 --- a/test/concrete/ob/OrderBook.removeOrder.entask.t.sol +++ b/test/concrete/ob/OrderBookV6.removeOrder.entask.t.sol @@ -2,37 +2,39 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, EvaluableV4, OrderV4, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; -contract OrderBookRemoveOrderEnactTest is OrderBookExternalRealTest { +contract OrderBookV6RemoveOrderEnactTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; using Strings for address; using Strings for uint256; - function checkReentrancyRW(uint256 expectedReads, uint256 expectedWrites) internal { + function checkReentrancyRW(uint256 expectedReads, uint256 expectedWrites) internal view { (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); // 3 reads for reentrancy guard. // 1 reads for remove order. assert(reads.length == expectedReads); - assert(reads[0] == bytes32(uint256(0))); - assert(reads[1] == bytes32(uint256(0))); - assert(reads[reads.length - 1] == bytes32(uint256(0))); + // ReentrancyGuard.REENTRANCY_GUARD_STORAGE + bytes32 reentrancyGuardStorage = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; + assert(reads[0] == reentrancyGuardStorage); + assert(reads[1] == reentrancyGuardStorage); + assert(reads[reads.length - 1] == reentrancyGuardStorage); // 2 writes for reentrancy guard. // 1 write for remove order. assert(writes.length == expectedWrites); - assert(writes[0] == bytes32(uint256(0))); - assert(writes[writes.length - 1] == bytes32(uint256(0))); + assert(writes[0] == reentrancyGuardStorage); + assert(writes[writes.length - 1] == reentrancyGuardStorage); } function checkRemoveOrder( @@ -53,7 +55,7 @@ contract OrderBookRemoveOrderEnactTest is OrderBookExternalRealTest { // Hacky way to give a unique nonce to each order passed in. config.nonce = keccak256(abi.encode(evalStrings)); if (addOrder) { - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); } OrderV4 memory order = OrderV4(owner, config.evaluable, config.validInputs, config.validOutputs, config.nonce); vm.record(); @@ -155,7 +157,7 @@ contract OrderBookRemoveOrderEnactTest is OrderBookExternalRealTest { bytes[] memory evals0 = new bytes[](1); evals0[0] = bytes(":;"); TaskV2[] memory actions = evalsToActions(evals0); - bool stateChanged = iOrderbook.addOrder3(config, actions); + bool stateChanged = iOrderbook.addOrder4(config, actions); assert(stateChanged); OrderV4 memory order = OrderV4(alice, config.evaluable, config.validInputs, config.validOutputs, config.nonce); diff --git a/test/concrete/ob/OrderBook.removeOrder.mock.t.sol b/test/concrete/ob/OrderBookV6.removeOrder.mock.t.sol similarity index 96% rename from test/concrete/ob/OrderBook.removeOrder.mock.t.sol rename to test/concrete/ob/OrderBookV6.removeOrder.mock.t.sol index f813d711b3..43e79a0b9a 100644 --- a/test/concrete/ob/OrderBook.removeOrder.mock.t.sol +++ b/test/concrete/ob/OrderBookV6.removeOrder.mock.t.sol @@ -2,16 +2,16 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import { OrderConfigV4, OrderV4, EvaluableV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {NotOrderOwner} from "src/concrete/ob/OrderBook.sol"; +import {NotOrderOwner} from "src/concrete/ob/OrderBookV6.sol"; -/// @title OrderBookRemoveOrderMockTest +/// @title OrderBookV6RemoveOrderMockTest /// @notice A contract to test the OrderBook removeOrder function. -contract OrderBookRemoveOrderMockTest is OrderBookExternalMockTest { +contract OrderBookV6RemoveOrderMockTest is OrderBookV6ExternalMockTest { /// An order MUST ONLY be removable by its owner. /// forge-config: default.fuzz.runs = 100 function testRemoveOrderOnlyOwner(address alice, address bob, OrderConfigV4 memory config, bytes memory expression) diff --git a/test/concrete/ob/OrderBook.removeOrder.owner.t.sol b/test/concrete/ob/OrderBookV6.removeOrder.owner.t.sol similarity index 87% rename from test/concrete/ob/OrderBook.removeOrder.owner.t.sol rename to test/concrete/ob/OrderBookV6.removeOrder.owner.t.sol index ee57eec1dc..568478e80a 100644 --- a/test/concrete/ob/OrderBook.removeOrder.owner.t.sol +++ b/test/concrete/ob/OrderBookV6.removeOrder.owner.t.sol @@ -2,15 +2,15 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, EvaluableV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -import {NotOrderOwner} from "src/concrete/ob/OrderBook.sol"; +import {NotOrderOwner} from "src/concrete/ob/OrderBookV6.sol"; -contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { +contract OrderBookV6RemoveOrderOwnerTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; /// forge-config: default.fuzz.runs = 100 @@ -22,10 +22,10 @@ contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { vm.startPrank(owner); for (uint256 i = 0; i < 2; i++) { - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(order.hash())); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(!stateChange); assert(iOrderbook.orderExists(order.hash())); @@ -53,7 +53,7 @@ contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { { vm.prank(alice); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderAlice.hash())); @@ -74,7 +74,7 @@ contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { { vm.prank(bob); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderBob.hash())); assert(!iOrderbook.orderExists(orderAlice.hash())); @@ -94,13 +94,13 @@ contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { { vm.prank(alice); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderAlice.hash())); assert(!iOrderbook.orderExists(orderBob.hash())); vm.prank(bob); - stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(orderBob.hash())); assert(iOrderbook.orderExists(orderAlice.hash())); @@ -127,7 +127,7 @@ contract OrderBookRemoveOrderOwnerTest is OrderBookExternalRealTest { OrderV4 memory order = OrderV4(alice, config.evaluable, config.validInputs, config.validOutputs, config.nonce); vm.prank(alice); - bool stateChange = iOrderbook.addOrder3(config, new TaskV2[](0)); + bool stateChange = iOrderbook.addOrder4(config, new TaskV2[](0)); assert(stateChange); assert(iOrderbook.orderExists(order.hash())); diff --git a/test/concrete/ob/OrderBook.takeOrder.badStack.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.badStack.t.sol similarity index 71% rename from test/concrete/ob/OrderBook.takeOrder.badStack.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.badStack.t.sol index f04b742094..834fcd1e6a 100644 --- a/test/concrete/ob/OrderBook.takeOrder.badStack.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.badStack.t.sol @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import { OrderConfigV4, @@ -10,14 +10,14 @@ import { OrderV4, EvaluableV4, TaskV2, - TakeOrdersConfigV4, + TakeOrdersConfigV5, TakeOrderConfigV4 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {UnsupportedCalculateOutputs} from "src/concrete/ob/OrderBook.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {UnsupportedCalculateOutputs} from "src/concrete/ob/OrderBookV6.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -contract OrderBookTakeOrderBadStackTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderBadStackTest is OrderBookV6ExternalRealTest { function checkBadStack( address alice, address bob, @@ -33,22 +33,23 @@ contract OrderBookTakeOrderBadStackTest is OrderBookExternalRealTest { TakeOrderConfigV4[] memory takeOrderConfigs = new TakeOrderConfigV4[](1); takeOrderConfigs[0] = TakeOrderConfigV4(order, 0, 0, new SignedContextV1[](0)); - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - takeOrderConfigs, - "" - ); + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: takeOrderConfigs, + data: "" + }); config.validInputs[0].token = address(iToken0); config.validOutputs[0].token = address(iToken1); vm.prank(alice); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); vm.prank(bob); vm.expectRevert(abi.encodeWithSelector(UnsupportedCalculateOutputs.selector, badStackHeight)); - iOrderbook.takeOrders3(takeOrdersConfig); + iOrderbook.takeOrders4(takeOrdersConfig); } /// forge-config: default.fuzz.runs = 100 diff --git a/test/concrete/ob/OrderBook.takeOrder.handleIO.revert.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.handleIO.revert.t.sol similarity index 92% rename from test/concrete/ob/OrderBook.takeOrder.handleIO.revert.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.handleIO.revert.t.sol index 603ac6b1c1..114f1211e6 100644 --- a/test/concrete/ob/OrderBook.takeOrder.handleIO.revert.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.handleIO.revert.t.sol @@ -3,26 +3,26 @@ pragma solidity =0.8.25; import {Vm} from "forge-std/Vm.sol"; -import {OrderBookExternalRealTest, IERC20} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest, IERC20} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { ClearConfigV2, OrderV4, TakeOrderConfigV4, IOV2, OrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, EvaluableV4, SignedContextV1, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {SourceIndexOutOfBounds} from "rain.interpreter.interface/error/ErrBytecode.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -/// @title OrderBookTakeOrderHandleIORevertTest +/// @title OrderBookV6TakeOrderHandleIORevertTest /// @notice A test harness for testing the OrderBook takeOrder function will run /// handle IO and revert if it fails. -contract OrderBookTakeOrderHandleIORevertTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderHandleIORevertTest is OrderBookV6ExternalRealTest { using LibDecimalFloat for Float; function checkTakeOrderHandleIO(bytes[] memory configs, bytes memory err, Float maxInput) internal { @@ -52,7 +52,7 @@ contract OrderBookTakeOrderHandleIORevertTest is OrderBookExternalRealTest { vm.mockCall(outputToken, abi.encodeWithSelector(IERC20.transfer.selector, address(this)), abi.encode(true)); vm.mockCall(inputToken, bytes(""), abi.encode(true)); } - iOrderbook.deposit3(outputToken, vaultId, LibDecimalFloat.packLossless(type(int224).max, -18), new TaskV2[](0)); + iOrderbook.deposit4(outputToken, vaultId, LibDecimalFloat.packLossless(type(int224).max, -18), new TaskV2[](0)); assertTrue( iOrderbook.vaultBalance2(address(this), outputToken, vaultId).eq( LibDecimalFloat.packLossless(type(int224).max, -18) @@ -67,21 +67,26 @@ contract OrderBookTakeOrderHandleIORevertTest is OrderBookExternalRealTest { config = OrderConfigV4(evaluable, validInputs, validOutputs, bytes32(i), bytes32(0), ""); vm.recordLogs(); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); assertEq(entries.length, 1); (,, OrderV4 memory order) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); orders[i] = TakeOrderConfigV4(order, 0, 0, new SignedContextV1[](0)); } - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), maxInput, LibDecimalFloat.packLossless(type(int224).max, 0), orders, "" - ); + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: maxInput, + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); if (err.length > 0) { vm.expectRevert(err); } - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(takeOrdersConfig); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(takeOrdersConfig); // We don't really care about the outputs as the tests are basically just // trying to show that the IO handler is running or not running by simple // reverts. diff --git a/test/concrete/ob/OrderBook.takeOrder.maximumInput.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.maximumInput.t.sol similarity index 92% rename from test/concrete/ob/OrderBook.takeOrder.maximumInput.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.maximumInput.t.sol index 6f72be3e04..82cfd79b8c 100644 --- a/test/concrete/ob/OrderBook.takeOrder.maximumInput.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.maximumInput.t.sol @@ -3,23 +3,23 @@ pragma solidity =0.8.25; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; -import {OrderBookExternalRealTest, Vm} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest, Vm} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderV4, TakeOrderConfigV4, - TakeOrdersConfigV4, - ZeroMaximumInput, + TakeOrdersConfigV5, IOV2, EvaluableV4, OrderConfigV4, - TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; + TaskV2, + IOrderBookV6 +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {SignedContextV1} from "rain.interpreter.interface/interface/deprecated/IInterpreterCallerV2.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {LibFormatDecimalFloat} from "rain.math.float/lib/format/LibFormatDecimalFloat.sol"; -contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderMaximumInputTest is OrderBookV6ExternalRealTest { using LibDecimalFloat for Float; using LibFormatDecimalFloat for Float; @@ -34,15 +34,16 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { SignedContextV1[] memory signedContexts = new SignedContextV1[](1); signedContexts[0] = signedContext; orders[0] = TakeOrderConfigV4(order, 0, 0, signedContexts); - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ); - vm.expectRevert(ZeroMaximumInput.selector); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(0, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); + vm.expectRevert(IOrderBookV6.ZeroMaximumIO.selector); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); (totalTakerInput, totalTakerOutput); } @@ -85,7 +86,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { vm.prank(testOrders[i].owner); vm.recordLogs(); - iOrderbook.addOrder3(orderConfig, new TaskV2[](0)); + iOrderbook.addOrder4(orderConfig, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); assertEq(entries.length, 1); (,, OrderV4 memory order) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); @@ -113,7 +114,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { ); Float balanceBefore = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); vm.prank(testVaults[i].owner); - iOrderbook.deposit3(testVaults[i].token, vaultId, testVaults[i].deposit, new TaskV2[](0)); + iOrderbook.deposit4(testVaults[i].token, vaultId, testVaults[i].deposit, new TaskV2[](0)); Float balanceAfter = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); Float expectedBalance = testVaults[i].deposit.add(balanceBefore); @@ -126,13 +127,14 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { for (uint256 i = 0; i < orders.length; i++) { takeOrders[i] = TakeOrderConfigV4(orders[i], 0, 0, new SignedContextV1[](0)); } - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - maximumTakerInput, - LibDecimalFloat.packLossless(type(int224).max, 0), - takeOrders, - "" - ); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: maximumTakerInput, + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: takeOrders, + data: "" + }); { uint256 expectedTakerInput18 = LibDecimalFloat.toFixedDecimalLossless(expectedTakerInput, 18); @@ -161,7 +163,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { } { vm.prank(bob); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); assertTrue(totalTakerInput.eq(expectedTakerInput), "totalTakerInput"); assertTrue(totalTakerOutput.eq(expectedTakerOutput), "totalTakerOutput"); } @@ -169,9 +171,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { for (uint256 i = 0; i < testVaults.length; i++) { Float vaultBalance = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); - Float diff = vaultBalance.sub(testVaults[i].expect); - - assertTrue(diff.lt(LibDecimalFloat.packLossless(11, -14)), "vaultBalance"); + assertTrue(vaultBalance.eq(testVaults[i].expect), "vaultBalance"); } } @@ -229,7 +229,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { address owner = address(uint160(uint256(keccak256("owner.rain.test")))); uint256 orderLimit = 1000; ownerDepositAmount18 = bound(ownerDepositAmount18, 0, orderLimit - 1); - maximumTakerInput18 = bound(maximumTakerInput18, 1000, uint256(int256(type(int224).max))); + maximumTakerInput18 = bound(maximumTakerInput18, orderLimit, uint256(int256(type(int224).max))); Float ownerDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerDepositAmount18, 18); Float maximumTakerInput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerInput18, 18); Float expectedTakerInput = ownerDepositAmount; @@ -329,6 +329,7 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { // Avoid information free overflow. ownerTwoDepositAmount18 = bound(ownerTwoDepositAmount18, 0, uint256(int256(type(int224).max)) / 10 - ownerOneDepositAmount18); + maximumTakerInput18 = bound(maximumTakerInput18, 1, uint256(int256(type(int224).max))); address ownerOne = address(uint160(uint256(keccak256("ownerOne.rain.test")))); address ownerTwo = address(uint160(uint256(keccak256("ownerTwo.rain.test")))); @@ -337,8 +338,6 @@ contract OrderBookTakeOrderMaximumInputTest is OrderBookExternalRealTest { testOrders[0] = TestOrder(ownerOne, "_ _:1e-15 2;:;"); testOrders[1] = TestOrder(ownerTwo, "_ _:5e-16 2;:;"); - maximumTakerInput18 = bound(maximumTakerInput18, 1, uint256(int256(type(int224).max))); - // The first owner's deposit is fully used before the second owner's // deposit is used. TestVault[] memory testVaults = new TestVault[](2); diff --git a/test/concrete/ob/OrderBookV6.takeOrder.maximumOutput.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.maximumOutput.t.sol new file mode 100644 index 0000000000..027db5fa86 --- /dev/null +++ b/test/concrete/ob/OrderBookV6.takeOrder.maximumOutput.t.sol @@ -0,0 +1,422 @@ +// SPDX-License-Identifier: LicenseRef-DCL-1.0 +// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd +pragma solidity =0.8.25; + +import {OrderBookV6ExternalRealTest, Vm} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; +import { + OrderV4, + TakeOrderConfigV4, + TakeOrdersConfigV5, + SignedContextV1, + IOrderBookV6, + OrderConfigV4, + IOV2, + EvaluableV4, + TaskV2 +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; + +contract OrderBookV6TakeOrderMaximumOutputTest is OrderBookV6ExternalRealTest { + using LibDecimalFloat for Float; + + /// It should be possible to take an order with zero maximum output. + function testTakeOrderMaximumOutputZero(OrderV4 memory order, SignedContextV1 memory signedContext) external { + vm.assume(order.validInputs.length > 0); + vm.assume(order.validOutputs.length > 0); + order.validInputs[0].token = address(iToken0); + order.validOutputs[0].token = address(iToken1); + TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](1); + SignedContextV1[] memory signedContexts = new SignedContextV1[](1); + signedContexts[0] = signedContext; + orders[0] = TakeOrderConfigV4({order: order, inputIOIndex: 0, outputIOIndex: 0, signedContext: signedContexts}); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + orders: orders, + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(0, 0), + maximumIORatio: LibDecimalFloat.packLossless(1, 0), + IOIsInput: false, + data: "" + }); + vm.expectRevert(IOrderBookV6.ZeroMaximumIO.selector); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); + (totalTakerInput, totalTakerOutput); + } + + struct TestOrder { + address owner; + bytes orderString; + } + + struct TestVault { + address owner; + address token; + Float deposit; + Float expect; + } + + function checkTakeOrderMaximumOutput( + TestOrder[] memory testOrders, + TestVault[] memory testVaults, + Float maximumTakerOutput, + Float expectedTakerInput, + Float expectedTakerOutput + ) internal { + address bob = address(uint160(uint256(keccak256("bob.rain.test")))); + bytes32 vaultId = 0; + + OrderV4[] memory orders = new OrderV4[](testOrders.length); + + for (uint256 i = 0; i < testOrders.length; i++) { + { + OrderConfigV4 memory orderConfig; + { + bytes memory bytecode = iParserV2.parse2(testOrders[i].orderString); + IOV2[] memory inputs = new IOV2[](1); + inputs[0] = IOV2({token: address(iToken0), vaultId: vaultId}); + IOV2[] memory outputs = new IOV2[](1); + outputs[0] = IOV2({token: address(iToken1), vaultId: vaultId}); + EvaluableV4 memory evaluable = + EvaluableV4({interpreter: iInterpreter, store: iStore, bytecode: bytecode}); + orderConfig = OrderConfigV4({ + evaluable: evaluable, + validInputs: inputs, + validOutputs: outputs, + nonce: bytes32(0), + secret: bytes32(0), + meta: "" + }); + } + + vm.prank(testOrders[i].owner); + vm.recordLogs(); + iOrderbook.addOrder4(orderConfig, new TaskV2[](0)); + Vm.Log[] memory logs = vm.getRecordedLogs(); + assertEq(logs.length, 1); + (,, OrderV4 memory order) = abi.decode(logs[0].data, (address, bytes32, OrderV4)); + orders[i] = order; + } + } + + for (uint256 i = 0; i < testVaults.length; i++) { + if (testVaults[i].deposit.gt(Float.wrap(0))) { + uint256 depositAmount18 = LibDecimalFloat.toFixedDecimalLossless(testVaults[i].deposit, 18); + + // Deposit the amount of tokens required to take the order. + vm.mockCall( + address(iToken1), + abi.encodeWithSelector( + iToken1.transferFrom.selector, testVaults[i].owner, address(iOrderbook), depositAmount18 + ), + abi.encode(true) + ); + vm.expectCall( + address(iToken1), + abi.encodeWithSelector( + iToken1.transferFrom.selector, testVaults[i].owner, address(iOrderbook), depositAmount18 + ), + 1 + ); + Float balanceBefore = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); + vm.prank(testVaults[i].owner); + iOrderbook.deposit4(testVaults[i].token, vaultId, testVaults[i].deposit, new TaskV2[](0)); + + Float balanceAfter = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); + Float expectedBalance = testVaults[i].deposit.add(balanceBefore); + + assertTrue(balanceAfter.eq(expectedBalance), "deposit"); + } + } + + TakeOrderConfigV4[] memory takeOrders = new TakeOrderConfigV4[](orders.length); + for (uint256 i = 0; i < orders.length; i++) { + takeOrders[i] = TakeOrderConfigV4({ + order: orders[i], + inputIOIndex: 0, + outputIOIndex: 0, + signedContext: new SignedContextV1[](0) + }); + } + + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + orders: takeOrders, + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: maximumTakerOutput, + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: false, + data: "" + }); + + { + (uint256 expectedTakerInput18,) = LibDecimalFloat.toFixedDecimalLossy(expectedTakerInput, 18); + (uint256 expectedTakerOutput18, bool losslessOutput) = + LibDecimalFloat.toFixedDecimalLossy(expectedTakerOutput, 18); + if (!losslessOutput) { + expectedTakerOutput18 += 1; + } + // Mock and expect the token transfers. + vm.mockCall( + address(iToken0), + abi.encodeWithSelector(iToken0.transferFrom.selector, bob, address(iOrderbook), expectedTakerOutput18), + abi.encode(true) + ); + vm.expectCall( + address(iToken0), + abi.encodeWithSelector(iToken0.transferFrom.selector, bob, address(iOrderbook), expectedTakerOutput18), + expectedTakerOutput18 > 0 ? 1 : 0 + ); + vm.mockCall( + address(iToken1), + abi.encodeWithSelector(iToken1.transfer.selector, bob, expectedTakerInput18), + abi.encode(true) + ); + vm.expectCall( + address(iToken1), + abi.encodeWithSelector(iToken1.transfer.selector, bob, expectedTakerInput18), + expectedTakerInput18 > 0 ? 1 : 0 + ); + } + { + vm.prank(bob); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); + + assertTrue(totalTakerInput.eq(expectedTakerInput), "taker input"); + assertTrue(totalTakerOutput.eq(expectedTakerOutput), "taker output"); + } + + for (uint256 i = 0; i < testVaults.length; i++) { + Float finalBalance = iOrderbook.vaultBalance2(testVaults[i].owner, testVaults[i].token, vaultId); + Float expectedFinalBalance = testVaults[i].expect; + assertTrue(finalBalance.eq(expectedFinalBalance), "final balance"); + } + } + + /// Add an order with unlimited maximum output and take it with a maximum + /// taker output. Only the maximum taker output should be used. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputSingleOrderUnlimitedMax(uint256 expectedTakerOutput18) external { + address owner = address(uint160(uint256(keccak256("owner.rain.test")))); + + expectedTakerOutput18 = bound(expectedTakerOutput18, 1, type(uint128).max); + uint256 expectedTakerInput18 = expectedTakerOutput18 * 2; + + Float expectedTakerInput = LibDecimalFloat.fromFixedDecimalLosslessPacked(expectedTakerInput18, 18); + Float expectedTakerOutput = LibDecimalFloat.fromFixedDecimalLosslessPacked(expectedTakerOutput18, 18); + + TestOrder[] memory testOrders = new TestOrder[](1); + testOrders[0] = TestOrder({owner: owner, orderString: "_ _: max-positive-value() 0.5;:;"}); + + TestVault[] memory testVaults = new TestVault[](2); + testVaults[0] = + TestVault({owner: owner, token: address(iToken1), deposit: expectedTakerInput, expect: Float.wrap(0)}); + testVaults[1] = + TestVault({owner: owner, token: address(iToken0), deposit: Float.wrap(0), expect: expectedTakerOutput}); + + checkTakeOrderMaximumOutput(testOrders, testVaults, expectedTakerInput, expectedTakerInput, expectedTakerOutput); + } + + /// Add an order with less than the maximum IO. Only the limit from the order + /// should be used. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputSingleOrderLimitedMax(uint256 maximumTakerOutput18) external { + address owner = address(uint160(uint256(keccak256("owner.rain.test")))); + maximumTakerOutput18 = bound(maximumTakerOutput18, 1e18, uint256(int256(type(int224).max))); + + Float maximumTakerOutput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerOutput18, 18); + + Float expectedTakerInput = LibDecimalFloat.packLossless(5, -2); + Float expectedTakerOutput = expectedTakerInput.mul(LibDecimalFloat.packLossless(2, 0)); + + TestOrder[] memory testOrders = new TestOrder[](1); + testOrders[0] = TestOrder({owner: owner, orderString: "_ _: 0.05 2;:;"}); + + TestVault[] memory testVaults = new TestVault[](2); + testVaults[0] = + TestVault({owner: owner, token: address(iToken1), deposit: expectedTakerInput, expect: Float.wrap(0)}); + testVaults[1] = + TestVault({owner: owner, token: address(iToken0), deposit: Float.wrap(0), expect: expectedTakerOutput}); + + checkTakeOrderMaximumOutput(testOrders, testVaults, maximumTakerOutput, expectedTakerInput, expectedTakerOutput); + } + + /// If the vault balance is less than both the maximum output and the order + /// limit, only the vault balance should be used. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputSingleOrderLimitedByVault( + uint256 ownerDepositAmount18, + uint256 maximumTakerInput18 + ) external { + address owner = address(uint160(uint256(keccak256("owner.rain.test")))); + + uint256 orderLimit18 = 1000; + ownerDepositAmount18 = bound(ownerDepositAmount18, 0, orderLimit18 - 1); + maximumTakerInput18 = bound(maximumTakerInput18, orderLimit18, uint256(int256(type(int224).max))); + + Float ownerDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerDepositAmount18, 18); + Float maximumTakerInput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerInput18, 18); + + Float orderIORatio = LibDecimalFloat.fromFixedDecimalLosslessPacked(2, 0); + Float maximumTakerOutput = maximumTakerInput.mul(orderIORatio); + + Float expectedTakerInput = ownerDepositAmount; + Float expectedTakerOutput = expectedTakerInput.mul(orderIORatio); + + TestOrder[] memory testOrders = new TestOrder[](1); + testOrders[0] = TestOrder({owner: owner, orderString: "_ _: 1000e-18 2;:;"}); + + TestVault[] memory testVaults = new TestVault[](2); + testVaults[0] = + TestVault({owner: owner, token: address(iToken1), deposit: ownerDepositAmount, expect: Float.wrap(0)}); + testVaults[1] = + TestVault({owner: owner, token: address(iToken0), deposit: Float.wrap(0), expect: expectedTakerOutput}); + checkTakeOrderMaximumOutput(testOrders, testVaults, maximumTakerOutput, expectedTakerInput, expectedTakerOutput); + } + + /// The deposit amount can be anything, the order taking should adjust + /// accordingly, and leave any unspent deposited tokens in the vault. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputSingleAnyDeposit(uint256 ownerDepositAmount18, uint256 maximumTakerOutput18) + external + { + address owner = address(uint160(uint256(keccak256("owner.rain.test")))); + uint256 orderLimit18 = 1000; + + TestOrder[] memory testOrders = new TestOrder[](1); + testOrders[0] = TestOrder({owner: owner, orderString: "_ _: 1000e-18 2;:;"}); + + ownerDepositAmount18 = bound(ownerDepositAmount18, 0, uint256(int256(type(int224).max))); + maximumTakerOutput18 = bound(maximumTakerOutput18, 1, uint256(int256(type(int224).max))); + + Float orderIO = LibDecimalFloat.fromFixedDecimalLosslessPacked(2, 0); + Float orderLimit = LibDecimalFloat.fromFixedDecimalLosslessPacked(orderLimit18, 18); + Float ownerDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerDepositAmount18, 18); + Float maximumTakerOutput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerOutput18, 18); + Float maximumTakerInput = maximumTakerOutput.div(orderIO); + + Float expectedTakerInput = maximumTakerInput.min(ownerDepositAmount); + expectedTakerInput = expectedTakerInput.min(orderLimit); + + Float expectedTakerOutput = expectedTakerInput.mul(orderIO); + + TestVault[] memory testVaults = new TestVault[](2); + testVaults[0] = TestVault({ + owner: owner, + token: address(iToken1), + deposit: ownerDepositAmount, + expect: ownerDepositAmount.sub(expectedTakerInput) + }); + testVaults[1] = + TestVault({owner: owner, token: address(iToken0), deposit: Float.wrap(0), expect: expectedTakerOutput}); + checkTakeOrderMaximumOutput(testOrders, testVaults, maximumTakerOutput, expectedTakerInput, expectedTakerOutput); + } + + /// The taker input can be sourced from multiple orders. Tests two orders + /// that combined make up the maximum taker output. Both orders have the same + /// owner for simplicity. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputMultipleOrders(uint256 ownerDepositAmount18, uint256 maximumTakerOutput18) + external + { + address owner = address(uint160(uint256(keccak256("owner.rain.test")))); + uint256 orderLimit18 = 1500; + + TestOrder[] memory testOrders = new TestOrder[](2); + testOrders[0] = TestOrder({owner: owner, orderString: "_ _: 1000e-18 2;:;"}); + testOrders[1] = TestOrder({owner: owner, orderString: "_ _: 500e-18 2;:;"}); + + ownerDepositAmount18 = bound(ownerDepositAmount18, 0, uint256(int256(type(int224).max))); + maximumTakerOutput18 = bound(maximumTakerOutput18, 1, uint256(int256(type(int224).max))); + + Float orderIO = LibDecimalFloat.fromFixedDecimalLosslessPacked(2, 0); + Float orderLimit = LibDecimalFloat.fromFixedDecimalLosslessPacked(orderLimit18, 18); + Float ownerDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerDepositAmount18, 18); + Float maximumTakerOutput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerOutput18, 18); + Float maximumTakerInput = maximumTakerOutput.div(orderIO); + + Float expectedTakerInput = maximumTakerInput.min(ownerDepositAmount); + expectedTakerInput = expectedTakerInput.min(orderLimit); + Float expectedTakerOutput = expectedTakerInput.mul(orderIO); + + TestVault[] memory testVaults = new TestVault[](2); + testVaults[0] = TestVault({ + owner: owner, + token: address(iToken1), + deposit: ownerDepositAmount, + expect: ownerDepositAmount.sub(expectedTakerInput) + }); + testVaults[1] = + TestVault({owner: owner, token: address(iToken0), deposit: Float.wrap(0), expect: expectedTakerOutput}); + + checkTakeOrderMaximumOutput(testOrders, testVaults, maximumTakerOutput, expectedTakerInput, expectedTakerOutput); + } + + /// The taker input can be sourced from multiple orders with different + /// owners. Tests two orders that combined make up the maximum taker output. + /// forge-config: default.fuzz.runs = 100 + function testTakeOrderMaximumOutputMultipleOrdersDifferentOwners( + uint256 ownerOneDepositAmount18, + uint256 ownerTwoDepositAmount18, + uint256 maximumTakerOutput18 + ) external { + address ownerOne = address(uint160(uint256(keccak256("owner.one.rain.test")))); + address ownerTwo = address(uint160(uint256(keccak256("owner.two.rain.test")))); + + ownerOneDepositAmount18 = bound(ownerOneDepositAmount18, 0, uint256(int256(type(int224).max))); + ownerTwoDepositAmount18 = + bound(ownerTwoDepositAmount18, 0, uint256(int256(type(int224).max)) - ownerOneDepositAmount18); + maximumTakerOutput18 = bound(maximumTakerOutput18, 1, uint256(int256(type(int224).max))); + + TestOrder[] memory testOrders = new TestOrder[](2); + testOrders[0] = TestOrder({owner: ownerOne, orderString: "_ _: 1000e-18 2;:;"}); + testOrders[1] = TestOrder({owner: ownerTwo, orderString: "_ _: 500e-18 2;:;"}); + + // The first owner's deposit is fully used before the second owner's + // deposit is used. + TestVault[] memory testVaults = new TestVault[](2); + + Float ownerOneDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerOneDepositAmount18, 18); + Float ownerTwoDepositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(ownerTwoDepositAmount18, 18); + Float ownerTwoOrderLimit = LibDecimalFloat.fromFixedDecimalLosslessPacked(500, 18); + Float orderIO = LibDecimalFloat.fromFixedDecimalLosslessPacked(2, 0); + Float maximumTakerOutput = LibDecimalFloat.fromFixedDecimalLosslessPacked(maximumTakerOutput18, 18); + Float maximumTakerInput = maximumTakerOutput.div(orderIO); + + Float expectedTakerInput; + Float ownerOneTakerInput; + { + Float ownerOneOrderLimit = LibDecimalFloat.fromFixedDecimalLosslessPacked(1000, 18); + + // Owner one can't pay more than either their deposit or their order + // limit. + Float ownerOneMaxPayment = ownerOneDepositAmount.min(ownerOneOrderLimit); + // Taker input from owner one is either the maximum taker input or + // what owner one can pay. + ownerOneTakerInput = maximumTakerInput.min(ownerOneMaxPayment); + expectedTakerInput = ownerOneTakerInput; + testVaults[0] = TestVault({ + owner: ownerOne, + token: address(iToken1), + deposit: ownerOneDepositAmount, + expect: ownerOneDepositAmount.sub(ownerOneTakerInput) + }); + } + + { + // Owner two can't pay more than either their deposit or their order + // limit. + Float ownerTwoMaxPayment = ownerTwoDepositAmount.min(ownerTwoOrderLimit); + // Taker input from owner two is whatever is remaining after owner + // one, up to what owner two can pay. + Float remainingTakerInput = maximumTakerInput.sub(ownerOneTakerInput); + Float ownerTwoTakerInput = remainingTakerInput.min(ownerTwoMaxPayment); + expectedTakerInput = expectedTakerInput.add(ownerTwoTakerInput); + testVaults[1] = TestVault({ + owner: ownerTwo, + token: address(iToken1), + deposit: ownerTwoDepositAmount, + expect: ownerTwoDepositAmount.sub(ownerTwoTakerInput) + }); + } + Float expectedTakerOutput = expectedTakerInput.mul(orderIO); + checkTakeOrderMaximumOutput(testOrders, testVaults, maximumTakerOutput, expectedTakerInput, expectedTakerOutput); + } +} diff --git a/test/concrete/ob/OrderBook.takeOrder.noop.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.noop.t.sol similarity index 81% rename from test/concrete/ob/OrderBook.takeOrder.noop.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.noop.t.sol index d0c77e3d3b..b9ec487d21 100644 --- a/test/concrete/ob/OrderBook.takeOrder.noop.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.noop.t.sol @@ -5,37 +5,37 @@ pragma solidity =0.8.25; import {Vm} from "forge-std/Test.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; -import {NoOrders} from "src/concrete/ob/OrderBook.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, TakeOrderConfigV4, SignedContextV1, EvaluableV4 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -/// @title OrderBookTakeOrderNoopTest +/// @title OrderBookV6TakeOrderNoopTest /// @notice A test harness for testing the OrderBook takeOrder function. Focuses /// on the no-op case. -contract OrderBookTakeOrderNoopTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderNoopTest is OrderBookV6ExternalRealTest { using LibOrder for OrderV4; using LibDecimalFloat for Float; /// Take orders makes no sense without any orders in the input array and the /// caller has full control over this so we error. function testTakeOrderNoopZeroOrders() external { - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - new TakeOrderConfigV4[](0), - "" - ); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: new TakeOrderConfigV4[](0), + data: "" + }); vm.expectRevert(NoOrders.selector); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); (totalTakerInput, totalTakerOutput); } @@ -66,17 +66,18 @@ contract OrderBookTakeOrderNoopTest is OrderBookExternalRealTest { TakeOrderConfigV4 memory orderConfig = TakeOrderConfigV4(order, inputIOIndex, outputIOIndex, signedContexts); TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](1); orders[0] = orderConfig; - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); vm.expectEmit(address(iOrderbook)); emit OrderNotFound(address(this), order.owner, order.hash()); vm.recordLogs(); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); assertTrue(totalTakerInput.isZero()); assertTrue(totalTakerOutput.isZero()); Vm.Log[] memory logs = vm.getRecordedLogs(); @@ -115,7 +116,7 @@ contract OrderBookTakeOrderNoopTest is OrderBookExternalRealTest { order1.validInputs[inputIOIndex1].token = order2.validInputs[inputIOIndex2].token; order1.validOutputs[outputIOIndex1].token = order2.validOutputs[outputIOIndex2].token; - TakeOrdersConfigV4 memory config; + TakeOrdersConfigV5 memory config; { TakeOrderConfigV4[] memory orders; { @@ -134,18 +135,19 @@ contract OrderBookTakeOrderNoopTest is OrderBookExternalRealTest { orders[1] = orderConfig2; } - config = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ); + config = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); } vm.recordLogs(); { - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); assertTrue(totalTakerInput.isZero()); assertTrue(totalTakerOutput.isZero()); } diff --git a/test/concrete/ob/OrderBook.takeOrder.precision.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.precision.t.sol similarity index 90% rename from test/concrete/ob/OrderBook.takeOrder.precision.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.precision.t.sol index 1e0e883595..3e691dabc1 100644 --- a/test/concrete/ob/OrderBook.takeOrder.precision.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.precision.t.sol @@ -3,23 +3,23 @@ pragma solidity =0.8.25; import {Vm} from "forge-std/Test.sol"; -import {OrderBookExternalRealTest, IERC20} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest, IERC20} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, TakeOrderConfigV4, IOV2, OrderConfigV4, EvaluableV4, SignedContextV1, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; -/// @title OrderBookTakeOrderPrecisionTest +/// @title OrderBookV6TakeOrderPrecisionTest /// @notice A test harness for testing the OrderBook takeOrder function. -contract OrderBookTakeOrderPrecisionTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderPrecisionTest is OrderBookV6ExternalRealTest { using LibDecimalFloat for Float; function checkPrecision( @@ -100,25 +100,26 @@ contract OrderBookTakeOrderPrecisionTest is OrderBookExternalRealTest { { if (expectedTakerTotalInput.gt(LibDecimalFloat.packLossless(0, 0))) { - iOrderbook.deposit3(outputToken, vaultId, expectedTakerTotalInput, new TaskV2[](0)); + iOrderbook.deposit4(outputToken, vaultId, expectedTakerTotalInput, new TaskV2[](0)); } assertTrue(iOrderbook.vaultBalance2(address(this), outputToken, vaultId).eq(expectedTakerTotalInput)); vm.recordLogs(); - iOrderbook.addOrder3(config, new TaskV2[](0)); + iOrderbook.addOrder4(config, new TaskV2[](0)); Vm.Log[] memory entries = vm.getRecordedLogs(); assertEq(entries.length, 1); (,, OrderV4 memory order) = abi.decode(entries[0].data, (address, bytes32, OrderV4)); TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](1); orders[0] = TakeOrderConfigV4(order, 0, 0, new SignedContextV1[](0)); - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4( - LibDecimalFloat.packLossless(0, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - LibDecimalFloat.packLossless(type(int224).max, 0), - orders, - "" - ); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(takeOrdersConfig); + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), + maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, + orders: orders, + data: "" + }); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(takeOrdersConfig); assertTrue(totalTakerInput.eq(expectedTakerTotalInput), "input"); assertTrue(totalTakerOutput.eq(expectedTakerTotalOutput), "output"); } diff --git a/test/concrete/ob/OrderBook.takeOrder.sameToken.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.sameToken.t.sol similarity index 67% rename from test/concrete/ob/OrderBook.takeOrder.sameToken.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.sameToken.t.sol index a606b4785b..f3ca5a6118 100644 --- a/test/concrete/ob/OrderBook.takeOrder.sameToken.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.sameToken.t.sol @@ -2,20 +2,20 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, OrderV4, TaskV2, TakeOrderConfigV4, SignedContextV1, - TakeOrdersConfigV4 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; + TakeOrdersConfigV5 +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; -import {TokenSelfTrade} from "src/concrete/ob/OrderBook.sol"; +import {TokenSelfTrade} from "src/concrete/ob/OrderBookV6.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; -contract OrderBookTakeOrderSameTokenTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderSameTokenTest is OrderBookV6ExternalRealTest { /// forge-config: default.fuzz.runs = 10 function testTakeOrderSameToken(address alice, OrderConfigV4 memory configAlice) external { LibTestAddOrder.conformConfig(configAlice, iInterpreter, iStore); @@ -26,7 +26,7 @@ contract OrderBookTakeOrderSameTokenTest is OrderBookExternalRealTest { OrderV4(alice, configAlice.evaluable, configAlice.validInputs, configAlice.validOutputs, configAlice.nonce); vm.prank(alice); - iOrderbook.addOrder3(configAlice, new TaskV2[](0)); + iOrderbook.addOrder4(configAlice, new TaskV2[](0)); TakeOrderConfigV4[] memory takeOrders = new TakeOrderConfigV4[](1); takeOrders[0] = TakeOrderConfigV4({ @@ -36,15 +36,16 @@ contract OrderBookTakeOrderSameTokenTest is OrderBookExternalRealTest { signedContext: new SignedContextV1[](0) }); - TakeOrdersConfigV4 memory takeOrdersConfig = TakeOrdersConfigV4({ - minimumInput: LibDecimalFloat.packLossless(0, 0), - maximumInput: LibDecimalFloat.packLossless(type(int224).max, 0), + TakeOrdersConfigV5 memory takeOrdersConfig = TakeOrdersConfigV5({ + minimumIO: LibDecimalFloat.packLossless(0, 0), + maximumIO: LibDecimalFloat.packLossless(type(int224).max, 0), maximumIORatio: LibDecimalFloat.packLossless(type(int224).max, 0), + IOIsInput: true, orders: takeOrders, data: "" }); vm.expectRevert(abi.encodeWithSelector(TokenSelfTrade.selector)); - iOrderbook.takeOrders3(takeOrdersConfig); + iOrderbook.takeOrders4(takeOrdersConfig); } } diff --git a/test/concrete/ob/OrderBook.takeOrder.tokenMismatch.t.sol b/test/concrete/ob/OrderBookV6.takeOrder.tokenMismatch.t.sol similarity index 77% rename from test/concrete/ob/OrderBook.takeOrder.tokenMismatch.t.sol rename to test/concrete/ob/OrderBookV6.takeOrder.tokenMismatch.t.sol index 5d07f51026..bc8bf70f55 100644 --- a/test/concrete/ob/OrderBook.takeOrder.tokenMismatch.t.sol +++ b/test/concrete/ob/OrderBookV6.takeOrder.tokenMismatch.t.sol @@ -2,22 +2,22 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderV4, IOV2, TakeOrderConfigV4, - TakeOrdersConfigV4, + TakeOrdersConfigV5, EvaluableV4, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {TokenMismatch} from "src/concrete/ob/OrderBook.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {TokenMismatch} from "src/concrete/ob/OrderBookV6.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; -/// @title OrderBookTakeOrderTokenMismatchTest -/// @notice A test harness for testing the OrderBook takeOrder function. +/// @title OrderBookV6TakeOrderTokenMismatchTest +/// @notice A test harness for testing the OrderBookV6 takeOrder function. /// Focuses on the token mismatch case. -contract OrderBookTakeOrderTokenMismatchTest is OrderBookExternalRealTest { +contract OrderBookV6TakeOrderTokenMismatchTest is OrderBookV6ExternalRealTest { /// It is only possible to get a token mismatch when there are at least two /// orders. This is because `takeOrders` is interactive so we assume that /// the caller's desired input and output tokens match the first order they @@ -55,15 +55,16 @@ contract OrderBookTakeOrderTokenMismatchTest is OrderBookExternalRealTest { TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](2); orders[0] = TakeOrderConfigV4(a, aInputIOIndex, aOutputIOIndex, new SignedContextV1[](0)); orders[1] = TakeOrderConfigV4(b, bInputIOIndex, bOutputIOIndex, new SignedContextV1[](0)); - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - Float.wrap(0), - LibDecimalFloat.fromFixedDecimalLosslessPacked(maxTakerInput18, 18), - LibDecimalFloat.fromFixedDecimalLosslessPacked(maxIORatio, 18), - orders, - "" - ); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: Float.wrap(0), + maximumIO: LibDecimalFloat.fromFixedDecimalLosslessPacked(maxTakerInput18, 18), + maximumIORatio: LibDecimalFloat.fromFixedDecimalLosslessPacked(maxIORatio, 18), + IOIsInput: true, + orders: orders, + data: "" + }); vm.expectRevert(abi.encodeWithSelector(TokenMismatch.selector)); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); (totalTakerInput, totalTakerOutput); } @@ -100,15 +101,16 @@ contract OrderBookTakeOrderTokenMismatchTest is OrderBookExternalRealTest { TakeOrderConfigV4[] memory orders = new TakeOrderConfigV4[](2); orders[0] = TakeOrderConfigV4(a, aInputIOIndex, aOutputIOIndex, new SignedContextV1[](0)); orders[1] = TakeOrderConfigV4(b, bInputIOIndex, bOutputIOIndex, new SignedContextV1[](0)); - TakeOrdersConfigV4 memory config = TakeOrdersConfigV4( - Float.wrap(0), - LibDecimalFloat.fromFixedDecimalLosslessPacked(maxTakerInput18, 18), - LibDecimalFloat.fromFixedDecimalLosslessPacked(maxIORatio18, 18), - orders, - "" - ); + TakeOrdersConfigV5 memory config = TakeOrdersConfigV5({ + minimumIO: Float.wrap(0), + maximumIO: LibDecimalFloat.fromFixedDecimalLosslessPacked(maxTakerInput18, 18), + maximumIORatio: LibDecimalFloat.fromFixedDecimalLosslessPacked(maxIORatio18, 18), + IOIsInput: true, + orders: orders, + data: "" + }); vm.expectRevert(abi.encodeWithSelector(TokenMismatch.selector)); - (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders3(config); + (Float totalTakerInput, Float totalTakerOutput) = iOrderbook.takeOrders4(config); (totalTakerInput, totalTakerOutput); } } diff --git a/test/concrete/ob/OrderBook.vaultBalance.t.sol b/test/concrete/ob/OrderBookV6.vaultBalance.t.sol similarity index 74% rename from test/concrete/ob/OrderBook.vaultBalance.t.sol rename to test/concrete/ob/OrderBookV6.vaultBalance.t.sol index 68856fa1fc..3d2d352d9e 100644 --- a/test/concrete/ob/OrderBook.vaultBalance.t.sol +++ b/test/concrete/ob/OrderBookV6.vaultBalance.t.sol @@ -2,12 +2,12 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalMockTest} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import {OrderBookV6ExternalMockTest} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; -/// @title OrderBookVaultBalanceTest +/// @title OrderBookV6VaultBalanceTest /// Tests the basic functionality of reading from the vault balance. -contract OrderBookVaultBalanceTest is OrderBookExternalMockTest { +contract OrderBookV6VaultBalanceTest is OrderBookV6ExternalMockTest { using LibDecimalFloat for Float; /// Test that reading the vault balance without deposits is always zero. diff --git a/test/concrete/ob/OrderBook.withdraw.entask.t.sol b/test/concrete/ob/OrderBookV6.withdraw.entask.t.sol similarity index 93% rename from test/concrete/ob/OrderBook.withdraw.entask.t.sol rename to test/concrete/ob/OrderBookV6.withdraw.entask.t.sol index 2dfae7464e..95971a36ae 100644 --- a/test/concrete/ob/OrderBook.withdraw.entask.t.sol +++ b/test/concrete/ob/OrderBookV6.withdraw.entask.t.sol @@ -2,41 +2,44 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookExternalRealTest} from "test/util/abstract/OrderBookExternalRealTest.sol"; +import {OrderBookV6ExternalRealTest} from "test/util/abstract/OrderBookV6ExternalRealTest.sol"; import { OrderConfigV4, EvaluableV4, TaskV2, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20} from "forge-std/interfaces/IERC20.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; import {LibFormatDecimalFloat} from "rain.math.float/lib/format/LibFormatDecimalFloat.sol"; +import {ReentrancyGuard} from "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol"; import {console2} from "forge-std/Test.sol"; -contract OrderBookWithdrawEvalTest is OrderBookExternalRealTest { +contract OrderBookV6WithdrawEvalTest is OrderBookV6ExternalRealTest { using Strings for address; using Strings for uint256; using LibDecimalFloat for Float; using LibFormatDecimalFloat for Float; - function checkReentrancyRW(uint256 expectedReads, uint256 expectedWrites) internal { + function checkReentrancyRW(uint256 expectedReads, uint256 expectedWrites) internal view { (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); // 3 reads for reentrancy guard. // 2 reads for deposit. assertEq(reads.length, expectedReads, "reads length"); - assertEq(reads[0], bytes32(uint256(0)), "reads[0]"); - assertEq(reads[1], bytes32(uint256(0)), "reads[1]"); - assertEq(reads[reads.length - 1], bytes32(uint256(0)), "reads[reads.length - 1]"); + // ReentrancyGuard.REENTRANCY_GUARD_STORAGE + bytes32 reentrancyGuardStorage = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; + assertEq(reads[0], reentrancyGuardStorage, "reads[0]"); + assertEq(reads[1], reentrancyGuardStorage, "reads[1]"); + assertEq(reads[reads.length - 1], reentrancyGuardStorage, "reads[reads.length - 1]"); // 2 writes for reentrancy guard. // 1 write for deposit. assertEq(writes.length, expectedWrites, "writes length"); - assertEq(writes[0], bytes32(uint256(0)), "writes[0]"); - assertEq(writes[writes.length - 1], bytes32(uint256(0)), "writes[writes.length - 1]"); + assertEq(writes[0], reentrancyGuardStorage, "writes[0]"); + assertEq(writes[writes.length - 1], reentrancyGuardStorage, "writes[writes.length - 1]"); } function checkWithdraw( @@ -78,7 +81,7 @@ contract OrderBookWithdrawEvalTest is OrderBookExternalRealTest { vm.startPrank(owner); if (depositAmountAbsolute > 0) { - iOrderbook.deposit3(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); } } @@ -112,7 +115,7 @@ contract OrderBookWithdrawEvalTest is OrderBookExternalRealTest { withdrawAmount18 ); } - iOrderbook.withdraw3(address(iToken0), vaultId, targetAmount, actions); + iOrderbook.withdraw4(address(iToken0), vaultId, targetAmount, actions); if (err.length == 0) { checkReentrancyRW(6, 3); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iStore)); @@ -309,7 +312,7 @@ contract OrderBookWithdrawEvalTest is OrderBookExternalRealTest { abi.encodeWithSelector(IERC20.transferFrom.selector, alice, address(iOrderbook), depositAmount18), abi.encode(true) ); - iOrderbook.deposit3(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); vm.mockCall( address(iToken0), @@ -324,7 +327,7 @@ contract OrderBookWithdrawEvalTest is OrderBookExternalRealTest { assertTrue(depositAmount.eq(iOrderbook.vaultBalance2(alice, address(iToken0), vaultId))); vm.expectRevert("revert in action"); - iOrderbook.withdraw3(address(iToken0), vaultId, withdrawAmount, actions); + iOrderbook.withdraw4(address(iToken0), vaultId, withdrawAmount, actions); assertTrue(depositAmount.eq(iOrderbook.vaultBalance2(alice, address(iToken0), vaultId))); } diff --git a/test/concrete/ob/OrderBook.withdraw.t.sol b/test/concrete/ob/OrderBookV6.withdraw.t.sol similarity index 90% rename from test/concrete/ob/OrderBook.withdraw.t.sol rename to test/concrete/ob/OrderBookV6.withdraw.t.sol index 67ce30abaa..2359720887 100644 --- a/test/concrete/ob/OrderBook.withdraw.t.sol +++ b/test/concrete/ob/OrderBookV6.withdraw.t.sol @@ -6,17 +6,20 @@ import {Test} from "forge-std/Test.sol"; import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol"; -import {OrderBookExternalMockTest, REVERTING_MOCK_BYTECODE} from "test/util/abstract/OrderBookExternalMockTest.sol"; +import { + OrderBookV6ExternalMockTest, REVERTING_MOCK_BYTECODE +} from "test/util/abstract/OrderBookV6ExternalMockTest.sol"; import {Reenteroor, IERC20} from "test/util/concrete/Reenteroor.sol"; -import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol"; import {LibDecimalFloatImplementation} from "rain.math.float/lib/implementation/LibDecimalFloatImplementation.sol"; +import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; -/// @title OrderBookWithdrawTest +/// @title OrderBookV6WithdrawTest /// Tests withdrawing from the order book. -contract OrderBookWithdrawTest is OrderBookExternalMockTest { +contract OrderBookV6WithdrawTest is OrderBookV6ExternalMockTest { using Math for uint256; using LibDecimalFloat for Float; @@ -30,7 +33,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { function testWithdrawZero(address alice, address token, bytes32 vaultId) external { vm.prank(alice); vm.expectRevert(abi.encodeWithSelector(ZeroWithdrawTargetAmount.selector, alice, token, vaultId)); - iOrderbook.withdraw3(token, vaultId, Float.wrap(0), new TaskV2[](0)); + iOrderbook.withdraw4(token, vaultId, Float.wrap(0), new TaskV2[](0)); } /// Withdrawing a non-zero amount from an empty vault should be a noop. @@ -42,7 +45,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { vm.expectEmit(false, false, false, true); emit WithdrawV2(alice, address(iToken0), vaultId, amount, Float.wrap(0), 0); vm.record(); - iOrderbook.withdraw3(address(iToken0), vaultId, amount, new TaskV2[](0)); + iOrderbook.withdraw4(address(iToken0), vaultId, amount, new TaskV2[](0)); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); assertEq(reads.length, 6, "reads"); assertEq(writes.length, 3, "writes"); @@ -65,7 +68,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { Float depositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(depositAmount18, 18); Float withdrawAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(withdrawAmount18, 18); - iOrderbook.deposit3(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); assertTrue(iOrderbook.vaultBalance2(address(alice), address(iToken0), vaultId).eq(depositAmount)); vm.prank(alice); @@ -74,7 +77,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { ); vm.expectEmit(false, false, false, true); emit WithdrawV2(alice, address(iToken0), vaultId, withdrawAmount, depositAmount, depositAmount18); - iOrderbook.withdraw3(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); + iOrderbook.withdraw4(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); assertTrue(iOrderbook.vaultBalance2(address(alice), address(iToken0), vaultId).isZero(), "vault balance"); } @@ -95,7 +98,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { Float depositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(depositAmount18, 18); Float withdrawAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(withdrawAmount18, 18); - iOrderbook.deposit3(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); assertTrue(iOrderbook.vaultBalance2(address(alice), address(iToken0), vaultId).eq(depositAmount)); vm.prank(alice); @@ -107,7 +110,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { vm.expectEmit(false, false, false, true); // The full withdraw amount is possible as it's only a partial withdraw. emit WithdrawV2(alice, address(iToken0), vaultId, withdrawAmount, withdrawAmount, withdrawAmount18); - iOrderbook.withdraw3(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); + iOrderbook.withdraw4(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); // The vault balance is reduced by the withdraw amount. assertTrue( iOrderbook.vaultBalance2(address(alice), address(iToken0), vaultId).eq(depositAmount.sub(withdrawAmount)) @@ -129,13 +132,13 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { ); Float depositAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(depositAmount18, 18); Float withdrawAmount = LibDecimalFloat.fromFixedDecimalLosslessPacked(withdrawAmount18, 18); - iOrderbook.deposit3(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); + iOrderbook.deposit4(address(iToken0), vaultId, depositAmount, new TaskV2[](0)); assertTrue(iOrderbook.vaultBalance2(address(alice), address(iToken0), vaultId).eq(depositAmount)); // The token contract always reverts when not mocked. vm.prank(alice); - vm.expectRevert("SafeERC20: low-level call failed"); - iOrderbook.withdraw3(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); + vm.expectRevert(); + iOrderbook.withdraw4(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); vm.prank(alice); vm.mockCall( @@ -143,8 +146,8 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { abi.encodeWithSelector(IERC20.transfer.selector, alice, withdrawAmount18.min(depositAmount18)), abi.encode(false) ); - vm.expectRevert("SafeERC20: ERC20 operation did not succeed"); - iOrderbook.withdraw3(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); + vm.expectRevert(abi.encodeWithSelector(SafeERC20.SafeERC20FailedOperation.selector, address(iToken0))); + iOrderbook.withdraw4(address(iToken0), vaultId, withdrawAmount, new TaskV2[](0)); } /// Defines an action that can be taken in withdrawal tests. @@ -211,7 +214,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { vm.expectEmit(false, false, false, true); emit DepositV2(action.alice, action.token, action.vaultId, action.amount); - iOrderbook.deposit3(action.token, action.vaultId, action.amountFloat, new TaskV2[](0)); + iOrderbook.deposit4(action.token, action.vaultId, action.amountFloat, new TaskV2[](0)); assertTrue( iOrderbook.vaultBalance2(action.alice, action.token, action.vaultId).eq( balance.add(action.amountFloat) @@ -241,7 +244,7 @@ contract OrderBookWithdrawTest is OrderBookExternalMockTest { expectedActualAmount18 ); } - iOrderbook.withdraw3(action.token, action.vaultId, action.amountFloat, new TaskV2[](0)); + iOrderbook.withdraw4(action.token, action.vaultId, action.amountFloat, new TaskV2[](0)); assertTrue( iOrderbook.vaultBalance2(action.alice, action.token, action.vaultId).eq( balance.sub(expectedActualAmount) diff --git a/test/concrete/parser/OrderBookSubParser.contextCalculatedIORatio.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextCalculatedIORatio.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextCalculatedIORatio.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextCalculatedIORatio.t.sol index 5619982605..ac9a80ffcc 100644 --- a/test/concrete/parser/OrderBookSubParser.contextCalculatedIORatio.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextCalculatedIORatio.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextCalculatedIORatioTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextCalculatedIORatioTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "calculated-io-ratio"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextCalculatedMaxOutput.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextCalculatedMaxOutput.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextCalculatedMaxOutput.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextCalculatedMaxOutput.t.sol index 387cafaf93..b0a2816734 100644 --- a/test/concrete/parser/OrderBookSubParser.contextCalculatedMaxOutput.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextCalculatedMaxOutput.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextCalculatedMaxOutputTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextCalculatedMaxOutputTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "calculated-max-output"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextInputToken.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextInputToken.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextInputToken.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextInputToken.t.sol index 329775729b..61fb0af35f 100644 --- a/test/concrete/parser/OrderBookSubParser.contextInputToken.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextInputToken.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextInputTokenTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextInputTokenTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "input-token"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextInputTokenDecimals.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextInputTokenDecimals.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextInputTokenDecimals.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextInputTokenDecimals.t.sol index bfcd54b558..ebb396827d 100644 --- a/test/concrete/parser/OrderBookSubParser.contextInputTokenDecimals.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextInputTokenDecimals.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextInputTokenDecimalsTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextInputTokenDecimalsTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "input-token-decimals"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceBefore.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceBefore.t.sol similarity index 56% rename from test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceBefore.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceBefore.t.sol index 6be948e08e..8302fc2c56 100644 --- a/test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceBefore.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceBefore.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextVaultBalanceBeforeTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextInputVaultBalanceBeforeTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "input-vault-before"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceIncrease.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceIncrease.t.sol similarity index 56% rename from test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceIncrease.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceIncrease.t.sol index c8026913a0..996c58ff70 100644 --- a/test/concrete/parser/OrderBookSubParser.contextInputVaultBalanceIncrease.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultBalanceIncrease.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextInputVaultBalanceIncreaseTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextInputVaultBalanceIncreaseTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "input-vault-increase"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextInputVaultId.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultId.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextInputVaultId.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextInputVaultId.t.sol index 88a00f9df2..fc80c44981 100644 --- a/test/concrete/parser/OrderBookSubParser.contextInputVaultId.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextInputVaultId.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderBookTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextInputVaultIdTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "input-vault-id"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOrderBook.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOrderBook.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOrderBook.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOrderBook.t.sol index 73e0d9cdcb..24a536891d 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOrderBook.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOrderBook.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderBookTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOrderBookTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "orderbook"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOrderClearer.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOrderClearer.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOrderClearer.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOrderClearer.t.sol index e488a967fe..b01cd5ebdf 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOrderClearer.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOrderClearer.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderClearerTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOrderClearerTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "order-clearer"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOrderCounterparty.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOrderCounterparty.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOrderCounterparty.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOrderCounterparty.t.sol index 3d596177c3..543c1093ca 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOrderCounterparty.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOrderCounterparty.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderCounterpartyTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOrderCounterpartyTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "order-counterparty"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOrderHash.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOrderHash.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOrderHash.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOrderHash.t.sol index 791ce726d2..f6132173e5 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOrderHash.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOrderHash.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderHashTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOrderHashTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "order-hash"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOrderOwner.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOrderOwner.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOrderOwner.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOrderOwner.t.sol index ad66c601e6..ce5ad54dc0 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOrderOwner.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOrderOwner.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderOwnerTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOrderOwnerTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "order-owner"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOutputToken.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOutputToken.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOutputToken.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOutputToken.t.sol index c5970ef602..5d8e3c1a12 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOutputToken.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOutputToken.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOutputTokenTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOutputTokenTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "output-token"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOutputTokenDecimals.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOutputTokenDecimals.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOutputTokenDecimals.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOutputTokenDecimals.t.sol index 6874cf6d8a..44c539b786 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOutputTokenDecimals.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOutputTokenDecimals.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOutputTokenDecimalsTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOutputTokenDecimalsTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "output-token-decimals"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceBefore.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceBefore.t.sol similarity index 56% rename from test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceBefore.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceBefore.t.sol index ec8fbeb2fb..e19466e653 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceBefore.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceBefore.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOutputVaultBalanceBeforeTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOutputVaultBalanceBeforeTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "output-vault-before"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceDecrease.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceDecrease.t.sol similarity index 56% rename from test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceDecrease.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceDecrease.t.sol index 538f996ae1..1774ff6f64 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOutputVaultBalanceDecrease.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultBalanceDecrease.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOutputVaultBalanceDecreaseTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOutputVaultBalanceDecreaseTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "output-vault-decrease"; } diff --git a/test/concrete/parser/OrderBookSubParser.contextOutputVaultId.t.sol b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultId.t.sol similarity index 57% rename from test/concrete/parser/OrderBookSubParser.contextOutputVaultId.t.sol rename to test/concrete/parser/OrderBookV6SubParser.contextOutputVaultId.t.sol index 8f26fe3481..3cc0b8d7b9 100644 --- a/test/concrete/parser/OrderBookSubParser.contextOutputVaultId.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.contextOutputVaultId.t.sol @@ -2,9 +2,9 @@ // SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd pragma solidity =0.8.25; -import {OrderBookSubParserContextTest} from "test/util/abstract/OrderBookSubParserContextTest.sol"; +import {OrderBookV6SubParserContextTest} from "test/util/abstract/OrderBookV6SubParserContextTest.sol"; -contract OrderBookSubParserContextOrderBookTest is OrderBookSubParserContextTest { +contract OrderBookV6SubParserContextOutputVaultIdTest is OrderBookV6SubParserContextTest { function word() internal pure override returns (string memory) { return "output-vault-id"; } diff --git a/test/concrete/parser/OrderBookSubParser.describedByMeta.t.sol b/test/concrete/parser/OrderBookV6SubParser.describedByMeta.t.sol similarity index 51% rename from test/concrete/parser/OrderBookSubParser.describedByMeta.t.sol rename to test/concrete/parser/OrderBookV6SubParser.describedByMeta.t.sol index 8f2b7b52eb..9b51f7abd2 100644 --- a/test/concrete/parser/OrderBookSubParser.describedByMeta.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.describedByMeta.t.sol @@ -3,12 +3,12 @@ pragma solidity =0.8.25; import {Test} from "forge-std/Test.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; -contract OrderBookSubParserDescribedByMetaV1Test is Test { - function testOrderBookSubParserDescribedByMetaV1Happy() external { - bytes memory describedByMeta = vm.readFileBinary("meta/OrderBookSubParser.rain.meta"); - OrderBookSubParser subParser = new OrderBookSubParser(); +contract OrderBookV6SubParserDescribedByMetaV1Test is Test { + function testOrderBookV6SubParserDescribedByMetaV1Happy() external { + bytes memory describedByMeta = vm.readFileBinary("meta/OrderBookV6SubParser.rain.meta"); + OrderBookV6SubParser subParser = new OrderBookV6SubParser(); assertEq(keccak256(describedByMeta), subParser.describedByMetaV1()); } diff --git a/test/concrete/parser/OrderBookSubParser.ierc165.t.sol b/test/concrete/parser/OrderBookV6SubParser.ierc165.t.sol similarity index 83% rename from test/concrete/parser/OrderBookSubParser.ierc165.t.sol rename to test/concrete/parser/OrderBookV6SubParser.ierc165.t.sol index 648d8ceec3..9bf26037f3 100644 --- a/test/concrete/parser/OrderBookSubParser.ierc165.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.ierc165.t.sol @@ -5,21 +5,21 @@ pragma solidity =0.8.25; import {Test} from "forge-std/Test.sol"; import {IERC165} from "openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {ISubParserV4} from "rain.interpreter.interface/interface/unstable/ISubParserV4.sol"; import {IDescribedByMetaV1} from "rain.metadata/interface/IDescribedByMetaV1.sol"; import {IParserToolingV1} from "rain.sol.codegen/interface/IParserToolingV1.sol"; import {ISubParserToolingV1} from "rain.sol.codegen/interface/ISubParserToolingV1.sol"; -contract OrderBookSubParserIERC165Test is Test { - function testOrderBookSubParserIERC165(bytes4 badInterfaceId) external { +contract OrderBookV6SubParserIERC165Test is Test { + function testOrderBookV6SubParserIERC165(bytes4 badInterfaceId) external { vm.assume(badInterfaceId != type(IERC165).interfaceId); vm.assume(badInterfaceId != type(ISubParserV4).interfaceId); vm.assume(badInterfaceId != type(IDescribedByMetaV1).interfaceId); vm.assume(badInterfaceId != type(IParserToolingV1).interfaceId); vm.assume(badInterfaceId != type(ISubParserToolingV1).interfaceId); - OrderBookSubParser subParser = new OrderBookSubParser(); + OrderBookV6SubParser subParser = new OrderBookV6SubParser(); assertTrue(subParser.supportsInterface(type(IERC165).interfaceId)); assertTrue(subParser.supportsInterface(type(ISubParserV4).interfaceId)); assertTrue(subParser.supportsInterface(type(IDescribedByMetaV1).interfaceId)); diff --git a/test/concrete/parser/OrderBookSubParser.pointers.t.sol b/test/concrete/parser/OrderBookV6SubParser.pointers.t.sol similarity index 86% rename from test/concrete/parser/OrderBookSubParser.pointers.t.sol rename to test/concrete/parser/OrderBookV6SubParser.pointers.t.sol index 84d1ce8ed2..d7cd6cbd28 100644 --- a/test/concrete/parser/OrderBookSubParser.pointers.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.pointers.t.sol @@ -8,11 +8,11 @@ import { SUB_PARSER_PARSE_META, SUB_PARSER_WORD_PARSERS, SUB_PARSER_OPERAND_HANDLERS, - OrderBookSubParser -} from "src/concrete/parser/OrderBookSubParser.sol"; + OrderBookV6SubParser +} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {LibGenParseMeta} from "rain.interpreter.interface/lib/codegen/LibGenParseMeta.sol"; -contract OrderBookSubParserPointersTest is Test { +contract OrderBookV6SubParserPointersTest is Test { function testSubParserParseMeta() external pure { bytes memory authoringMetaBytes = LibOrderBookSubParser.authoringMetaV2(); AuthoringMetaV2[] memory authoringMeta = abi.decode(authoringMetaBytes, (AuthoringMetaV2[])); @@ -22,14 +22,14 @@ contract OrderBookSubParserPointersTest is Test { } function testSubParserFunctionPointers() external { - OrderBookSubParser extern = new OrderBookSubParser(); + OrderBookV6SubParser extern = new OrderBookV6SubParser(); bytes memory expected = extern.buildSubParserWordParsers(); bytes memory actual = SUB_PARSER_WORD_PARSERS; assertEq(actual, expected); } function testSubParserOperandParsers() external { - OrderBookSubParser extern = new OrderBookSubParser(); + OrderBookV6SubParser extern = new OrderBookV6SubParser(); bytes memory expected = extern.buildOperandHandlerFunctionPointers(); bytes memory actual = SUB_PARSER_OPERAND_HANDLERS; assertEq(actual, expected); diff --git a/test/concrete/parser/OrderBookSubParser.signedContext.t.sol b/test/concrete/parser/OrderBookV6SubParser.signedContext.t.sol similarity index 85% rename from test/concrete/parser/OrderBookSubParser.signedContext.t.sol rename to test/concrete/parser/OrderBookV6SubParser.signedContext.t.sol index 5532a691e1..bcda85f208 100644 --- a/test/concrete/parser/OrderBookSubParser.signedContext.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.signedContext.t.sol @@ -6,15 +6,15 @@ import {StackAllocationMismatch} from "rain.interpreter/error/ErrIntegrity.sol"; import {ExpectedOperand, UnexpectedOperandValue} from "rain.interpreter/error/ErrParse.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; import {OpTest, StackItem} from "rain.interpreter/../test/abstract/OpTest.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {LibOrderBookSubParserContextFixture} from "test/util/fixture/LibOrderBookSubParserContextFixture.sol"; -contract OrderBookSubParserSignedContextTest is OpTest { +contract OrderBookV6SubParserSignedContextTest is OpTest { using Strings for address; /// Test signed-context-0-0 function testSubParserContextSignedContextHappy0() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signed-context-0-0"))); @@ -30,7 +30,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context-0-1 function testSubParserContextSignedContextHappy1() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signed-context-0-1"))); @@ -46,7 +46,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context-1-0 function testSubParserContextSignedContextHappy2() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signed-context-1-0"))); @@ -62,7 +62,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context-1-1 function testSubParserContextSignedContextHappy3() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signed-context-1-1"))); @@ -78,7 +78,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context without an operand errors. function testSubParserContextSignedContextUnhappyNoOperand() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes( string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: signed-context();") @@ -89,7 +89,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context with too many operands errors. function testSubParserContextSignedContextUnhappyTooManyOperands() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes( string.concat( @@ -102,7 +102,7 @@ contract OrderBookSubParserSignedContextTest is OpTest { /// Test signed-context with an input errors. function testSubParserContextSignedContextUnhappyInput() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes( string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: signed-context<0 0>(0);") diff --git a/test/concrete/parser/OrderBookSubParser.signers.t.sol b/test/concrete/parser/OrderBookV6SubParser.signers.t.sol similarity index 83% rename from test/concrete/parser/OrderBookSubParser.signers.t.sol rename to test/concrete/parser/OrderBookV6SubParser.signers.t.sol index f8f0e115b0..93c61b3bcb 100644 --- a/test/concrete/parser/OrderBookSubParser.signers.t.sol +++ b/test/concrete/parser/OrderBookV6SubParser.signers.t.sol @@ -6,15 +6,15 @@ import {StackAllocationMismatch} from "rain.interpreter/error/ErrIntegrity.sol"; import {ExpectedOperand, UnexpectedOperandValue} from "rain.interpreter/error/ErrParse.sol"; import {OpTest, StackItem} from "rain.interpreter/../test/abstract/OpTest.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {LibOrderBookSubParserContextFixture} from "test/util/fixture/LibOrderBookSubParserContextFixture.sol"; -contract OrderBookSubParserSignersTest is OpTest { +contract OrderBookV6SubParserSignersTest is OpTest { using Strings for address; /// Test signer-0 function testSubParserContextSignerHappy0() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signer-0"))); @@ -27,7 +27,7 @@ contract OrderBookSubParserSignersTest is OpTest { /// Test signer-1 function testSubParserContextSignerHappy1() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes("signer-1"))); @@ -40,7 +40,7 @@ contract OrderBookSubParserSignersTest is OpTest { /// Test signer without an operand errors. function testSubParserContextSignerUnhappyNoOperand() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes(string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: signer();")); @@ -50,7 +50,7 @@ contract OrderBookSubParserSignersTest is OpTest { /// Test signer with too many operands errors. function testSubParserContextSignerUnhappyTooManyOperands() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes(string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: signer<0 1>();")); @@ -60,7 +60,7 @@ contract OrderBookSubParserSignersTest is OpTest { /// Test signer with an input errors. function testSubParserContextSignerUnhappyInput() external { - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes(string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: signer<0>(0);")); diff --git a/test/util/abstract/ArbTest.sol b/test/util/abstract/ArbTest.sol index 6abec678d8..8467986e45 100644 --- a/test/util/abstract/ArbTest.sol +++ b/test/util/abstract/ArbTest.sol @@ -17,8 +17,8 @@ import { SignedContextV1, EvaluableV4 } from "test/util/concrete/FlashLendingMockOrderBook.sol"; -import {OrderBookV5ArbConfig} from "src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol"; -import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {OrderBookV6ArbConfig} from "src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol"; +import {TaskV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IInterpreterV4} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; import {TOFUTokenDecimals, LibTOFUTokenDecimals} from "rain.tofu.erc20-decimals/concrete/TOFUTokenDecimals.sol"; @@ -41,14 +41,14 @@ abstract contract ArbTest is Test { FlashLendingMockOrderBook immutable iOrderBook; address immutable iArb; - /// Mimics the `Construct` event from `OrderBookV5ArbCommon`. - event Construct(address sender, OrderBookV5ArbConfig config); + /// Mimics the `Construct` event from `OrderBookV6ArbCommon`. + event Construct(address sender, OrderBookV6ArbConfig config); function expression() internal virtual returns (bytes memory) { return ""; } - function buildArb(OrderBookV5ArbConfig memory config) internal virtual returns (address); + function buildArb(OrderBookV6ArbConfig memory config) internal virtual returns (address); constructor() { // Put the TOFU decimals contract in place so that any calls to it @@ -69,7 +69,7 @@ abstract contract ArbTest is Test { iOrderBook = new FlashLendingMockOrderBook(); vm.label(address(iOrderBook), "iOrderBook"); - OrderBookV5ArbConfig memory config = OrderBookV5ArbConfig( + OrderBookV6ArbConfig memory config = OrderBookV6ArbConfig( address(iOrderBook), TaskV2({ evaluable: EvaluableV4(iInterpreter, iInterpreterStore, expression()), diff --git a/test/util/abstract/GenericPoolOrderBookV5ArbOrderTakerTest.sol b/test/util/abstract/GenericPoolOrderBookV5ArbOrderTakerTest.sol deleted file mode 100644 index 658b4a124b..0000000000 --- a/test/util/abstract/GenericPoolOrderBookV5ArbOrderTakerTest.sol +++ /dev/null @@ -1,17 +0,0 @@ -// SPDX-License-Identifier: LicenseRef-DCL-1.0 -// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd -pragma solidity =0.8.25; - -import {ArbTest} from "./ArbTest.sol"; -import { - GenericPoolOrderBookV5ArbOrderTaker, - OrderBookV5ArbConfig -} from "src/concrete/arb/GenericPoolOrderBookV5ArbOrderTaker.sol"; - -contract GenericPoolOrderBookV5ArbOrderTakerTest is ArbTest { - function buildArb(OrderBookV5ArbConfig memory config) internal override returns (address) { - return address(new GenericPoolOrderBookV5ArbOrderTaker(config)); - } - - constructor() ArbTest() {} -} diff --git a/test/util/abstract/GenericPoolOrderBookV6ArbOrderTakerTest.sol b/test/util/abstract/GenericPoolOrderBookV6ArbOrderTakerTest.sol new file mode 100644 index 0000000000..6b217e2593 --- /dev/null +++ b/test/util/abstract/GenericPoolOrderBookV6ArbOrderTakerTest.sol @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: LicenseRef-DCL-1.0 +// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd +pragma solidity =0.8.25; + +import {ArbTest} from "./ArbTest.sol"; +import { + GenericPoolOrderBookV6ArbOrderTaker, + OrderBookV6ArbConfig +} from "src/concrete/arb/GenericPoolOrderBookV6ArbOrderTaker.sol"; + +contract GenericPoolOrderBookV6ArbOrderTakerTest is ArbTest { + function buildArb(OrderBookV6ArbConfig memory config) internal override returns (address) { + return address(new GenericPoolOrderBookV6ArbOrderTaker(config)); + } + + constructor() ArbTest() {} +} diff --git a/test/util/abstract/IOrderBookV5Stub.sol b/test/util/abstract/IOrderBookV6Stub.sol similarity index 72% rename from test/util/abstract/IOrderBookV5Stub.sol rename to test/util/abstract/IOrderBookV6Stub.sol index 49e1e610d2..28bec54a30 100644 --- a/test/util/abstract/IOrderBookV5Stub.sol +++ b/test/util/abstract/IOrderBookV6Stub.sol @@ -3,47 +3,47 @@ pragma solidity =0.8.25; import { - IOrderBookV5, + IOrderBookV6, OrderConfigV4, OrderV4, ClearConfigV2, SignedContextV1, - TakeOrdersConfigV4, + TakeOrdersConfigV5, EvaluableV4, TaskV2, QuoteV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC3156FlashLender} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashLender.sol"; import {IERC3156FlashBorrower} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; -abstract contract IOrderBookV5Stub is IOrderBookV5 { - /// @inheritdoc IOrderBookV5 +abstract contract IOrderBookV6Stub is IOrderBookV6 { + /// @inheritdoc IOrderBookV6 function entask2(TaskV2[] calldata) external pure { revert("eval"); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function quote2(QuoteV2 calldata) external pure returns (bool, Float, Float) { revert("quote"); } - /// @inheritdoc IOrderBookV5 - function addOrder3(OrderConfigV4 calldata, TaskV2[] calldata) external pure returns (bool) { + /// @inheritdoc IOrderBookV6 + function addOrder4(OrderConfigV4 calldata, TaskV2[] calldata) external pure returns (bool) { revert("addOrder"); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function orderExists(bytes32) external pure returns (bool) { revert("orderExists"); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function removeOrder3(OrderV4 calldata, TaskV2[] calldata) external pure returns (bool) { revert("removeOrder"); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function clear3( OrderV4 memory, OrderV4 memory, @@ -54,23 +54,23 @@ abstract contract IOrderBookV5Stub is IOrderBookV5 { revert("clear"); } - /// @inheritdoc IOrderBookV5 - function deposit3(address, bytes32, Float, TaskV2[] calldata) external pure { + /// @inheritdoc IOrderBookV6 + function deposit4(address, bytes32, Float, TaskV2[] calldata) external pure { revert("deposit"); } - /// @inheritdoc IOrderBookV5 - function takeOrders3(TakeOrdersConfigV4 calldata) external pure returns (Float, Float) { + /// @inheritdoc IOrderBookV6 + function takeOrders4(TakeOrdersConfigV5 calldata) external pure returns (Float, Float) { revert("takeOrders"); } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function vaultBalance2(address, address, bytes32) external pure returns (Float) { revert("vaultBalance"); } - /// @inheritdoc IOrderBookV5 - function withdraw3(address, bytes32, Float, TaskV2[] calldata) external pure { + /// @inheritdoc IOrderBookV6 + function withdraw4(address, bytes32, Float, TaskV2[] calldata) external pure { revert("withdraw"); } diff --git a/test/util/abstract/OrderBookExternalMockTest.sol b/test/util/abstract/OrderBookV6ExternalMockTest.sol similarity index 90% rename from test/util/abstract/OrderBookExternalMockTest.sol rename to test/util/abstract/OrderBookV6ExternalMockTest.sol index 51a5dbec82..f41ce0e264 100644 --- a/test/util/abstract/OrderBookExternalMockTest.sol +++ b/test/util/abstract/OrderBookV6ExternalMockTest.sol @@ -7,21 +7,21 @@ import {Test} from "forge-std/Test.sol"; import {IMetaV1_2} from "rain.metadata/lib/LibMeta.sol"; import {REVERTING_MOCK_BYTECODE} from "test/util/lib/LibTestConstants.sol"; -import {IOrderBookV5Stub} from "test/util/abstract/IOrderBookV5Stub.sol"; +import {IOrderBookV6Stub} from "test/util/abstract/IOrderBookV6Stub.sol"; import {LibTestAddOrder} from "test/util/lib/LibTestAddOrder.sol"; import {IInterpreterV4} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; import { - IOrderBookV5, OrderConfigV4, OrderV4, TaskV2 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; + IOrderBookV6, OrderConfigV4, OrderV4, TaskV2 +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -import {OrderBook} from "src/concrete/ob/OrderBook.sol"; +import {OrderBookV6} from "src/concrete/ob/OrderBookV6.sol"; import {EvaluableV4} from "rain.interpreter.interface/interface/unstable/IInterpreterCallerV4.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {TOFUTokenDecimals, LibTOFUTokenDecimals} from "rain.tofu.erc20-decimals/concrete/TOFUTokenDecimals.sol"; -/// @title OrderBookExternalTest +/// @title OrderBookV6ExternalTest /// Abstract contract that performs common setup needed for testing an orderbook /// from its external interface. /// @@ -31,11 +31,11 @@ import {TOFUTokenDecimals, LibTOFUTokenDecimals} from "rain.tofu.erc20-decimals/ /// - Deploys a mockable deployer contract for a DISpair. /// /// Inherits from Test so that it can be used as a base contract for other tests. -/// Implements IOrderBookV5 so that it has access to all the relevant events. -abstract contract OrderBookExternalMockTest is Test, IMetaV1_2, IOrderBookV5Stub { +/// Implements IOrderBookV6 so that it has access to all the relevant events. +abstract contract OrderBookV6ExternalMockTest is Test, IMetaV1_2, IOrderBookV6Stub { IInterpreterV4 immutable iInterpreter; IInterpreterStoreV3 immutable iStore; - IOrderBookV5 immutable iOrderbook; + IOrderBookV6 immutable iOrderbook; IERC20 immutable iToken0; IERC20 immutable iToken1; @@ -50,7 +50,7 @@ abstract contract OrderBookExternalMockTest is Test, IMetaV1_2, IOrderBookV5Stub vm.etch(address(iInterpreter), REVERTING_MOCK_BYTECODE); iStore = IInterpreterStoreV3(address(uint160(uint256(keccak256("store.rain.test"))))); vm.etch(address(iStore), REVERTING_MOCK_BYTECODE); - iOrderbook = IOrderBookV5(address(new OrderBook())); + iOrderbook = IOrderBookV6(address(new OrderBookV6())); iToken0 = IERC20(address(uint160(uint256(keccak256("token0.rain.test"))))); vm.etch(address(iToken0), REVERTING_MOCK_BYTECODE); @@ -79,7 +79,7 @@ abstract contract OrderBookExternalMockTest is Test, IMetaV1_2, IOrderBookV5Stub vm.record(); vm.recordLogs(); vm.prank(owner); - assertTrue(iOrderbook.addOrder3(config, new TaskV2[](0))); + assertTrue(iOrderbook.addOrder4(config, new TaskV2[](0))); // MetaV1 is NOT emitted if the meta is empty. assertEq(vm.getRecordedLogs().length, config.meta.length > 0 ? 2 : 1); (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(iOrderbook)); @@ -96,7 +96,7 @@ abstract contract OrderBookExternalMockTest is Test, IMetaV1_2, IOrderBookV5Stub vm.record(); vm.recordLogs(); vm.prank(owner); - assertFalse(iOrderbook.addOrder3(config, new TaskV2[](0))); + assertFalse(iOrderbook.addOrder4(config, new TaskV2[](0))); assertEq(vm.getRecordedLogs().length, 0); (reads, writes) = vm.accesses(address(iOrderbook)); // 3x for reentrancy guard, 1x for dead order check. diff --git a/test/util/abstract/OrderBookExternalRealTest.sol b/test/util/abstract/OrderBookV6ExternalRealTest.sol similarity index 87% rename from test/util/abstract/OrderBookExternalRealTest.sol rename to test/util/abstract/OrderBookV6ExternalRealTest.sol index 2e7b7ddde0..3dab4d9517 100644 --- a/test/util/abstract/OrderBookExternalRealTest.sol +++ b/test/util/abstract/OrderBookV6ExternalRealTest.sol @@ -11,32 +11,32 @@ import { } from "rain.interpreter/concrete/RainterpreterExpressionDeployer.sol"; import {LibAllStandardOps} from "rain.interpreter/lib/op/LibAllStandardOps.sol"; import {REVERTING_MOCK_BYTECODE} from "test/util/lib/LibTestConstants.sol"; -import {IOrderBookV5Stub} from "test/util/abstract/IOrderBookV5Stub.sol"; +import {IOrderBookV6Stub} from "test/util/abstract/IOrderBookV6Stub.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; import {IParserV2} from "rain.interpreter.interface/interface/IParserV2.sol"; import { - IOrderBookV5, + IOrderBookV6, IInterpreterV4, TaskV2, EvaluableV4, SignedContextV1 -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; -import {OrderBook, IERC20} from "src/concrete/ob/OrderBook.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; +import {OrderBookV6, IERC20} from "src/concrete/ob/OrderBookV6.sol"; import {RainterpreterParser} from "rain.interpreter/concrete/RainterpreterParser.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {IERC20Metadata} from "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {LibDecimalFloat, Float} from "rain.math.float/lib/LibDecimalFloat.sol"; import {TOFUTokenDecimals, LibTOFUTokenDecimals} from "rain.tofu.erc20-decimals/concrete/TOFUTokenDecimals.sol"; -abstract contract OrderBookExternalRealTest is Test, IOrderBookV5Stub { +abstract contract OrderBookV6ExternalRealTest is Test, IOrderBookV6Stub { IInterpreterV4 internal immutable iInterpreter; IInterpreterStoreV3 internal immutable iStore; RainterpreterParser internal immutable iParser; IParserV2 internal immutable iParserV2; - IOrderBookV5 internal immutable iOrderbook; + IOrderBookV6 internal immutable iOrderbook; IERC20 internal immutable iToken0; IERC20 internal immutable iToken1; - OrderBookSubParser internal immutable iSubParser; + OrderBookV6SubParser internal immutable iSubParser; constructor() { // Put the TOFU decimals contract in place so that any calls to it @@ -54,7 +54,7 @@ abstract contract OrderBookExternalRealTest is Test, IOrderBookV5Stub { }) ); - iOrderbook = IOrderBookV5(address(new OrderBook())); + iOrderbook = IOrderBookV6(address(new OrderBookV6())); iToken0 = IERC20(address(uint160(uint256(keccak256("token0.rain.test"))))); vm.etch(address(iToken0), REVERTING_MOCK_BYTECODE); @@ -64,7 +64,7 @@ abstract contract OrderBookExternalRealTest is Test, IOrderBookV5Stub { vm.etch(address(iToken1), REVERTING_MOCK_BYTECODE); vm.mockCall(address(iToken1), abi.encodeWithSelector(IERC20Metadata.decimals.selector), abi.encode(18)); - iSubParser = new OrderBookSubParser(); + iSubParser = new OrderBookV6SubParser(); } function assumeEtchable(address account) internal view { diff --git a/test/util/abstract/OrderBookSelfTest.sol b/test/util/abstract/OrderBookV6SelfTest.sol similarity index 63% rename from test/util/abstract/OrderBookSelfTest.sol rename to test/util/abstract/OrderBookV6SelfTest.sol index 198da0da3a..228d4f6c42 100644 --- a/test/util/abstract/OrderBookSelfTest.sol +++ b/test/util/abstract/OrderBookV6SelfTest.sol @@ -6,10 +6,10 @@ import {Test} from "forge-std/Test.sol"; import {REVERTING_MOCK_BYTECODE} from "test/util/lib/LibTestConstants.sol"; -import {OrderBook} from "src/concrete/ob/OrderBook.sol"; +import {OrderBookV6} from "src/concrete/ob/OrderBookV6.sol"; -/// @title OrderBookSelfTest -/// Abstract contract that is an `OrderBook` and can be used to test itself. +/// @title OrderBookV6SelfTest +/// Abstract contract that is an `OrderBookV6` and can be used to test itself. /// Inherits from Test so that it can be used as a base contract for other tests. /// Mocks all externalities during construction. -abstract contract OrderBookSelfTest is Test, OrderBook {} +abstract contract OrderBookV6SelfTest is Test, OrderBookV6 {} diff --git a/test/util/abstract/OrderBookSubParserContextTest.sol b/test/util/abstract/OrderBookV6SubParserContextTest.sol similarity index 82% rename from test/util/abstract/OrderBookSubParserContextTest.sol rename to test/util/abstract/OrderBookV6SubParserContextTest.sol index 281091af41..024ce9cabe 100644 --- a/test/util/abstract/OrderBookSubParserContextTest.sol +++ b/test/util/abstract/OrderBookV6SubParserContextTest.sol @@ -5,17 +5,17 @@ pragma solidity =0.8.25; import {StackAllocationMismatch} from "rain.interpreter/error/ErrIntegrity.sol"; import {OpTest, StackItem} from "rain.interpreter/../test/abstract/OpTest.sol"; import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol"; -import {OrderBookSubParser} from "src/concrete/parser/OrderBookSubParser.sol"; +import {OrderBookV6SubParser} from "src/concrete/parser/OrderBookV6SubParser.sol"; import {LibOrderBookSubParserContextFixture} from "test/util/fixture/LibOrderBookSubParserContextFixture.sol"; -abstract contract OrderBookSubParserContextTest is OpTest { +abstract contract OrderBookV6SubParserContextTest is OpTest { using Strings for address; function word() internal pure virtual returns (string memory); function testSubParserContextHappy() external { string memory w = word(); - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); StackItem[] memory expectedStack = new StackItem[](1); expectedStack[0] = StackItem.wrap(keccak256(bytes(w))); @@ -28,7 +28,7 @@ abstract contract OrderBookSubParserContextTest is OpTest { function testSubParserContextUnhappyDisallowedOperand() external { string memory w = word(); - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes(string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: ", w, "<1>();")); @@ -38,7 +38,7 @@ abstract contract OrderBookSubParserContextTest is OpTest { function testSubParserContextUnhappyDisallowedInputs() external { string memory w = word(); - OrderBookSubParser orderBookSubParser = new OrderBookSubParser(); + OrderBookV6SubParser orderBookSubParser = new OrderBookV6SubParser(); bytes memory rainlang = bytes(string.concat("using-words-from ", address(orderBookSubParser).toHexString(), " _: ", w, "(1);")); diff --git a/test/util/abstract/RouteProcessorOrderBookV5ArbOrderTakerTest.sol b/test/util/abstract/RouteProcessorOrderBookV5ArbOrderTakerTest.sol deleted file mode 100644 index 8f98523ff6..0000000000 --- a/test/util/abstract/RouteProcessorOrderBookV5ArbOrderTakerTest.sol +++ /dev/null @@ -1,17 +0,0 @@ -// SPDX-License-Identifier: LicenseRef-DCL-1.0 -// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd -pragma solidity =0.8.25; - -import {ArbTest} from "./ArbTest.sol"; -import { - RouteProcessorOrderBookV5ArbOrderTaker, - OrderBookV5ArbConfig -} from "src/concrete/arb/RouteProcessorOrderBookV5ArbOrderTaker.sol"; - -contract RouteProcessorOrderBookV5ArbOrderTakerTest is ArbTest { - function buildArb(OrderBookV5ArbConfig memory config) internal override returns (address) { - return address(new RouteProcessorOrderBookV5ArbOrderTaker(config)); - } - - constructor() ArbTest() {} -} diff --git a/test/util/abstract/RouteProcessorOrderBookV6ArbOrderTakerTest.sol b/test/util/abstract/RouteProcessorOrderBookV6ArbOrderTakerTest.sol new file mode 100644 index 0000000000..8e3185e4f7 --- /dev/null +++ b/test/util/abstract/RouteProcessorOrderBookV6ArbOrderTakerTest.sol @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: LicenseRef-DCL-1.0 +// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd +pragma solidity =0.8.25; + +import {ArbTest} from "./ArbTest.sol"; +import { + RouteProcessorOrderBookV6ArbOrderTaker, + OrderBookV6ArbConfig +} from "src/concrete/arb/RouteProcessorOrderBookV6ArbOrderTaker.sol"; + +contract RouteProcessorOrderBookV6ArbOrderTakerTest is ArbTest { + function buildArb(OrderBookV6ArbConfig memory config) internal override returns (address) { + return address(new RouteProcessorOrderBookV6ArbOrderTaker(config)); + } + + constructor() ArbTest() {} +} diff --git a/test/util/concrete/ChildOrderBookV5ArbOrderTaker.sol b/test/util/concrete/ChildOrderBookV6ArbOrderTaker.sol similarity index 77% rename from test/util/concrete/ChildOrderBookV5ArbOrderTaker.sol rename to test/util/concrete/ChildOrderBookV6ArbOrderTaker.sol index 7fe8224587..1856602033 100644 --- a/test/util/concrete/ChildOrderBookV5ArbOrderTaker.sol +++ b/test/util/concrete/ChildOrderBookV6ArbOrderTaker.sol @@ -3,21 +3,21 @@ pragma solidity =0.8.25; import { - OrderBookV5ArbOrderTaker, + OrderBookV6ArbOrderTaker, SignedContextV1, EvaluableV4, TaskV2, - OrderBookV5ArbConfig -} from "src/abstract/OrderBookV5ArbOrderTaker.sol"; + OrderBookV6ArbConfig +} from "src/abstract/OrderBookV6ArbOrderTaker.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; import {IInterpreterV4} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; /// @dev We need a contract that is deployable in order to test the abstract /// base contract. -contract ChildOrderBookV5ArbOrderTaker is OrderBookV5ArbOrderTaker { +contract ChildOrderBookV6ArbOrderTaker is OrderBookV6ArbOrderTaker { constructor() - OrderBookV5ArbOrderTaker( - OrderBookV5ArbConfig( + OrderBookV6ArbOrderTaker( + OrderBookV6ArbConfig( address(0), TaskV2({ evaluable: EvaluableV4(IInterpreterV4(address(0)), IInterpreterStoreV3(address(0)), ""), diff --git a/test/util/concrete/FlashLendingMockOrderBook.sol b/test/util/concrete/FlashLendingMockOrderBook.sol index d95d5544cd..db55b227dd 100644 --- a/test/util/concrete/FlashLendingMockOrderBook.sol +++ b/test/util/concrete/FlashLendingMockOrderBook.sol @@ -7,18 +7,18 @@ import { IOV2, OrderV4, SignedContextV1, - IOrderBookV5, - TakeOrdersConfigV4, + IOrderBookV6, + TakeOrdersConfigV5, OrderConfigV4, ClearConfigV2, EvaluableV4, TaskV2, QuoteV2, Float -} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IERC3156FlashBorrower} from "rain.orderbook.interface/interface/ierc3156/IERC3156FlashBorrower.sol"; -contract FlashLendingMockOrderBook is IOrderBookV5 { +contract FlashLendingMockOrderBook is IOrderBookV6 { function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data) external returns (bool) @@ -29,16 +29,16 @@ contract FlashLendingMockOrderBook is IOrderBookV5 { function entask2(TaskV2[] calldata) external pure {} - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function quote2(QuoteV2 calldata) external pure returns (bool, Float, Float) { revert("quote"); } - /// @inheritdoc IOrderBookV5 - function takeOrders3(TakeOrdersConfigV4 calldata) external pure returns (Float, Float) {} + /// @inheritdoc IOrderBookV6 + function takeOrders4(TakeOrdersConfigV5 calldata) external pure returns (Float, Float) {} - /// @inheritdoc IOrderBookV5 - function addOrder3(OrderConfigV4 calldata, TaskV2[] calldata) external pure returns (bool) { + /// @inheritdoc IOrderBookV6 + function addOrder4(OrderConfigV4 calldata, TaskV2[] calldata) external pure returns (bool) { return false; } @@ -46,7 +46,7 @@ contract FlashLendingMockOrderBook is IOrderBookV5 { return false; } - /// @inheritdoc IOrderBookV5 + /// @inheritdoc IOrderBookV6 function clear3( OrderV4 memory, OrderV4 memory, @@ -54,11 +54,11 @@ contract FlashLendingMockOrderBook is IOrderBookV5 { SignedContextV1[] memory, SignedContextV1[] memory ) external {} - function deposit3(address, bytes32, Float, TaskV2[] calldata) external {} + function deposit4(address, bytes32, Float, TaskV2[] calldata) external {} function flashFee(address, uint256) external view returns (uint256) {} function maxFlashLoan(address) external view returns (uint256) {} function removeOrder3(OrderV4 calldata, TaskV2[] calldata) external returns (bool) {} function vaultBalance2(address, address, bytes32) external view returns (Float) {} - function withdraw3(address, bytes32, Float, TaskV2[] calldata) external {} + function withdraw4(address, bytes32, Float, TaskV2[] calldata) external {} } diff --git a/test/util/lib/LibTestAddOrder.sol b/test/util/lib/LibTestAddOrder.sol index d7ec971ca0..1b024e2237 100644 --- a/test/util/lib/LibTestAddOrder.sol +++ b/test/util/lib/LibTestAddOrder.sol @@ -4,11 +4,11 @@ pragma solidity ^0.8.19; import {META_MAGIC_NUMBER_V1} from "rain.metadata/lib/LibMeta.sol"; import {LibOrder} from "src/lib/LibOrder.sol"; -import {OrderConfigV4, OrderV4, IOV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV5.sol"; +import {OrderConfigV4, OrderV4, IOV2} from "rain.orderbook.interface/interface/unstable/IOrderBookV6.sol"; import {IInterpreterV4, SourceIndexV2} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; import {IInterpreterStoreV3} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; import {EvaluableV4} from "rain.interpreter.interface/interface/unstable/IInterpreterCallerV4.sol"; -import {HANDLE_IO_ENTRYPOINT} from "src/concrete/ob/OrderBook.sol"; +import {HANDLE_IO_ENTRYPOINT} from "src/concrete/ob/OrderBookV6.sol"; import {LibBytecode} from "rain.interpreter.interface/lib/bytecode/LibBytecode.sol"; library LibTestAddOrder {