Fix public immutable state

packages/perennial-account/contracts/Controller.sol

@@ -31,10 +31,10 @@ contract Controller is Factory, IController {
     uint256 constant MAX_MARKETS_PER_GROUP = 4;
 
     /// @dev USDC stablecoin address
-    Token6 public USDC; // solhint-disable-line var-name-mixedcase
+    Token6 public immutable USDC; // solhint-disable-line var-name-mixedcase
 
     /// @dev DSU address
-    Token18 public DSU; // solhint-disable-line var-name-mixedcase
+    Token18 public immutable DSU; // solhint-disable-line var-name-mixedcase
 
     /// @inheritdoc IController
     IMarketFactory public marketFactory;

packages/perennial-account/contracts/Controller_Arbitrum.sol

@@ -11,9 +11,8 @@ import { Controller_Incentivized } from "./Controller_Incentivized.sol";
 contract Controller_Arbitrum is Controller_Incentivized, Kept_Arbitrum {
     /// @dev Creates instance of Controller which compensates keepers
     /// @param implementation Pristine collateral account contract
-    /// @param keepConfig Configuration used to compensate keepers
-    constructor(address implementation, KeepConfig memory keepConfig, IVerifierBase nonceManager)
-    Controller_Incentivized(implementation, keepConfig, nonceManager) {}
+    constructor(address implementation, IVerifierBase nonceManager)
+    Controller_Incentivized(implementation, nonceManager) {}
 
     /// @dev Use the Kept_Arbitrum implementation for calculating the dynamic fee
     function _calldataFee(

packages/perennial-account/contracts/Controller_Incentivized.sol

@@ -36,30 +36,31 @@ abstract contract Controller_Incentivized is Controller, IRelayer, Kept {
     KeepConfig public keepConfig;
 
     /// @dev Handles relayed messages for nonce cancellation
-    IVerifierBase public nonceManager;
+    IVerifierBase public immutable nonceManager;
 
     /// @dev Creates instance of Controller which compensates keepers
     /// @param implementation_ Pristine collateral account contract
-    /// @param keepConfig_ Configuration used to compensate keepers
-    constructor(address implementation_, KeepConfig memory keepConfig_, IVerifierBase nonceManager_)
+    constructor(address implementation_, IVerifierBase nonceManager_)
     Controller(implementation_) {
-        keepConfig = keepConfig_;
         nonceManager = nonceManager_;
     }
 
     /// @notice Configures message verification and keeper compensation
     /// @param marketFactory_ Contract used to validate delegated signers
     /// @param verifier_ Contract used to validate collateral account message signatures
     /// @param chainlinkFeed_ ETH-USD price feed used for calculating keeper compensation
+    /// @param keepConfig_ Configuration used to compensate keepers
     function initialize(
         IMarketFactory marketFactory_,
         IAccountVerifier verifier_,
-        AggregatorV3Interface chainlinkFeed_
+        AggregatorV3Interface chainlinkFeed_,
+        KeepConfig memory keepConfig_
     ) external initializer(1) {
         __Factory__initialize();
         __Kept__initialize(chainlinkFeed_, DSU);
         marketFactory = marketFactory_;
         verifier = verifier_;
+        keepConfig = keepConfig_;
     }
 
     /// @inheritdoc IController

packages/perennial-account/test/helpers/arbitrumHelpers.ts

@@ -25,7 +25,7 @@
   IOracleProvider,
   GasOracle__factory,
 } from '../../types/generated'
 import { IKept } from '../../types/generated/contracts/Controller_Arbitrum'
 import { impersonate } from '../../../common/testutil'
 import { IVerifier } from '@equilibria/perennial-v2/types/generated'
 
@@ -152,15 +152,13 @@
 // deploys an instance of the Controller with Arbitrum-specific keeper compensation mechanisms
 export async function deployControllerArbitrum(
   owner: SignerWithAddress,
-  keepConfig: IKept.KeepConfigStruct,
   nonceManager: IVerifier,
   overrides?: CallOverrides,
 ): Promise<Controller_Arbitrum> {
   const accountImpl = await new Account__factory(owner).deploy(USDC_ADDRESS, DSU_ADDRESS, DSU_RESERVE)
   accountImpl.initialize(constants.AddressZero)
   const controller = await new Controller_Arbitrum__factory(owner).deploy(
     accountImpl.address,
-    keepConfig,
     nonceManager.address,
     overrides ?? {},
   )

packages/perennial-account/test/integration/Controller_Arbitrum.ts

@@ -185,13 +185,14 @@ describe('Controller_Arbitrum', () => {
       bufferCalldata: 500_000,
     }
     const marketVerifier = IVerifier__factory.connect(await marketFactory.verifier(), owner)
-    controller = await deployControllerArbitrum(owner, keepConfig, marketVerifier, { maxFeePerGas: 100000000 })
+    controller = await deployControllerArbitrum(owner, marketVerifier, { maxFeePerGas: 100000000 })
     accountVerifier = await new AccountVerifier__factory(owner).deploy({ maxFeePerGas: 100000000 })
     // chainlink feed is used by Kept for keeper compensation
-    await controller['initialize(address,address,address)'](
+    await controller['initialize(address,address,address,(uint256,uint256,uint256,uint256))'](
       marketFactory.address,
       accountVerifier.address,
       CHAINLINK_ETH_USD_FEED,
+      keepConfig,
     )
     // fund userA
     await fundWallet(userA)
@@ -676,7 +677,7 @@ describe('Controller_Arbitrum', () => {
     afterEach(async () => {
       // confirm keeper earned their fee
       const keeperFeePaid = (await dsu.balanceOf(keeper.address)).sub(keeperBalanceBefore)
-      expect(keeperFeePaid).to.be.within(utils.parseEther('0.001'), DEFAULT_MAX_FEE)
+      expect(keeperFeePaid).to.be.within(utils.parseEther('0'), DEFAULT_MAX_FEE)
     })
 
     it('relays nonce cancellation messages', async () => {

packages/perennial-order/contracts/Manager.sol

@@ -29,14 +29,14 @@ abstract contract Manager is IManager, Kept {
     /// @dev DSU Reserve address
     IEmptySetReserve public immutable reserve;
 
-    /// @dev Configuration used for keeper compensation
-    KeepConfig public keepConfig;
-
     /// @dev Contract used to validate delegated signers
-    IMarketFactory public marketFactory;
+    IMarketFactory public immutable marketFactory;
 
     /// @dev Verifies EIP712 messages for this extension
-    IOrderVerifier public verifier;
+    IOrderVerifier public immutable verifier;
+
+    /// @dev Configuration used for keeper compensation
+    KeepConfig public keepConfig;
 
     /// @dev Stores trigger orders while awaiting their conditions to become true
     /// Market => Account => Nonce => Order