Feat/collateral swap 2

.github/workflows/ci.yml

@@ -31,13 +31,12 @@ jobs:
 
       - name: Run lint
         run: |
-          yarn cache clean --all
-          YARN_CHECKSUM_BEHAVIOR=update yarn
+          touch .env
           yarn
-          yarn build
-          yarn doc
-          yarn lint
-          yarn size
+          make build
+          make doc
+          make lint
+          make size
 
   tests:
     name: Unit Tests
@@ -65,11 +64,10 @@ jobs:
 
       - name: Run unit tests
         run: |
-          yarn cache clean --all
-          YARN_CHECKSUM_BEHAVIOR=update yarn
+          touch .env
           yarn
-          yarn build
-          yarn test
+          make build
+          make test
 
   coverage:
     name: Coverage Check
@@ -95,11 +93,10 @@ jobs:
         with:
           node-version: ${{ matrix.node }}
       - run: |
-          yarn cache clean --all
-          YARN_CHECKSUM_BEHAVIOR=update yarn
+          touch .env
           yarn
-          yarn build
-          yarn coverage
+          make build
+          make coverage
         env:
           NODE_OPTIONS: --max_old_space_size=8192
       - name: Publish coverage

Makefile

@@ -47,7 +47,6 @@ doc:
 
 .PHONY: lint
 lint:
-	typos
 	yarn lint
 
 .PHONY: coverage
@@ -104,6 +103,18 @@ test-erc20-liquidation:
 test-erc20-borrow:
 	make TEST_TARGET=_pool_core_erc20_borrow.spec.ts test
 
+.PHONY: test-erc20-borrow-swap
+test-erc20-borrow-swap:
+	make TEST_TARGET=_pool_core_erc20_borrow_swap.spec.ts test
+
+.PHONY: test-erc20-ptoken-swap
+test-erc20-ptoken-swap:
+	make TEST_TARGET=_pool_core_erc20_ptoken_swap.spec.ts test
+
+.PHONY: test-erc20-debt-swap
+test-erc20-debt-swap:
+	make TEST_TARGET=_pool_core_erc20_debt_swap.spec.ts test
+
 .PHONY: test-erc20-supply
 test-erc20-supply:
 	make TEST_TARGET=_pool_core_erc20_supply.spec.ts test
@@ -172,6 +183,10 @@ test-moonbirds:
 test-marketplace-buy:
 	make TEST_TARGET=_pool_marketplace_buy_with_credit.spec.ts test
 
+.PHONY: test-marketplace-buy-any
+test-marketplace-buy-any:
+	make TEST_TARGET=_pool_marketplace_buy_any_with_credit.spec.ts test
+
 .PHONY: test-marketplace-accept-bid
 test-marketplace-accept-bid:
 	make TEST_TARGET=_pool_marketplace_accept_bid_with_credit.spec.ts test

contracts/account-abstraction/base-account-abstraction/core/BaseAccount.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 /* solhint-disable avoid-low-level-calls */
 /* solhint-disable no-empty-blocks */

contracts/account-abstraction/base-account-abstraction/interfaces/IAccount.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 import {UserOperation} from "../utils/UserOperation.sol";
 

contracts/account-abstraction/base-account-abstraction/interfaces/IAggregator.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 import {UserOperation} from "../utils/UserOperation.sol";
 

contracts/account-abstraction/base-account-abstraction/interfaces/IEntryPoint.sol

@@ -3,7 +3,7 @@
  ** Only one instance required on each chain.
  **/
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 /* solhint-disable avoid-low-level-calls */
 /* solhint-disable no-inline-assembly */

contracts/account-abstraction/base-account-abstraction/interfaces/INonceManager.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 interface INonceManager {
     /**

contracts/account-abstraction/base-account-abstraction/interfaces/IPaymaster.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 import {UserOperation} from "../utils/UserOperation.sol";
 

contracts/account-abstraction/base-account-abstraction/interfaces/IStakeManager.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 /**
  * manage deposits and stakes.

contracts/account-abstraction/base-account-abstraction/utils/UserOperation.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.0;
 
 /**
  * User Operation struct

contracts/dependencies/uniswapv3-core/libraries/BytesLib.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * @title Solidity Bytes Arrays Utils
+ * @author Gonçalo Sá <goncalo.sa@consensys.net>
+ *
+ * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
+ *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
+ */
+pragma solidity ^0.8.0;
+
+library BytesLib {
+    function slice(
+        bytes memory _bytes,
+        uint256 _start,
+        uint256 _length
+    ) internal pure returns (bytes memory) {
+        require(_length + 31 >= _length, 'slice_overflow');
+        require(_start + _length >= _start, 'slice_overflow');
+        require(_bytes.length >= _start + _length, 'slice_outOfBounds');
+
+        bytes memory tempBytes;
+
+        assembly {
+            switch iszero(_length)
+                case 0 {
+                    // Get a location of some free memory and store it in tempBytes as
+                    // Solidity does for memory variables.
+                    tempBytes := mload(0x40)
+
+                    // The first word of the slice result is potentially a partial
+                    // word read from the original array. To read it, we calculate
+                    // the length of that partial word and start copying that many
+                    // bytes into the array. The first word we copy will start with
+                    // data we don't care about, but the last `lengthmod` bytes will
+                    // land at the beginning of the contents of the new array. When
+                    // we're done copying, we overwrite the full first word with
+                    // the actual length of the slice.
+                    let lengthmod := and(_length, 31)
+
+                    // The multiplication in the next line is necessary
+                    // because when slicing multiples of 32 bytes (lengthmod == 0)
+                    // the following copy loop was copying the origin's length
+                    // and then ending prematurely not copying everything it should.
+                    let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
+                    let end := add(mc, _length)
+
+                    for {
+                        // The multiplication in the next line has the same exact purpose
+                        // as the one above.
+                        let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
+                    } lt(mc, end) {
+                        mc := add(mc, 0x20)
+                        cc := add(cc, 0x20)
+                    } {
+                        mstore(mc, mload(cc))
+                    }
+
+                    mstore(tempBytes, _length)
+
+                    //update free-memory pointer
+                    //allocating the array padded to 32 bytes like the compiler does now
+                    mstore(0x40, and(add(mc, 31), not(31)))
+                }
+                //if we want a zero-length slice let's just return a zero-length array
+                default {
+                    tempBytes := mload(0x40)
+                    //zero out the 32 bytes slice we are about to return
+                    //we need to do it because Solidity does not garbage collect
+                    mstore(tempBytes, 0)
+
+                    mstore(0x40, add(tempBytes, 0x20))
+                }
+        }
+
+        return tempBytes;
+    }
+
+    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
+        require(_start + 20 >= _start, 'toAddress_overflow');
+        require(_bytes.length >= _start + 20, 'toAddress_outOfBounds');
+        address tempAddress;
+
+        assembly {
+            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
+        }
+
+        return tempAddress;
+    }
+
+    function toUint24(bytes memory _bytes, uint256 _start) internal pure returns (uint24) {
+        require(_start + 3 >= _start, 'toUint24_overflow');
+        require(_bytes.length >= _start + 3, 'toUint24_outOfBounds');
+        uint24 tempUint;
+
+        assembly {
+            tempUint := mload(add(add(_bytes, 0x3), _start))
+        }
+
+        return tempUint;
+    }
+}

contracts/dependencies/uniswapv3-core/libraries/Path.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {BytesLib} from './BytesLib.sol';
+
+/// @title Functions for manipulating path data for multihop swaps
+library Path {
+    using BytesLib for bytes;
+
+    /// @dev The length of the bytes encoded address
+    uint256 private constant ADDR_SIZE = 20;
+    /// @dev The length of the bytes encoded fee
+    uint256 private constant FEE_SIZE = 3;
+
+    /// @dev The offset of a single token address and pool fee
+    uint256 private constant NEXT_OFFSET = ADDR_SIZE + FEE_SIZE;
+    /// @dev The offset of an encoded pool key
+    uint256 private constant POP_OFFSET = NEXT_OFFSET + ADDR_SIZE;
+    /// @dev The minimum length of an encoding that contains 2 or more pools
+    uint256 private constant MULTIPLE_POOLS_MIN_LENGTH = POP_OFFSET + NEXT_OFFSET;
+
+    /// @notice Returns true iff the path contains two or more pools
+    /// @param path The encoded swap path
+    /// @return True if path contains two or more pools, otherwise false
+    function hasMultiplePools(bytes memory path) internal pure returns (bool) {
+        return path.length >= MULTIPLE_POOLS_MIN_LENGTH;
+    }
+
+    /// @notice Returns the number of pools in the path
+    /// @param path The encoded swap path
+    /// @return The number of pools in the path
+    function numPools(bytes memory path) internal pure returns (uint256) {
+        // Ignore the first token address. From then on every fee and token offset indicates a pool.
+        return ((path.length - ADDR_SIZE) / NEXT_OFFSET);
+    }
+
+    /// @notice Decodes the first pool in path
+    /// @param path The bytes encoded swap path
+    /// @return tokenA The first token of the given pool
+    /// @return tokenB The second token of the given pool
+    /// @return fee The fee level of the pool
+    function decodeFirstPool(bytes memory path)
+        internal
+        pure
+        returns (
+            address tokenA,
+            address tokenB,
+            uint24 fee
+        )
+    {
+        tokenA = path.toAddress(0);
+        fee = path.toUint24(ADDR_SIZE);
+        tokenB = path.toAddress(NEXT_OFFSET);
+    }
+
+    /// @notice Gets the segment corresponding to the first pool in the path
+    /// @param path The bytes encoded swap path
+    /// @return The segment containing all data necessary to target the first pool in the path
+    function getFirstPool(bytes memory path) internal pure returns (bytes memory) {
+        return path.slice(0, POP_OFFSET);
+    }
+
+    /// @notice Skips a token + fee element from the buffer and returns the remainder
+    /// @param path The swap path
+    /// @return The remaining token + fee elements in the path
+    function skipToken(bytes memory path) internal pure returns (bytes memory) {
+        return path.slice(NEXT_OFFSET, path.length - NEXT_OFFSET);
+    }
+}

contracts/interfaces/IOneInch.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.0;
+
+interface IAggregationExecutor {
+    /// @notice propagates information about original msg.sender and executes arbitrary data
+    function execute(address msgSender) external payable; // 0x4b64e492
+}
+
+interface IOneInch {
+    struct SwapDescription {
+        address srcToken;
+        address dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    function swap(
+        IAggregationExecutor executor,
+        SwapDescription calldata desc,
+        bytes calldata permit,
+        bytes calldata data
+    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
+}