Improve test coverage action [@coderabbit ignore]

.github/workflows/enforceTestCoverage.yml

@@ -6,7 +6,7 @@ name: Enforce Min Test Coverage
 
 on:
   pull_request:
-    types: [opened, synchronize, reopened]
+    types: [opened, synchronize, reopened, ready_for_review]
 
 jobs:
   enforce-min-test-coverage:
@@ -27,6 +27,8 @@ jobs:
       MIN_TEST_COVERAGE: 74 # = 74% line coverage
     steps:
       - uses: actions/[email protected]
+        with:
+          fetch-depth: 0 ##### Fetch all history for all branches
 
       - name: Set up Node.js
         uses: actions/setup-node@v4
@@ -54,12 +56,20 @@ jobs:
 
           echo "Coverage report successfully filtered"
 
-      - name: Generate Coverage Summary
+      # Step to get modified or added files in the src/ folder
+      - name: Get Modified Files
+        id: get_modified_files
         run: |
+          # Get list of modified or added files in src directory
+          MODIFIED_FILES=$(git diff --name-only --diff-filter=AM origin/main | grep '^src/.*\.sol$')
+          echo "modified_files=$MODIFIED_FILES" >> "$GITHUB_ENV"
 
+      - name: Generate Coverage Summary
+        run: |
 
           # Path to the lcov info file
           LCOV_FILE="lcov-filtered.info"
+          MODIFIED_FILES=(${MODIFIED_FILES})
 
           # Initialize counters
           TOTAL_LINES_FOUND=0
@@ -69,14 +79,23 @@ jobs:
           TOTAL_BRANCHES_FOUND=0
           TOTAL_BRANCHES_HIT=0
 
+          # Clear the per-file coverage report file
+          echo "" > per_file_coverage_report.txt
+
           # Read through the lcov file
           while IFS= read -r line; do
               case $line in
+                  SF:*)
+                      CURRENT_FILE=${line#SF:}
+                      FILE_NAME=$(basename "$CURRENT_FILE")
+                      ;;
                   LF:*)
                       TOTAL_LINES_FOUND=$((TOTAL_LINES_FOUND + ${line#LF:}))
+                      FILE_LINES_FOUND=${line#LF:}
                       ;;
                   LH:*)
                       TOTAL_LINES_HIT=$((TOTAL_LINES_HIT + ${line#LH:}))
+                      FILE_LINES_HIT=${line#LH:}
                       ;;
                   FNF:*)
                       TOTAL_FUNCTIONS_FOUND=$((TOTAL_FUNCTIONS_FOUND + ${line#FNF:}))
@@ -91,6 +110,16 @@ jobs:
                       TOTAL_BRANCHES_HIT=$((TOTAL_BRANCHES_HIT + ${line#BRH:}))
                       ;;
               esac
+
+              # Check if the file is in the list of modified files
+              if [[ " ${MODIFIED_FILES[@]} " =~ " $FILE_NAME " ]]; then
+                # Calculate line coverage percentage for the current file
+                LINE_COVERAGE_PERCENTAGE=$(echo "scale=2; $FILE_LINES_HIT / $FILE_LINES_FOUND * 100" | bc)
+
+                # Append the per-file coverage to the report file
+                echo "File: $FILE_NAME - Line Coverage: $LINE_COVERAGE_PERCENTAGE% ($FILE_LINES_HIT / $FILE_LINES_FOUND)" >> per_file_coverage_report.txt
+              fi
+
           done < "$LCOV_FILE"
 
           # Calculate percentages with high precision
@@ -118,7 +147,7 @@ jobs:
             exit 1
           fi
 
-          # Output result_COVERAGE_REPORTs
+          # Output results
           echo "$LINE_COVERAGE_REPORT"
           echo "$FUNCTION_COVERAGE_REPORT"
           echo "$BRANCH_COVERAGE_REPORT"
@@ -131,14 +160,3 @@ jobs:
           echo "BRANCH_COVERAGE_REPORT=$BRANCH_COVERAGE_REPORT"
           echo "RESULT_COVERAGE_REPORT=$RESULT_COVERAGE_REPORT"
           } >> "$GITHUB_ENV"
-
-      - name: Comment with Coverage Summary in PR
-        uses: mshick/[email protected]
-        with:
-          repo-token: ${{ secrets.GIT_ACTIONS_BOT_PAT_CLASSIC }}
-          message: |
-            ## Test Coverage Report
-            ${{ env.LINE_COVERAGE_REPORT }}
-            ${{ env.FUNCTION_COVERAGE_REPORT }}
-            ${{ env.BRANCH_COVERAGE_REPORT }}
-            ${{ env.RESULT_COVERAGE_REPORT }}

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "lib/solady"]
 	path = lib/solady
 	url = https://github.com/Vectorized/solady
+[submodule "lib/Permit2"]
+	path = lib/Permit2
+	url = https://github.com/Uniswap/Permit2

config/permit2.json

@@ -0,0 +1,31 @@
+{
+  "mainnet": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "arbitrum": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "aurora": "",
+  "avalanche": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "base": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "blast": "0x000000000022d473030f116ddee9f6b43ac78ba3",
+  "boba": "",
+  "bsc": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "celo": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "fantom": "",
+  "fraxtal": "",
+  "fuse": "",
+  "gnosis": "",
+  "gravity": "",
+  "immutablezkevm": "",
+  "linea": "",
+  "mantle": "",
+  "metis": "",
+  "mode": "",
+  "moonbeam": "",
+  "moonriver": "",
+  "optimism": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "polygon": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+  "polygonzkevm": "",
+  "rootstock": "",
+  "scroll": "",
+  "sei": "",
+  "taiko": "",
+  "zksync": "0x0000000000225e31d15943971f47ad3022f714fa"
+}

deployments/_deployments_log_file.json

@@ -22453,5 +22453,21 @@
         ]
       }
     }
+  },
+  "Permit2Proxy": {
+    "arbitrum": {
+      "staging": {
+        "1.0.0": [
+          {
+            "ADDRESS": "0xA3C7a31a2A97b847D967e0B755921D084C46a742",
+            "OPTIMIZER_RUNS": "1000000",
+            "TIMESTAMP": "2024-08-30 14:01:34",
+            "CONSTRUCTOR_ARGS": "0x000000000000000000000000d3b2b0ac0afdd0d166a495f5e9fca4ecc715a782000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3",
+            "SALT": "09072024",
+            "VERIFIED": "true"
+          }
+        ]
+      }
+    }
   }
 }

deployments/arbitrum.staging.json

@@ -44,5 +44,6 @@
   "CircleBridgeFacet": "0xa73a8BC8d36472269138c3233e24D0Ee0c344bd8",
   "HopFacetOptimized": "0xf82135385765f1324257ffF74489F16382EBBb8A",
   "LiFuelFeeCollector": "0x94EA56D8049e93E0308B9c7d1418Baf6A7C68280",
-  "TokenWrapper": "0xF63b27AE2Dc887b88f82E2Cc597d07fBB2E78E70"
+  "TokenWrapper": "0xF63b27AE2Dc887b88f82E2Cc597d07fBB2E78E70",
+  "Permit2Proxy": "0xA3C7a31a2A97b847D967e0B755921D084C46a742"
 }

docs/Permit2Proxy.md

@@ -0,0 +1,126 @@
+# Permit2 Proxy
+
+## Description
+
+Periphery contract which enables gasless and semi-gasless transaction flows
+enabled through ERC20 Permit and Uniswap's Permit2
+
+## How To Use
+
+The contract has a number of methods for making gasless and semi-gasless calls
+as well as a few helpful utility methods.
+
+The following methods are available:
+
+This method is used to execute a transaction where the approval is granted
+using an ERC20 Permit signature. It can only be called by the signer in order
+to prevent front-running attacks.
+
+```solidity
+/// @notice Allows to bridge tokens through a LI.FI diamond contract using
+/// an EIP2612 gasless permit (only works with tokenAddresses that
+/// implement EIP2612) (in contrast to Permit2, calldata and diamondAddress
+/// are not signed by the user and could therefore be replaced by the user)
+/// Can only be called by the permit signer to prevent front-running.
+/// @param tokenAddress Address of the token to be bridged
+/// @param amount Amount of tokens to be bridged
+/// @param deadline Transaction must be completed before this timestamp
+/// @param v User signature (recovery ID)
+/// @param r User signature (ECDSA output)
+/// @param s User signature (ECDSA output)
+/// @param diamondCalldata Address of the token to be bridged
+function callDiamondWithEIP2612Signature(
+    address tokenAddress,
+    uint256 amount,
+    uint256 deadline,
+    uint8 v,
+    bytes32 r,
+    bytes32 s,
+    bytes calldata diamondCalldata
+) public payable 
+````
+
+This method is used to execute a transaction where the approval is granted via
+Uniswap's Permit2 contract. It can only be called by the signer in order to
+prevent front-running attacks.
+
+```solidity
+/// @notice Allows to bridge tokens of one type through a LI.FI diamond
+///         contract using Uniswap's Permit2 contract and a user signature
+///         that verifies allowance. The calldata can be changed by the
+///         user. Can only be called by the permit signer to prevent
+///         front-running.
+/// @param _diamondCalldata the calldata to execute
+/// @param _permit the Uniswap Permit2 parameters
+/// @param _signature the signature giving approval to transfer tokens
+function callDiamondWithPermit2(
+    bytes calldata _diamondCalldata,
+    ISignatureTransfer.PermitTransferFrom calldata _permit,
+    bytes calldata _signature
+) external payable
+```
+
+This method enables a gasless flow by allowing a user to sign a Uniswap Permit2
+message hash which includes a "witness" type. This extra type restricts which
+calldata can be called during execution and cannot be changed. Anyone with the
+signature can execute the transaction on behalf of the signer.
+
+```solidity
+/// @notice Allows to bridge tokens of one type through a LI.FI diamond
+///         contract using Uniswap's Permit2 contract and a user signature
+///         that verifies allowance, diamondAddress and diamondCalldata
+/// @param _diamondCalldata the calldata to execute
+/// @param _signer the signer giving permission to transfer tokens
+/// @param _permit the Uniswap Permit2 parameters
+/// @param _signature the signature giving approval to transfer tokens
+function callDiamondWithPermit2Witness(
+    bytes calldata _diamondCalldata,
+    address _signer,
+    ISignatureTransfer.PermitTransferFrom calldata _permit,
+    bytes calldata _signature
+) external payable
+```
+
+There are a few utility methods to make it easier to generate the necessary
+signature for the gasless flow.
+
+Calling this method will return a valid message hash that can then be signed
+in order to be executed later by another wallet.
+
+```solidity
+/// @notice utitlity method for constructing a valid Permit2 message hash
+/// @param _diamondCalldata the calldata to execute
+/// @param _assetId the address of the token to approve
+/// @param _amount amount of tokens to approve
+/// @param _nonce the nonce to use
+/// @param _deadline the expiration deadline
+function getPermit2MsgHash(
+    bytes calldata _diamondCalldata,
+    address _assetId,
+    uint256 _amount,
+    uint256 _nonce,
+    uint256 _deadline
+) external view returns (bytes32 msgHash)
+```
+
+Permit2 nonces are non-sequential and are a bit complicated to work with. The
+following utility methods allow you to fetch the next valid nonce or sequence
+of nonces for use when generating Permit2 signatures.
+
+```solidity
+/// @notice Finds the next valid nonce for a user, starting from 0.
+/// @param owner The owner of the nonces
+/// @return nonce The first valid nonce starting from 0
+function nextNonce(address owner) external view returns (uint256 nonce)
+
+/// @notice Finds the next valid nonce for a user, after from a given nonce.
+/// @dev This can be helpful if you're signing multiple nonces in a row and 
+///      need the next nonce to sign but the start one is still valid.
+/// @param owner The owner of the nonces
+/// @param start The nonce to start from
+/// @return nonce The first valid nonce after the given nonce
+function nextNonceAfter(
+    address owner,
+    uint256 start
+) external view returns (uint256 nonce)
+```

docs/README.md

@@ -56,3 +56,4 @@
 - [FeeCollector](./FeeCollector.md)
 - [Receiver](./Receiver.md)
 - [RelayerCelerIM](./RelayerCelerIM.md)
+- [Permit2Proxy](./Permit2Proxy.md)

remappings.txt

@@ -9,7 +9,7 @@ celer-network/=lib/sgn-v2-contracts/
 create3-factory/=lib/create3-factory/src/
 solmate/=lib/solmate/src/
 solady/=lib/solady/src/
-
+permit2/=lib/Permit2/src/
 ds-test/=lib/ds-test/src/
 forge-std/=lib/forge-std/src/