# Aggregator

The core interface of the `Aggregator` contract is as follows:

```
interface IAggregator {
  function validateUserOpSignature(UserOperation calldata userOp) external view returns (bytes memory sigForUserOp);

  function aggregateSignatures(UserOperation[] calldata userOps) external view returns (bytes memory aggregatesSignature);

  function validateSignatures(UserOperation[] calldata userOps, bytes calldata signature) view external;
}
```

**Working with Aggregators in the Ethereum System**:

**Using an Aggregator**:

* An account can opt to use an aggregator to combine multiple signatures.
* If it does, when the system checks or "simulates" how a UserOp will be validated (using `simulateValidation()`), it will give a response called `ValidationResultWithAggregator` instead of just `ValidationResult` if something goes wrong.

**Validating User Operations**:

* Before accepting a UserOp, the bundler (special actor that packages multiple UserOps) must double-check the UserOp's authenticity using the `validateUserOpSignature()` method.

**Aggregating Signatures**:

* The method `aggregateSignatures()` is responsible for bringing all individual UserOp signatures together into one unified value.

**Helper Methods**:

* The methods mentioned above, like `validateUserOpSignature()` and `aggregateSignatures()`, are tools to assist the bundler.
* However, bundlers aren't strictly limited to these. They can choose to use their own libraries or tools to perform these validations and aggregations if they wish.

**Final Signature Check**:

* The method `validateSignatures()` is vital. It checks to ensure that the combined or "aggregated" signature is a perfect match for all the UserOps grouped together. If there's any discrepancy, the operation will stop or "revert".
* This critical check is done on-chain when the `handleOps()` method is called.

In a nutshell, when using an aggregator to handle multiple signatures, the system provides tools to ensure each step is verified and consolidated appropriately. Bundlers can use built-in methods or their own tools, but the final check always ensures everything matches up before processing.