# PublicResolver

### Overview

`PublicResolver` is a contract that provides additional functionality for managing operator approvals and registration controllers for Payment ID tokens. The contract supports both direct and signature-based authorization.

### Key Concepts

| Concept                       | Description                                                                           |
| ----------------------------- | ------------------------------------------------------------------------------------- |
| **Operator Approvals**        | Allows owners to authorize operators to manage their Payment ID tokens.               |
| **Signature-Based Approvals** | Enables gasless approvals using EIP-712 signatures.                                   |
| **Registration Controller**   | Manages centralized registration operations and is initialized once.                  |
| **PID Registry Integration**  | Ensures authorization consistency by verifying token ownership with the PID registry. |

### Data Structures

#### Immutable Components

| Name                        | Type      | Description                                    |
| --------------------------- | --------- | ---------------------------------------------- |
| `APPROVAL_FOR_ALL_TYPEHASH` | `bytes32` | Type hash for operator approval via signature. |

#### State Variables

| Name                     | Type                                           | Description                                        |
| ------------------------ | ---------------------------------------------- | -------------------------------------------------- |
| `pidRegistry`            | `IPIDRegistry`                                 | Stores the reference to the PID registry contract. |
| `registrationController` | `address`                                      | Stores the address of the registration controller. |
| `_operatorApprovals`     | `mapping(address => mapping(address => bool))` | Mapping tracking operator approvals for owners.    |

### Functions

#### Initialization

**Constructor**

```solidity
constructor(address _pidRegistry, address _publicKeyRegistry)
```

| Input Parameter      | Type      | Description                                  |
| -------------------- | --------- | -------------------------------------------- |
| `_pidRegistry`       | `address` | Address of the PID registry contract.        |
| `_publicKeyRegistry` | `address` | Address of the public key registry contract. |

**init**

```solidity
function init(address _registrationController) external
```

| Input Parameter           | Type      | Description                             |
| ------------------------- | --------- | --------------------------------------- |
| `_registrationController` | `address` | Address of the registration controller. |

#### Operator Management

**setApprovalForAll**

```solidity
function setApprovalForAll(address operator, bool approved) external
```

| Input Parameter | Type      | Description                           |
| --------------- | --------- | ------------------------------------- |
| `operator`      | `address` | Address to be approved or revoked.    |
| `approved`      | `bool`    | `true` to approve, `false` to revoke. |

**setApprovalForAllWithSig**

```solidity
function setApprovalForAllWithSig(address owner, address operator, bool approved, bytes calldata signature) external
```

| Input Parameter | Type             | Description                                 |
| --------------- | ---------------- | ------------------------------------------- |
| `owner`         | `address`        | Address of the token owner.                 |
| `operator`      | `address`        | Address to be approved or revoked.          |
| `approved`      | `bool`           | `true` to approve, `false` to revoke.       |
| `signature`     | `bytes calldata` | EIP-712 signature authorizing the approval. |

**isApprovedForAll**

```solidity
function isApprovedForAll(address account, address operator) public view returns (bool)
```

| Input Parameter | Type      | Description                                    |
| --------------- | --------- | ---------------------------------------------- |
| `account`       | `address` | Owner account to check for operator approvals. |
| `operator`      | `address` | Address to check.                              |
| **Returns**     | `bool`    | `true` if approved, `false` otherwise.         |

#### Authorization Check

**isAuthorised**

```solidity
function isAuthorised(uint256 tokenId) internal view override returns (bool)
```

| Input Parameter | Type      | Description                              |
| --------------- | --------- | ---------------------------------------- |
| `tokenId`       | `uint256` | Token ID to verify authorization for.    |
| **Returns**     | `bool`    | `true` if authorized, `false` otherwise. |

### Events

| Event                           | Parameters                                         | Description                                          |
| ------------------------------- | -------------------------------------------------- | ---------------------------------------------------- |
| `ApprovalForAll`                | `(address owner, address operator, bool approved)` | Emitted when operator approval status is updated.    |
| `RegistrationControllerUpdated` | `(address oldController, address newController)`   | Emitted when the registration controller is updated. |

### Errors

| Error                                           | Description                                                         |
| ----------------------------------------------- | ------------------------------------------------------------------- |
| `PublicResolver__InvalidOperator`               | Thrown when an operator action is invalid.                          |
| `PublicResolver__AlreadyInitialized`            | Thrown when trying to reinitialize the registration controller.     |
| `PublicResolver__InvalidRegistrationController` | Thrown when an invalid registration controller address is provided. |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.space.id/payment-id/core-contracts/publicresolver.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.