contracts: implement fee vault config encoding

packages/contracts-bedrock/src/libraries/Encoding.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.0;
 import { Types } from "src/libraries/Types.sol";
 import { Hashing } from "src/libraries/Hashing.sol";
 import { RLPWriter } from "src/libraries/rlp/RLPWriter.sol";
+import { UnsafeCast } from "src/libraries/errors/CommonErrors.sol";
 
 /// @title Encoding
 /// @notice Encoding handles Optimism's various different encoding schemes.
@@ -134,6 +135,37 @@ library Encoding {
         return (nonce, version);
     }
 
+    /// @notice Encodes a fee vault configuration into a single bytes32 value.
+    /// @param _recipient Address of the recipient of the fee vault.
+    /// @param _amount    Minimum withdrawal amount of the fee vault.
+    /// @param _network   Withdrawal network for the fee vault.
+    function encodeFeeVaultConfig(
+        address _recipient,
+        uint256 _amount,
+        Types.WithdrawalNetwork _network
+    )
+        internal
+        pure
+        returns (bytes32)
+    {
+        if (_amount > type(uint88).max) revert UnsafeCast();
+        return bytes32(uint256(_network) << 248 | _amount << 160 | uint256(uint160(_recipient)));
+    }
+
+    /// @notice Decodes a fee vault configuration from a single bytes32 value.
+    /// @return recipient_ Address of the recipient of the fee vault.
+    /// @return amount_    Minimum withdrawal amount of the fee vault.
+    /// @return network_   Withdrawal network for the fee vault.
+    function decodeFeeVaultConfig(bytes32 _data)
+        internal
+        pure
+        returns (address recipient_, uint256 amount_, Types.WithdrawalNetwork network_)
+    {
+        recipient_ = address(uint160(uint256(_data) & uint256(type(uint160).max)));
+        amount_ = (uint256(_data) & uint256(type(uint88).max) << 160) >> 160;
+        network_ = Types.WithdrawalNetwork(uint8(uint256(_data >> 248)));
+    }
+
     /// @notice Returns an appropriately encoded call to L1Block.setL1BlockValuesEcotone
     /// @param _baseFeeScalar       L1 base fee Scalar
     /// @param _blobBaseFeeScalar   L1 blob base fee Scalar

packages/contracts-bedrock/src/libraries/Types.sol

@@ -67,4 +67,12 @@ library Types {
         uint256 gasLimit;
         bytes data;
     }
+
+    /// @notice Enum representing where the FeeVault withdraws funds to.
+    /// @custom:value L1 FeeVault withdraws funds to L1.
+    /// @custom:value L2 FeeVault withdraws funds to L2.
+    enum WithdrawalNetwork {
+        L1,
+        L2
+    }
 }

packages/contracts-bedrock/src/libraries/errors/CommonErrors.sol

@@ -12,3 +12,6 @@ error NotCustomGasToken();
 
 /// @notice Error for when a transfer via call fails.
 error TransferFailed();
+
+/// @notice Error for when a type cast is unsafe.
+error UnsafeCast();

packages/contracts-bedrock/test/libraries/Encoding.t.sol

@@ -93,4 +93,16 @@ contract Encoding_Test is CommonTest {
 
         assertEq(txn, _txn);
     }
+
+    /// @notice Roundtrip test for fee vault encoding.
+    //          A boolean is used to determine which network should be used.
+    function testFuzz_encodeFeeVaultConfig_succeeds(address _recipient, uint88 _amount, bool _network) public pure {
+        Types.WithdrawalNetwork _withdrawalNetwork = _network ? Types.WithdrawalNetwork.L2 : Types.WithdrawalNetwork.L1;
+        bytes32 encoded = Encoding.encodeFeeVaultConfig(_recipient, uint256(_amount), _withdrawalNetwork);
+        (address recipient, uint256 amount, Types.WithdrawalNetwork withdrawalNetwork) =
+            Encoding.decodeFeeVaultConfig(encoded);
+        assertEq(_recipient, recipient, "bad recipient");
+        assertEq(uint256(_amount), amount, "bad amount");
+        assertEq(uint256(withdrawalNetwork), uint256(withdrawalNetwork), "bad network");
+    }
 }