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)))); }