Fix issue with settle() asyncFee is left in the KeepFactory and is not transfer to the keeper

packages/perennial-oracle/contracts/interfaces/IKeeperOracle.sol

@@ -48,7 +48,7 @@ interface IKeeperOracle is IOracleProvider, IInstance {
     function initialize() external;
     function register(IOracle newOracle) external;
     function commit(OracleVersion memory version, address receiver, uint256 value) external;
-    function settle(uint256 version, uint256 maxCount) external;
+    function settle(uint256 version, uint256 maxCount, address receiver) external;
     function next() external view returns (uint256);
     function localCallbacks(uint256 version) external view returns (address[] memory);
 

packages/perennial-oracle/contracts/keeper/KeeperFactory.sol

@@ -164,8 +164,9 @@ abstract contract KeeperFactory is IKeeperFactory, Factory {
         if (oracleIds.length == 0 || oracleIds.length != versions.length || oracleIds.length != maxCounts.length)
             revert KeeperFactoryInvalidSettleError();
 
-        for (uint256 i; i < oracleIds.length; i++)
-            IKeeperOracle(address(oracles[oracleIds[i]])).settle(versions[i], maxCounts[i]);
+        for (uint256 i; i < oracleIds.length; i++) {
+            IKeeperOracle(address(oracles[oracleIds[i]])).settle(versions[i], maxCounts[i], msg.sender);
+        }
     }
 
     /// @notice Returns the oracle parameter set

packages/perennial-oracle/contracts/keeper/KeeperOracle.sol

@@ -157,7 +157,8 @@ contract KeeperOracle is IKeeperOracle, Instance {
     /// @dev Distribution of keeper incentive is consolidated in the oracle's factory
     /// @param version The version to settle
     /// @param maxCount The maximum number of settlement callbacks to perform before exiting
-    function settle(uint256 version, uint256 maxCount) external virtual onlyFactory {
+    /// @param receiver The receiver of the async fee
+    function settle(uint256 version, uint256 maxCount, address receiver) external virtual onlyFactory {
         EnumerableSet.AddressSet storage callbacks = _localCallbacks[version];
 
         if (_global.latestVersion < version) revert KeeperOracleVersionOutsideRangeError();
@@ -174,7 +175,7 @@ contract KeeperOracle is IKeeperOracle, Instance {
 
             // full settlement fee already cleamed in commit
             PriceResponse memory priceResponse = _responses[version].read();
-            market.token().push(msg.sender, UFixed18Lib.from(priceResponse.asyncFee));
+            market.token().push(receiver, UFixed18Lib.from(priceResponse.asyncFee));
         }
     }
 

packages/perennial-oracle/contracts/keeper/KeeperOracle_Migration.sol

@@ -35,5 +35,5 @@ contract KeeperOracle_Migration is KeeperOracle {
     function latest() public pure override returns (OracleVersion memory) { revert NotImplementedError(); }
     function current() public pure override returns (uint256) { revert NotImplementedError(); }
     function commit(OracleVersion memory, address, uint256) external pure override { revert NotImplementedError(); }
-    function settle(uint256, uint256) external pure override { revert NotImplementedError(); }
+    function settle(uint256, uint256, address) external pure override { revert NotImplementedError(); }
 }

packages/perennial-oracle/test/integration/pyth/PythOracleFactory.test.ts

@@ -1220,12 +1220,15 @@ testOracles.forEach(testOracle => {
           await ethers.provider.send('hardhat_setNextBlockBaseFeePerGas', ['0x5F5E100'])
           expect(await keeperOracle.requests(1)).to.be.equal(STARTING_TIME)
           expect(await keeperOracle.next()).to.be.equal(STARTING_TIME)
+          const balanceBeforeCommit = await dsu.balanceOf(user.address)
           await pythOracleFactory.connect(user).commit([PYTH_ETH_USD_PRICE_FEED], STARTING_TIME, VAA, {
             value: 1,
             maxFeePerGas: 100000000,
           })
-
           expect((await market.position()).timestamp).to.equal(STARTING_TIME)
+          // ensure keeper was compensated for committing a price
+          const balanceBeforeSettle = await dsu.balanceOf(user.address)
+          expect(balanceBeforeSettle.sub(balanceBeforeCommit)).to.equal(utils.parseEther('0.370586'))
 
           await expect(
             pythOracleFactory.connect(user).settle([PYTH_ETH_USD_PRICE_FEED], [STARTING_TIME], [1], {
@@ -1235,11 +1238,8 @@ testOracles.forEach(testOracle => {
           // .withArgs([market.address, user.address, STARTING_TIME]) cannot parse indexed tuples in events
 
           expect((await market.positions(user.address)).timestamp).to.equal(STARTING_TIME)
-
-          const reward = utils.parseEther('0.370586')
-          expect(await dsu.balanceOf(user.address)).to.be.equal(
-            utils.parseEther('200000').sub(utils.parseEther('10')).add(reward),
-          )
+          // ensure keeper was compensated for settling
+          expect((await dsu.balanceOf(user.address)).sub(balanceBeforeSettle)).to.equal(utils.parseEther('0.129155'))
         })
 
         it('reverts if array lengths mismatch', async () => {