Farseen0/scar-pairs huggingface dataset:
LOW severity: [ETRP-7] Improper validation of message padding during Poseidon decryption in EERC SDK. **Severity:** Low

**Path:** src/crypto/poseidon/poseidon.ts:L199

**Description:** `poseidonDecrypt` function implements decryption of the transfer amounts and balances via Poseidon decryption algorithm described in the Encryption with Poseidon paper. 

The current implementation validates...

Vulnerable code:
if (length > 3) {
  if (length % 3 === 2) {
    checkEqual(
      msg[msg.length - 1],
      this.field.zero,
      this.field,
      "The last element of the message must be 0",
    );
  } else if (length % 3 === 1) {
    checkEqual(
      msg[msg.length - 1],
      this.field.zero,
      this.field,
      "The last element of the message must be 0",
    );
    checkEqual(
      msg[msg.length - 2],
      this.field.zero,
      this.field,
      "The second to last element of the message must be 0",
    );
  }
}
LOW severity: [ETRP-8] Non-uniform Distribution in Random Nonce Generation Due to JavaScript Number Precision Limitations. **Severity:** Low

**Description:** The randomNonce() function in jub/jub.ts uses Math.random() and Number() type conversion to generate random nonces, which can lead to non-uniform distribution of values due to JavaScript's number precision limitations.

- This implementation has two issues:

-...

Vulnerable code:
console.log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log("2n ** 53n:", 2n ** 53n);                            // 9007199254740992
console.log(Number(2n ** 53n) + 1);                              // 9007199254740992
console.log(Number(2n ** 53n) + 2);                              // 9007199254740994
console.log(Number(2n ** 53n) + 3);                              // 9007199254740996
console.log(Number(2n ** 53n) + 4);                              // 9007199254740996

export const randomNonce = (): bigint =>
    BigInt(Math.floor(Math.random() * Number(2n ** 128n - 1n)) + 1);
LOW severity: [OIN8-7] Incomplete `expiration_time` check allows orders to be instantly expired. **Severity:** Low

**Path:** programs/fusion-swap/src/lib.rs#L40-L43

**Description:** According to the documentation, the `create` function is used for creating orders with special parameters by the maker:

- `Context<Create>` bundles all the required accounts, including the escrow account to be...

Vulnerable code:
...
require!(
    Clock::get()?.unix_timestamp <= order.expiration_time as i64,
    EscrowError::OrderExpired
);
...
LOW severity: [OIN8-5] Protocol fee associated token account is not checked against a configured account. **Severity:** Low

**Path:** programs/fusion-swap/src/lib.rs#L337, programs/fusion-swap/src/lib.rs#163-184

**Description:** The associated token account (ATA) for collecting protocol fees `protocol_dst_ata` is not verified/checked against a configured account. This means that a maker can set the...

Vulnerable code:
...
    // Take protocol fee
    if protocol_fee_amount > 0 {
        let protocol_dst_ata = ctx
            .accounts
            .protocol_dst_ata
            .as_ref()
            .ok_or(EscrowError::InconsistentProtocolFeeConfig)?;
    
        transfer_checked(
            CpiContext::new(
                ctx.accounts.dst_token_program.to_account_info(),
                TransferChecked {
                    from: ctx.accounts.taker_dst_ata.to_account_info(),
                    mint: ctx.accounts.dst_mint.to_account_info(),
                    to: protocol_dst_ata.to_account_info(),
                    authority: ctx.accounts.taker.to_account_info(),
                },
            ),
            protocol_fee_amount,
            ctx.accounts.dst_mint.decimals,
        )?;
    }
...
    #[account(
        constraint = protocol_dst_ata.mint == dst_mint.key() @ EscrowError::InconsistentProtocolFeeConfig
    )]
    protocol_dst_ata: Option<Box<InterfaceAccount<'info, TokenAccount>>>,
...
LOW severity: [OIN8-8] Self-exchange is possible. **Severity:** Low

**Path:** programs/fusion-swap/src/lib.rs#L106-L258 

**Description:** `fusion-swap` does not prevent the fulfillment of orders with identical maker and taker accounts. Although this was not observed to be directly exploitable, this allows for self-fulfillment of orders for...

Vulnerable code:
...    
    pub fn fill(ctx: Context<Fill>, order_id: u32, amount: u64) -> Result<()> {
        ...
++      require!(
++          ctx.accounts.maker.key() != ctx.accounts.taker.key(),
++          EscrowError::MakerAndTakerIdentical
        );
        ...
      }
...
LOW severity: [VLTS3-5] The calculation of shares in STEXAMM is incorrect because of using the outdated amountToken1PendingLPWithdrawal. **Severity:** Critical

**Path:** src/STEXAMM.sol#L468-L479, src/STEXAMM.sol#L550-L555

**Description:** The calculation of shares in `deposit()` function of STEXAMM contract:

`amountToken0PendingUnstaking()` is the amount that the withdrawal module is waiting for the overseer contract to claim...

Vulnerable code:
(uint256 reserve0Pool, uint256 reserve1Pool) = ISovereignPool(pool).getReserves();
// Account for token0 in pool (liquid) and pending unstaking (locked)
uint256 reserve0Total = reserve0Pool + _withdrawalModule.amountToken0PendingUnstaking();
// Account for token1 pending withdrawal to LPs (locked)
uint256 reserve1PendingWithdrawal = _withdrawalModule.amountToken1PendingLPWithdrawal();
// shares calculated in terms of token1
shares = Math.mulDiv(
    _amount,
    totalSupplyCache,
    reserve1Pool + _withdrawalModule.amountToken1LendingPool()
        + _withdrawalModule.convertToToken1(reserve0Total) - reserve1PendingWithdrawal
);

function amountToken0PendingUnstaking() public view override returns (uint256) {
    uint256 balanceNative = address(this).balance;
    uint256 excessNative =
        balanceNative > amountToken1ClaimableLPWithdrawal ? balanceNative - amountToken1ClaimableLPWithdrawal : 0;
    // stHYPE is rebase, hence no need for conversion
    uint256 excessToken0 = excessNative > 0 ? excessNative : 0;

    uint256 amountToken0PendingUnstakingCache = _amountToken0PendingUnstaking;
    if (amountToken0PendingUnstakingCache > excessToken0) {
        return amountToken0PendingUnstakingCache - excessToken0;
    } else {
        return 0;
    }
}
HIGH severity: [VLTS3-3] Loss of funds when setting a new lendingModule with stHYPEWithdrawalModule::setProposedLendingModule. **Severity:** High

**Description:** When a new `lendingModule` is set via `stHYPEWithdrawalModule::setProposedLendingModule` the wrapped native token is transferred from the current `lendingModule` to the `stHYPEWithdrawalModule` contract:

As a consequence, these funds may be stuck in the...

Vulnerable code:
if (address(lendingModule) != address(0)) {
    lendingModule.withdraw(lendingModule.assetBalance(), address(this));
}

function setProposedLendingModule() external onlyOwner {
    if (lendingModuleProposal.startTimestamp > block.timestamp) {
        revert stHYPEWithdrawalModule__setProposedLendingModule_ProposalNotActive();
    }

    if (lendingModuleProposal.startTimestamp == 0) {
        revert stHYPEWithdrawalModule__setProposedLendingModule_InactiveProposal();
    }

    if (address(lendingModule) != address(0)) {
        lendingModule.withdraw(lendingModule.assetBalance(), address(this));
    }

    lendingModule = ILendingModule(lendingModuleProposal.lendingModule);
    delete lendingModuleProposal;
    emit LendingModuleSet(address(lendingModule));
}
HIGH severity: [VLTS3-9] Withdrawal queue priority bypass for feeless instant withdrawal. **Severity:** High

**Description:** When a `Withdrawal` is created, it references the `cumulativeAmountToken1ClaimableLPWithdrawalCheckpoint` pointer to track when a claim is allowed, according to the existing withdrawal queue.

However, `cumulativeAmountToken1ClaimableLPWithdrawal` only gets...

Vulnerable code:
LPWithdrawals[idLPWithdrawal] = LPWithdrawalRequest({
      recipient: _recipient,
      amountToken1: amountToken1.toUint96(),
      cumulativeAmountToken1ClaimableLPWithdrawalCheckpoint: cumulativeAmountToken1ClaimableLPWithdrawal
  });

if (address(this).balance <= amountToken1ClaimableLPWithdrawalCache) {
        amountToken1ClaimableLPWithdrawal = address(this).balance;
        return;
}

if (
    cumulativeAmountToken1ClaimableLPWithdrawal
        < request.cumulativeAmountToken1ClaimableLPWithdrawalCheckpoint + request.amountToken1
) {
    revert stHYPEWithdrawalModule__claim_cannotYetClaim();
}
LOW severity: [VLTS3-14] Read-only reentrancy in withdraw can lead to swap fee manipulation. **Severity:** Medium

**Path:** src/STEXAMM.sol:withdraw#L523-L624

**Description:** In the `withdraw` function for LP shareholders in STEXAMM, the caller can choose to unwrap their wHYPE and receive native HYPE instead. This happens on lines 599-602 and an external call is made to the receiver,...

Vulnerable code:
function withdraw(
        uint256 _shares,
        uint256 _amount0Min,
        uint256 _amount1Min,
        uint256 _deadline,
        address _recipient,
        bool _unwrapToNativeToken,
        bool _isInstantWithdrawal
    ) external override nonReentrant returns (uint256 amount0, uint256 amount1) {
        [..]
        
        if (cache.amount1LendingPool > 0) {
          _withdrawalModule.withdrawToken1FromLendingPool(
              cache.amount1LendingPool, _unwrapToNativeToken ? address(this) : _recipient
          );

          if (_unwrapToNativeToken) {
              IWETH9(token1).withdraw(cache.amount1LendingPool);
              Address.sendValue(payable(_recipient), cache.amount1LendingPool);
          }
        }
        
        [..]
    }
HIGH severity: [VLTS3-7] Potential DoS condition when trying to set a new proposed lending module. **Severity:** Low

**Path:** src/stHYPEWithdrawalModule.sol#L312

**Description:** [AAVE V3 Pool](https://github.com/aave/aave-v3-core/blob/782f51917056a53a2c228701058a6c3fb233684a/contracts/protocol/libraries/logic/ValidationLogic.sol#L66-L71) reverts when withdrawing zero amount:

Thus, when...

Vulnerable code:
function validateWithdraw(
    DataTypes.ReserveCache memory reserveCache,
    uint256 amount,
    uint256 userBalance
  ) internal view {
    require(amount != 0, Errors.INVALID_AMOUNT);

if (address(lendingModule) != address(0)) {
    lendingModule.withdraw(lendingModule.assetBalance(), address(this));
}

function setProposedLendingModule() external onlyOwner {
    if (lendingModuleProposal.startTimestamp > block.timestamp) {
        revert stHYPEWithdrawalModule__setProposedLendingModule_ProposalNotActive();
    }

    if (lendingModuleProposal.startTimestamp == 0) {
        revert stHYPEWithdrawalModule__setProposedLendingModule_InactiveProposal();
    }

    if (address(lendingModule) != address(0)) {
        lendingModule.withdraw(lendingModule.assetBalance(), address(this));
    }

    lendingModule = ILendingModule(lendingModuleProposal.lendingModule);
    delete lendingModuleProposal;
    emit LendingModuleSet(address(lendingModule));
}
LOW severity: [VLTS3-10] Owner is able to set new FeeParams without a time lock. **Severity:** Low

**Path:** src/STEXRatioSwapFeeModule.sol:setSwapFeeParams#L155-L192

**Description:** The `SwapFeeModule` in `STEXAMM` is set through a proposal of a new `STEXRatioSwapFeeModule` by calling the function `setProposedSwapFeeModule`, however the new fee parameters can be set...

Vulnerable code:
function setSwapFeeParams(
        uint32 _minThresholdRatioBips,
        uint32 _maxThresholdRatioBips,
        uint32 _feeMinBips,
        uint32 _feeMaxBips
    ) external override onlyOwner {
        // Reserve ratio threshold params must be in BIPS
        if (_minThresholdRatioBips >= BIPS) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_invalidMinThresholdRatio();
        }
        if (_maxThresholdRatioBips > BIPS) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_invalidMaxThresholdRatio();
        }
        if (_minThresholdRatioBips >= _maxThresholdRatioBips) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_inconsistentThresholdRatioParams();
        }

        // Fees must be lower than 50% (5_000 bips)
        if (_feeMinBips >= BIPS / 2) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_invalidFeeMin();
        }
        if (_feeMaxBips >= BIPS / 2) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_invalidFeeMax();
        }

        if (_feeMinBips > _feeMaxBips) {
            revert STEXRatioSwapFeeModule__setSwapFeeParams_inconsistentFeeParams();
        }

        feeParams = FeeParams({
            minThresholdRatioBips: _minThresholdRatioBips,
            maxThresholdRatioBips: _maxThresholdRatioBips,
            feeMinBips: _feeMinBips,
            feeMaxBips: _feeMaxBips
        });

        emit SwapFeeParamsSet(_minThresholdRatioBips, _maxThresholdRatioBips, _feeMinBips, _feeMaxBips);
    }
LOW severity: [VLTS3-11] Aave lending module could be a source of temporary DoS. **Severity:** Low

**Path:** src/AaveLendingModule:withdraw#L75-L77

**Description:** The STEXAMM leverages supplying token1 (WETH) collateral to a lending platform (Aave) to earn extra yield. The depositing happens manually by the owner, but the withdrawing happens automatically upon a call to...

Vulnerable code:
function withdraw(uint256 _amount, address _recipient) external onlyOwner {
        pool.withdraw(asset, _amount, _recipient);
    }
MEDIUM severity: [ETRP-16] Missing Curve Validation in BabyJubjub Circom Implementation. **Severity:** Medium

**Path:** circom/components.circom, circom/circomlib/babyjub.circom

**Description:** The Circom implementation of BabyJubjub curve operations does not validate that points lie on the curve before performing operations. In Circom (`babyjub.circom`), while a `BabyCheck()`...

Vulnerable code:
template CheckValue() {
    signal input value;
    signal input privKey;
    signal input valueC1[2];
    signal input valueC2[2];

    // Verify the value is less than the base order
    assert(value < 2736030358979909402780800718157159386076813972158567259200215660948447373041);

    component checkValue = ElGamalDecrypt();
    checkValue.c1[0] <== valueC1[0];
    checkValue.c1[1] <== valueC1[1];
    checkValue.c2[0] <== valueC2[0];
    checkValue.c2[1] <== valueC2[1];
    checkValue.privKey <== privKey;
    
    component valueToPoint = BabyPbk();
    valueToPoint.in <== value;

    valueToPoint.Ax === checkValue.outx;
    valueToPoint.Ay === checkValue.outy;
}

template BabyCheck() {
    signal input x;
    signal input y;

    signal x2;
    signal y2;

    var a = 168700;
    var d = 168696;

    x2 <== x*x;
    y2 <== y*y;

    a*x2 + y2 === 1 + d*x2*y2;
}
HIGH severity: [ETRP-18] Missing Subgroup Order Check in CheckReceiverValue component. **Severity:** Informational

**Path:** circom/components.circom

**Description:** `CheckReceiverValue` component validates receiver’s encrypted amount equals to the actual receiving amount.

The `receiverRandom` value misses the check to be less than the BabyJubJub subgroup...

Vulnerable code:
template CheckReceiverValue() {
    signal input receiverValue;
    signal input receiverPublicKey[2];
    signal input receiverRandom;
    signal input receiverValueC1[2];
    signal input receiverValueC2[2];

    component receiverValueToPoint = BabyPbk();
    receiverValueToPoint.in <== receiverValue;

    component receiverValueEncrypt = ElGamalEncrypt();
    receiverValueEncrypt.random <== receiverRandom;
    receiverValueEncrypt.pk[0] <== receiverPublicKey[0];
    receiverValueEncrypt.pk[1] <== receiverPublicKey[1];
    receiverValueEncrypt.msg[0] <== receiverValueToPoint.Ax;
    receiverValueEncrypt.msg[1] <== receiverValueToPoint.Ay;

    receiverValueEncrypt.encryptedC1X === receiverValueC1[0];
    receiverValueEncrypt.encryptedC1Y === receiverValueC1[1];
    receiverValueEncrypt.encryptedC2X === receiverValueC2[0];
    receiverValueEncrypt.encryptedC2Y === receiverValueC2[1];
}
LOW severity: [EIGEN2-14] Stake deviations due to adding/removing strategy may allow for ejector manipulation. **Severity:** Medium

**Path:** src/StakeRegistry.sol#L128-L174
src/StakeRegistry.sol#L727-L731
src/EjectionManager.sol#L135-L163

**Description:** In the StakeRegistry contract, the `updateOperatorsStake()` function is triggered by the `updateOperators()` function of the RegistryCoordinator...

Vulnerable code:
(uint96[] memory stakeWeights, bool[] memory hasMinimumStakes) =
    _weightOfOperatorsForQuorum(quorumNumber, operators);

int256 totalStakeDelta = 0;
// If the operator no longer meets the minimum stake, set their stake to zero and mark them for removal
/// also handle setting the operator's stake to 0 and remove them from the quorum
for (uint256 i = 0; i < operators.length; i++) {
    if (!hasMinimumStakes[i]) {
        stakeWeights[i] = 0;
        shouldBeDeregistered[i] = true;
    }

    // Update the operator's stake and retrieve the delta
    // If we're deregistering them, their weight is set to 0
    int256 stakeDelta = _recordOperatorStakeUpdate({
        operatorId: operatorIds[i],
        quorumNumber: quorumNumber,
        newStake: stakeWeights[i]
    });

    totalStakeDelta += stakeDelta;
}

// Apply the delta to the quorum's total stake
_recordTotalStakeUpdate(quorumNumber, totalStakeDelta);
LOW severity: [EIGEN2-5] Max operator limit can be exceeded. **Severity:** Medium

**Path:** SlashingRegistryCoordinator.sol:_kickOperator (L395-409)

**Description:** The function `_kickOperator` is used to forcefully remove an operator from a set of quorum numbers. It is called from `ejectOperator`, `_updateOperatorsStakes` and...

Vulnerable code:
if (results.numOperatorsPerQuorum[i] > operatorSetParams.maxOperatorCount) {
    _validateChurn({
        quorumNumber: uint8(quorumNumbers[i]),
        totalQuorumStake: results.totalStakes[i],
        newOperator: operator,
        newOperatorStake: results.operatorStakes[i],
        kickParams: operatorKickParams[i],
        setParams: operatorSetParams
    });

    bytes memory singleQuorumNumber = new bytes(1);
    singleQuorumNumber[0] = quorumNumbers[i];
    _kickOperator(operatorKickParams[i].operator, singleQuorumNumber);
}

if (quorumsToRemove.isSubsetOf(currentBitmap)) {
    _forceDeregisterOperator(operator, quorumNumbers);
}

function _kickOperator(address operator, bytes memory quorumNumbers) internal virtual {
    OperatorInfo storage operatorInfo = _operatorInfo[operator];
    // Only proceed if operator is currently registered
    require(operatorInfo.status == OperatorStatus.REGISTERED, OperatorNotRegistered());

    bytes32 operatorId = operatorInfo.operatorId;
    uint192 quorumsToRemove =
        uint192(BitmapUtils.orderedBytesArrayToBitmap(quorumNumbers, quorumCount));
    uint192 currentBitmap = _currentOperatorBitmap(operatorId);

    // Check if operator is registered for all quorums we're trying to remove them from
    if (quorumsToRemove.isSubsetOf(currentBitmap)) {
        _forceDeregisterOperator(operator, quorumNumbers);
    }
}
LOW severity: [EIGEN2-4] Missing constraint check for modification of lookahead time of slashable quorum. **Severity:** Medium

**Path:** StakeRegistry.sol:_setLookAheadPeriod#L794-L802

**Description:** The StakeRegistry exposes the external function `setLookAheadPeriod`, which calls the internal variant and allows the CoordinatorOwner to set the lookahead time for a slashable quorum...

Vulnerable code:
require(
    AllocationManager(address(allocationManager)).DEALLOCATION_DELAY() > lookAheadPeriod,
    LookAheadPeriodTooLong()
);

function _setLookAheadPeriod(uint8 quorumNumber, uint32 _lookAheadBlocks) internal {
        require(
            stakeTypePerQuorum[quorumNumber] == IStakeRegistryTypes.StakeType.TOTAL_SLASHABLE,
            QuorumNotSlashable()
        );
        uint32 oldLookAheadDays = slashableStakeLookAheadPerQuorum[quorumNumber];
        slashableStakeLookAheadPerQuorum[quorumNumber] = _lookAheadBlocks;
        emit LookAheadPeriodChanged(oldLookAheadDays, _lookAheadBlocks);
    }
MEDIUM severity: [EIGEN2-2] Current rate limit logic allows ejection beyond allowed limit. **Severity:** Medium

**Path:** EjectionManager.sol:ejectOperators

**Description:** The owner or an ejector can eject operators. Only the ejector has a rate limit, which restricts how much can be totally rejected during a quorum, that is based on a limit set by the owner.

When an ejector calls...

Vulnerable code:
function ejectOperators(
    bytes32[][] memory operatorIds
) external {  

-- SNIP -- 

  if (
      isEjector[msg.sender]
          && quorumEjectionParams[quorumNumber].rateLimitWindow > 0
          && stakeForEjection + operatorStake > amountEjectable
  ) {

      ratelimitHit = true;

      stakeForEjection += operatorStake;
      ++ejectedOperators;

      slashingRegistryCoordinator.ejectOperator(
          slashingRegistryCoordinator.getOperatorFromId(operatorIds[i][j]),
          abi.encodePacked(quorumNumber)
      );

      emit OperatorEjected(operatorIds[i][j], quorumNumber);

      break;
  }

stakeForEjection + operatorStake > amountEjectable
0 + 10e18 > 1e16

function ejectOperators(
    bytes32[][] memory operatorIds
) external {  

-- SNIP -- 

  if (
      isEjector[msg.sender]
          && quorumEjectionParams[quorumNumber].rateLimitWindow > 0
          && stakeForEjection + operatorStake > amountEjectable
  ) {

      ratelimitHit = true;

--    stakeForEjection += operatorStake;
--    ++ejectedOperators;

--    slashingRegistryCoordinator.ejectOperator(
--         slashingRegistryCoordinator.getOperatorFromId(operatorIds[i][j]),
--         abi.encodePacked(quorumNumber)
--     );

--     emit OperatorEjected(operatorIds[i][j], quorumNumber);

      break;
  }
LOW severity: [EIGEN2-15] Ejection timestamp is not updated when operator is kicked out in update loop. **Severity:** Low

**Description:** An operator could be kicked by ejection, which invokes the kick functions in `SlashingRegistryCoordinator.sol` It sets a `lastEjectionTimestamp` to the current block.timestamp, which disallows the same operator to register immediately again.

However...

Vulnerable code:
function ejectOperator(
    address operator,
    bytes memory quorumNumbers
) public virtual onlyEjector {
    lastEjectionTimestamp[operator] = block.timestamp;
    _kickOperator(operator, quorumNumbers);
}

function _updateOperatorsStakes(... ) internal virtual {
      -- snip
      if (doesNotMeetStakeThreshold[j]) {
          _kickOperator(operators[j], singleQuorumNumber);
      }
  }
}

function ejectOperator(
    address operator,
    bytes memory quorumNumbers
) public virtual onlyEjector {
    lastEjectionTimestamp[operator] = block.timestamp;
    _kickOperator(operator, quorumNumbers);
}
LOW severity: [EIGEN2-10] A new operator could replace another operator with less staking amount. **Severity:** Low

**Path:** SlashingRegistryCoordinator.sol:_setOperatorSetParams

**Description:** The function `_setOperatorSetParams` sets the configuration for a quorumNumber for the `SlashingRegistryCoordinator`. 

Currently, there are no checks for the `kickBIPsOfOperatorStake` and ...

Vulnerable code:
_validateChurn
    require(
          newOperatorStake > _individualKickThreshold(operatorToKickStake, setParams),
          InsufficientStakeForChurn()
      );

function _individualKickThreshold(
    uint96 operatorStake,
    OperatorSetParam memory setParams
) internal pure returns (uint96) {
    return operatorStake * setParams.kickBIPsOfOperatorStake / BIPS_DENOMINATOR;
}

function _setOperatorSetParams(
        uint8 quorumNumber,
        OperatorSetParam memory operatorSetParams
    ) internal {
        _quorumParams[quorumNumber] = operatorSetParams;
        emit OperatorSetParamsUpdated(quorumNumber, operatorSetParams);
    }