feat(lockinginfo): update setSequencerOwner process flow

contracts/SequencerInfo.sol

@@ -81,15 +81,23 @@ contract SequencerInfo is OwnableUpgradeable, ISequencerInfo {
      * @dev setSequencerOwner update sequencer owner
      * @param _seqId The sequencerId
      * @param _owner the new owner
+     * @notice whitelisting is still required for the new owner
      */
-    function setSequencerOwner(
-        uint256 _seqId,
-        address _owner
-    ) external whitelistRequired {
+    function setSequencerOwner(uint256 _seqId, address _owner) external {
         if (_owner == address(0)) {
             revert NullAddress();
         }
 
+        // the new owner should be whitelisted
+        if (!whitelist[_owner]) {
+            revert NotWhitelisted();
+        }
+
+        // the new owner doesn't have any sequencer nodes
+        if (seqOwners[_owner] != 0) {
+            revert OwnedSequencer();
+        }
+
         Sequencer storage seq = sequencers[_seqId];
         if (seq.status != Status.Active) {
             revert SeqNotActive();

ts-src/test/LockingManager.ts

@@ -566,6 +566,43 @@ describe("locking", async () => {
     );
   });
 
+  it("setSequencerOwner", async () => {
+    const { lockingInfo, lockingPool, whitelised, unwhitelist } = await loadFixture(fixture);
+
+    const [wallet0, wallet1, wallet2] = whitelised;
+    const [wallet3] = unwhitelist;
+    const minLock = 1n;
+    await lockingInfo.setMinLock(minLock);
+
+    expect(
+      await lockingPool.signerUpdateThrottle(),
+      "default signerUpdateThrottle",
+    ).to.be.eq(1);
+
+    const wallet0Pubkey = trimPubKeyPrefix(wallet0.signingKey.publicKey);
+    const wallet1Pubkey = trimPubKeyPrefix(wallet1.signingKey.publicKey);
+
+    // seq1
+    await lockingPool.connect(wallet0).lockFor(wallet0, minLock, wallet0Pubkey);
+    // seq2
+    await lockingPool.connect(wallet1).lockFor(wallet1, minLock, wallet1Pubkey);
+
+    await expect(lockingPool.connect(wallet0).setSequencerOwner(1, ethers.ZeroAddress)).revertedWithCustomError(lockingPool, "NullAddress")
+    await expect(lockingPool.connect(wallet0).setSequencerOwner(1, wallet3)).revertedWithCustomError(lockingPool, "NotWhitelisted")
+    await expect(lockingPool.connect(wallet0).setSequencerOwner(1, wallet1)).revertedWithCustomError(lockingPool, "OwnedSequencer")
+    await expect(lockingPool.connect(wallet1).setSequencerOwner(1, wallet2)).revertedWithCustomError(lockingPool, "NotSeqOwner")
+
+    await lockingPool.setWhitelist(wallet0, false)
+    expect(await lockingPool.connect(wallet0).setSequencerOwner(1, wallet2)).emit(lockingPool, "SequencerOwnerChanged").withArgs(1n, wallet2.address)
+
+    const { owner } =
+      await lockingPool.sequencers(1);
+    expect(owner).eq(wallet2.address);
+
+    expect(await lockingPool.seqOwners(wallet2.address)).eq(1)
+    expect(await lockingPool.seqOwners(wallet0.address)).eq(0)
+  });
+
   it("relock/withoutReward", async () => {
     const { lockingInfo, lockingPool, whitelised, unwhitelist } =
       await loadFixture(fixture);