Merge pull request #5 from filbeam/feat/migrate-filbeam-controller

feat: add FWSS controller migration method to FilBeamOperator

Author: pyropy

SPEC.md

@@ -142,12 +142,29 @@ The Filecoin Beam (FilBeamOperator) contract is responsible for managing CDN (ca
 - **Purpose**: Update the authorized address for usage reporting and payment rail termination
 - **Events**: Emits `FilBeamOperatorControllerUpdated` event
 
+**Method**: `transferFwssFilBeamController(address newController)`
+
+- **Access**: Contract owner only
+- **Requirements**: New controller address cannot be zero address
+- **Purpose**: Transfer FilBeamController authorization in FWSS to a new operator contract. This is used during contract upgrades to migrate control from the current FilBeamOperator to a new FilBeamOperator instance.
+- **Functionality**: Calls `transferFilBeamController(newController)` on the FWSS contract, which will update the authorized caller in FWSS to the new operator address
+- **Events**:
+  - Emits `FwssFilBeamControllerMigrated(address indexed previousController, address indexed newController)` from FilBeamOperator
+  - FWSS will emit `FilBeamControllerChanged(address indexed oldController, address indexed newController)`
+- **Migration Flow**:
+  1. Deploy new FilBeamOperator contract
+  2. Call `transferFwssFilBeamController(newOperatorAddress)` on old operator contract
+  3. FWSS authorization transfers to new operator
+  4. Old operator can no longer call FWSS methods
+  5. New operator can now interact with FWSS
+
 #### Events
 - `UsageReported(uint256 indexed dataSetId, uint256 indexed fromEpoch, uint256 indexed toEpoch, uint256 cdnBytesUsed, uint256 cacheMissBytesUsed)`
 - `CDNSettlement(uint256 indexed dataSetId, uint256 fromEpoch, uint256 toEpoch, uint256 cdnAmount)`
 - `CacheMissSettlement(uint256 indexed dataSetId, uint256 fromEpoch, uint256 toEpoch, uint256 cacheMissAmount)`
 - `PaymentRailsTerminated(uint256 indexed dataSetId)`
 - `FilBeamOperatorControllerUpdated(address indexed oldController, address indexed newController)`
+- `FwssFilBeamControllerMigrated(address indexed previousController, address indexed newController)`
 
 #### Access Control
 - **Owner**: Address authorized to manage contract ownership and set FilBeamOperator controller

src/FilBeamOperator.sol

@@ -37,6 +37,8 @@ contract FilBeamOperator is Ownable {
 
     event FilBeamControllerUpdated(address indexed oldController, address indexed newController);
 
+    event FwssFilBeamControllerChanged(address indexed previousController, address indexed newController);
+
     /// @notice Initializes the FilBeamOperator contract
     /// @param fwssAddress Address of the FWSS contract
     /// @param _paymentsAddress Address of the Payments contract
@@ -128,6 +130,19 @@ contract FilBeamOperator is Ownable {
         emit FilBeamControllerUpdated(oldController, _filBeamOperatorController);
     }
 
+    /// @notice Transfers the FilBeamController authorization in FWSS to a new operator
+    /// @dev Can only be called by the contract owner. This is used during contract upgrades
+    /// to transfer control from the current operator to a new operator contract.
+    /// @param newController Address of the new FilBeamOperator contract
+    function transferFwssFilBeamController(address newController) external onlyOwner {
+        if (newController == address(0)) revert InvalidAddress();
+
+        // Transfer the controller authorization in FWSS to the new operator
+        IFWSS(fwssContractAddress).transferFilBeamController(newController);
+
+        emit FwssFilBeamControllerChanged(address(this), newController);
+    }
+
     /// @dev Internal function to record usage for a single data set
     /// @param dataSetId The data set ID
     /// @param toEpoch The epoch number to record usage for

src/interfaces/IFWSS.sol

@@ -22,4 +22,6 @@ interface IFWSS {
     function terminateCDNPaymentRails(uint256 dataSetId) external;
 
     function usdfcTokenAddress() external view returns (address);
+
+    function transferFilBeamController(address newController) external;
 }

src/mocks/MockFWSS.sol

@@ -19,6 +19,7 @@ contract MockFWSS is IFWSS {
 
     event PaymentRailsSettled(uint256 indexed dataSetId, uint256 cdnAmount, uint256 cacheMissAmount);
     event PaymentRailsTerminated(uint256 indexed dataSetId);
+    event FilBeamControllerChanged(address indexed oldController, address indexed newController);
 
     error UnauthorizedCaller();
 
@@ -77,4 +78,11 @@ contract MockFWSS is IFWSS {
     function setDataSetInfo(uint256 dataSetId, DataSetInfo memory info) external {
         dataSetInfos[dataSetId] = info;
     }
+
+    function transferFilBeamController(address newController) external onlyAuthorized {
+        require(newController != address(0), "Zero address");
+        address oldController = authorizedCaller;
+        authorizedCaller = newController;
+        emit FilBeamControllerChanged(oldController, newController);
+    }
 }

test/FilBeamOperator.t.sol

@@ -35,6 +35,10 @@ contract FilBeamOperatorTest is Test {
 
     event CacheMissSettlement(uint256 indexed dataSetId, uint256 cacheMissAmount);
 
+    event FwssFilBeamControllerChanged(address indexed previousController, address indexed newController);
+
+    event FilBeamControllerChanged(address indexed oldController, address indexed newController);
+
     event PaymentRailsTerminated(uint256 indexed dataSetId);
 
     event FilBeamControllerUpdated(address indexed oldController, address indexed newController);
@@ -1279,4 +1283,153 @@ contract FilBeamOperatorTest is Test {
         assertEq(cdnAmount, 100000, "CDN amount should still be accumulated");
         assertEq(cacheMissAmount, 100000, "Cache miss amount should still be accumulated");
     }
+
+    // ============ Migration Tests ============
+
+    function test_TransferFwssFilBeamController_Success() public {
+        address newOperator = address(0x9999);
+
+        // Verify initial state
+        assertEq(mockFWSS.authorizedCaller(), address(filBeam), "Initial authorized caller should be current operator");
+
+        // FWSS emits FilBeamControllerChanged event first (from inside the call)
+        vm.expectEmit(true, true, false, true, address(mockFWSS));
+        emit FilBeamControllerChanged(address(filBeam), newOperator);
+
+        // Then FilBeamOperator emits FwssFilBeamControllerChanged event
+        vm.expectEmit(true, true, false, true, address(filBeam));
+        emit FwssFilBeamControllerChanged(address(filBeam), newOperator);
+
+        // Call as owner
+        vm.prank(owner);
+        filBeam.transferFwssFilBeamController(newOperator);
+
+        // Verify FWSS authorization was transferred
+        assertEq(mockFWSS.authorizedCaller(), newOperator, "FWSS authorized caller should be new operator");
+    }
+
+    function test_TransferFwssFilBeamController_RevertNonOwner() public {
+        address newOperator = address(0x9999);
+
+        // Try as non-owner (controller)
+        vm.prank(filBeamOperatorController);
+        vm.expectRevert();
+        filBeam.transferFwssFilBeamController(newOperator);
+
+        // Try as random user
+        vm.prank(user1);
+        vm.expectRevert();
+        filBeam.transferFwssFilBeamController(newOperator);
+
+        // Verify authorization wasn't changed
+        assertEq(mockFWSS.authorizedCaller(), address(filBeam), "Authorized caller should remain unchanged");
+    }
+
+    function test_TransferFwssFilBeamController_RevertZeroAddress() public {
+        // Try with zero address
+        vm.prank(owner);
+        vm.expectRevert(InvalidAddress.selector);
+        filBeam.transferFwssFilBeamController(address(0));
+
+        // Verify authorization wasn't changed
+        assertEq(mockFWSS.authorizedCaller(), address(filBeam), "Authorized caller should remain unchanged");
+    }
+
+    function test_TransferFwssFilBeamController_OldOperatorCannotCallAfterMigration() public {
+        address newOperator = address(0x9999);
+
+        // First record some usage to verify old operator works
+        vm.prank(filBeamOperatorController);
+        filBeam.recordUsageRollups(
+            200, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(1000), _singleUint256Array(500)
+        );
+
+        // Migrate to new operator
+        vm.prank(owner);
+        filBeam.transferFwssFilBeamController(newOperator);
+
+        // Old operator should no longer be able to call FWSS methods (settle will fail)
+        vm.expectRevert(MockFWSS.UnauthorizedCaller.selector);
+        filBeam.settleCDNPaymentRails(_singleUint256Array(DATA_SET_ID_1));
+    }
+
+    function test_TransferFwssFilBeamController_NewOperatorCanCallAfterMigration() public {
+        // Deploy a new FilBeamOperator instance to act as the new operator
+        FilBeamOperator newOperator = new FilBeamOperator(
+            address(mockFWSS),
+            address(mockPayments),
+            CDN_RATE_PER_BYTE,
+            CACHE_MISS_RATE_PER_BYTE,
+            filBeamOperatorController
+        );
+
+        // Record usage with old operator
+        vm.prank(filBeamOperatorController);
+        filBeam.recordUsageRollups(
+            200, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(1000), _singleUint256Array(500)
+        );
+
+        // Migrate to new operator
+        vm.prank(owner);
+        filBeam.transferFwssFilBeamController(address(newOperator));
+
+        // New operator should be able to record and settle
+        vm.prank(filBeamOperatorController);
+        newOperator.recordUsageRollups(
+            300, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(2000), _singleUint256Array(1000)
+        );
+
+        // New operator can settle
+        newOperator.settleCDNPaymentRails(_singleUint256Array(DATA_SET_ID_1));
+
+        // Verify settlement was successful
+        assertGt(mockFWSS.getSettlementsCount(), 0, "Settlement should have occurred");
+    }
+
+    function test_TransferFwssFilBeamController_IntegrationFlow() public {
+        // Deploy new operator
+        FilBeamOperator newOperator = new FilBeamOperator(
+            address(mockFWSS),
+            address(mockPayments),
+            CDN_RATE_PER_BYTE,
+            CACHE_MISS_RATE_PER_BYTE,
+            filBeamOperatorController
+        );
+
+        // 1. Old operator records usage
+        vm.prank(filBeamOperatorController);
+        filBeam.recordUsageRollups(
+            200, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(1000), _singleUint256Array(500)
+        );
+
+        // 2. Settle partially with old operator (this works)
+        filBeam.settleCDNPaymentRails(_singleUint256Array(DATA_SET_ID_1));
+        uint256 settlementCountBefore = mockFWSS.getSettlementsCount();
+
+        // 3. Old operator records more usage (to have accumulated amount after migration)
+        vm.prank(filBeamOperatorController);
+        filBeam.recordUsageRollups(
+            250, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(5000), _singleUint256Array(2500)
+        );
+
+        // 4. Migrate to new operator
+        vm.prank(owner);
+        filBeam.transferFwssFilBeamController(address(newOperator));
+
+        // 5. New operator records more usage
+        vm.prank(filBeamOperatorController);
+        newOperator.recordUsageRollups(
+            300, _singleUint256Array(DATA_SET_ID_1), _singleUint256Array(2000), _singleUint256Array(1000)
+        );
+
+        // 6. New operator settles
+        newOperator.settleCDNPaymentRails(_singleUint256Array(DATA_SET_ID_1));
+
+        // Verify settlements occurred
+        assertGt(mockFWSS.getSettlementsCount(), settlementCountBefore, "New settlement should have occurred");
+
+        // 7. Old operator cannot settle anymore (has accumulated amount but can't settle to FWSS)
+        vm.expectRevert(MockFWSS.UnauthorizedCaller.selector);
+        filBeam.settleCDNPaymentRails(_singleUint256Array(DATA_SET_ID_1));
+    }
 }