fix(f02): pair id with record so a batch's lengths can't mismatch

Assisted-by: Claude:claude-sonnet-4-6

Author: wjmelements

src/lib/FVMRewardTypes.sol

@@ -19,6 +19,14 @@ struct WeightRecord {
     int256 cap;
 }
 
+/// @notice One entry in a SetWeightRecords/StepWeightRecords batch.
+/// @dev Bundling the id with its record makes a batch's two lengths structurally equal -- there
+/// is no encoding for a mismatch, so none needs to be checked for.
+struct WeightRecordUpdate {
+    uint64 id;
+    WeightRecord record;
+}
+
 /// @notice One entry in an EXPLICIT stream's wallet-to-share map.
 /// @dev Shares across a stream's map must sum to SHARE_TOTAL (1e18); a single share must
 ///      therefore fit uint64.

src/lib/FVMRewards.sol

@@ -17,7 +17,7 @@ import {
     SET_SHARES,
     CLAIM
 } from "./FVMRewardMethod.sol";
-import {WeightRecord, Share, PendingOp} from "./FVMRewardTypes.sol";
+import {WeightRecord, WeightRecordUpdate, Share, PendingOp} from "./FVMRewardTypes.sol";
 
 /// @notice Calls the f02 (Reward actor) methods specified by FIP-0118, for the Stream Weight
 /// Actor (solstice#3) and Service Rewards Actor (solstice#4).
@@ -42,9 +42,6 @@ library FVMRewards {
     error ValueOutOfRange(int256 value);
     /// @dev An implicit stream (null distribution) carries no share map.
     error ImplicitStreamWithShares();
-    /// @dev The wire carries one array of `[id, record]` pairs, so the two inputs must be equal in
-    /// length; a mismatch has no encoding.
-    error ArrayLengthMismatch(uint256 ids, uint256 records);
 
     /// @dev Sentinel for the unexpected case where the syscall reverts or returns fewer than 32
     /// bytes. Kept at -1 to match `fvm-solidity`'s behavior.
@@ -274,53 +271,42 @@ library FVMRewards {
     // -------------------------------------------------------------------------
 
     /// @notice Queues a discretionary weight-schedule write, without reverting on actor error.
-    function trySetWeightRecords(uint64[] memory ids, WeightRecord[] memory records)
-        internal
-        returns (int256 exitCode)
-    {
-        return _tryWeightRecords(SET_WEIGHT_RECORDS, ids, records);
+    function trySetWeightRecords(WeightRecordUpdate[] memory updates) internal returns (int256 exitCode) {
+        return _tryWeightRecords(SET_WEIGHT_RECORDS, updates);
     }
 
     /// @notice Queues a gate-originated weight-schedule write, without reverting on actor error.
     /// @dev Encodes identically to SetWeightRecords and differs only in dispatch, but the two are
     /// separate calls because f02 treats them differently: a StepWeightRecords write cannot be
     /// cancelled, so the discretionary path cannot revoke what the governance gate produced.
-    function tryStepWeightRecords(uint64[] memory ids, WeightRecord[] memory records)
-        internal
-        returns (int256 exitCode)
-    {
-        return _tryWeightRecords(STEP_WEIGHT_RECORDS, ids, records);
+    function tryStepWeightRecords(WeightRecordUpdate[] memory updates) internal returns (int256 exitCode) {
+        return _tryWeightRecords(STEP_WEIGHT_RECORDS, updates);
     }
 
     /// @dev Params CBOR: `[[[id, record], ...]]` -- one array of pairs, inside the single-field
     /// tuple wrapper f02's parameter struct produces.
-    function _tryWeightRecords(uint64 method, uint64[] memory ids, WeightRecord[] memory records)
-        private
-        returns (int256 exitCode)
-    {
-        if (ids.length != records.length) revert ArrayLengthMismatch(ids.length, records.length);
-
+    function _tryWeightRecords(uint64 method, WeightRecordUpdate[] memory updates) private returns (int256 exitCode) {
         // [[[id, record], ...]]
-        (uint256 base, uint256 p) = _begin(method, MAX_HEAD_BYTES + MAX_HEAD_BYTES + ids.length * MAX_UPDATE_BYTES);
+        (uint256 base, uint256 p) = _begin(method, MAX_HEAD_BYTES + MAX_HEAD_BYTES + updates.length * MAX_UPDATE_BYTES);
         p = _writeArrayHeader(p, 1);
-        p = _writeArrayHeader(p, ids.length);
-        for (uint256 i = 0; i < ids.length; i++) {
+        p = _writeArrayHeader(p, updates.length);
+        for (uint256 i = 0; i < updates.length; i++) {
             p = _writeArrayHeader(p, 2);
-            p = _writeUint(p, ids[i]);
-            p = _writeRecord(p, records[i]);
+            p = _writeUint(p, updates[i].id);
+            p = _writeRecord(p, updates[i].record);
         }
         return _invoke(base, p);
     }
 
     /// @notice Queues a discretionary weight-schedule write, reverting on actor error.
-    function setWeightRecords(uint64[] memory ids, WeightRecord[] memory records) internal {
-        int256 exitCode = trySetWeightRecords(ids, records);
+    function setWeightRecords(WeightRecordUpdate[] memory updates) internal {
+        int256 exitCode = trySetWeightRecords(updates);
         require(exitCode == EXIT_SUCCESS, SetWeightRecordsFailed(exitCode));
     }
 
     /// @notice Queues a gate-originated weight-schedule write, reverting on actor error.
-    function stepWeightRecords(uint64[] memory ids, WeightRecord[] memory records) internal {
-        int256 exitCode = tryStepWeightRecords(ids, records);
+    function stepWeightRecords(WeightRecordUpdate[] memory updates) internal {
+        int256 exitCode = tryStepWeightRecords(updates);
         require(exitCode == EXIT_SUCCESS, StepWeightRecordsFailed(exitCode));
     }
 

test/mocks/FVMRewardActor.t.sol

@@ -25,6 +25,7 @@ import {
 } from "./FVMRewardActor.sol";
 import {CLAIM, SWA_TIMELOCK} from "../../src/lib/FVMRewardMethod.sol";
 import {FVMRewards} from "../../src/lib/FVMRewards.sol";
+import {WeightRecordUpdate} from "../../src/lib/FVMRewardTypes.sol";
 
 /// @dev A distinct external caller, so tests can check authorization by identity rather than
 /// by happenstance of who the test contract is. The typed methods below go through FVMRewards
@@ -53,12 +54,12 @@ contract RewardCaller {
         exitCode = uint32(uint256(FVMRewards.tryRemoveStream(id)));
     }
 
-    function setWeightRecords(uint64[] memory ids, WeightRecord[] memory records) external returns (uint32 exitCode) {
-        exitCode = uint32(uint256(FVMRewards.trySetWeightRecords(ids, records)));
+    function setWeightRecords(WeightRecordUpdate[] memory updates) external returns (uint32 exitCode) {
+        exitCode = uint32(uint256(FVMRewards.trySetWeightRecords(updates)));
     }
 
-    function stepWeightRecords(uint64[] memory ids, WeightRecord[] memory records) external returns (uint32 exitCode) {
-        exitCode = uint32(uint256(FVMRewards.tryStepWeightRecords(ids, records)));
+    function stepWeightRecords(WeightRecordUpdate[] memory updates) external returns (uint32 exitCode) {
+        exitCode = uint32(uint256(FVMRewards.tryStepWeightRecords(updates)));
     }
 
     function setDistribution(uint64 id, address writer) external returns (uint32 exitCode) {
@@ -141,26 +142,22 @@ contract FVMRewardActorTest is MockRewardTest {
         return swaCaller.registerStream(id, record, writer, initial, uint64(block.number) + SWA_TIMELOCK);
     }
 
-    /// @dev Bundles a single id/record into the arrays SetWeightRecords batches over.
+    /// @dev Bundles a single id/record into the batch SetWeightRecords takes.
     function _singleWeightRecord(uint64 id, WeightRecord memory record)
         internal
         pure
-        returns (uint64[] memory ids, WeightRecord[] memory records)
+        returns (WeightRecordUpdate[] memory updates)
     {
-        ids = new uint64[](1);
-        ids[0] = id;
-        records = new WeightRecord[](1);
-        records[0] = record;
+        updates = new WeightRecordUpdate[](1);
+        updates[0] = WeightRecordUpdate({id: id, record: record});
     }
 
     function _setWeightRecords(RewardCaller caller, uint64 id, WeightRecord memory record) internal returns (uint32) {
-        (uint64[] memory ids, WeightRecord[] memory records) = _singleWeightRecord(id, record);
-        return caller.setWeightRecords(ids, records);
+        return caller.setWeightRecords(_singleWeightRecord(id, record));
     }
 
     function _stepWeightRecords(RewardCaller caller, uint64 id, WeightRecord memory record) internal returns (uint32) {
-        (uint64[] memory ids, WeightRecord[] memory records) = _singleWeightRecord(id, record);
-        return caller.stepWeightRecords(ids, records);
+        return caller.stepWeightRecords(_singleWeightRecord(id, record));
     }
 
     function _registerExplicit(uint64 id, address writer) internal {
@@ -421,27 +418,15 @@ contract FVMRewardActorTest is MockRewardTest {
         assertEq(exitCode, USR_NOT_FOUND);
     }
 
-    // The wire carries one array of [id, record] pairs, so mismatched lengths have no encoding.
-    // f02 never sees this; the caller is stopped at the boundary.
-    function test_SetWeightRecords_MismatchedArrayLengths_Reverts() public {
-        uint64[] memory ids = new uint64[](2);
-        WeightRecord[] memory records = new WeightRecord[](1);
-        vm.expectRevert(abi.encodeWithSelector(FVMRewards.ArrayLengthMismatch.selector, uint256(2), uint256(1)));
-        swaCaller.setWeightRecords(ids, records);
-    }
-
     function test_SetWeightRecords_DuplicateIdInBatch_IllegalArgument() public {
         assertEq(_registerStream(SERVICE_ID, _constantRecord(0.1e18), DistributionKind.IMPLICIT, address(0)), 0);
         _warpPastTimelockAndSettle();
 
-        uint64[] memory ids = new uint64[](2);
-        ids[0] = SERVICE_ID;
-        ids[1] = SERVICE_ID;
-        WeightRecord[] memory records = new WeightRecord[](2);
-        records[0] = _constantRecord(0.5e18);
-        records[1] = _constantRecord(0.5e18);
+        WeightRecordUpdate[] memory updates = new WeightRecordUpdate[](2);
+        updates[0] = WeightRecordUpdate({id: SERVICE_ID, record: _constantRecord(0.5e18)});
+        updates[1] = WeightRecordUpdate({id: SERVICE_ID, record: _constantRecord(0.5e18)});
 
-        uint32 exitCode = swaCaller.setWeightRecords(ids, records);
+        uint32 exitCode = swaCaller.setWeightRecords(updates);
         assertEq(exitCode, USR_ILLEGAL_ARGUMENT, "a repeated id queues two PendingKeys for one slot");
     }
 

test/mocks/FVMRewardWire.t.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.36;
 
 import {MockRewardTest} from "./MockRewardTest.sol";
-import {WeightRecord, Share, PendingOp} from "../../src/lib/FVMRewardTypes.sol";
+import {WeightRecord, WeightRecordUpdate, Share, PendingOp} from "../../src/lib/FVMRewardTypes.sol";
 import {FVMRewards} from "../../src/lib/FVMRewards.sol";
 
 /// @dev Tests to match with Rust `fil_actor_reward` tests/types_test.rs `mod serialization`, whose
@@ -48,14 +48,15 @@ contract FVMRewardWireTest is MockRewardTest {
     // ]]
     function test_SetWeightRecords_WalksEveryIntegerWidth() public {
         uint64[8] memory v = [uint64(23), 24, 255, 256, 65_535, 65_536, 4_294_967_295, 4_294_967_296];
-        uint64[] memory ids = new uint64[](8);
-        WeightRecord[] memory records = new WeightRecord[](8);
+        WeightRecordUpdate[] memory updates = new WeightRecordUpdate[](8);
         for (uint256 i = 0; i < 8; i++) {
-            ids[i] = v[i];
-            records[i] = _record(int256(uint256(v[i])), -int256(uint256(v[i])) - 1, v[i], 0, int256(uint256(v[i])));
+            updates[i] = WeightRecordUpdate({
+                id: v[i],
+                record: _record(int256(uint256(v[i])), -int256(uint256(v[i])) - 1, v[i], 0, int256(uint256(v[i])))
+            });
         }
 
-        FVMRewards.trySetWeightRecords(ids, records);
+        FVMRewards.trySetWeightRecords(updates);
         assertEq(
             _sent(),
             hex"81888217851737170017821818851818381818180018188218ff8518ff38ff18ff0018ff"
@@ -69,28 +70,25 @@ contract FVMRewardWireTest is MockRewardTest {
     /// @dev Identical params, different dispatch. The two are separate calls because f02 will not
     /// let the discretionary path cancel what the gate produced.
     function test_StepWeightRecords_EncodesLikeSetWeightRecords() public {
-        uint64[] memory ids = new uint64[](1);
-        WeightRecord[] memory records = new WeightRecord[](1);
-        ids[0] = 23;
-        records[0] = _record(23, -24, 23, 0, 23);
+        WeightRecordUpdate[] memory updates = new WeightRecordUpdate[](1);
+        updates[0] = WeightRecordUpdate({id: 23, record: _record(23, -24, 23, 0, 23)});
 
-        FVMRewards.trySetWeightRecords(ids, records);
+        FVMRewards.trySetWeightRecords(updates);
         bytes memory set = _sent();
-        FVMRewards.tryStepWeightRecords(ids, records);
+        FVMRewards.tryStepWeightRecords(updates);
         assertEq(_sent(), set);
     }
 
     // [[]] and one entry at the widest form. Step encodes identically to Set but is pinned
     // separately, so this table stands alone as a description of the method.
     function test_StepWeightRecords_EmptyAndBoundaryBatch() public {
-        FVMRewards.tryStepWeightRecords(new uint64[](0), new WeightRecord[](0));
+        FVMRewards.tryStepWeightRecords(new WeightRecordUpdate[](0));
         assertEq(_sent(), hex"8180");
 
-        uint64[] memory ids = new uint64[](1);
-        WeightRecord[] memory records = new WeightRecord[](1);
-        ids[0] = 4_294_967_296;
-        records[0] = _record(4_294_967_296, -4_294_967_297, 65_536, 256, 1e18);
-        FVMRewards.tryStepWeightRecords(ids, records);
+        WeightRecordUpdate[] memory updates = new WeightRecordUpdate[](1);
+        updates[0] =
+            WeightRecordUpdate({id: 4_294_967_296, record: _record(4_294_967_296, -4_294_967_297, 65_536, 256, 1e18)});
+        FVMRewards.tryStepWeightRecords(updates);
         assertEq(
             _sent(),
             hex"8181821b0000000100000000851b00000001000000003b0000000100000000" hex"1a000100001901001b0de0b6b3a7640000"