Merge branch 'master' into development

Author: kasperpawlowski

docs/selector-access-control.md

@@ -87,9 +87,9 @@ If you prefer to deploy the components individually:
 
 This contract is a specialized risk management contract that combines `SelectorAccessControl` with controlled parameter adjustment capabilities for EVK vaults. It is compatible with the `GovernorAccessControl` and `GovernorAccessControlEmergency` contracts and enables authorized users to modify vault parameters (caps and interest rate models) while enforcing safety limits.
 
-`CapRiskSteward` allows autorized users to increase/decrease supply and borrow caps by up to 50% over 3 days. The maximum readjustment factor recharges over time. 
+`CapRiskSteward` allows authorized users to increase/decrease supply and borrow caps by up to 50% over 3 days. The maximum readjustment factor recharges over time. 
 
-`CapRiskSteward` allows autorized users to substitute the interest rate model for an interest model deployed by the recognized factory.
+`CapRiskSteward` allows authorized users to substitute the interest rate model for an interest model deployed by the recognized factory.
 
 ### Usage
 
@@ -108,4 +108,4 @@ This contract can be associated with one or more vaults deployed by the specifie
 1. Deploy an instance of `HookTargetAccessControl`, specifying the EVC address, default admin, and associated EVault factory address
 2. Grant roles to addresses for specific function selectors or the `WILD_CARD`
 3. Install the `HookTargetAccessControl` instance as a hook target for the desired vault(s) and configure hooked operations
-4. The vault will now enforce access control checks for hooked operations
+4. The vault will now enforce access control checks for hooked operations

docs/swaps.md

@@ -2,7 +2,7 @@
 
 The `Swapper` and `SwapVerifier` contracts are helpers for executing swaps and swaps-to-repay operations on EVK vaults, using EVC batches.
 
-## Security and trust boundries
+## Security and trust boundaries
 
 The `Swapper` contract is not trusted. From the protocol's perspective, it is a black box. Provided with a token to sell, it is supposed to execute the swap and return the bought token either as a balance available for deposit or as repaid debt. No assumptions are made about how the swap is performed or about the security of the `Swapper` code. In fact, the `Swapper` has no access control and allows anyone to remove any token balance it holds at any time. The provided implementation is just a reference; users are generally free to use any swapper they choose.
 
@@ -34,7 +34,7 @@ The general steps to use the `Swapper` contract are following:
 
 The `Swapper` contract should implement the `ISwapper` interface. This ensures, that users could potentially provide their own implementations of the swapper contract in the UI, without needing to modify the FE code.
 
-The main function is `swap()`, which takes a swap definition in a `SwapParams` struct. The params define a handler to use, swapping mode, bought and sold tokens, the amounts etc. See [ISwapper natspec](../src/Swaps/ISwapper.sol) for details. Note, that some parameters might be ignored in certain modes or by certain handlers, while others (`amountOut`) might have differrent semantics in certain modes.
+The main function is `swap()`, which takes a swap definition in a `SwapParams` struct. The params define a handler to use, swapping mode, bought and sold tokens, the amounts etc. See [ISwapper natspec](../src/Swaps/ISwapper.sol) for details. Note, that some parameters might be ignored in certain modes or by certain handlers, while others (`amountOut`) might have different semantics in certain modes.
 
 The interface also defines helper functions like `sweep`, `deposit`, `repay` and `repayAndDeposit` which allow consuming the contract's balance.
 
@@ -111,7 +111,7 @@ F2. Swap deposits from one EVault (A) to exact amount of another (B)
   - `A.withdraw` to the swapper contract. The amount must cover all of the estimated swap costs with some extra, to account for slippage
   - `swapper.multicall` with the following items:
     - `Swapper.swap` - `exact input` on the generic handler with the off-chain payload
-    - `Swapper.swap` - `exact output` on one of the supportin handlers (Uni V2/V3) with the user specified `amountOut`. The receiver can be either the swapper contract or B vault.
+    - `Swapper.swap` - `exact output` on one of the supporting handlers (Uni V2/V3) with the user specified `amountOut`. The receiver can be either the swapper contract or B vault.
     - `Swapper.sweep` the output token, into the B vault
   - `SwapVerifier.verifyAmountMinAndSkim` check a minimum required amount was bought and claim the funds for the user. Because exact output swaps are not guaranteed to be exact always, a small slippage could be allowed.
 

script/22_EulerSwapFactory.s.sol

@@ -13,9 +13,9 @@ contract EulerSwapFactoryDeployer is ScriptUtils {
         address eVaultFactory = vm.parseJsonAddress(json, ".eVaultFactory");
         address eulerSwapImplementation = vm.parseJsonAddress(json, ".eulerSwapImplementation");
         address feeOwner = vm.parseJsonAddress(json, ".feeOwner");
-        address feeReceipientSetter = vm.parseJsonAddress(json, ".feeReceipientSetter");
+        address feeRecipientSetter = vm.parseJsonAddress(json, ".feeRecipientSetter");
 
-        eulerSwapFactory = execute(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeReceipientSetter);
+        eulerSwapFactory = execute(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeRecipientSetter);
 
         string memory object;
         object = vm.serializeAddress("factory", "eulerSwapFactory", eulerSwapFactory);
@@ -28,21 +28,21 @@ contract EulerSwapFactoryDeployer is ScriptUtils {
         address eVaultFactory,
         address eulerSwapImplementation,
         address feeOwner,
-        address feeReceipientSetter
+        address feeRecipientSetter
     ) public broadcast returns (address eulerSwapFactory) {
-        eulerSwapFactory = execute(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeReceipientSetter);
+        eulerSwapFactory = execute(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeRecipientSetter);
     }
 
     function execute(
         address evc,
         address eVaultFactory,
         address eulerSwapImplementation,
         address feeOwner,
-        address feeReceipientSetter
+        address feeRecipientSetter
     ) public returns (address eulerSwapFactory) {
         bytes memory bytecode = abi.encodePacked(
             vm.getCode("out-euler-swap/EulerSwapFactory.sol/EulerSwapFactory.json"),
-            abi.encode(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeReceipientSetter)
+            abi.encode(evc, eVaultFactory, eulerSwapImplementation, feeOwner, feeRecipientSetter)
         );
         assembly {
             eulerSwapFactory := create(0, add(bytecode, 0x20), mload(bytecode))

test/Governor/FactoryGovernor.t.sol

@@ -91,7 +91,7 @@ contract FactoryGovernorTests is EVaultTestBase {
         assertEq(eTST.balanceOf(depositor), 102e18);
     }
 
-    function test_FactoryGovernor_unathorizedCantTriggePause() external {
+    function test_FactoryGovernor_unauthorizedCantTriggePause() external {
         vm.prank(admin);
         vm.expectRevert();
         factoryGovernor.pause(address(factory));
@@ -132,7 +132,7 @@ contract FactoryGovernorTests is EVaultTestBase {
         assertEq(eTST.balanceOf(depositor), 101e18);
     }
 
-    function test_FactoryGovernor_unathorizedCantTriggeUnpause() external {
+    function test_FactoryGovernor_unauthorizedCantTriggeUnpause() external {
         vm.prank(admin);
         vm.expectRevert();
         factoryGovernor.unpause(address(factory));