From e694e29530ca2ecb51ea0f70aaaf238b1567f0d9 Mon Sep 17 00:00:00 2001 From: mfw78 Date: Thu, 30 Jul 2026 03:56:01 +0000 Subject: [PATCH] refactor!: rename ComposableCoW to ComposableCow Solidity's CapWords convention does not carry branding capitalisation into an identifier, and the registry was the last place the fork still spelled it that way. The surrounding code had already moved on: the poller work uses `ComposableCowPoller`, and `TWAP` holds a `composableCow` while `ERC1271Forwarder` held a `composableCoW`, which is the same inconsistency in miniature. Renames the contract, its library, the test and script counterparts, the matching filenames, and the `networks.json` key. The `CoW Protocol` spelling is retained in prose and in vendored upstream identifiers such as `GPv2Settlement` and `CoWSettlement`. The audit PDFs are published artefacts and keep their filenames; only the link text in the README is updated. `.gas-snapshot` keys are rewritten in place. A rename cannot change gas, and the committed snapshot is byte-exact against a fresh `forge snapshot` here, so the rewrite and a regeneration agree. BREAKING CHANGE: the contract, its build artefact and the `networks.json` key are all renamed. The manifest describes a version that is not yet deployed and will be superseded by `deployments/networks.json`, so no live consumer is affected. --- .gas-snapshot | 108 +++++++++--------- .github/ISSUE_TEMPLATE/bug_report.md | 4 +- .github/ISSUE_TEMPLATE/feature_request.md | 2 +- README.md | 32 +++--- dev/verify-contracts.sh | 2 +- networks.json | 2 +- script/deploy_AnvilStack.s.sol | 4 +- ...leCoW.s.sol => deploy_ComposableCow.s.sol} | 6 +- script/deploy_OrderTypes.s.sol | 4 +- script/deploy_ProdStack.s.sol | 8 +- script/submit_SingleOrder.s.sol | 8 +- src/{ComposableCoW.sol => ComposableCow.sol} | 4 +- src/ERC1271Forwarder.sol | 28 ++--- src/interfaces/ISwapGuard.sol | 2 +- src/interfaces/IValueFactory.sol | 2 +- src/types/twap/TWAP.sol | 6 +- .../CurrentBlockTimestampFactory.sol | 2 +- test/ComposableCoW.t.sol | 64 +++++------ ...oW.base.t.sol => ComposableCow.base.t.sol} | 34 +++--- ...er.t.sol => ComposableCow.forwarder.t.sol} | 8 +- ...eCoW.gat.t.sol => ComposableCow.gat.t.sol} | 16 +-- ...uards.t.sol => ComposableCow.guards.t.sol} | 20 ++-- ...oss.t.sol => ComposableCow.stoploss.t.sol} | 6 +- ...eCoW.tat.t.sol => ComposableCow.tat.t.sol} | 8 +- ...oW.twap.t.sol => ComposableCow.twap.t.sol} | 20 ++-- ...bleCoWLib.t.sol => ComposableCowLib.t.sol} | 2 +- 26 files changed, 201 insertions(+), 201 deletions(-) rename script/{deploy_ComposableCoW.s.sol => deploy_ComposableCow.s.sol} (72%) rename src/{ComposableCoW.sol => ComposableCow.sol} (99%) rename test/{ComposableCoW.base.t.sol => ComposableCow.base.t.sol} (91%) rename test/{ComposableCoW.forwarder.t.sol => ComposableCow.forwarder.t.sol} (85%) rename test/{ComposableCoW.gat.t.sol => ComposableCow.gat.t.sol} (97%) rename test/{ComposableCoW.guards.t.sol => ComposableCow.guards.t.sol} (90%) rename test/{ComposableCoW.stoploss.t.sol => ComposableCow.stoploss.t.sol} (98%) rename test/{ComposableCoW.tat.t.sol => ComposableCow.tat.t.sol} (93%) rename test/{ComposableCoW.twap.t.sol => ComposableCow.twap.t.sol} (98%) rename test/libraries/{ComposableCoWLib.t.sol => ComposableCowLib.t.sol} (99%) diff --git a/.gas-snapshot b/.gas-snapshot index 018a0146..9bc27f3e 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,54 +1,54 @@ -BaseComposableCoWTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10773) -BaseComposableCoWTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17547) -ComposableCoWForwarderTest:test_ERC1271Forwarder_isValidSignature_RevertsOnBadHash() (gas: 693566) -ComposableCoWForwarderTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10773) -ComposableCoWForwarderTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17525) -ComposableCoWGatTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10751) -ComposableCoWGatTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17569) -ComposableCoWGatTest:test_getTradeableOrder_FuzzContext(address,address,uint256,uint256,uint256,uint256,bool) (runs: 256, μ: 113908, ~: 113944) -ComposableCoWGatTest:test_getTradeableOrder_FuzzRevertBeforeStartTime(uint256,uint256) (runs: 256, μ: 21002, ~: 21002) -ComposableCoWGatTest:test_getTradeableOrder_FuzzRevertBelowMinBalance(uint256,uint256) (runs: 256, μ: 107931, ~: 107940) -ComposableCoWGatTest:test_getTradeableOrder_FuzzRevertTooLowOutput(uint256,uint256,uint256) (runs: 256, μ: 119112, ~: 119216) -ComposableCoWGatTest:test_getTradeableOrder_e2e_Fuzz(uint256,uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 297875, ~: 297798) -ComposableCoWGatTest:test_getTradeableOrder_e2e_FuzzWithPriceChecker(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 311409, ~: 311208) -ComposableCoWGatTest:test_settle_e2e() (gas: 503727) -ComposableCoWGatTest:test_verify_e2e_fuzz(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 133257, ~: 133024) -ComposableCoWGuardsTest:test_BaseSwapGuard_supportsInterface() (gas: 170924) -ComposableCoWGuardsTest:test_ReceiverLock_verify_FuzzRevertsWhenReceiverNotSelf(address) (runs: 256, μ: 320763, ~: 320763) -ComposableCoWGuardsTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10773) -ComposableCoWGuardsTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17524) -ComposableCoWGuardsTest:test_setSwapGuard_FuzzSetAndEmit(address,address) (runs: 256, μ: 29978, ~: 29952) -ComposableCoWGuardsTest:test_setSwapGuard_e2e() (gas: 1101368) -ComposableCoWTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10751) -ComposableCoWTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17546) -ComposableCoWTest:test_createAndRemove_FuzzSetAndEmit(address,address,bytes32,bytes) (runs: 256, μ: 33701, ~: 33497) -ComposableCoWTest:test_createAndRemove_e2e() (gas: 481342) -ComposableCoWTest:test_create_RevertOnInvalidHandler() (gas: 9204) -ComposableCoWTest:test_getTradeableOrderWithSignature_FuzzRevertInvalidProof(address,bytes32[],bytes32,address,bytes32,bytes) (runs: 256, μ: 111941, ~: 113448) -ComposableCoWTest:test_getTradeableOrderWithSignature_FuzzRevertInvalidSingleOrder(address,address,bytes32,bytes) (runs: 256, μ: 17143, ~: 17022) -ComposableCoWTest:test_getTradeableOrderWithSignature_ReturnsValidPayloadForNonSafe() (gas: 710270) -ComposableCoWTest:test_getTradeableOrderWithSignature_ReturnsValidPayloadForSafe() (gas: 108970) -ComposableCoWTest:test_getTradeableOrderWithSignature_RevertInterfaceNotSupported() (gas: 48201) -ComposableCoWTest:test_isValidSafeSignature_BaseConditionalOrder_RevertOnInvalidHash() (gas: 63054) -ComposableCoWTest:test_isValidSafeSignature_FuzzPassesContextToHandler(address,bytes32) (runs: 256, μ: 218294, ~: 218294) -ComposableCoWTest:test_isValidSafeSignature_FuzzRevertInvalidProof(address,bytes32[],bytes32,address,bytes32,bytes) (runs: 256, μ: 134946, ~: 136933) -ComposableCoWTest:test_isValidSafeSignature_FuzzRevertInvalidSingleOrder(address,address,bytes32,bytes) (runs: 256, μ: 20697, ~: 20534) -ComposableCoWTest:test_setRoot_FuzzSetAndEmit(address,bytes32) (runs: 256, μ: 38327, ~: 38327) -ComposableCoWTest:test_setRoot_e2e() (gas: 12432651) -ComposableCoWTwapTest:test_SetUpState_ComposableCoWDomainSeparator_is_set() (gas: 10795) -ComposableCoWTwapTest:test_SetUpState_ComposableCoWDomainVerifier_is_set() (gas: 17569) -ComposableCoWTwapTest:test_TWAPOrderMathLib_calculateValidTo(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 12832, ~: 12752) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertIfBeforeStart(uint256,uint256) (runs: 256, μ: 26972, ~: 26972) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertIfExpired(uint256,uint256) (runs: 256, μ: 27151, ~: 27151) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertIfOutsideSpan(uint256,uint256) (runs: 256, μ: 28708, ~: 28708) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidFrequency(uint256) (runs: 256, μ: 18490, ~: 18494) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidNumParts(uint256) (runs: 256, μ: 18446, ~: 18451) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidSpan(uint256,uint256) (runs: 256, μ: 18894, ~: 18894) -ComposableCoWTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidStartTime(uint256) (runs: 256, μ: 18303, ~: 18303) -ComposableCoWTwapTest:test_getTradeableOrder_RevertOnSameTokens() (gas: 17808) -ComposableCoWTwapTest:test_getTradeableOrder_RevertOnTokenZero() (gas: 23558) -ComposableCoWTwapTest:test_getTradeableOrder_RevertOnZeroMinPartLimit() (gas: 17791) -ComposableCoWTwapTest:test_getTradeableOrder_RevertOnZeroPartSellAmount() (gas: 17834) -ComposableCoWTwapTest:test_getTradeableOrder_e2e_fuzz(uint256,uint256) (runs: 256, μ: 196394, ~: 196396) -ComposableCoWTwapTest:test_settle_e2e() (gas: 12480525) -ComposableCoWTwapTest:test_verify_e2e_fuzz(uint256,uint256) (runs: 256, μ: 33600, ~: 33600) \ No newline at end of file +BaseComposableCowTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10773) +BaseComposableCowTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17547) +ComposableCowForwarderTest:test_ERC1271Forwarder_isValidSignature_RevertsOnBadHash() (gas: 693566) +ComposableCowForwarderTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10773) +ComposableCowForwarderTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17525) +ComposableCowGatTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10751) +ComposableCowGatTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17569) +ComposableCowGatTest:test_getTradeableOrder_FuzzContext(address,address,uint256,uint256,uint256,uint256,bool) (runs: 256, μ: 113908, ~: 113944) +ComposableCowGatTest:test_getTradeableOrder_FuzzRevertBeforeStartTime(uint256,uint256) (runs: 256, μ: 21002, ~: 21002) +ComposableCowGatTest:test_getTradeableOrder_FuzzRevertBelowMinBalance(uint256,uint256) (runs: 256, μ: 107931, ~: 107940) +ComposableCowGatTest:test_getTradeableOrder_FuzzRevertTooLowOutput(uint256,uint256,uint256) (runs: 256, μ: 119112, ~: 119216) +ComposableCowGatTest:test_getTradeableOrder_e2e_Fuzz(uint256,uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 297875, ~: 297798) +ComposableCowGatTest:test_getTradeableOrder_e2e_FuzzWithPriceChecker(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 311409, ~: 311208) +ComposableCowGatTest:test_settle_e2e() (gas: 503727) +ComposableCowGatTest:test_verify_e2e_fuzz(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 133257, ~: 133024) +ComposableCowGuardsTest:test_BaseSwapGuard_supportsInterface() (gas: 170924) +ComposableCowGuardsTest:test_ReceiverLock_verify_FuzzRevertsWhenReceiverNotSelf(address) (runs: 256, μ: 320763, ~: 320763) +ComposableCowGuardsTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10773) +ComposableCowGuardsTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17524) +ComposableCowGuardsTest:test_setSwapGuard_FuzzSetAndEmit(address,address) (runs: 256, μ: 29978, ~: 29952) +ComposableCowGuardsTest:test_setSwapGuard_e2e() (gas: 1101368) +ComposableCowTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10751) +ComposableCowTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17546) +ComposableCowTest:test_createAndRemove_FuzzSetAndEmit(address,address,bytes32,bytes) (runs: 256, μ: 33701, ~: 33497) +ComposableCowTest:test_createAndRemove_e2e() (gas: 481342) +ComposableCowTest:test_create_RevertOnInvalidHandler() (gas: 9204) +ComposableCowTest:test_getTradeableOrderWithSignature_FuzzRevertInvalidProof(address,bytes32[],bytes32,address,bytes32,bytes) (runs: 256, μ: 111941, ~: 113448) +ComposableCowTest:test_getTradeableOrderWithSignature_FuzzRevertInvalidSingleOrder(address,address,bytes32,bytes) (runs: 256, μ: 17143, ~: 17022) +ComposableCowTest:test_getTradeableOrderWithSignature_ReturnsValidPayloadForNonSafe() (gas: 710270) +ComposableCowTest:test_getTradeableOrderWithSignature_ReturnsValidPayloadForSafe() (gas: 108970) +ComposableCowTest:test_getTradeableOrderWithSignature_RevertInterfaceNotSupported() (gas: 48201) +ComposableCowTest:test_isValidSafeSignature_BaseConditionalOrder_RevertOnInvalidHash() (gas: 63054) +ComposableCowTest:test_isValidSafeSignature_FuzzPassesContextToHandler(address,bytes32) (runs: 256, μ: 218294, ~: 218294) +ComposableCowTest:test_isValidSafeSignature_FuzzRevertInvalidProof(address,bytes32[],bytes32,address,bytes32,bytes) (runs: 256, μ: 134946, ~: 136933) +ComposableCowTest:test_isValidSafeSignature_FuzzRevertInvalidSingleOrder(address,address,bytes32,bytes) (runs: 256, μ: 20697, ~: 20534) +ComposableCowTest:test_setRoot_FuzzSetAndEmit(address,bytes32) (runs: 256, μ: 38327, ~: 38327) +ComposableCowTest:test_setRoot_e2e() (gas: 12432651) +ComposableCowTwapTest:test_SetUpState_ComposableCowDomainSeparator_is_set() (gas: 10795) +ComposableCowTwapTest:test_SetUpState_ComposableCowDomainVerifier_is_set() (gas: 17569) +ComposableCowTwapTest:test_TWAPOrderMathLib_calculateValidTo(uint256,uint256,uint256,uint256,uint256) (runs: 256, μ: 12832, ~: 12752) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertIfBeforeStart(uint256,uint256) (runs: 256, μ: 26972, ~: 26972) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertIfExpired(uint256,uint256) (runs: 256, μ: 27151, ~: 27151) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertIfOutsideSpan(uint256,uint256) (runs: 256, μ: 28708, ~: 28708) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidFrequency(uint256) (runs: 256, μ: 18490, ~: 18494) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidNumParts(uint256) (runs: 256, μ: 18446, ~: 18451) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidSpan(uint256,uint256) (runs: 256, μ: 18894, ~: 18894) +ComposableCowTwapTest:test_getTradeableOrder_FuzzRevertOnInvalidStartTime(uint256) (runs: 256, μ: 18303, ~: 18303) +ComposableCowTwapTest:test_getTradeableOrder_RevertOnSameTokens() (gas: 17808) +ComposableCowTwapTest:test_getTradeableOrder_RevertOnTokenZero() (gas: 23558) +ComposableCowTwapTest:test_getTradeableOrder_RevertOnZeroMinPartLimit() (gas: 17791) +ComposableCowTwapTest:test_getTradeableOrder_RevertOnZeroPartSellAmount() (gas: 17834) +ComposableCowTwapTest:test_getTradeableOrder_e2e_fuzz(uint256,uint256) (runs: 256, μ: 196394, ~: 196396) +ComposableCowTwapTest:test_settle_e2e() (gas: 12480525) +ComposableCowTwapTest:test_verify_e2e_fuzz(uint256,uint256) (runs: 256, μ: 33600, ~: 33600) \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 576d982f..19d9200e 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -26,8 +26,8 @@ A clear and concise description of what you expected to happen. ### Screenshots/logs If applicable, add screenshots or logs to help explain your problem. -### ComposableCoW version/commit hash -State the version of ComposableCoW where you've encountered the bug or, if built off a specific commit, the relevant commit hash. +### ComposableCow version/commit hash +State the version of ComposableCow where you've encountered the bug or, if built off a specific commit, the relevant commit hash. - e.g. `v0.9` or `ed53bcd` ### Additional context diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md index 52e0b4aa..707760ee 100644 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -1,6 +1,6 @@ --- name: Feature request -about: Suggest an idea for ComposableCoW +about: Suggest an idea for ComposableCow title: 'feat: ' labels: track:production assignees: '' diff --git a/README.md b/README.md index ae703021..53f4006e 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ -# `ComposableCoW`: Composable Conditional orders +# `ComposableCow`: Composable Conditional orders -This repository is the next in evolution of the [`conditional-smart-orders`](https://github.com/cowprotocol/conditional-smart-orders), providing a unified interface for stateless, composable conditional orders. `ComposableCoW` is designed to be used with the [`ExtensibleFallbackHandler`](https://github.com/rndlabs/safe-contracts/tree/merged-efh-sigmuxer), a powerful _extensible_ fallback handler that allows for significant customisation of a `Safe`, while preserving strong security guarantees. +This repository is the next in evolution of the [`conditional-smart-orders`](https://github.com/cowprotocol/conditional-smart-orders), providing a unified interface for stateless, composable conditional orders. `ComposableCow` is designed to be used with the [`ExtensibleFallbackHandler`](https://github.com/rndlabs/safe-contracts/tree/merged-efh-sigmuxer), a powerful _extensible_ fallback handler that allows for significant customisation of a `Safe`, while preserving strong security guarantees. ## Architecture @@ -11,7 +11,7 @@ A detailed explanation on the architecture is available [here](https://hackmd.io For the purposes of outlining the methodologies, it is assumed that: 1. The `Safe` has already had its fallback handler set to `ExtensibleFallbackHandler`. -2. The `Safe` has set the `domainVerifier` for the `GPv2Settlement.domainSeparator()` to `ComposableCoW` +2. The `Safe` has set the `domainVerifier` for the `GPv2Settlement.domainSeparator()` to `ComposableCow` #### Conditional order creation @@ -23,13 +23,13 @@ A conditional order is a struct `ConditionalOrderParams`, consisting of: ##### Single Order -1. From the context of the Safe that is placing the order, call `ComposableCoW.create` with the `ConditionalOrderParams` struct. Optionally set `dispatch = true` to have events emitted that are picked up by a watch tower. +1. From the context of the Safe that is placing the order, call `ComposableCow.create` with the `ConditionalOrderParams` struct. Optionally set `dispatch = true` to have events emitted that are picked up by a watch tower. ##### Merkle Root 1. Collect all the conditional orders, which are multiple structs of `ConditionalOrderParams`. 2. Populate a merkle tree with the leaves from (1), where each leaf is a double hashed of the ABI-encoded struct. -3. Determine the merkle root of the tree and set this as the root, calling `ComposableCoW.setRoot`. The `proof` must be set, and currently: +3. Determine the merkle root of the tree and set this as the root, calling `ComposableCow.setRoot`. The `proof` must be set, and currently: a. Set a `location` of `0` for no proofs emitted. b. Otherwise, set a `location` of `1` at which case the payload in the proof will be interpreted as an array of proofs and indexed by the watch tower. @@ -37,7 +37,7 @@ A conditional order is a struct `ConditionalOrderParams`, consisting of: Conditional orders may generate one or many discrete orders depending on their implementation. To retrieve a discrete order that is valid at the current block: -1. Call `ComposableCoW.getTradeableOrderWithSignature(address owner, ConditionalOrderParams params, bytes offchainInput, bytes32[] proof)` where: +1. Call `ComposableCow.getTradeableOrderWithSignature(address owner, ConditionalOrderParams params, bytes offchainInput, bytes32[] proof)` where: - `owner`: smart contract / `Safe` - `params`: mentioned above. - `offchainInput` is any implementation specific offchain input for discrete order generation / validation. @@ -51,13 +51,13 @@ Conditional orders may generate one or many discrete orders depending on their i ##### Single Order 1. Determine the digest for the conditional order, ie.`H(Params)`. -2. Call `ComposableCoW.remove(H(Params))` +2. Call `ComposableCow.remove(H(Params))` ##### Merkle Root 1. Prune the leaf from the merkle tree. 2. Determine the new root. -3. Call `ComposableCoW.setRoot` with the new root, which will invalidate any orders that have been pruned from the tree. +3. Call `ComposableCow.setRoot` with the new root, which will invalidate any orders that have been pruned from the tree. ## Time-weighted average price (TWAP) @@ -105,10 +105,10 @@ To create a TWAP order: - `handler`: set to the `TWAP` smart contract deployment. - `salt`: set to a unique value. - `staticInput`: the ABI-encoded `TWAP.Data` struct. -2. Use the `struct` from (1) as either a Merkle leaf, or with `ComposableCoW.create` to create a single conditional order. +2. Use the `struct` from (1) as either a Merkle leaf, or with `ComposableCow.create` to create a single conditional order. 3. Approve `GPv2VaultRelayer` to trade `n x partSellAmount` of the safe's `sellToken` tokens (in the example above, `GPv2VaultRelayer` would receive approval for spending 12,000,000 DAI tokens). -**NOTE**: When calling `ComposableCoW.create`, setting `dispatch = true` will cause `ComposableCoW` to emit event logs that are indexed by the watch tower automatically. If you wish to maintain a private order (and will submit to the CoW Protocol API through your own infrastructure, you may set `dispatch` to `false`). +**NOTE**: When calling `ComposableCow.create`, setting `dispatch = true` will cause `ComposableCow` to emit event logs that are indexed by the watch tower automatically. If you wish to maintain a private order (and will submit to the CoW Protocol API through your own infrastructure, you may set `dispatch` to `false`). Fortunately, when using Safe, it is possible to batch together all the above calls to perform this step atomically, and optimise gas consumption / UX. For code examples on how to do this, please refer to the [CLI](#CLI). @@ -126,7 +126,7 @@ Fortunately, when using Safe, it is possible to batch together all the above cal | Contract Name | Ethereum Mainnet | Gnosis Chain | Sepolia | Arbitrum One | Base | Bsc | Avalanche | Optimism | Polygon | Lens | | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `ExtensibleFallbackHandler` | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://etherscan.io/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://gnosisscan.io/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://sepolia.etherscan.io/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://arbiscan.io/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://basescan.org/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://bscscan.com/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://snowscan.xyz/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://optimistic.etherscan.io/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://polygonscan.com/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | [0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5](https://explorer.lens.xyz/address/0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5) | -| `ComposableCoW` | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://gnosisscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://sepolia.etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://arbiscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://basescan.org/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://bscscan.com/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://snowscan.xyz/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://optimistic.etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://polygonscan.com/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://explorer.lens.xyz/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | +| `ComposableCow` | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://gnosisscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://sepolia.etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://arbiscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://basescan.org/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://bscscan.com/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://snowscan.xyz/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://optimistic.etherscan.io/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://polygonscan.com/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | [0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74](https://explorer.lens.xyz/address/0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74) | | `TWAP` | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://etherscan.io/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://gnosisscan.io/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://sepolia.etherscan.io/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://arbiscan.io/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://basescan.org/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://bscscan.com/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://snowscan.xyz/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://optimistic.etherscan.io/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://polygonscan.com/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | [0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5](https://explorer.lens.xyz/address/0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5) | | `GoodAfterTime` | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://etherscan.io/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://gnosisscan.io/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://sepolia.etherscan.io/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://arbiscan.io/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://basescan.org/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://bscscan.com/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://snowscan.xyz/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://optimistic.etherscan.io/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://polygonscan.com/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | [0xdaf33924925e03c9cc3a10d434016d6cfad0add5](https://explorer.lens.xyz/address/0xdaf33924925e03c9cc3a10d434016d6cfad0add5) | | `PerpetualStableSwap` | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://etherscan.io/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://gnosisscan.io/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://sepolia.etherscan.io/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://arbiscan.io/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://basescan.org/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://bscscan.com/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://snowscan.xyz/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://optimistic.etherscan.io/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://polygonscan.com/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | [0x519BA24e959E33b3B6220CA98bd353d8c2D89920](https://explorer.lens.xyz/address/0x519BA24e959E33b3B6220CA98bd353d8c2D89920) | @@ -138,9 +138,9 @@ Fortunately, when using Safe, it is possible to batch together all the above cal The above deployed contracts have been audited by: -- Ackee Blockchain: [CoW Protocol - `ComposableCoW` and `ExtensibleFallbackHandler`](./audits/ackee-blockchain-cow-protocol-composablecow-extensiblefallbackhandler-report-1.2.pdf) -- Gnosis internal audit: [ComposableCoW - May/July 2023](./audits/gnosis-ComposableCoWMayJul2023.pdf) -- Gnosis internal audit (August 2024): [ComposableCoW - Diff between May/July 2023 and August 2024](./audits/Composable_CoW_Diff.pdf) +- Ackee Blockchain: [CoW Protocol - `ComposableCow` and `ExtensibleFallbackHandler`](./audits/ackee-blockchain-cow-protocol-composablecow-extensiblefallbackhandler-report-1.2.pdf) +- Gnosis internal audit: [ComposableCow - May/July 2023](./audits/gnosis-ComposableCoWMayJul2023.pdf) +- Gnosis internal audit (August 2024): [ComposableCow - Diff between May/July 2023 and August 2024](./audits/Composable_CoW_Diff.pdf) ### Environment setup @@ -191,8 +191,8 @@ forge script script/deploy_ProdStack.s.sol:DeployProdStack --rpc-url $ETH_RPC_UR To deploy individual contracts: ```bash -# Deploy ComposableCoW -forge script script/deploy_ComposableCoW.s.sol:DeployComposableCoW --rpc-url $ETH_RPC_URL --broadcast -vvvv --verify +# Deploy ComposableCow +forge script script/deploy_ComposableCow.s.sol:DeployComposableCow --rpc-url $ETH_RPC_URL --broadcast -vvvv --verify # Deploy order types forge script script/deploy_OrderTypes.s.sol:DeployOrderTypes --rpc-url $ETH_RPC_URL --broadcast -vvvv --verify ``` diff --git a/dev/verify-contracts.sh b/dev/verify-contracts.sh index c134870c..9a27958a 100755 --- a/dev/verify-contracts.sh +++ b/dev/verify-contracts.sh @@ -61,7 +61,7 @@ forge_verify() { for path in \ "lib/safe/contracts/handler/ExtensibleFallbackHandler.sol" \ - "src/ComposableCoW.sol" \ + "src/ComposableCow.sol" \ "src/types/twap/TWAP.sol" \ "src/types/GoodAfterTime.sol" \ "src/types/PerpetualStableSwap.sol" \ diff --git a/networks.json b/networks.json index d6590c77..be4656f9 100644 --- a/networks.json +++ b/networks.json @@ -1,5 +1,5 @@ { - "ComposableCoW": { + "ComposableCow": { "1": { "address": "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74", "transactionHash": "0x2d4159ae0d4f026e2063292f3e40d898982619853484b8cd84f3748503fcdd19" diff --git a/script/deploy_AnvilStack.s.sol b/script/deploy_AnvilStack.s.sol index 0b59a6fe..45124aa8 100644 --- a/script/deploy_AnvilStack.s.sol +++ b/script/deploy_AnvilStack.s.sol @@ -20,7 +20,7 @@ import {ExtensibleFallbackHandler} from "safe/handler/ExtensibleFallbackHandler. import {SafeLib} from "../test/libraries/SafeLib.t.sol"; // Composable CoW -import {ComposableCoW} from "../src/ComposableCoW.sol"; +import {ComposableCow} from "../src/ComposableCow.sol"; import {TWAP} from "../src/types/twap/TWAP.sol"; import {GoodAfterTime} from "../src/types/GoodAfterTime.sol"; import {PerpetualStableSwap} from "../src/types/PerpetualStableSwap.sol"; @@ -60,7 +60,7 @@ contract DeployAnvilStack is Script { SafeProxy proxy = deploySafe(vm.addr(deployerPrivateKey)); // deploy the Composable CoW - ComposableCoW composableCow = new ComposableCoW(address(settlement)); + ComposableCow composableCow = new ComposableCow(address(settlement)); new TWAP(composableCow); new GoodAfterTime(); new PerpetualStableSwap(); diff --git a/script/deploy_ComposableCoW.s.sol b/script/deploy_ComposableCow.s.sol similarity index 72% rename from script/deploy_ComposableCoW.s.sol rename to script/deploy_ComposableCow.s.sol index f33e9f42..f866ae2b 100644 --- a/script/deploy_ComposableCoW.s.sol +++ b/script/deploy_ComposableCow.s.sol @@ -3,15 +3,15 @@ pragma solidity >=0.8.0 <0.9.0; import {Script} from "forge-std/Script.sol"; -import {ComposableCoW} from "../src/ComposableCoW.sol"; +import {ComposableCow} from "../src/ComposableCow.sol"; -contract DeployComposableCoW is Script { +contract DeployComposableCow is Script { function run() external { uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY"); address settlement = vm.envAddress("SETTLEMENT"); vm.startBroadcast(deployerPrivateKey); - new ComposableCoW(settlement); + new ComposableCow(settlement); vm.stopBroadcast(); } diff --git a/script/deploy_OrderTypes.s.sol b/script/deploy_OrderTypes.s.sol index b9d09bc2..3a666ba2 100644 --- a/script/deploy_OrderTypes.s.sol +++ b/script/deploy_OrderTypes.s.sol @@ -3,7 +3,7 @@ pragma solidity >=0.8.0 <0.9.0; import {Script} from "forge-std/Script.sol"; -import {ComposableCoW} from "../src/ComposableCoW.sol"; +import {ComposableCow} from "../src/ComposableCow.sol"; import {TWAP} from "../src/types/twap/TWAP.sol"; import {GoodAfterTime} from "../src/types/GoodAfterTime.sol"; @@ -16,7 +16,7 @@ contract DeployOrderTypes is Script { address composableCow = vm.envAddress("COMPOSABLE_COW"); vm.startBroadcast(deployerPrivateKey); - new TWAP(ComposableCoW(composableCow)); + new TWAP(ComposableCow(composableCow)); new GoodAfterTime(); new PerpetualStableSwap(); new TradeAboveThreshold(); diff --git a/script/deploy_ProdStack.s.sol b/script/deploy_ProdStack.s.sol index cf685387..67d3fa0c 100644 --- a/script/deploy_ProdStack.s.sol +++ b/script/deploy_ProdStack.s.sol @@ -6,8 +6,8 @@ import {Script} from "forge-std/Script.sol"; // ExtensibleFallbackHandler import {ExtensibleFallbackHandler} from "../lib/safe/contracts/handler/ExtensibleFallbackHandler.sol"; -// ComposableCoW -import {ComposableCoW} from "../src/ComposableCoW.sol"; +// ComposableCow +import {ComposableCow} from "../src/ComposableCow.sol"; // Order types import {TWAP} from "../src/types/twap/TWAP.sol"; @@ -29,8 +29,8 @@ contract DeployProdStack is Script { // Deploy ExtensibleFallbackHandler new ExtensibleFallbackHandler{salt: "v1.0.0"}(); - // Deploy ComposableCoW - ComposableCoW composableCow = new ComposableCoW{salt: "v1.0.0"}(settlement); + // Deploy ComposableCow + ComposableCow composableCow = new ComposableCow{salt: "v1.0.0"}(settlement); // Deploy order types new TWAP{salt: "v1.0.0"}(composableCow); diff --git a/script/submit_SingleOrder.s.sol b/script/submit_SingleOrder.s.sol index 57d32634..380215c9 100644 --- a/script/submit_SingleOrder.s.sol +++ b/script/submit_SingleOrder.s.sol @@ -16,11 +16,11 @@ import {ExtensibleFallbackHandler} from "safe/handler/ExtensibleFallbackHandler. import {SafeLib} from "../test/libraries/SafeLib.t.sol"; // Composable CoW -import {IConditionalOrder, ComposableCoW} from "../src/ComposableCoW.sol"; +import {IConditionalOrder, ComposableCow} from "../src/ComposableCow.sol"; import {TWAP, TWAPOrder} from "../src/types/twap/TWAP.sol"; /** - * @title Submit a single order to ComposableCoW + * @title Submit a single order to ComposableCow * @author mfw78 */ contract SubmitSingleOrder is Script { @@ -31,7 +31,7 @@ contract SubmitSingleOrder is Script { Safe safe = Safe(payable(vm.envAddress("SAFE"))); TWAP twap = TWAP(vm.envAddress("TWAP")); - ComposableCoW composableCow = ComposableCoW(vm.envAddress("COMPOSABLE_COW")); + ComposableCow composableCow = ComposableCow(vm.envAddress("COMPOSABLE_COW")); TWAPOrder.Data memory twapOrder = TWAPOrder.Data({ sellToken: IERC20(address(1)), @@ -48,7 +48,7 @@ contract SubmitSingleOrder is Script { vm.startBroadcast(deployerPrivateKey); - // call to ComposableCoW to submit a single order + // call to ComposableCow to submit a single order safe.executeSingleOwner( address(composableCow), 0, diff --git a/src/ComposableCoW.sol b/src/ComposableCow.sol similarity index 99% rename from src/ComposableCoW.sol rename to src/ComposableCow.sol index 044bcd24..3151c359 100644 --- a/src/ComposableCoW.sol +++ b/src/ComposableCow.sol @@ -16,11 +16,11 @@ import {IValueFactory} from "./interfaces/IValueFactory.sol"; import {CoWSettlement} from "./vendored/CoWSettlement.sol"; /** - * @title ComposableCoW - A contract that allows users to create multiple conditional orders + * @title ComposableCow - A contract that allows users to create multiple conditional orders * @author mfw78 * @dev Designed to be used with Safe + ExtensibleFallbackHandler */ -contract ComposableCoW is ISafeSignatureVerifier { +contract ComposableCow is ISafeSignatureVerifier { // --- errors error ProofNotAuthed(); error SingleOrderNotAuthed(); diff --git a/src/ERC1271Forwarder.sol b/src/ERC1271Forwarder.sol index 6ea8fc88..ebab1d0a 100644 --- a/src/ERC1271Forwarder.sol +++ b/src/ERC1271Forwarder.sol @@ -4,44 +4,44 @@ pragma solidity >=0.8.0 <0.9.0; import {ERC1271, Safe} from "safe/handler/extensible/SignatureVerifierMuxer.sol"; import {GPv2Order} from "cowprotocol/contracts/libraries/GPv2Order.sol"; -import {ComposableCoW} from "./ComposableCoW.sol"; +import {ComposableCow} from "./ComposableCow.sol"; /** - * @title ERC1271 Forwarder - An abstract contract that implements ERC1271 forwarding to ComposableCoW + * @title ERC1271 Forwarder - An abstract contract that implements ERC1271 forwarding to ComposableCow * @author mfw78 - * @dev Designed to be extended from by a contract that wants to use ComposableCoW + * @dev Designed to be extended from by a contract that wants to use ComposableCow */ abstract contract ERC1271Forwarder is ERC1271 { - ComposableCoW public immutable composableCoW; + ComposableCow public immutable composableCow; - constructor(ComposableCoW _composableCoW) { - composableCoW = _composableCoW; + constructor(ComposableCow _composableCow) { + composableCow = _composableCow; } // When the pre-image doesn't match the hash, revert with this error. error InvalidHash(); /** - * Re-arrange the request into something that ComposableCoW can understand + * Re-arrange the request into something that ComposableCow can understand * @param _hash GPv2Order.Data digest - * @param signature The abi.encoded tuple of (GPv2Order.Data, ComposableCoW.PayloadStruct) + * @param signature The abi.encoded tuple of (GPv2Order.Data, ComposableCow.PayloadStruct) */ function isValidSignature(bytes32 _hash, bytes memory signature) public view override returns (bytes4) { - (GPv2Order.Data memory order, ComposableCoW.PayloadStruct memory payload) = - abi.decode(signature, (GPv2Order.Data, ComposableCoW.PayloadStruct)); - bytes32 domainSeparator = composableCoW.domainSeparator(); + (GPv2Order.Data memory order, ComposableCow.PayloadStruct memory payload) = + abi.decode(signature, (GPv2Order.Data, ComposableCow.PayloadStruct)); + bytes32 domainSeparator = composableCow.domainSeparator(); if (!(GPv2Order.hash(order, domainSeparator) == _hash)) { revert InvalidHash(); } - return composableCoW.isValidSafeSignature( + return composableCow.isValidSafeSignature( Safe(payable(address(this))), // owner msg.sender, // sender _hash, // GPv2Order digest domainSeparator, // GPv2Settlement domain separator - bytes32(0), // typeHash (not used by ComposableCoW) + bytes32(0), // typeHash (not used by ComposableCow) abi.encode(order), // GPv2Order - abi.encode(payload) // ComposableCoW.PayloadStruct + abi.encode(payload) // ComposableCow.PayloadStruct ); } } diff --git a/src/interfaces/ISwapGuard.sol b/src/interfaces/ISwapGuard.sol index a47195dd..a0a84837 100644 --- a/src/interfaces/ISwapGuard.sol +++ b/src/interfaces/ISwapGuard.sol @@ -6,7 +6,7 @@ import {IERC165} from "safe/interfaces/IERC165.sol"; import {IConditionalOrder, GPv2Order} from "./IConditionalOrder.sol"; /** - * @title SwapGuard Interface - Restrict CoW Protocol settlement for an account using `ComposableCoW`. + * @title SwapGuard Interface - Restrict CoW Protocol settlement for an account using `ComposableCow`. * @author mfw78 */ interface ISwapGuard is IERC165 { diff --git a/src/interfaces/IValueFactory.sol b/src/interfaces/IValueFactory.sol index 97df89b3..fd327f5b 100644 --- a/src/interfaces/IValueFactory.sol +++ b/src/interfaces/IValueFactory.sol @@ -4,7 +4,7 @@ pragma solidity >=0.8.0 <0.9.0; /** * @title IValueFactory - An interface for on-chain value determination * @author mfw78 - * @dev Designed to be used with Safe + ExtensibleFallbackHandler + ComposableCoW + * @dev Designed to be used with Safe + ExtensibleFallbackHandler + ComposableCow */ interface IValueFactory { /** diff --git a/src/types/twap/TWAP.sol b/src/types/twap/TWAP.sol index 84c6cb62..be7389e5 100644 --- a/src/types/twap/TWAP.sol +++ b/src/types/twap/TWAP.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.8.0 <0.9.0; -import {ComposableCoW} from "../../ComposableCoW.sol"; +import {ComposableCow} from "../../ComposableCow.sol"; import { IConditionalOrder, @@ -27,9 +27,9 @@ string constant NOT_WITHIN_SPAN = "not within span"; * @dev Designed to be used with the CoW Protocol Conditional Order Framework. */ contract TWAP is BaseConditionalOrder { - ComposableCoW public immutable composableCow; + ComposableCow public immutable composableCow; - constructor(ComposableCoW _composableCow) { + constructor(ComposableCow _composableCow) { composableCow = _composableCow; } diff --git a/src/value_factories/CurrentBlockTimestampFactory.sol b/src/value_factories/CurrentBlockTimestampFactory.sol index 301d2bcd..7b8769c9 100644 --- a/src/value_factories/CurrentBlockTimestampFactory.sol +++ b/src/value_factories/CurrentBlockTimestampFactory.sol @@ -5,7 +5,7 @@ import {IValueFactory} from "../interfaces/IValueFactory.sol"; /** * @title CurrentBlockTimestampFactory - An on-chain value factory that returns the current block timestamp - * @dev Designed to be used with Safe + ExtensibleFallbackHandler + ComposableCoW + * @dev Designed to be used with Safe + ExtensibleFallbackHandler + ComposableCow * @author mfw78 */ contract CurrentBlockTimestampFactory is IValueFactory { diff --git a/test/ComposableCoW.t.sol b/test/ComposableCoW.t.sol index 34027c50..302ae7d3 100644 --- a/test/ComposableCoW.t.sol +++ b/test/ComposableCoW.t.sol @@ -6,18 +6,18 @@ import {ERC1271} from "safe/handler/extensible/SignatureVerifierMuxer.sol"; import { IConditionalOrder, GPv2Order, - ComposableCoW, - ComposableCoWLib, + ComposableCow, + ComposableCowLib, INVALID_HASH, - BaseComposableCoWTest, + BaseComposableCowTest, Safe, TestNonSafeWallet -} from "./ComposableCoW.base.t.sol"; +} from "./ComposableCow.base.t.sol"; -contract ComposableCoWTest is BaseComposableCoWTest { - using ComposableCoWLib for IConditionalOrder.ConditionalOrderParams[]; +contract ComposableCowTest is BaseComposableCowTest { + using ComposableCowLib for IConditionalOrder.ConditionalOrderParams[]; - function setUp() public virtual override(BaseComposableCoWTest) { + function setUp() public virtual override(BaseComposableCowTest) { // setup Base super.setUp(); } @@ -26,17 +26,17 @@ contract ComposableCoWTest is BaseComposableCoWTest { * @dev Can set the Merkle root for `owner` */ function test_setRoot_FuzzSetAndEmit(address owner, bytes32 root) public { - _setRoot(owner, root, ComposableCoW.Proof({location: 0, data: ""})); + _setRoot(owner, root, ComposableCow.Proof({location: 0, data: ""})); } function test_setRootWithContext_FuzzSetAndEmit(address owner, bytes32 root, bytes32 data) public { _setRootWithContext( - owner, root, ComposableCoW.Proof({location: 0, data: ""}), testContextValue, abi.encode(data) + owner, root, ComposableCow.Proof({location: 0, data: ""}), testContextValue, abi.encode(data) ); } /** - * @dev An end-to-end test of the ComposableCoW contract that tests the following: + * @dev An end-to-end test of the ComposableCow contract that tests the following: * 1. Does **NOT** validate a proof that is not authorized * 2. `owner` can set their merkle root * 3. **DOES** validate a proof that is authorized @@ -49,11 +49,11 @@ contract ComposableCoWTest is BaseComposableCoWTest { _leaves.getRootAndProof(0, leaves, getRoot, getProof); // should fail to validate the proof as root is still set bytes32(0) - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); // should set the root correctly - ComposableCoW.Proof memory proofStruct = ComposableCoW.Proof({location: 0, data: ""}); + ComposableCow.Proof memory proofStruct = ComposableCow.Proof({location: 0, data: ""}); _setRoot(address(safe1), root, proofStruct); // should pass with the root correctly set @@ -73,12 +73,12 @@ contract ComposableCoWTest is BaseComposableCoWTest { _setRoot(address(safe1), bytes32(0), proofStruct); // should fail as the root is set to bytes32(0) - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); } /** - * @dev An end-to-end test of the ComposableCoW contract that tests the following: + * @dev An end-to-end test of the ComposableCow contract that tests the following: * 1. Does **NOT** validate a proof that is not authorized * 2. `owner` can set their merkle root * 3. **DOES** validate a proof that is authorized @@ -91,11 +91,11 @@ contract ComposableCoWTest is BaseComposableCoWTest { _leaves.getRootAndProof(0, leaves, getRoot, getProof); // should fail to validate the proof as root is still set bytes32(0) - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); // should set the root correctly - ComposableCoW.Proof memory proofStruct = ComposableCoW.Proof({location: 0, data: ""}); + ComposableCow.Proof memory proofStruct = ComposableCow.Proof({location: 0, data: ""}); _setRootWithContext(address(safe1), root, proofStruct, testContextValue, abi.encode(bytes32("testValue"))); // should pass with the root correctly set @@ -115,7 +115,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { _setRoot(address(safe1), bytes32(0), proofStruct); // should fail as the root is set to bytes32(0) - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); } @@ -129,7 +129,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { staticInput: "" }); - vm.expectRevert(ComposableCoW.InvalidHandler.selector); + vm.expectRevert(ComposableCow.InvalidHandler.selector); // should revert as the handler (address(0)) is invalid composableCow.create(params, true); @@ -195,7 +195,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { } /** - * @dev An end-to-end test of the ComposableCoW contract that tests the following: + * @dev An end-to-end test of the ComposableCow contract that tests the following: * 1. Does **NOT** validate a single order that is not authorized * 2. `owner` can create a single order * 3. Can lookup the validity of the single order for `owner` @@ -212,7 +212,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { assertEq(composableCow.singleOrders(address(safe1), orderHash), false); // should fail to return the order as it is not authorized - vm.expectRevert(ComposableCoW.SingleOrderNotAuthed.selector); + vm.expectRevert(ComposableCow.SingleOrderNotAuthed.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); // can create the order @@ -235,7 +235,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { _remove(address(safe1), params); // should fail to settle the order as it has been removed - settle(address(safe1), bob, order, signature, ComposableCoW.SingleOrderNotAuthed.selector); + settle(address(safe1), bob, order, signature, ComposableCow.SingleOrderNotAuthed.selector); } /** @@ -265,7 +265,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { bytes32(0), abi.encode(order1), abi.encode( - ComposableCoW.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: abi.encode(order2)}) + ComposableCow.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: abi.encode(order2)}) ) ); } @@ -291,10 +291,10 @@ contract ComposableCoWTest is BaseComposableCoWTest { }); // should set the root - _setRoot(owner, root, ComposableCoW.Proof({location: 0, data: ""})); + _setRoot(owner, root, ComposableCow.Proof({location: 0, data: ""})); // should revert as the proof is invalid - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.isValidSafeSignature( Safe(payable(owner)), address(0), // sender isn't used @@ -302,7 +302,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { keccak256("some domain separator"), bytes32(0), // typeHash isn't used abi.encode(getBlankOrder()), - abi.encode(ComposableCoW.PayloadStruct({proof: proof, params: params, offchainInput: bytes("")})) + abi.encode(ComposableCow.PayloadStruct({proof: proof, params: params, offchainInput: bytes("")})) ); } @@ -324,7 +324,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { }); // should revert as the order has not been created - vm.expectRevert(ComposableCoW.SingleOrderNotAuthed.selector); + vm.expectRevert(ComposableCow.SingleOrderNotAuthed.selector); composableCow.isValidSafeSignature( Safe(payable(owner)), address(0), // sender isn't used @@ -332,7 +332,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { keccak256("some domain separator"), bytes32(0), // typeHash isn't used abi.encode(getBlankOrder()), - abi.encode(ComposableCoW.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: bytes("")})) + abi.encode(ComposableCow.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: bytes("")})) ); } @@ -366,7 +366,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { bytes32(0), // typeHash isn't used abi.encode(order), abi.encode( - ComposableCoW.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: offchainInput}) + ComposableCow.PayloadStruct({proof: new bytes32[](0), params: params, offchainInput: offchainInput}) ) ) ); @@ -408,7 +408,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { _create(alice.addr, params, false); // should revert as the interface is not supported - vm.expectRevert(ComposableCoW.InterfaceNotSupported.selector); + vm.expectRevert(ComposableCow.InterfaceNotSupported.selector); composableCow.getTradeableOrderWithSignature(alice.addr, params, bytes(""), new bytes32[](0)); } @@ -433,10 +433,10 @@ contract ComposableCoWTest is BaseComposableCoWTest { }); // should set the root - _setRoot(owner, root, ComposableCoW.Proof({location: 0, data: ""})); + _setRoot(owner, root, ComposableCow.Proof({location: 0, data: ""})); // should revert as the proof is invalid - vm.expectRevert(ComposableCoW.ProofNotAuthed.selector); + vm.expectRevert(ComposableCow.ProofNotAuthed.selector); composableCow.getTradeableOrderWithSignature(owner, params, bytes(""), proof); } @@ -456,7 +456,7 @@ contract ComposableCoWTest is BaseComposableCoWTest { }); // should revert as the order has not been created - vm.expectRevert(ComposableCoW.SingleOrderNotAuthed.selector); + vm.expectRevert(ComposableCow.SingleOrderNotAuthed.selector); composableCow.getTradeableOrderWithSignature(owner, params, bytes(""), new bytes32[](0)); } diff --git a/test/ComposableCoW.base.t.sol b/test/ComposableCow.base.t.sol similarity index 91% rename from test/ComposableCoW.base.t.sol rename to test/ComposableCow.base.t.sol index bb4801de..1b624ef5 100644 --- a/test/ComposableCoW.base.t.sol +++ b/test/ComposableCow.base.t.sol @@ -9,7 +9,7 @@ import {Safe, IERC165, Enum} from "safe/Safe.sol"; import {Base} from "./Base.t.sol"; import {TestAccount, TestAccountLib} from "./libraries/TestAccountLib.t.sol"; import {SafeLib} from "./libraries/SafeLib.t.sol"; -import {ComposableCoWLib} from "./libraries/ComposableCoWLib.t.sol"; +import {ComposableCowLib} from "./libraries/ComposableCowLib.t.sol"; import {IConditionalOrder, IERC20, BaseConditionalOrder, INVALID_HASH} from "../src/BaseConditionalOrder.sol"; import {BaseSwapGuard} from "../src/guards/BaseSwapGuard.sol"; @@ -21,17 +21,17 @@ import {ReceiverLock} from "../src/guards/ReceiverLock.sol"; import {IValueFactory} from "../src/interfaces/IValueFactory.sol"; -import {ISwapGuard, ComposableCoW, GPv2Order} from "../src/ComposableCoW.sol"; +import {ISwapGuard, ComposableCow, GPv2Order} from "../src/ComposableCow.sol"; -contract BaseComposableCoWTest is Base, Merkle { - using ComposableCoWLib for IConditionalOrder.ConditionalOrderParams; +contract BaseComposableCowTest is Base, Merkle { + using ComposableCowLib for IConditionalOrder.ConditionalOrderParams; using SafeLib for Safe; - event MerkleRootSet(address indexed owner, bytes32 root, ComposableCoW.Proof proof); + event MerkleRootSet(address indexed owner, bytes32 root, ComposableCow.Proof proof); event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params); event SwapGuardSet(address indexed owner, ISwapGuard swapGuard); - ComposableCoW composableCow; + ComposableCow composableCow; TestConditionalOrderGenerator passThrough; TestContextSpecifyValue testContextValue; @@ -45,9 +45,9 @@ contract BaseComposableCoWTest is Base, Merkle { super.setUp(); // deploy composable cow - composableCow = new ComposableCoW(address(settlement)); + composableCow = new ComposableCow(address(settlement)); - // set safe1 to have the ComposableCoW `ISafeSignatureVerifier` custom verifier + // set safe1 to have the ComposableCow `ISafeSignatureVerifier` custom verifier // we will set the domainSeparator to settlement.domainSeparator() safe1.execute( address(safe1), @@ -70,16 +70,16 @@ contract BaseComposableCoWTest is Base, Merkle { } /** - * @dev Ensure `ComposableCoW` contract is the `ISafeSignatureVerifier` for `safe1` on the `settlement` domain + * @dev Ensure `ComposableCow` contract is the `ISafeSignatureVerifier` for `safe1` on the `settlement` domain */ - function test_SetUpState_ComposableCoWDomainVerifier_is_set() public { + function test_SetUpState_ComposableCowDomainVerifier_is_set() public { assertEq(address(eHandler.domainVerifiers(safe1, settlement.domainSeparator())), address(composableCow)); } /** - * @dev Ensure `ComposableCoW` and `Settlement` have the same domain separator + * @dev Ensure `ComposableCow` and `Settlement` have the same domain separator */ - function test_SetUpState_ComposableCoWDomainSeparator_is_set() public { + function test_SetUpState_ComposableCowDomainSeparator_is_set() public { assertEq(composableCow.domainSeparator(), settlement.domainSeparator()); } @@ -88,7 +88,7 @@ contract BaseComposableCoWTest is Base, Merkle { /** * @dev Sets the root and checks events / state */ - function _setRoot(address owner, bytes32 root, ComposableCoW.Proof memory proof) internal { + function _setRoot(address owner, bytes32 root, ComposableCow.Proof memory proof) internal { vm.prank(owner); vm.expectEmit(true, true, true, true); emit MerkleRootSet(owner, root, proof); @@ -102,7 +102,7 @@ contract BaseComposableCoWTest is Base, Merkle { function _setRootWithContext( address owner, bytes32 root, - ComposableCoW.Proof memory proof, + ComposableCow.Proof memory proof, IValueFactory valueFactory, bytes memory data ) internal { @@ -228,7 +228,7 @@ contract BaseComposableCoWTest is Base, Merkle { appData: keccak256("test.twap") }); - // 2. Create n conditional orders as leaves of the ComposableCoW + // 2. Create n conditional orders as leaves of the ComposableCow _leaves = new IConditionalOrder.ConditionalOrderParams[](n); for (uint256 i = 0; i < _leaves.length; i++) { _leaves[i] = IConditionalOrder.ConditionalOrderParams({ @@ -291,10 +291,10 @@ contract TestConditionalOrderGenerator is BaseConditionalOrder { } /** - * @dev Stub ERC1271Forwarder that forwards to a ComposableCoW + * @dev Stub ERC1271Forwarder that forwards to a ComposableCow */ contract TestNonSafeWallet is ERC1271Forwarder { - constructor(address composableCow) ERC1271Forwarder(ComposableCoW(composableCow)) {} + constructor(address composableCow) ERC1271Forwarder(ComposableCow(composableCow)) {} } /** diff --git a/test/ComposableCoW.forwarder.t.sol b/test/ComposableCow.forwarder.t.sol similarity index 85% rename from test/ComposableCoW.forwarder.t.sol rename to test/ComposableCow.forwarder.t.sol index a2125235..535216a8 100644 --- a/test/ComposableCoW.forwarder.t.sol +++ b/test/ComposableCow.forwarder.t.sol @@ -4,13 +4,13 @@ pragma solidity >=0.8.0 <0.9.0; import { GPv2Order, IConditionalOrder, - BaseComposableCoWTest, + BaseComposableCowTest, TestNonSafeWallet, ERC1271Forwarder -} from "./ComposableCoW.base.t.sol"; +} from "./ComposableCow.base.t.sol"; -contract ComposableCoWForwarderTest is BaseComposableCoWTest { - function setUp() public virtual override(BaseComposableCoWTest) { +contract ComposableCowForwarderTest is BaseComposableCowTest { + function setUp() public virtual override(BaseComposableCowTest) { // setup Base super.setUp(); } diff --git a/test/ComposableCoW.gat.t.sol b/test/ComposableCow.gat.t.sol similarity index 97% rename from test/ComposableCoW.gat.t.sol rename to test/ComposableCow.gat.t.sol index 4b58ab2b..1f82b31e 100644 --- a/test/ComposableCoW.gat.t.sol +++ b/test/ComposableCow.gat.t.sol @@ -9,10 +9,10 @@ import { IConditionalOrder, Safe, SafeLib, - BaseComposableCoWTest, - ComposableCoW, - ComposableCoWLib -} from "./ComposableCoW.base.t.sol"; + BaseComposableCowTest, + ComposableCow, + ComposableCowLib +} from "./ComposableCow.base.t.sol"; import { IExpectedOutCalculator, @@ -22,15 +22,15 @@ import { PRICE_CHECKER_FAILED } from "../src/types/GoodAfterTime.sol"; -contract ComposableCoWGatTest is BaseComposableCoWTest { - using ComposableCoWLib for IConditionalOrder.ConditionalOrderParams[]; +contract ComposableCowGatTest is BaseComposableCowTest { + using ComposableCowLib for IConditionalOrder.ConditionalOrderParams[]; using SafeLib for Safe; GoodAfterTime gat; TestExpectedOutCalculator testOutCalculator; - function setUp() public virtual override(BaseComposableCoWTest) { + function setUp() public virtual override(BaseComposableCowTest) { super.setUp(); // deploy the GAT handler @@ -319,7 +319,7 @@ contract ComposableCoWGatTest is BaseComposableCoWTest { } /** - * @dev Test the entire flow of a GAT order from `ComposableCoW`'s perspective + * @dev Test the entire flow of a GAT order from `ComposableCow`'s perspective */ function test_settle_e2e() public { // Create the price checker payload diff --git a/test/ComposableCoW.guards.t.sol b/test/ComposableCow.guards.t.sol similarity index 90% rename from test/ComposableCoW.guards.t.sol rename to test/ComposableCow.guards.t.sol index 22eec6a1..341c1756 100644 --- a/test/ComposableCoW.guards.t.sol +++ b/test/ComposableCow.guards.t.sol @@ -7,15 +7,15 @@ import { IERC165, IConditionalOrder, GPv2Order, - ComposableCoW, - BaseComposableCoWTest, + ComposableCow, + BaseComposableCowTest, ISwapGuard, TestSwapGuard, ReceiverLock -} from "./ComposableCoW.base.t.sol"; +} from "./ComposableCow.base.t.sol"; -contract ComposableCoWGuardsTest is BaseComposableCoWTest { - function setUp() public virtual override(BaseComposableCoWTest) { +contract ComposableCowGuardsTest is BaseComposableCowTest { + function setUp() public virtual override(BaseComposableCowTest) { // setup Base super.setUp(); } @@ -38,7 +38,7 @@ contract ComposableCoWGuardsTest is BaseComposableCoWTest { } /** - * @dev An end-to-end test of the ComposableCoW contract that tests the following: + * @dev An end-to-end test of the ComposableCow contract that tests the following: * 1. Validates a single order with no swap guard * 2. `owner` can set a swap guard * 3. Swap guard does **NOT** allow an invalid order to be validated @@ -76,10 +76,10 @@ contract ComposableCoWGuardsTest is BaseComposableCoWTest { _setSwapGuard(address(safe1), evenSwapGuard); // should not be able to settle as the swap guard doesn't allow it - settle(address(safe1), bob, order, signature, ComposableCoW.SwapGuardRestricted.selector); + settle(address(safe1), bob, order, signature, ComposableCow.SwapGuardRestricted.selector); // should not be able to return the order as the swap guard doesn't allow it - vm.expectRevert(ComposableCoW.SwapGuardRestricted.selector); + vm.expectRevert(ComposableCow.SwapGuardRestricted.selector); composableCow.getTradeableOrderWithSignature(address(safe1), params, bytes(""), proof); // should set the swap guard to the odd swap guard @@ -131,13 +131,13 @@ contract ComposableCoWGuardsTest is BaseComposableCoWTest { _setSwapGuard(address(safe1), lock); // should revert as the receiver is not the safe - vm.expectRevert(ComposableCoW.SwapGuardRestricted.selector); + vm.expectRevert(ComposableCow.SwapGuardRestricted.selector); composableCow.getTradeableOrderWithSignature( address(safe1), params, abi.encode(orderOtherReceiver), new bytes32[](0) ); // should revert as the receiver is not the safe - vm.expectRevert(ComposableCoW.SwapGuardRestricted.selector); + vm.expectRevert(ComposableCow.SwapGuardRestricted.selector); ERC1271(address(safe1)).isValidSignature(GPv2Order.hash(order, domainSeparator), signature); } } diff --git a/test/ComposableCoW.stoploss.t.sol b/test/ComposableCow.stoploss.t.sol similarity index 98% rename from test/ComposableCoW.stoploss.t.sol rename to test/ComposableCow.stoploss.t.sol index f2fb7841..089cefb3 100644 --- a/test/ComposableCoW.stoploss.t.sol +++ b/test/ComposableCow.stoploss.t.sol @@ -1,11 +1,11 @@ // SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.8.0 <0.9.0; -import {IERC20, GPv2Order, IConditionalOrder, BaseComposableCoWTest} from "./ComposableCoW.base.t.sol"; +import {IERC20, GPv2Order, IConditionalOrder, BaseComposableCowTest} from "./ComposableCow.base.t.sol"; import {IAggregatorV3Interface} from "../src/interfaces/IAggregatorV3Interface.sol"; import {StopLoss, STRIKE_NOT_REACHED, ORACLE_STALE_PRICE, ORACLE_INVALID_PRICE, ORDER_EXPIRED} from "../src/types/StopLoss.sol"; -contract ComposableCoWStopLossTest is BaseComposableCoWTest { +contract ComposableCowStopLossTest is BaseComposableCowTest { IERC20 immutable SELL_TOKEN = IERC20(address(0x1)); IERC20 immutable BUY_TOKEN = IERC20(address(0x2)); address constant SELL_ORACLE = address(0x3); @@ -17,7 +17,7 @@ contract ComposableCoWStopLossTest is BaseComposableCoWTest { StopLoss stopLoss; address safe; - function setUp() public virtual override(BaseComposableCoWTest) { + function setUp() public virtual override(BaseComposableCowTest) { super.setUp(); stopLoss = new StopLoss(); diff --git a/test/ComposableCoW.tat.t.sol b/test/ComposableCow.tat.t.sol similarity index 93% rename from test/ComposableCoW.tat.t.sol rename to test/ComposableCow.tat.t.sol index 650f6fd3..fcf9d73e 100644 --- a/test/ComposableCoW.tat.t.sol +++ b/test/ComposableCow.tat.t.sol @@ -3,18 +3,18 @@ pragma solidity >=0.8.0 <0.9.0; import {ERC1271} from "safe/handler/extensible/SignatureVerifierMuxer.sol"; -import "./ComposableCoW.base.t.sol"; +import "./ComposableCow.base.t.sol"; import "../src/types/TradeAboveThreshold.sol"; import {ConditionalOrdersUtilsLib as Utils} from "../src/types/ConditionalOrdersUtilsLib.sol"; -contract ComposableCoWTatTest is BaseComposableCoWTest { - using ComposableCoWLib for IConditionalOrder.ConditionalOrderParams[]; +contract ComposableCowTatTest is BaseComposableCowTest { + using ComposableCowLib for IConditionalOrder.ConditionalOrderParams[]; using SafeLib for Safe; TradeAboveThreshold tat; - function setUp() public virtual override(BaseComposableCoWTest) { + function setUp() public virtual override(BaseComposableCowTest) { super.setUp(); // deploy the TAT handler diff --git a/test/ComposableCoW.twap.t.sol b/test/ComposableCow.twap.t.sol similarity index 98% rename from test/ComposableCoW.twap.t.sol rename to test/ComposableCow.twap.t.sol index 09c47eef..c9f6d432 100644 --- a/test/ComposableCoW.twap.t.sol +++ b/test/ComposableCow.twap.t.sol @@ -9,12 +9,12 @@ import { IConditionalOrder, IValueFactory, GPv2Order, - ComposableCoW, - ComposableCoWLib, + ComposableCow, + ComposableCowLib, Safe, SafeLib, - BaseComposableCoWTest -} from "./ComposableCoW.base.t.sol"; + BaseComposableCowTest +} from "./ComposableCow.base.t.sol"; import {TWAP, NOT_WITHIN_SPAN} from "../src/types/twap/TWAP.sol"; import { @@ -40,8 +40,8 @@ uint32 constant FREQUENCY = 1 hours; uint32 constant NUM_PARTS = 24; uint32 constant SPAN = 5 minutes; -contract ComposableCoWTwapTest is BaseComposableCoWTest { - using ComposableCoWLib for IConditionalOrder.ConditionalOrderParams[]; +contract ComposableCowTwapTest is BaseComposableCowTest { + using ComposableCowLib for IConditionalOrder.ConditionalOrderParams[]; using SafeLib for Safe; TWAPOrder.Data defaultBundle; @@ -51,7 +51,7 @@ contract ComposableCoWTwapTest is BaseComposableCoWTest { mapping(bytes32 => uint256) public orderFills; - function setUp() public virtual override(BaseComposableCoWTest) { + function setUp() public virtual override(BaseComposableCowTest) { super.setUp(); // deploy the TWAP handler @@ -424,10 +424,10 @@ contract ComposableCoWTwapTest is BaseComposableCoWTest { } /** - * @dev Test the entire flow of a TWAP order from `ComposableCoW`'s perspective + * @dev Test the entire flow of a TWAP order from `ComposableCow`'s perspective */ function test_settle_e2e() public { - // 1. Get the TWAP conditional orders that will be used to dogfood the ComposableCoW + // 1. Get the TWAP conditional orders that will be used to dogfood the ComposableCow IConditionalOrder.ConditionalOrderParams[] memory _leaves = getBundle(safe1, 50); // 2. Do the merkle tree dance @@ -435,7 +435,7 @@ contract ComposableCoWTwapTest is BaseComposableCoWTest { _leaves.getRootAndProof(0, leaves, getRoot, getProof); // 3. Set the root - _setRoot(address(safe1), root, ComposableCoW.Proof({location: 0, data: ""})); + _setRoot(address(safe1), root, ComposableCow.Proof({location: 0, data: ""})); // 4. Get the order and signature (GPv2Order.Data memory order, bytes memory signature) = diff --git a/test/libraries/ComposableCoWLib.t.sol b/test/libraries/ComposableCowLib.t.sol similarity index 99% rename from test/libraries/ComposableCoWLib.t.sol rename to test/libraries/ComposableCowLib.t.sol index afeb8f54..8a843c1f 100644 --- a/test/libraries/ComposableCoWLib.t.sol +++ b/test/libraries/ComposableCowLib.t.sol @@ -4,7 +4,7 @@ pragma solidity >=0.8.0 <0.9.0; import {Merkle} from "murky/Merkle.sol"; import {IConditionalOrder} from "../../src/interfaces/IConditionalOrder.sol"; -library ComposableCoWLib { +library ComposableCowLib { function hash(IConditionalOrder.ConditionalOrderParams memory params) internal pure returns (bytes32) { return keccak256(bytes.concat(keccak256(abi.encode(params)))); }