added _createPatchedData

deployments/_deployments_log_file.json

@@ -30339,9 +30339,9 @@
         ],
         "1.1.0": [
           {
-            "ADDRESS": "0x08BfAc22A3B41637edB8A7920754fDb30B18f740",
+            "ADDRESS": "0xF336cc028Fc5328472f96e377d32Fd32F8eE1750",
             "OPTIMIZER_RUNS": "1000000",
-            "TIMESTAMP": "2024-12-31 12:23:04",
+            "TIMESTAMP": "2025-05-27 13:50:22",
             "CONSTRUCTOR_ARGS": "0x000000000000000000000000e35e9842fceaca96570b734083f4a58e8f7c5f2a00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1",
             "SALT": "",
             "VERIFIED": "true"
@@ -32870,9 +32870,9 @@
       "staging": {
         "1.0.0": [
           {
-            "ADDRESS": "0x3cf7dE0e31e13C93c8Aada774ADF1C7eD58157f5",
+            "ADDRESS": "0x681a3409c35F12224c436D50Ce14F25f954B6Ea2",
             "OPTIMIZER_RUNS": "1000000",
-            "TIMESTAMP": "2024-11-07 14:15:11",
+            "TIMESTAMP": "2025-05-23 17:41:51",
             "CONSTRUCTOR_ARGS": "0x000000000000000000000000a5f565650890fba1824ee0f21ebbbf660a179934000000000000000000000000f70da97812cb96acdf810712aa562db8dfa3dbef",
             "SALT": "",
             "VERIFIED": "true"
@@ -33830,5 +33830,51 @@
         ]
       }
     }
+  },
+  "WhitelistManagerFacet": {
+    "arbitrum": {
+      "staging": {
+        "1.0.3": [
+          {
+            "ADDRESS": "0x603f0c31B37E5ca3eA75D5730CCfaBCFF6D17aa3",
+            "OPTIMIZER_RUNS": "1000000",
+            "TIMESTAMP": "2025-05-16 14:32:49",
+            "CONSTRUCTOR_ARGS": "0x",
+            "SALT": "",
+            "VERIFIED": "true"
+          }
+        ]
+      }
+    }
+  },
+  "Patcher": {
+    "arbitrum": {
+      "staging": {
+        "1.0.0": [
+          {
+            "ADDRESS": "0x18069208cA7c2D55aa0073E047dD45587B26F6D4",
+            "OPTIMIZER_RUNS": "1000000",
+            "TIMESTAMP": "2025-06-04 12:55:52",
+            "CONSTRUCTOR_ARGS": "0x",
+            "SALT": "",
+            "VERIFIED": "true"
+          }
+        ]
+      }
+    },
+    "base": {
+      "staging": {
+        "1.0.0": [
+          {
+            "ADDRESS": "0x18069208cA7c2D55aa0073E047dD45587B26F6D4",
+            "OPTIMIZER_RUNS": "1000000",
+            "TIMESTAMP": "2025-06-03 16:39:25",
+            "CONSTRUCTOR_ARGS": "0x",
+            "SALT": "",
+            "VERIFIED": "true"
+          }
+        ]
+      }
+    }
   }
 }

deployments/arbitrum.diamond.staging.json

@@ -173,7 +173,8 @@
       "ReceiverChainflip": "",
       "ReceiverStargateV2": "",
       "RelayerCelerIM": "0xa1Ed8783AC96385482092b82eb952153998e9b70",
-      "TokenWrapper": "0xF63b27AE2Dc887b88f82E2Cc597d07fBB2E78E70"
+      "TokenWrapper": "0xF63b27AE2Dc887b88f82E2Cc597d07fBB2E78E70",
+      "Patcher": "0x3971A968c03cd9640239C937F8d30D024840E691"
     }
   }
 }

deployments/arbitrum.staging.json

@@ -47,11 +47,13 @@
   "TokenWrapper": "0xF63b27AE2Dc887b88f82E2Cc597d07fBB2E78E70",
   "EmergencyPauseFacet": "0x17Bb203F42d8e404ac7E8dB6ff972B7E8473850b",
   "Permit2Proxy": "0x6FC01BC9Ff6Cdab694Ec8Ca41B21a2F04C8c37E5",
-  "AcrossFacetV3": "0x08BfAc22A3B41637edB8A7920754fDb30B18f740",
+  "AcrossFacetV3": "0xF336cc028Fc5328472f96e377d32Fd32F8eE1750",
   "ReceiverAcrossV3": "0xe4F3DEF14D61e47c696374453CD64d438FD277F8",
   "AcrossFacetPackedV3": "0x21767081Ff52CE5563A29f27149D01C7127775A2",
-  "RelayFacet": "0x3cf7dE0e31e13C93c8Aada774ADF1C7eD58157f5",
+  "RelayFacet": "0x681a3409c35F12224c436D50Ce14F25f954B6Ea2",
   "GlacisFacet": "0xF82830B952Bc60b93206FA22f1cD4770cedb2840",
   "GasZipFacet": "0x37f3F3E9d909fB1163448C511193b8481e541C62",
-  "ChainflipFacet": "0xa884c21873A671bD010567cf97c937b153F842Cc"
-}
+  "ChainflipFacet": "0xa884c21873A671bD010567cf97c937b153F842Cc",
+  "Patcher": "0x18069208cA7c2D55aa0073E047dD45587B26F6D4",
+  "WhitelistManagerFacet": "0x603f0c31B37E5ca3eA75D5730CCfaBCFF6D17aa3"
+}

deployments/base.staging.json

@@ -1,3 +1,4 @@
 {
-  "StandardizedCallFacet": "0x637Ac9AddC9C38b3F52878E11620a9060DC71d8B"
+  "StandardizedCallFacet": "0x637Ac9AddC9C38b3F52878E11620a9060DC71d8B",
+  "Patcher": "0x18069208cA7c2D55aa0073E047dD45587B26F6D4"
 }

docs/Patcher.md

@@ -0,0 +1,163 @@
+# Patcher
+
+## Description
+
+The Patcher is a utility contract that enables dynamic calldata patching before execution. It allows you to retrieve values dynamically from external contracts and use them to patch specific positions in calldata before executing the final call. This is particularly useful for scenarios where exact amounts are only known at execution time, such as token balances after deposits or bridge transfers.
+
+## How it works
+
+The Patcher works by:
+1. Retrieving dynamic values from external contracts via static calls
+2. Patching these values into predetermined positions in calldata
+3. Executing the final call with the patched data
+
+```mermaid
+graph LR;
+    A[User] --> B[Patcher Contract]
+    B --> C[Value Source Contract]
+    C --> B
+    B --> D[Final Target Contract]
+    B --> E[Patch Calldata]
+    E --> D
+```
+
+## Public Methods
+
+### Single Value Patching
+
+- `function executeWithDynamicPatches(address valueSource, bytes calldata valueGetter, address finalTarget, uint256 value, bytes calldata data, uint256[] calldata offsets, bool delegateCall)`
+  - Retrieves a single dynamic value and patches it into multiple positions in the calldata before execution
+
+### Token Deposit with Single Value Patching
+
+- `function depositAndExecuteWithDynamicPatches(address tokenAddress, address valueSource, bytes calldata valueGetter, address finalTarget, uint256 value, bytes calldata data, uint256[] calldata offsets, bool delegateCall)`
+  - Transfers the caller's entire token balance to the Patcher, approves the final target, then executes with dynamic patching
+
+### Multiple Value Patching
+
+- `function executeWithMultiplePatches(address[] calldata valueSources, bytes[] calldata valueGetters, address finalTarget, uint256 value, bytes calldata data, uint256[][] calldata offsetGroups, bool delegateCall)`
+  - Retrieves multiple dynamic values from different sources and patches them into different positions in the calldata
+
+### Token Deposit with Multiple Value Patching
+
+- `function depositAndExecuteWithMultiplePatches(address tokenAddress, address[] calldata valueSources, bytes[] calldata valueGetters, address finalTarget, uint256 value, bytes calldata data, uint256[][] calldata offsetGroups, bool delegateCall)`
+  - Transfers the caller's entire token balance to the Patcher, approves the final target, then executes with multiple dynamic patches
+
+## Parameters
+
+### Common Parameters
+
+- `valueSource` / `valueSources`: The contract(s) to query for dynamic values
+- `valueGetter` / `valueGetters`: The calldata to use for retrieving the dynamic value(s) (e.g., `balanceOf(address)` call)
+- `finalTarget`: The contract to call with the patched data
+- `value`: The ETH value to send with the final call
+- `data`: The original calldata to patch and execute
+- `offsets` / `offsetGroups`: Byte offset(s) in the calldata where the dynamic value(s) should be written
+- `delegateCall`: Whether to use delegatecall instead of a regular call for the final execution
+- `tokenAddress`: The ERC20 token to transfer from the caller (for deposit methods)
+
+### Offset Calculation
+
+Offsets specify the exact byte position in the calldata where a 32-byte value should be written. These are typically calculated by:
+1. Encoding the target function call with placeholder values
+2. Finding the byte position of the placeholder in the encoded data
+3. Using that position as the offset
+
+## Use Cases
+
+### Cross-Chain Bridge with Destination Swap
+
+The Patcher is particularly useful for cross-chain scenarios where the exact amount received from a bridge is unknown until execution:
+
+1. **Bridge tokens** from source chain to destination chain
+2. **Receive variable amount** due to fees, slippage, or exchange rates
+3. **Use Patcher** to query the actual received balance
+4. **Patch the balance** into a swap call to use the exact amount received
+5. **Execute the swap** with the correct amount
+
+### Dynamic Balance Swaps
+
+When you need to swap the entire balance of a token but don't know the exact amount:
+
+1. **Deposit tokens** to the Patcher contract
+2. **Query the balance** dynamically
+3. **Patch the balance** into a DEX swap call
+4. **Execute the swap** using the entire deposited amount
+
+### Oracle-Based Transactions
+
+For transactions that depend on real-time data:
+
+1. **Query price oracles** or other data sources
+2. **Patch the values** into transaction parameters
+3. **Execute** with up-to-date information
+
+## Error Handling
+
+The Patcher includes several error types for different failure scenarios:
+
+- `FailedToGetDynamicValue()`: Thrown when the static call to retrieve a dynamic value fails
+- `MismatchedArrayLengths()`: Thrown when input arrays have different lengths in multiple patch methods
+- `InvalidPatchOffset()`: Thrown when a patch offset would write beyond the calldata bounds
+
+## Security Considerations
+
+- The Patcher uses `staticcall` to retrieve dynamic values, ensuring no state changes during value retrieval
+- Offset validation prevents writing beyond calldata boundaries
+- The contract is designed to be used with delegate calls for integration into larger systems
+- Token approvals are given to the final target contract, not stored permanently
+
+## Integration Patterns
+
+### With Bridge Receivers
+
+The Patcher is commonly used in bridge receiver contracts to handle variable bridge amounts:
+
+```solidity
+// Pseudo-code example
+function handleBridgeMessage(bytes calldata message) external {
+    // Decode swap parameters from message
+    SwapData memory swapData = abi.decode(message, (SwapData));
+
+    // Use Patcher to deposit received tokens and execute swap with exact balance
+    patcher.depositAndExecuteWithDynamicPatches(
+        bridgedToken,
+        bridgedToken, // value source
+        abi.encodeCall(IERC20.balanceOf, (address(patcher))), // value getter
+        dexAggregator, // final target
+        0, // no ETH value
+        swapCalldata, // calldata with placeholder amount
+        [amountOffset], // where to patch the amount
+        false // regular call
+    );
+}
+```
+
+### With DEX Aggregators
+
+For swapping entire token balances through DEX aggregators:
+
+```solidity
+// Pseudo-code example
+function swapEntireBalance(address token, bytes calldata swapCalldata, uint256 amountOffset) external {
+    patcher.depositAndExecuteWithDynamicPatches(
+        token,
+        token, // query token balance
+        abi.encodeCall(IERC20.balanceOf, (address(patcher))),
+        dexAggregator,
+        0,
+        swapCalldata,
+        [amountOffset],
+        false
+    );
+}
+```
+
+## Best Practices
+
+1. **Calculate offsets carefully**: Ensure offsets point to the correct parameter positions in the calldata
+2. **Use appropriate value getters**: Choose the right function to call for retrieving dynamic values
+3. **Handle failures gracefully**: The Patcher will revert if value retrieval fails
+4. **Consider gas costs**: Multiple patches and complex calls increase gas usage
+5. **Test thoroughly**: Dynamic patching can be complex - test with various scenarios
+6. **Validate inputs**: Ensure array lengths match for multiple patch operations

docs/README.md

@@ -57,6 +57,7 @@
 - [Executor](./Executor.md)
 - [FeeCollector](./FeeCollector.md)
 - [LiFuelFeeCollector](./LiFuelFeeCollector.md)
+- [Patcher](./Patcher.md)
 - [Receiver](./Receiver.md)
 - [ReceiverStargateV2](./ReceiverStargateV2.md)
 - [ReceiverChainflip](./ReceiverChainflip.md)

package.json

@@ -83,6 +83,7 @@
   },
   "dependencies": {
     "@arbitrum/sdk": "^3.0.0",
+    "@cowprotocol/cow-sdk": "^5.10.3",
     "@hop-protocol/sdk": "0.0.1-beta.310",
     "@layerzerolabs/lz-v2-utilities": "^2.3.21",
     "@ledgerhq/hw-app-eth": "^6.43.0",