master 9c5ffa8b4c79 cached
382 files
14.6 MB
3.9M tokens
2807 symbols
1 requests
Copy disabled (too large) Download .txt
Showing preview only (15,419K chars total). Download the full file to get everything.
Repository: ethereum-attestation-service/eas-contracts
Branch: master
Commit: 9c5ffa8b4c79
Files: 382
Total size: 14.6 MB

Directory structure:
gitextract_0o9h11kw/

├── .github/
│   └── workflows/
│       └── ci.yml
├── .gitignore
├── .prettierrc
├── .solcover.ts
├── .solhint.json
├── LICENSE
├── README.md
├── components/
│   └── Contracts.ts
├── contracts/
│   ├── Common.sol
│   ├── EAS.sol
│   ├── IEAS.sol
│   ├── ISchemaRegistry.sol
│   ├── ISemver.sol
│   ├── Indexer.sol
│   ├── SchemaRegistry.sol
│   ├── Semver.sol
│   ├── eip1271/
│   │   └── EIP1271Verifier.sol
│   ├── eip712/
│   │   └── proxy/
│   │       ├── EIP712Proxy.sol
│   │       └── examples/
│   │           └── PermissionedEIP712Proxy.sol
│   ├── resolver/
│   │   ├── ISchemaResolver.sol
│   │   ├── SchemaResolver.sol
│   │   └── examples/
│   │       ├── AttestationResolver.sol
│   │       ├── AttesterResolver.sol
│   │       ├── DataResolver.sol
│   │       ├── ExpirationTimeResolver.sol
│   │       ├── PayingResolver.sol
│   │       ├── RecipientResolver.sol
│   │       ├── RevocationResolver.sol
│   │       ├── TokenResolver.sol
│   │       └── ValueResolver.sol
│   └── tests/
│       ├── TestEAS.sol
│       ├── TestERC20Token.sol
│       ├── TestSchemaResolver.sol
│       ├── eip1271/
│       │   ├── TestEIP1271Signer.sol
│       │   └── TestEIP1271Verifier.sol
│       └── eip712/
│           └── proxy/
│               └── TestEIP712Proxy.sol
├── deployments/
│   ├── arbitrum-nova/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── arbitrum-one/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   ├── arbitrum-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── EAS.ts
│   │       │           ├── Indexer.ts
│   │       │           ├── SchemaRegistry.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── EAS__factory.ts
│   │                       ├── Indexer__factory.ts
│   │                       ├── SchemaRegistry__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── base/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── base-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── base-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── celo/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── hardhat/
│   │   └── .chainId
│   ├── ink/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── Indexer__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── ink-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   ├── solcInputs/
│   │   │   └── ab2e55c92b39ec3be86af0608f634927.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── linea/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── linea-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── mainnet/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   ├── optimism/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── optimism-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── optimism-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── polygon/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── polygon-amoy/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── scroll/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── scroll-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── soneium/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── telos/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── EAS.ts
│   │       │           ├── Indexer.ts
│   │       │           ├── SchemaRegistry.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── EAS__factory.ts
│   │                       ├── Indexer__factory.ts
│   │                       ├── SchemaRegistry__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── unichain/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   └── zksync/
│       ├── .chainId
│       ├── .migrations.json
│       ├── EAS.json
│       ├── EIP712Proxy.json
│       ├── Indexer.json
│       ├── SchemaRegistry.json
│       └── types/
│           ├── contracts/
│           │   ├── EAS.ts
│           │   ├── Indexer.ts
│           │   ├── SchemaRegistry.ts
│           │   └── eip712/
│           │       └── proxy/
│           │           └── EIP712Proxy.ts
│           └── factories/
│               └── contracts/
│                   ├── EAS__factory.ts
│                   ├── Indexer__factory.ts
│                   ├── SchemaRegistry__factory.ts
│                   └── eip712/
│                       └── proxy/
│                           └── EIP712Proxy__factory.ts
├── eslint.config.mjs
├── foundry.toml
├── funding.json
├── hardhat.config.ts
├── package.json
├── test/
│   ├── EAS.ts
│   ├── Indexer.ts
│   ├── SchemaRegistry.ts
│   ├── eip1271/
│   │   └── EIP1271Verifier.ts
│   ├── eip712/
│   │   └── proxy/
│   │       ├── EIP712Proxy.ts
│   │       └── PermissionedEIP712Proxy.ts
│   ├── helpers/
│   │   ├── Chai.ts
│   │   ├── EAS.ts
│   │   ├── EIP712ProxyUtils.ts
│   │   ├── EIP712Utils.ts
│   │   ├── Time.ts
│   │   ├── Transaction.ts
│   │   └── Wallet.ts
│   └── resolver/
│       ├── AttestationResolver.ts
│       ├── AttesterResolver.ts
│       ├── DataResolver.ts
│       ├── ExpirationTimeResolver.ts
│       ├── PayingResolver.ts
│       ├── RecipientResolver.ts
│       ├── RevocationResolver.ts
│       ├── SchemaResolver.ts
│       ├── TokenResolver.ts
│       └── ValueResoler.ts
├── tsconfig.json
├── tsconfig.release.json
└── utils/
    ├── Constants.ts
    ├── EAS.ts
    ├── Logger.ts
    └── Time.ts

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/workflows/ci.yml
================================================
name: CI

on:
  workflow_dispatch:
  push:
    branches:
      - master
  pull_request:

jobs:
  test:
    name: Test

    runs-on: ubuntu-latest

    steps:
      - name: Check out the Repository
        uses: actions/checkout@v4

      - name: Install Packages
        run: sudo apt-get update && sudo apt-get -y install pkg-config libusb-1.0 libudev-dev

      - name: Install PNPM
        uses: pnpm/action-setup@v4
        id: pnpm-install
        with:
          version: 8
          run_install: false

      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'pnpm'

      - name: Install Dependencies
        run: pnpm install

      - name: Install Foundry
        uses: foundry-rs/foundry-toolchain@v1
        with:
          version: nightly

      - name: Lint
        run: pnpm lint

      - name: Compile (Hardhat)
        run: pnpm compile

      - name: Test
        run: pnpm test

      - name: Compile (Foundry)
        run: forge build


================================================
FILE: .gitignore
================================================
.DS_Store
.vscode/
*/**/.DS_Store

/node_modules

dist
cache
artifacts
typechain-types
cache-zk
artifacts-zk
deployments-zk

deployments/mainnet/solcInputs/*
deployments/optimism/solcInputs/*
deployments/base/solcInputs/*
deployments/arbitrum-one/solcInputs/*
deployments/arbitrum-nova/solcInputs/*
deployments/polygon/solcInputs/*
deployments/scroll/solcInputs/*
deployments/zksync/solcInputs/*
deployments/celo/solcInputs/*
deployments/linea/solcInputs/*
deployments/telos/solcInputs/*
deployments/soneium/solcInputs/*
deployments/ink/solcInputs/*
deployments/unichain/solcInputs/*
deployments/sepolia/solcInputs/*
deployments/optimism-sepolia/solcInputs/*
deployments/optimism-goerli/solcInputs/*
deployments/base-sepolia/solcInputs/*
deployments/base-goerli/solcInputs/*
deployments/arbitrum-sepolia/solcInputs/*
deployments/polygon-amoy/solcInputs/*
deployments/scroll-sepolia/solcInputs/*
deployments/linea-goerli/solcInputs/*
deployments/hardhat/*
!deployments/hardhat/.chainId

.coverage_artifacts
.coverage_contracts
/coverage
/coverage.json
allFiredEvents
scTopics

.env*
!.env.template


================================================
FILE: .prettierrc
================================================
{
  "plugins": ["@ianvs/prettier-plugin-sort-imports", "prettier-package-json", "prettier-plugin-solidity"],
  "overrides": [
    {
      "files": "*.sol",
      "options": {
        "tabWidth": 4,
        "singleQuote": false
      }
    }
  ],
  "printWidth": 120,
  "tabWidth": 2,
  "useTabs": false,
  "semi": true,
  "singleQuote": true,
  "trailingComma": "none",
  "arrowParens": "always",
  "bracketSpacing": true,
  "importOrderTypeScriptVersion": "5.0.0"
}


================================================
FILE: .solcover.ts
================================================
module.exports = {
  skipFiles: ['tests']
};


================================================
FILE: .solhint.json
================================================
{
  "extends": "solhint:recommended",
  "rules": {
    "avoid-throw": "off",
    "avoid-suicide": "error",
    "avoid-sha3": "warn",
    "not-rely-on-time": "off",
    "no-empty-blocks": "off",
    "mark-callable-contracts": "off",
    "func-visibility": ["error", { "ignoreConstructors": true }],
    "func-named-parameters": "off",
    "immutable-vars-naming": "off",
    "compiler-version": ["error", "^0.8.0"],
    "imports-order": "warn"
  }
}


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2020 Leonid Beder

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# Ethereum Attestation Service

[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://eas.eth.link)
[![NPM Package](https://img.shields.io/npm/v/@ethereum-attestation-service/eas-contracts.svg)](https://www.npmjs.org/package/@ethereum-attestation-service/eas-contracts)
[![Test](https://github.com/ethereum-attestation-service/eas-contracts/actions/workflows/ci.yml/badge.svg)](https://github.com/ethereum-attestation-service/eas-contracts/actions/workflows/ci.yml)
[![License](https://img.shields.io/github/license/ethereum-attestation-service/eas-contracts?style=flat-square)](https://github.com/ethereum-attestation-service/eas-contracts/blob/master/LICENSE)

## Introduction

The Ethereum Attestation Service is a free and open protocol for on-chain attestations on EVM compatible blockchains. It is a generalized service that allows anyone to register a schema for their particular use case, and then make attestations following their schema.

Schemas can be registered using the `SchemaRegistry.sol` contract, and attestations are made using the `EAS.sol` contract.

In addition, we provide a resolver contract for advanced use cases, such as on-chain verification of attestation data, and also attaching payments to attestations (which makes a new suite of powerful web3 applications possible).

We also provide an SDK for developers.

On-chain attestations will enable a powerful new range of web3 applications, including:

* Identity
* Trust Scores
* Goodness Scores
* Credit Scores
* Clout
* Land Registries
* Social Networks
* Portable Trust Layers
* Retroactive Public Goods Funding
* KYC Services
* Uncollateralized Lending / Borrowing
* Voting
* Oracles (who can be atomically paid for making attestations inside the protocol)
* Likes/Dislikes
* Content Filtering
* And many more!

## Deployments

Please note that you can also import and use the addresses directly in your code using the `@ethereum-attestation-service/eas-contracts/deployments` deployment artifacts corresponding to your desired network.

### Mainnets

#### Ethereum

Version 0.26:

* **EAS**:
  * Contract: [0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587](https://etherscan.io/address/0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587)
  * Deployment and ABI: [EAS.json](./deployments/mainnet/EAS.json)
* **SchemaRegistry**:
  * Contract: [0xA7b39296258348C78294F95B872b282326A97BDF](https://etherscan.io/address/0xA7b39296258348C78294F95B872b282326A97BDF)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/mainnet/SchemaRegistry.json)

#### Optimism

Version 1.0.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/optimism/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/optimism/SchemaRegistry.json)

Version 1.2.0:

* **EIP712Proxy**:
  * Contract: [0xE132c2E90274B44FfD8090b58399D04ddc060AE1](https://optimistic.etherscan.io/address/0xE132c2E90274B44FfD8090b58399D04ddc060AE1)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/optimism/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x6dd0CB3C3711c8B5d03b3790e5339Bbc2Bbcf934](https://optimistic.etherscan.io/address/0x6dd0CB3C3711c8B5d03b3790e5339Bbc2Bbcf934)
  * Deployment and ABI: [Indexer.json](./deployments/optimism/Indexer.json)

#### Base

Version 1.0.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://basescan.org/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/base/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://basescan.org/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/base/SchemaRegistry.json)

Version 1.2.0:

* **EIP712Proxy**:
  * Contract: [0xF095fE4b23958b08D38e52d5d5674bBF0C03cbF6](https://basescan.org/address/0xF095fE4b23958b08D38e52d5d5674bBF0C03cbF6)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/base/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x37AC6006646f2e687B7fB379F549Dc7634dF5b84](https://basescan.org/address/0x37AC6006646f2e687B7fB379F549Dc7634dF5b84)
  * Deployment and ABI: [Indexer.json](./deployments/base/Indexer.json)

#### Arbitrum One

Version 0.26:

* **EAS**:
  * Contract: [0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458](https://arbiscan.io/address/0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458)
  * Deployment and ABI: [EAS.json](./deployments/arbitrum-one/EAS.json)
* **SchemaRegistry**:
  * Contract: [0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB](https://arbiscan.io/address/0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/arbitrum-one/SchemaRegistry.json)

#### Arbitrum Nova

Version 1.3.0:

* **EAS**:
  * Contract: [0x6d3dC0Fe5351087E3Af3bDe8eB3F7350ed894fc3](https://nova.arbiscan.io/address/0x6d3dC0Fe5351087E3Af3bDe8eB3F7350ed894fc3)
  * Deployment and ABI: [EAS.json](./deployments/arbitrum-nova/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x49563d0DA8DF38ef2eBF9C1167270334D72cE0AE](https://nova.arbiscan.io/address/0x49563d0DA8DF38ef2eBF9C1167270334D72cE0AE)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/arbitrum-nova/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0xEbf2DeeD690F8A68b8248d6a12231ee70ED2154A](https://nova.arbiscan.io/address/0xEbf2DeeD690F8A68b8248d6a12231ee70ED2154A)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/arbitrum-nova/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x7182Be5e84aFEe9Dc29C69D081F8A0FA834d6CB8](https://nova.arbiscan.io/address/0x7182Be5e84aFEe9Dc29C69D081F8A0FA834d6CB8)
  * Deployment and ABI: [Indexer.json](./deployments/arbitrum-nova/Indexer.json)

#### Polygon

Version 1.3.0:

* **EAS**:
  * Contract: [0x5E634ef5355f45A855d02D66eCD687b1502AF790](https://polygonscan.com/address/0x5E634ef5355f45A855d02D66eCD687b1502AF790)
  * Deployment and ABI: [EAS.json](./deployments/polygon/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x7876EEF51A891E737AF8ba5A5E0f0Fd29073D5a7](https://polygonscan.com/address/0x7876EEF51A891E737AF8ba5A5E0f0Fd29073D5a7)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/polygon/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x4be71865917C7907ccA531270181D9B7dD4f2733](https://polygonscan.com/address/0x4be71865917C7907ccA531270181D9B7dD4f2733)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/polygon/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x12d0f50Eb2d67b14293bdDA2C248358f3dfE5308](https://polygonscan.com/address/0x12d0f50Eb2d67b14293bdDA2C248358f3dfE5308)
  * Deployment and ABI: [Indexer.json](./deployments/polygon/Indexer.json)

#### Scroll

Version 1.3.0:

* **EAS**:
  * Contract: [0xC47300428b6AD2c7D03BB76D05A176058b47E6B0](https://scrollscan.com/address/0xC47300428b6AD2c7D03BB76D05A176058b47E6B0)
  * Deployment and ABI: [EAS.json](./deployments/scroll/EAS.json)
* **SchemaRegistry**:
  * Contract: [0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6](https://scrollscan.com/address/0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/scroll/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x77b7DA1c40762Cd8AFfE2069b575328EfD4D9801](https://scrollscan.com/address/0x77b7DA1c40762Cd8AFfE2069b575328EfD4D9801)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/scroll/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x8314bc1B2f7F286cb4f0323FE7119C0F99D4A083](https://scrollscan.com/address/0x8314bc1B2f7F286cb4f0323FE7119C0F99D4A083)
  * Deployment and ABI: [Indexer.json](./deployments/scroll/Indexer.json)

#### zkSync

Version 1.3.0:

* **EAS**:
  * Contract: [0x21d8d4eE83b80bc0Cc0f2B7df3117Cf212d02901](https://explorer.zksync.io/address/0x21d8d4eE83b80bc0Cc0f2B7df3117Cf212d02901)
  * Deployment and ABI: [EAS.json](./deployments/zksync/EAS.json)
* **SchemaRegistry**:
  * Contract: [0xB8566376dFe68B76FA985D5448cc2FbD578412a2](https://explorer.zksync.io/address/0xB8566376dFe68B76FA985D5448cc2FbD578412a2)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/zksync/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x8E8F79e9A1Cd4da7bD2f15e5B0a4B4a613E37C5a](https://explorer.zksync.io/address/0x8E8F79e9A1Cd4da7bD2f15e5B0a4B4a613E37C5a)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/zksync/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x8AdA7852df64A66ca89EFc82144e6be71Bd53B4E](https://explorer.zksync.io/address/0x8AdA7852df64A66ca89EFc82144e6be71Bd53B4E)
  * Deployment and ABI: [Indexer.json](./deployments/zksync/Indexer.json)

#### Celo

Version 1.3.0:

* **EAS**:
  * Contract: [0x72E1d8ccf5299fb36fEfD8CC4394B8ef7e98Af92](https://celoscan.io/address/0x72E1d8ccf5299fb36fEfD8CC4394B8ef7e98Af92)
  * Deployment and ABI: [EAS.json](./deployments/celo/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x5ece93bE4BDCF293Ed61FA78698B594F2135AF34](https://celoscan.io/address/0x5ece93bE4BDCF293Ed61FA78698B594F2135AF34)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/celo/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x6792B6AE17c6416016b943585e957a29bc452806](https://celoscan.io/address/0x6792B6AE17c6416016b943585e957a29bc452806)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/celo/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x76591b332d0F099E89FA335fC827D44C47705D2f](https://celoscan.io/address/0x76591b332d0F099E89FA335fC827D44C47705D2f)
  * Deployment and ABI: [Indexer.json](./deployments/celo/Indexer.json)

#### Telos

Version 1.4.0:

* **EAS**:
  * Contract: [0x9898C3FF2fdCA9E734556fC4BCCd5b9239218155](https://teloscan.io/address/0x9898C3FF2fdCA9E734556fC4BCCd5b9239218155)
  * Deployment and ABI: [EAS.json](./deployments/telos/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x842511adC21B85C0B2fdB02AAcFA92fdf7Cda470](https://teloscan.io/address/0x842511adC21B85C0B2fdB02AAcFA92fdf7Cda470)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/telos/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0xA76973759A350D4D7EC7aF042c6c2A32be861AD9](https://teloscan.io/address/0xA76973759A350D4D7EC7aF042c6c2A32be861AD9)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/telos/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x6Abe1F9489B97d9f11E1347567f61137BC61B6F9](https://teloscan.io/address/0x6Abe1F9489B97d9f11E1347567f61137BC61B6F9)
  * Deployment and ABI: [Indexer.json](./deployments/telos/Indexer.json)

#### Soneium

Version 1.4.1-beta.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://soneium.blockscout.com/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/soneium/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://soneium.blockscout.com/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/soneium/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x465a34dd6dDb5DF22DBC67D005b5BF4a0BF7f8AE](https://soneium.blockscout.com/address/0x465a34dd6dDb5DF22DBC67D005b5BF4a0BF7f8AE)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/soneium/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x16613642e9793d413c296f9AB5457077b99AA7B0](https://soneium.blockscout.com/address/0x16613642e9793d413c296f9AB5457077b99AA7B0)
  * Deployment and ABI: [Indexer.json](./deployments/soneium/Indexer.json)

#### Ink

Version 1.4.1-beta.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://explorer.inkonchain.com/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/ink/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://explorer.inkonchain.com/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/ink/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x6511967899445c5944f555Fe2B2D5EC4D74d2579](https://explorer.inkonchain.com/address/0x6511967899445c5944f555Fe2B2D5EC4D74d2579)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/ink/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0xd87dCB0E5E0044Ba5Aa57D383cd3f8D0509a42b9](https://explorer.inkonchain.com/address/0xd87dCB0E5E0044Ba5Aa57D383cd3f8D0509a42b9)
  * Deployment and ABI: [Indexer.json](./deployments/ink/Indexer.json)

#### Unichain

Version 1.4.1-beta.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://uniscan.xyz/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/unichain/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://uniscan.xyz/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/unichain/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x65c83e3C5f1505C4220B2f57815285Dc58464088](https://uniscan.xyz/address/0x65c83e3C5f1505C4220B2f57815285Dc58464088)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/unichain/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0xE6afd49f7beF444e39BFDFbB6BE63119a8BdE88F](https://uniscan.xyz/address/0xE6afd49f7beF444e39BFDFbB6BE63119a8BdE88F)
  * Deployment and ABI: [Indexer.json](./deployments/unichain/Indexer.json)

#### Blast

Version 1.3.0:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://blastscan.io/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/blast/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://blastscan.io/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/blast/SchemaRegistry.json)

#### Linea

Version 1.2.0:

* **EAS**:
  * Contract: [0xaEF4103A04090071165F78D45D83A0C0782c2B2a](https://lineascan.build/address/0xaEF4103A04090071165F78D45D83A0C0782c2B2a)
  * Deployment and ABI: [EAS.json](./deployments/linea/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797](https://lineascan.build/address/0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/linea/SchemaRegistry.json)

### Testnets

#### Sepolia

Version 0.26:

* **EAS**:
  * Contract: [0xC2679fBD37d54388Ce493F1DB75320D236e1815e](https://sepolia.etherscan.io/address/0xC2679fBD37d54388Ce493F1DB75320D236e1815e)
  * Deployment and ABI: [EAS.json](./deployments/sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0](https://sepolia.etherscan.io/address/0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/sepolia/SchemaRegistry.json)

Version 1.2.0:

* **EIP712Proxy**:
  * Contract: [0x9C9d17bEE150E4eCDf3b99baFA62c08Cb30E82BC](https://sepolia.etherscan.io/address/0x9C9d17bEE150E4eCDf3b99baFA62c08Cb30E82BC)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0xaEF4103A04090071165F78D45D83A0C0782c2B2a](https://sepolia.etherscan.io/address/0xaEF4103A04090071165F78D45D83A0C0782c2B2a)
  * Deployment and ABI: [Indexer.json](./deployments/sepolia/Indexer.json)

#### Optimism Sepolia

Version 1.0.2:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://sepolia-optimism.etherscan.io/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/optimism-sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://sepolia-optimism.etherscan.io/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/optimism-sepolia/SchemaRegistry.json)

Version 1.3.0:

* **EIP712Proxy**:
  * Contract: [0x37AC6006646f2e687B7fB379F549Dc7634dF5b84](https://sepolia-optimism.etherscan.io/address/0x37AC6006646f2e687B7fB379F549Dc7634dF5b84)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/optimism-sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x97e6822A36E38D4d93C0c810CC2be1C6Fd492b64](https://sepolia-optimism.etherscan.io/address/0x97e6822A36E38D4d93C0c810CC2be1C6Fd492b64)
  * Deployment and ABI: [Indexer.json](./deployments/optimism-sepolia/Indexer.json)

#### Optimism Goerli

Version 1.0.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://goerli-optimism.etherscan.io/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/optimism-goerli/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://goerli-optimism.etherscan.io/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/optimism-goerli/SchemaRegistry.json)

Version 1.2.0:

* **EIP712Proxy**:
  * Contract: [0x88D1bd62AC014424b987CE5ABf311BD7749e426B](https://goerli-optimism.etherscan.io/address/0x88D1bd62AC014424b987CE5ABf311BD7749e426B)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/optimism-goerli/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0xa42428D1bf904d762adD02b27ADac26d53643782](https://goerli-optimism.etherscan.io/address/0xa42428D1bf904d762adD02b27ADac26d53643782)
  * Deployment and ABI: [Indexer.json](./deployments/optimism-goerli/Indexer.json)

#### Base Sepolia

Version 1.2.0:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://sepolia.basescan.org/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/base-sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://sepolia.basescan.org/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/base-sepolia/SchemaRegistry.json)

Version 1.3.0:

* **EIP712Proxy**:
  * Contract: [0xAd64A04c20dDBbA7cBb0EcAe4823095B4adA5c57](https://sepolia.basescan.org/address/0xAd64A04c20dDBbA7cBb0EcAe4823095B4adA5c57)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/base-sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x2C7BCE69D5Ee84EF73CC9286416F68E60F9A61b3](https://sepolia.basescan.org/address/0x2C7BCE69D5Ee84EF73CC9286416F68E60F9A61b3)
  * Deployment and ABI: [Indexer.json](./deployments/base-sepolia/Indexer.json)

#### Base Goerli

Version 1.0.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://goerli.basescan.org/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/base-goerli/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://goerli.basescan.org/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/base-goerli/SchemaRegistry.json)

Version 1.2.0:

* **EIP712Proxy**:
  * Contract: [0x37AC6006646f2e687B7fB379F549Dc7634dF5b84](https://goerli.basescan.org/address/0x37AC6006646f2e687B7fB379F549Dc7634dF5b84)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/base-goerli/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0xE0893F47009776D6aEC3De8455Cb0ed325Eea74a](https://goerli.basescan.org/address/0xE0893F47009776D6aEC3De8455Cb0ed325Eea74a)
  * Deployment and ABI: [Indexer.json](./deployments/base-goerli/Indexer.json)

#### Arbitrum Sepolia

Version 1.3.0:

* **EAS**:
  * Contract: [0x2521021fc8BF070473E1e1801D3c7B4aB701E1dE](https:/sepolia.arbiscan.io/address/0x2521021fc8BF070473E1e1801D3c7B4aB701E1dE)
  * Deployment and ABI: [EAS.json](./deployments/arbitrum-sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x45CB6Fa0870a8Af06796Ac15915619a0f22cd475](https:/sepolia.arbiscan.io/address/0x45CB6Fa0870a8Af06796Ac15915619a0f22cd475)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/arbitrum-sepolia/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x8E807011c16E538B2dEEf1dc652EFe7724E09397](https://sepolia.arbiscan.io/address/0x8E807011c16E538B2dEEf1dc652EFe7724E09397)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/arbitrum-sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x501D6d86240De5A57E91414356ad4B1778F0AB18](https://sepolia.arbiscan.io/address/0x501D6d86240De5A57E91414356ad4B1778F0AB18)
  * Deployment and ABI: [Indexer.json](./deployments/arbitrum-sepolia/Indexer.json)

#### Polygon Amoy

Version 1.3.0:

* **EAS**:
  * Contract: [0xb101275a60d8bfb14529C421899aD7CA1Ae5B5Fc](https://amoy.polygonscan.com/address/0xb101275a60d8bfb14529C421899aD7CA1Ae5B5Fc)
  * Deployment and ABI: [EAS.json](./deployments/polygon-amoy/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x23c5701A1BDa89C61d181BD79E5203c730708AE7](https://amoy.polygonscan.com/address/0x23c5701A1BDa89C61d181BD79E5203c730708AE7)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/polygon-amoy/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0xA0ec8a80a0b8496B9Cf6Ee703bC16ABdC9F4cf2e](https://amoy.polygonscan.com/address/0xA0ec8a80a0b8496B9Cf6Ee703bC16ABdC9F4cf2e)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/polygon-amoy/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x9F07c0B0E52C36D78Ac8ABfC543c77f83888ac64](https://amoy.polygonscan.com/address/0x9F07c0B0E52C36D78Ac8ABfC543c77f83888ac64)
  * Deployment and ABI: [Indexer.json](./deployments/polygon-amoy/Indexer.json)

#### Scroll Sepolia

Version 1.3.0:

* **EAS**:
  * Contract: [0xaEF4103A04090071165F78D45D83A0C0782c2B2a](https://sepolia.scrollscan.com/address/0xaEF4103A04090071165F78D45D83A0C0782c2B2a)
  * Deployment and ABI: [EAS.json](./deployments/scroll-sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797](https://sepolia.scrollscan.com/address/0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/scroll-sepolia/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b](https://sepolia.scrollscan.com/address/0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/scroll-sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x7C2cb1eDC328491da52de2a0afc44D3B0Ae7ee17](https://sepolia.scrollscan.com/address/0x7C2cb1eDC328491da52de2a0afc44D3B0Ae7ee17)
  * Deployment and ABI: [Indexer.json](./deployments/scroll-sepolia/Indexer.json)

#### Ink Sepolia

Version 1.4.1-beta.1:

* **EAS**:
  * Contract: [0x4200000000000000000000000000000000000021](https://explorer-sepolia.inkonchain.com/address/0x4200000000000000000000000000000000000021)
  * Deployment and ABI: [EAS.json](./deployments/ink-sepolia/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x4200000000000000000000000000000000000020](https://explorer-sepolia.inkonchain.com/address/0x4200000000000000000000000000000000000020)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/ink-sepolia/SchemaRegistry.json)
* **EIP712Proxy**:
  * Contract: [0x79369eEe29e7e191F5a6278185eA4a0D906b9b9F](https://explorer-sepolia.inkonchain.com/address/0x79369eEe29e7e191F5a6278185eA4a0D906b9b9F)
  * Deployment and ABI: [EIP712Proxy.json](./deployments/ink-sepolia/EIP712Proxy.json)
* **Indexer**:
  * Contract: [0x367A20665BAB1bb4DB6D80A4CF20db5Be1568d1e](https://explorer-sepolia.inkonchain.com/address/0x367A20665BAB1bb4DB6D80A4CF20db5Be1568d1e)
  * Deployment and ABI: [Indexer.json](./deployments/ink-sepolia/Indexer.json)

#### Linea Goerli

Version 1.2.0:

* **EAS**:
  * Contract: [0xaEF4103A04090071165F78D45D83A0C0782c2B2a](https://goerli.lineascan.build/address/0xaEF4103A04090071165F78D45D83A0C0782c2B2a)
  * Deployment and ABI: [EAS.json](./deployments/linea-goerli/EAS.json)
* **SchemaRegistry**:
  * Contract: [0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797](https://goerli.lineascan.build/address/0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797)
  * Deployment and ABI: [SchemaRegistry.json](./deployments/linea-goerli/SchemaRegistry.json)

## Installation

```sh
pnpm add @ethereum-attestation-service/eas-contracts
```

## Testing

Testing the protocol is possible via multiple approaches:

### Unit Tests

You can run the full test suite via:

```sh
pnpm test
```

### Test Coverage

#### Latest Test Coverage Report (2023-10-31)

* 100% Statements 350/350
* 100% Branches 172/172
* 100% Functions 120/120
* 100% Lines 491/491

```sh
----------------------------------|----------|----------|----------|----------|----------------|
File                              |  % Stmts | % Branch |  % Funcs |  % Lines |Uncovered Lines |
----------------------------------|----------|----------|----------|----------|----------------|
 contracts/                       |      100 |      100 |      100 |      100 |                |
  Common.sol                      |      100 |      100 |      100 |      100 |                |
  EAS.sol                         |      100 |      100 |      100 |      100 |                |
  IEAS.sol                        |      100 |      100 |      100 |      100 |                |
  ISchemaRegistry.sol             |      100 |      100 |      100 |      100 |                |
  Indexer.sol                     |      100 |      100 |      100 |      100 |                |
  SchemaRegistry.sol              |      100 |      100 |      100 |      100 |                |
  Semver.sol                      |      100 |      100 |      100 |      100 |                |
 contracts/eip1271/               |      100 |      100 |      100 |      100 |                |
  EIP1271Verifier.sol             |      100 |      100 |      100 |      100 |                |
 contracts/eip712/proxy/          |      100 |      100 |      100 |      100 |                |
  EIP712Proxy.sol                 |      100 |      100 |      100 |      100 |                |
 contracts/eip712/proxy/examples/ |      100 |      100 |      100 |      100 |                |
  PermissionedEIP712Proxy.sol     |      100 |      100 |      100 |      100 |                |
 contracts/resolver/              |      100 |      100 |      100 |      100 |                |
  ISchemaResolver.sol             |      100 |      100 |      100 |      100 |                |
  SchemaResolver.sol              |      100 |      100 |      100 |      100 |                |
 contracts/resolver/examples/     |      100 |      100 |      100 |      100 |                |
  AttestationResolver.sol         |      100 |      100 |      100 |      100 |                |
  AttesterResolver.sol            |      100 |      100 |      100 |      100 |                |
  DataResolver.sol                |      100 |      100 |      100 |      100 |                |
  ExpirationTimeResolver.sol      |      100 |      100 |      100 |      100 |                |
  PayingResolver.sol              |      100 |      100 |      100 |      100 |                |
  RecipientResolver.sol           |      100 |      100 |      100 |      100 |                |
  RevocationResolver.sol          |      100 |      100 |      100 |      100 |                |
  TokenResolver.sol               |      100 |      100 |      100 |      100 |                |
  ValueResolver.sol               |      100 |      100 |      100 |      100 |                |
----------------------------------|----------|----------|----------|----------|----------------|
All files                         |      100 |      100 |      100 |      100 |                |
----------------------------------|----------|----------|----------|----------|----------------|
```

#### Instructions

In order to audit the test coverage of the full test suite, run:

```sh
pnpm test:coverage
```

## Profiling

You can profile the gas costs of all of the user-focused flows via:

```sh
pnpm test:profile
```

## License

EAS is open source and distributed under the MIT License (see [`LICENSE`](./LICENSE)).


================================================
FILE: components/Contracts.ts
================================================
import { ContractFactory, Signer } from 'ethers';
import { ethers } from 'hardhat';
import {
  AttestationResolver__factory,
  AttesterResolver__factory,
  DataResolver__factory,
  EAS__factory,
  ExpirationTimeResolver__factory,
  Indexer__factory,
  PayingResolver__factory,
  PermissionedEIP712Proxy__factory,
  RecipientResolver__factory,
  RevocationResolver__factory,
  SchemaRegistry__factory,
  TestEAS__factory,
  TestEIP712Proxy__factory,
  TestEIP1271Signer__factory,
  TestEIP1271Verifier__factory,
  TestERC20Token__factory,
  TestSchemaResolver__factory,
  TokenResolver__factory,
  ValueResolver__factory
} from '../typechain-types';

export * from '../typechain-types';

type AsyncReturnType<T extends (...args: any) => any> = T extends (...args: any) => Promise<infer U>
  ? U
  : T extends (...args: any) => infer U
    ? U
    : any;

type Contract<F extends ContractFactory> = AsyncReturnType<F['deploy']>;

export interface ContractBuilder<F extends ContractFactory> {
  metadata: {
    bytecode: string;
  };
  deploy(...args: Parameters<F['deploy']>): Promise<Contract<F>>;
  attach(address: string, passedSigner?: Signer): Promise<Contract<F>>;
}

export type FactoryConstructor<F extends ContractFactory> = {
  new (signer?: Signer): F;
  abi: unknown;
  bytecode: string;
};

export const deployOrAttach = <F extends ContractFactory>(
  FactoryConstructor: FactoryConstructor<F>,
  initialSigner?: Signer
): ContractBuilder<F> => {
  return {
    metadata: {
      bytecode: FactoryConstructor.bytecode
    },
    deploy: async (...args: Parameters<F['deploy']>): Promise<Contract<F>> => {
      const defaultSigner = initialSigner ?? ((await ethers.getSigners())[0] as any as Signer);

      return new FactoryConstructor(defaultSigner).deploy(...(args || [])) as Promise<Contract<F>>;
    },
    attach: attachOnly<F>(FactoryConstructor, initialSigner).attach
  };
};

export const attachOnly = <F extends ContractFactory>(
  FactoryConstructor: FactoryConstructor<F>,
  initialSigner?: Signer
) => {
  return {
    attach: async (address: string, signer?: Signer): Promise<Contract<F>> => {
      const defaultSigner = initialSigner ?? ((await ethers.getSigners())[0] as any as Signer);
      return new FactoryConstructor(signer ?? defaultSigner).attach(address) as Contract<F>;
    }
  };
};

const getContracts = (signer?: Signer) => ({
  connect: (signer: Signer) => getContracts(signer),

  AttestationResolver: deployOrAttach(AttestationResolver__factory, signer),
  AttesterResolver: deployOrAttach(AttesterResolver__factory, signer),
  DataResolver: deployOrAttach(DataResolver__factory, signer),
  EAS: deployOrAttach(EAS__factory, signer),
  ExpirationTimeResolver: deployOrAttach(ExpirationTimeResolver__factory, signer),
  Indexer: deployOrAttach(Indexer__factory, signer),
  PayingResolver: deployOrAttach(PayingResolver__factory, signer),
  PermissionedEIP712Proxy: deployOrAttach(PermissionedEIP712Proxy__factory, signer),
  RecipientResolver: deployOrAttach(RecipientResolver__factory, signer),
  RevocationResolver: deployOrAttach(RevocationResolver__factory, signer),
  SchemaRegistry: deployOrAttach(SchemaRegistry__factory, signer),
  TestEAS: deployOrAttach(TestEAS__factory, signer),
  TestEIP712Proxy: deployOrAttach(TestEIP712Proxy__factory, signer),
  TestEIP1271Signer: deployOrAttach(TestEIP1271Signer__factory, signer),
  TestEIP1271Verifier: deployOrAttach(TestEIP1271Verifier__factory, signer),
  TestERC20Token: deployOrAttach(TestERC20Token__factory, signer),
  TestSchemaResolver: deployOrAttach(TestSchemaResolver__factory, signer),
  TokenResolver: deployOrAttach(TokenResolver__factory, signer),
  ValueResolver: deployOrAttach(ValueResolver__factory, signer)
});

export default getContracts();


================================================
FILE: contracts/Common.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// A representation of an empty/uninitialized UID.
bytes32 constant EMPTY_UID = 0;

// A zero expiration represents an non-expiring attestation.
uint64 constant NO_EXPIRATION_TIME = 0;

error AccessDenied();
error DeadlineExpired();
error InvalidEAS();
error InvalidLength();
error InvalidSignature();
error NotFound();

/// @notice A struct representing ECDSA signature data.
struct Signature {
    uint8 v; // The recovery ID.
    bytes32 r; // The x-coordinate of the nonce R.
    bytes32 s; // The signature data.
}

/// @notice A struct representing a single attestation.
struct Attestation {
    bytes32 uid; // A unique identifier of the attestation.
    bytes32 schema; // The unique identifier of the schema.
    uint64 time; // The time when the attestation was created (Unix timestamp).
    uint64 expirationTime; // The time when the attestation expires (Unix timestamp).
    uint64 revocationTime; // The time when the attestation was revoked (Unix timestamp).
    bytes32 refUID; // The UID of the related attestation.
    address recipient; // The recipient of the attestation.
    address attester; // The attester/sender of the attestation.
    bool revocable; // Whether the attestation is revocable.
    bytes data; // Custom attestation data.
}


================================================
FILE: contracts/EAS.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { Address } from "@openzeppelin/contracts/utils/Address.sol";

import { EIP1271Verifier } from "./eip1271/EIP1271Verifier.sol";

import { ISchemaResolver } from "./resolver/ISchemaResolver.sol";

// prettier-ignore
import {
    AccessDenied,
    EMPTY_UID,
    InvalidLength,
    NotFound,
    NO_EXPIRATION_TIME
} from "./Common.sol";

// prettier-ignore
import {
    Attestation,
    AttestationRequest,
    AttestationRequestData,
    DelegatedAttestationRequest,
    DelegatedRevocationRequest,
    IEAS,
    MultiAttestationRequest,
    MultiDelegatedAttestationRequest,
    MultiDelegatedRevocationRequest,
    MultiRevocationRequest,
    RevocationRequest,
    RevocationRequestData
} from "./IEAS.sol";

import { Semver } from "./Semver.sol";
import { ISchemaRegistry, SchemaRecord } from "./ISchemaRegistry.sol";

/// @title EAS
/// @notice The Ethereum Attestation Service protocol.
contract EAS is IEAS, Semver, EIP1271Verifier {
    using Address for address payable;

    error AlreadyRevoked();
    error AlreadyRevokedOffchain();
    error AlreadyTimestamped();
    error InsufficientValue();
    error InvalidAttestation();
    error InvalidAttestations();
    error InvalidExpirationTime();
    error InvalidOffset();
    error InvalidRegistry();
    error InvalidRevocation();
    error InvalidRevocations();
    error InvalidSchema();
    error InvalidVerifier();
    error Irrevocable();
    error NotPayable();
    error WrongSchema();

    /// @notice A struct representing an internal attestation result.
    struct AttestationsResult {
        uint256 usedValue; // Total ETH amount that was sent to resolvers.
        bytes32[] uids; // UIDs of the new attestations.
    }

    // The global schema registry.
    ISchemaRegistry private immutable _schemaRegistry;

    // The global mapping between attestations and their UIDs.
    mapping(bytes32 uid => Attestation attestation) private _db;

    // The global mapping between data and their timestamps.
    mapping(bytes32 data => uint64 timestamp) private _timestamps;

    // The global mapping between data and their revocation timestamps.
    mapping(address revoker => mapping(bytes32 data => uint64 timestamp) timestamps) private _revocationsOffchain;

    /// @dev Creates a new EAS instance.
    /// @param registry The address of the global schema registry.
    constructor(ISchemaRegistry registry) Semver(1, 4, 0) EIP1271Verifier("EAS", "1.4.0") {
        if (address(registry) == address(0)) {
            revert InvalidRegistry();
        }

        _schemaRegistry = registry;
    }

    /// @inheritdoc IEAS
    function getSchemaRegistry() external view returns (ISchemaRegistry) {
        return _schemaRegistry;
    }

    /// @inheritdoc IEAS
    function attest(AttestationRequest calldata request) external payable returns (bytes32) {
        AttestationRequestData[] memory data = new AttestationRequestData[](1);
        data[0] = request.data;

        return _attest(request.schema, data, msg.sender, msg.value, true).uids[0];
    }

    /// @inheritdoc IEAS
    function attestByDelegation(
        DelegatedAttestationRequest calldata delegatedRequest
    ) external payable returns (bytes32) {
        _verifyAttest(delegatedRequest);

        AttestationRequestData[] memory data = new AttestationRequestData[](1);
        data[0] = delegatedRequest.data;

        return _attest(delegatedRequest.schema, data, delegatedRequest.attester, msg.value, true).uids[0];
    }

    /// @inheritdoc IEAS
    function multiAttest(MultiAttestationRequest[] calldata multiRequests) external payable returns (bytes32[] memory) {
        // Since a multi-attest call is going to make multiple attestations for multiple schemas, we'd need to collect
        // all the returned UIDs into a single list.
        uint256 length = multiRequests.length;
        bytes32[][] memory totalUIDs = new bytes32[][](length);
        uint256 totalUIDCount = 0;

        // We are keeping track of the total available ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 availableValue = msg.value;

        for (uint256 i = 0; i < length; ++i) {
            // The last batch is handled slightly differently: if the total available ETH wasn't spent in full and there
            // is a remainder - it will be refunded back to the attester (something that we can only verify during the
            // last and final batch).
            bool last;
            unchecked {
                last = i == length - 1;
            }

            // Process the current batch of attestations.
            MultiAttestationRequest calldata multiRequest = multiRequests[i];

            // Ensure that data isn't empty.
            if (multiRequest.data.length == 0) {
                revert InvalidLength();
            }

            AttestationsResult memory res = _attest(
                multiRequest.schema,
                multiRequest.data,
                msg.sender,
                availableValue,
                last
            );

            // Ensure to deduct the ETH that was forwarded to the resolver during the processing of this batch.
            availableValue -= res.usedValue;

            // Collect UIDs (and merge them later).
            totalUIDs[i] = res.uids;
            unchecked {
                totalUIDCount += res.uids.length;
            }
        }

        // Merge all the collected UIDs and return them as a flatten array.
        return _mergeUIDs(totalUIDs, totalUIDCount);
    }

    /// @inheritdoc IEAS
    function multiAttestByDelegation(
        MultiDelegatedAttestationRequest[] calldata multiDelegatedRequests
    ) external payable returns (bytes32[] memory) {
        // Since a multi-attest call is going to make multiple attestations for multiple schemas, we'd need to collect
        // all the returned UIDs into a single list.
        uint256 length = multiDelegatedRequests.length;
        bytes32[][] memory totalUIDs = new bytes32[][](length);
        uint256 totalUIDCount = 0;

        // We are keeping track of the total available ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 availableValue = msg.value;

        for (uint256 i = 0; i < length; ++i) {
            // The last batch is handled slightly differently: if the total available ETH wasn't spent in full and there
            // is a remainder - it will be refunded back to the attester (something that we can only verify during the
            // last and final batch).
            bool last;
            unchecked {
                last = i == length - 1;
            }

            MultiDelegatedAttestationRequest calldata multiDelegatedRequest = multiDelegatedRequests[i];
            AttestationRequestData[] calldata data = multiDelegatedRequest.data;

            // Ensure that no inputs are missing.
            uint256 dataLength = data.length;
            if (dataLength == 0 || dataLength != multiDelegatedRequest.signatures.length) {
                revert InvalidLength();
            }

            // Verify signatures. Please note that the signatures are assumed to be signed with increasing nonces.
            for (uint256 j = 0; j < dataLength; ++j) {
                _verifyAttest(
                    DelegatedAttestationRequest({
                        schema: multiDelegatedRequest.schema,
                        data: data[j],
                        signature: multiDelegatedRequest.signatures[j],
                        attester: multiDelegatedRequest.attester,
                        deadline: multiDelegatedRequest.deadline
                    })
                );
            }

            // Process the current batch of attestations.
            AttestationsResult memory res = _attest(
                multiDelegatedRequest.schema,
                data,
                multiDelegatedRequest.attester,
                availableValue,
                last
            );

            // Ensure to deduct the ETH that was forwarded to the resolver during the processing of this batch.
            availableValue -= res.usedValue;

            // Collect UIDs (and merge them later).
            totalUIDs[i] = res.uids;
            unchecked {
                totalUIDCount += res.uids.length;
            }
        }

        // Merge all the collected UIDs and return them as a flatten array.
        return _mergeUIDs(totalUIDs, totalUIDCount);
    }

    /// @inheritdoc IEAS
    function revoke(RevocationRequest calldata request) external payable {
        RevocationRequestData[] memory data = new RevocationRequestData[](1);
        data[0] = request.data;

        _revoke(request.schema, data, msg.sender, msg.value, true);
    }

    /// @inheritdoc IEAS
    function revokeByDelegation(DelegatedRevocationRequest calldata delegatedRequest) external payable {
        _verifyRevoke(delegatedRequest);

        RevocationRequestData[] memory data = new RevocationRequestData[](1);
        data[0] = delegatedRequest.data;

        _revoke(delegatedRequest.schema, data, delegatedRequest.revoker, msg.value, true);
    }

    /// @inheritdoc IEAS
    function multiRevoke(MultiRevocationRequest[] calldata multiRequests) external payable {
        // We are keeping track of the total available ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 availableValue = msg.value;

        uint256 length = multiRequests.length;
        for (uint256 i = 0; i < length; ++i) {
            // The last batch is handled slightly differently: if the total available ETH wasn't spent in full and there
            // is a remainder - it will be refunded back to the attester (something that we can only verify during the
            // last and final batch).
            bool last;
            unchecked {
                last = i == length - 1;
            }

            MultiRevocationRequest calldata multiRequest = multiRequests[i];

            // Ensure to deduct the ETH that was forwarded to the resolver during the processing of this batch.
            availableValue -= _revoke(multiRequest.schema, multiRequest.data, msg.sender, availableValue, last);
        }
    }

    /// @inheritdoc IEAS
    function multiRevokeByDelegation(
        MultiDelegatedRevocationRequest[] calldata multiDelegatedRequests
    ) external payable {
        // We are keeping track of the total available ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 availableValue = msg.value;

        uint256 length = multiDelegatedRequests.length;
        for (uint256 i = 0; i < length; ++i) {
            // The last batch is handled slightly differently: if the total available ETH wasn't spent in full and there
            // is a remainder - it will be refunded back to the attester (something that we can only verify during the
            // last and final batch).
            bool last;
            unchecked {
                last = i == length - 1;
            }

            MultiDelegatedRevocationRequest memory multiDelegatedRequest = multiDelegatedRequests[i];
            RevocationRequestData[] memory data = multiDelegatedRequest.data;

            // Ensure that no inputs are missing.
            uint256 dataLength = data.length;
            if (dataLength == 0 || dataLength != multiDelegatedRequest.signatures.length) {
                revert InvalidLength();
            }

            // Verify signatures. Please note that the signatures are assumed to be signed with increasing nonces.
            for (uint256 j = 0; j < dataLength; ++j) {
                _verifyRevoke(
                    DelegatedRevocationRequest({
                        schema: multiDelegatedRequest.schema,
                        data: data[j],
                        signature: multiDelegatedRequest.signatures[j],
                        revoker: multiDelegatedRequest.revoker,
                        deadline: multiDelegatedRequest.deadline
                    })
                );
            }

            // Ensure to deduct the ETH that was forwarded to the resolver during the processing of this batch.
            availableValue -= _revoke(
                multiDelegatedRequest.schema,
                data,
                multiDelegatedRequest.revoker,
                availableValue,
                last
            );
        }
    }

    /// @inheritdoc IEAS
    function timestamp(bytes32 data) external returns (uint64) {
        uint64 time = _time();

        _timestamp(data, time);

        return time;
    }

    /// @inheritdoc IEAS
    function revokeOffchain(bytes32 data) external returns (uint64) {
        uint64 time = _time();

        _revokeOffchain(msg.sender, data, time);

        return time;
    }

    /// @inheritdoc IEAS
    function multiRevokeOffchain(bytes32[] calldata data) external returns (uint64) {
        uint64 time = _time();

        uint256 length = data.length;
        for (uint256 i = 0; i < length; ++i) {
            _revokeOffchain(msg.sender, data[i], time);
        }

        return time;
    }

    /// @inheritdoc IEAS
    function multiTimestamp(bytes32[] calldata data) external returns (uint64) {
        uint64 time = _time();

        uint256 length = data.length;
        for (uint256 i = 0; i < length; ++i) {
            _timestamp(data[i], time);
        }

        return time;
    }

    /// @inheritdoc IEAS
    function getAttestation(bytes32 uid) external view returns (Attestation memory) {
        return _db[uid];
    }

    /// @inheritdoc IEAS
    function isAttestationValid(bytes32 uid) public view returns (bool) {
        return _db[uid].uid != EMPTY_UID;
    }

    /// @inheritdoc IEAS
    function getTimestamp(bytes32 data) external view returns (uint64) {
        return _timestamps[data];
    }

    /// @inheritdoc IEAS
    function getRevokeOffchain(address revoker, bytes32 data) external view returns (uint64) {
        return _revocationsOffchain[revoker][data];
    }

    /// @dev Attests to a specific schema.
    /// @param schemaUID The unique identifier of the schema to attest to.
    /// @param data The arguments of the attestation requests.
    /// @param attester The attesting account.
    /// @param availableValue The total available ETH amount that can be sent to the resolver.
    /// @param last Whether this is the last attestations/revocations set.
    /// @return The UID of the new attestations and the total sent ETH amount.
    function _attest(
        bytes32 schemaUID,
        AttestationRequestData[] memory data,
        address attester,
        uint256 availableValue,
        bool last
    ) private returns (AttestationsResult memory) {
        uint256 length = data.length;

        AttestationsResult memory res;
        res.uids = new bytes32[](length);

        // Ensure that we aren't attempting to attest to a non-existing schema.
        SchemaRecord memory schemaRecord = _schemaRegistry.getSchema(schemaUID);
        if (schemaRecord.uid == EMPTY_UID) {
            revert InvalidSchema();
        }

        Attestation[] memory attestations = new Attestation[](length);
        uint256[] memory values = new uint256[](length);

        for (uint256 i = 0; i < length; ++i) {
            AttestationRequestData memory request = data[i];

            // Ensure that either no expiration time was set or that it was set in the future.
            if (request.expirationTime != NO_EXPIRATION_TIME && request.expirationTime <= _time()) {
                revert InvalidExpirationTime();
            }

            // Ensure that we aren't trying to make a revocable attestation for a non-revocable schema.
            if (!schemaRecord.revocable && request.revocable) {
                revert Irrevocable();
            }

            Attestation memory attestation = Attestation({
                uid: EMPTY_UID,
                schema: schemaUID,
                refUID: request.refUID,
                time: _time(),
                expirationTime: request.expirationTime,
                revocationTime: 0,
                recipient: request.recipient,
                attester: attester,
                revocable: request.revocable,
                data: request.data
            });

            // Look for the first non-existing UID (and use a bump seed/nonce in the rare case of a conflict).
            bytes32 uid;
            uint32 bump = 0;
            while (true) {
                uid = _getUID(attestation, bump);
                if (_db[uid].uid == EMPTY_UID) {
                    break;
                }

                unchecked {
                    ++bump;
                }
            }
            attestation.uid = uid;

            _db[uid] = attestation;

            if (request.refUID != EMPTY_UID) {
                // Ensure that we aren't trying to attest to a non-existing referenced UID.
                if (!isAttestationValid(request.refUID)) {
                    revert NotFound();
                }
            }

            attestations[i] = attestation;
            values[i] = request.value;

            res.uids[i] = uid;

            emit Attested(request.recipient, attester, uid, schemaUID);
        }

        res.usedValue = _resolveAttestations(schemaRecord, attestations, values, false, availableValue, last);

        return res;
    }

    /// @dev Revokes an existing attestation to a specific schema.
    /// @param schemaUID The unique identifier of the schema to attest to.
    /// @param data The arguments of the revocation requests.
    /// @param revoker The revoking account.
    /// @param availableValue The total available ETH amount that can be sent to the resolver.
    /// @param last Whether this is the last attestations/revocations set.
    /// @return Returns the total sent ETH amount.
    function _revoke(
        bytes32 schemaUID,
        RevocationRequestData[] memory data,
        address revoker,
        uint256 availableValue,
        bool last
    ) private returns (uint256) {
        // Ensure that a non-existing schema ID wasn't passed by accident.
        SchemaRecord memory schemaRecord = _schemaRegistry.getSchema(schemaUID);
        if (schemaRecord.uid == EMPTY_UID) {
            revert InvalidSchema();
        }

        uint256 length = data.length;
        Attestation[] memory attestations = new Attestation[](length);
        uint256[] memory values = new uint256[](length);

        for (uint256 i = 0; i < length; ++i) {
            RevocationRequestData memory request = data[i];

            Attestation storage attestation = _db[request.uid];

            // Ensure that we aren't attempting to revoke a non-existing attestation.
            if (attestation.uid == EMPTY_UID) {
                revert NotFound();
            }

            // Ensure that a wrong schema ID wasn't passed by accident.
            if (attestation.schema != schemaUID) {
                revert InvalidSchema();
            }

            // Allow only original attesters to revoke their attestations.
            if (attestation.attester != revoker) {
                revert AccessDenied();
            }

            // Please note that also checking of the schema itself is revocable is unnecessary, since it's not possible to
            // make revocable attestations to an irrevocable schema.
            if (!attestation.revocable) {
                revert Irrevocable();
            }

            // Ensure that we aren't trying to revoke the same attestation twice.
            if (attestation.revocationTime != 0) {
                revert AlreadyRevoked();
            }
            attestation.revocationTime = _time();

            attestations[i] = attestation;
            values[i] = request.value;

            emit Revoked(attestations[i].recipient, revoker, request.uid, schemaUID);
        }

        return _resolveAttestations(schemaRecord, attestations, values, true, availableValue, last);
    }

    /// @dev Resolves a new attestation or a revocation of an existing attestation.
    /// @param schemaRecord The schema of the attestation.
    /// @param attestation The data of the attestation to make/revoke.
    /// @param value An explicit ETH amount to send to the resolver.
    /// @param isRevocation Whether to resolve an attestation or its revocation.
    /// @param availableValue The total available ETH amount that can be sent to the resolver.
    /// @param last Whether this is the last attestations/revocations set.
    /// @return Returns the total sent ETH amount.
    function _resolveAttestation(
        SchemaRecord memory schemaRecord,
        Attestation memory attestation,
        uint256 value,
        bool isRevocation,
        uint256 availableValue,
        bool last
    ) private returns (uint256) {
        ISchemaResolver resolver = schemaRecord.resolver;
        if (address(resolver) == address(0)) {
            // Ensure that we don't accept payments if there is no resolver.
            if (value != 0) {
                revert NotPayable();
            }

            if (last) {
                _refund(availableValue);
            }

            return 0;
        }

        // Ensure that we don't accept payments which can't be forwarded to the resolver.
        if (value != 0) {
            if (!resolver.isPayable()) {
                revert NotPayable();
            }

            // Ensure that the attester/revoker doesn't try to spend more than available.
            if (value > availableValue) {
                revert InsufficientValue();
            }

            // Ensure to deduct the sent value explicitly.
            unchecked {
                availableValue -= value;
            }
        }

        if (isRevocation) {
            if (!resolver.revoke{ value: value }(attestation)) {
                revert InvalidRevocation();
            }
        } else if (!resolver.attest{ value: value }(attestation)) {
            revert InvalidAttestation();
        }

        if (last) {
            _refund(availableValue);
        }

        return value;
    }

    /// @dev Resolves multiple attestations or revocations of existing attestations.
    /// @param schemaRecord The schema of the attestation.
    /// @param attestations The data of the attestations to make/revoke.
    /// @param values Explicit ETH amounts to send to the resolver.
    /// @param isRevocation Whether to resolve an attestation or its revocation.
    /// @param availableValue The total available ETH amount that can be sent to the resolver.
    /// @param last Whether this is the last attestations/revocations set.
    /// @return Returns the total sent ETH amount.
    function _resolveAttestations(
        SchemaRecord memory schemaRecord,
        Attestation[] memory attestations,
        uint256[] memory values,
        bool isRevocation,
        uint256 availableValue,
        bool last
    ) private returns (uint256) {
        uint256 length = attestations.length;
        if (length == 1) {
            return _resolveAttestation(schemaRecord, attestations[0], values[0], isRevocation, availableValue, last);
        }

        ISchemaResolver resolver = schemaRecord.resolver;
        if (address(resolver) == address(0)) {
            // Ensure that we don't accept payments if there is no resolver.
            for (uint256 i = 0; i < length; ++i) {
                if (values[i] != 0) {
                    revert NotPayable();
                }
            }

            if (last) {
                _refund(availableValue);
            }

            return 0;
        }

        uint256 totalUsedValue = 0;
        bool isResolverPayable = resolver.isPayable();

        for (uint256 i = 0; i < length; ++i) {
            uint256 value = values[i];

            // Ensure that we don't accept payments which can't be forwarded to the resolver.
            if (value == 0) {
                continue;
            }

            if (!isResolverPayable) {
                revert NotPayable();
            }

            // Ensure that the attester/revoker doesn't try to spend more than available.
            if (value > availableValue) {
                revert InsufficientValue();
            }

            // Ensure to deduct the sent value explicitly and add it to the total used value by the batch.
            unchecked {
                availableValue -= value;
                totalUsedValue += value;
            }
        }

        if (isRevocation) {
            if (!resolver.multiRevoke{ value: totalUsedValue }(attestations, values)) {
                revert InvalidRevocations();
            }
        } else if (!resolver.multiAttest{ value: totalUsedValue }(attestations, values)) {
            revert InvalidAttestations();
        }

        if (last) {
            _refund(availableValue);
        }

        return totalUsedValue;
    }

    /// @dev Calculates a UID for a given attestation.
    /// @param attestation The input attestation.
    /// @param bump A bump value to use in case of a UID conflict.
    /// @return Attestation UID.
    function _getUID(Attestation memory attestation, uint32 bump) private pure returns (bytes32) {
        return
            keccak256(
                abi.encodePacked(
                    attestation.schema,
                    attestation.recipient,
                    attestation.attester,
                    attestation.time,
                    attestation.expirationTime,
                    attestation.revocable,
                    attestation.refUID,
                    attestation.data,
                    bump
                )
            );
    }

    /// @dev Refunds remaining ETH amount to the attester.
    /// @param remainingValue The remaining ETH amount that was not sent to the resolver.
    function _refund(uint256 remainingValue) private {
        if (remainingValue > 0) {
            // Using a regular transfer here might revert, for some non-EOA attesters, due to exceeding of the 2300
            // gas limit which is why we're using call instead (via sendValue), which the 2300 gas limit does not
            // apply for.
            payable(msg.sender).sendValue(remainingValue);
        }
    }

    /// @dev Timestamps the specified bytes32 data.
    /// @param data The data to timestamp.
    /// @param time The timestamp.
    function _timestamp(bytes32 data, uint64 time) private {
        if (_timestamps[data] != 0) {
            revert AlreadyTimestamped();
        }

        _timestamps[data] = time;

        emit Timestamped(data, time);
    }

    /// @dev Revokes the specified bytes32 data.
    /// @param revoker The revoking account.
    /// @param data The data to revoke.
    /// @param time The timestamp the data was revoked with.
    function _revokeOffchain(address revoker, bytes32 data, uint64 time) private {
        mapping(bytes32 data => uint64 timestamp) storage revocations = _revocationsOffchain[revoker];

        if (revocations[data] != 0) {
            revert AlreadyRevokedOffchain();
        }

        revocations[data] = time;

        emit RevokedOffchain(revoker, data, time);
    }

    /// @dev Merges lists of UIDs.
    /// @param uidLists The provided lists of UIDs.
    /// @param uidCount Total UID count.
    /// @return A merged and flatten list of all the UIDs.
    function _mergeUIDs(bytes32[][] memory uidLists, uint256 uidCount) private pure returns (bytes32[] memory) {
        bytes32[] memory uids = new bytes32[](uidCount);

        uint256 currentIndex = 0;
        uint256 uidListLength = uidLists.length;
        for (uint256 i = 0; i < uidListLength; ++i) {
            bytes32[] memory currentUIDs = uidLists[i];
            uint256 currentUIDsLength = currentUIDs.length;
            for (uint256 j = 0; j < currentUIDsLength; ++j) {
                uids[currentIndex] = currentUIDs[j];

                unchecked {
                    ++currentIndex;
                }
            }
        }

        return uids;
    }
}


================================================
FILE: contracts/IEAS.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { ISchemaRegistry } from "./ISchemaRegistry.sol";
import { ISemver } from "./ISemver.sol";
import { Attestation, Signature } from "./Common.sol";

/// @notice A struct representing the arguments of the attestation request.
struct AttestationRequestData {
    address recipient; // The recipient of the attestation.
    uint64 expirationTime; // The time when the attestation expires (Unix timestamp).
    bool revocable; // Whether the attestation is revocable.
    bytes32 refUID; // The UID of the related attestation.
    bytes data; // Custom attestation data.
    uint256 value; // An explicit ETH amount to send to the resolver. This is important to prevent accidental user errors.
}

/// @notice A struct representing the full arguments of the attestation request.
struct AttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData data; // The arguments of the attestation request.
}

/// @notice A struct representing the full arguments of the full delegated attestation request.
struct DelegatedAttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData data; // The arguments of the attestation request.
    Signature signature; // The ECDSA signature data.
    address attester; // The attesting account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the full arguments of the multi attestation request.
struct MultiAttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData[] data; // The arguments of the attestation request.
}

/// @notice A struct representing the full arguments of the delegated multi attestation request.
struct MultiDelegatedAttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData[] data; // The arguments of the attestation requests.
    Signature[] signatures; // The ECDSA signatures data. Please note that the signatures are assumed to be signed with increasing nonces.
    address attester; // The attesting account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the arguments of the revocation request.
struct RevocationRequestData {
    bytes32 uid; // The UID of the attestation to revoke.
    uint256 value; // An explicit ETH amount to send to the resolver. This is important to prevent accidental user errors.
}

/// @notice A struct representing the full arguments of the revocation request.
struct RevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData data; // The arguments of the revocation request.
}

/// @notice A struct representing the arguments of the full delegated revocation request.
struct DelegatedRevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData data; // The arguments of the revocation request.
    Signature signature; // The ECDSA signature data.
    address revoker; // The revoking account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the full arguments of the multi revocation request.
struct MultiRevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData[] data; // The arguments of the revocation request.
}

/// @notice A struct representing the full arguments of the delegated multi revocation request.
struct MultiDelegatedRevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData[] data; // The arguments of the revocation requests.
    Signature[] signatures; // The ECDSA signatures data. Please note that the signatures are assumed to be signed with increasing nonces.
    address revoker; // The revoking account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @title IEAS
/// @notice EAS - Ethereum Attestation Service interface.
interface IEAS is ISemver {
    /// @notice Emitted when an attestation has been made.
    /// @param recipient The recipient of the attestation.
    /// @param attester The attesting account.
    /// @param uid The UID of the new attestation.
    /// @param schemaUID The UID of the schema.
    event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID);

    /// @notice Emitted when an attestation has been revoked.
    /// @param recipient The recipient of the attestation.
    /// @param attester The attesting account.
    /// @param schemaUID The UID of the schema.
    /// @param uid The UID the revoked attestation.
    event Revoked(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID);

    /// @notice Emitted when a data has been timestamped.
    /// @param data The data.
    /// @param timestamp The timestamp.
    event Timestamped(bytes32 indexed data, uint64 indexed timestamp);

    /// @notice Emitted when a data has been revoked.
    /// @param revoker The address of the revoker.
    /// @param data The data.
    /// @param timestamp The timestamp.
    event RevokedOffchain(address indexed revoker, bytes32 indexed data, uint64 indexed timestamp);

    /// @notice Returns the address of the global schema registry.
    /// @return The address of the global schema registry.
    function getSchemaRegistry() external view returns (ISchemaRegistry);

    /// @notice Attests to a specific schema.
    /// @param request The arguments of the attestation request.
    /// @return The UID of the new attestation.
    ///
    /// Example:
    ///     attest({
    ///         schema: "0facc36681cbe2456019c1b0d1e7bedd6d1d40f6f324bf3dd3a4cef2999200a0",
    ///         data: {
    ///             recipient: "0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf",
    ///             expirationTime: 0,
    ///             revocable: true,
    ///             refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
    ///             data: "0xF00D",
    ///             value: 0
    ///         }
    ///     })
    function attest(AttestationRequest calldata request) external payable returns (bytes32);

    /// @notice Attests to a specific schema via the provided ECDSA signature.
    /// @param delegatedRequest The arguments of the delegated attestation request.
    /// @return The UID of the new attestation.
    ///
    /// Example:
    ///     attestByDelegation({
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: {
    ///             recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
    ///             expirationTime: 1673891048,
    ///             revocable: true,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x1234',
    ///             value: 0
    ///         },
    ///         signature: {
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         attester: '0xc5E8740aD971409492b1A63Db8d83025e0Fc427e',
    ///         deadline: 1673891048
    ///     })
    function attestByDelegation(
        DelegatedAttestationRequest calldata delegatedRequest
    ) external payable returns (bytes32);

    /// @notice Attests to multiple schemas.
    /// @param multiRequests The arguments of the multi attestation requests. The requests should be grouped by distinct
    ///     schema ids to benefit from the best batching optimization.
    /// @return The UIDs of the new attestations.
    ///
    /// Example:
    ///     multiAttest([{
    ///         schema: '0x33e9094830a5cba5554d1954310e4fbed2ef5f859ec1404619adea4207f391fd',
    ///         data: [{
    ///             recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf',
    ///             expirationTime: 1673891048,
    ///             revocable: true,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x1234',
    ///             value: 1000
    ///         },
    ///         {
    ///             recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
    ///             expirationTime: 0,
    ///             revocable: false,
    ///             refUID: '0x480df4a039efc31b11bfdf491b383ca138b6bde160988222a2a3509c02cee174',
    ///             data: '0x00',
    ///             value: 0
    ///         }],
    ///     },
    ///     {
    ///         schema: '0x5ac273ce41e3c8bfa383efe7c03e54c5f0bff29c9f11ef6ffa930fc84ca32425',
    ///         data: [{
    ///             recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf',
    ///             expirationTime: 0,
    ///             revocable: true,
    ///             refUID: '0x75bf2ed8dca25a8190c50c52db136664de25b2449535839008ccfdab469b214f',
    ///             data: '0x12345678',
    ///             value: 0
    ///         },
    ///     }])
    function multiAttest(MultiAttestationRequest[] calldata multiRequests) external payable returns (bytes32[] memory);

    /// @notice Attests to multiple schemas using via provided ECDSA signatures.
    /// @param multiDelegatedRequests The arguments of the delegated multi attestation requests. The requests should be
    ///     grouped by distinct schema ids to benefit from the best batching optimization.
    /// @return The UIDs of the new attestations.
    ///
    /// Example:
    ///     multiAttestByDelegation([{
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: [{
    ///             recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
    ///             expirationTime: 1673891048,
    ///             revocable: true,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x1234',
    ///             value: 0
    ///         },
    ///         {
    ///             recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf',
    ///             expirationTime: 0,
    ///             revocable: false,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x00',
    ///             value: 0
    ///         }],
    ///         signatures: [{
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         {
    ///             v: 28,
    ///             r: '0x487s...67bb',
    ///             s: '0x12ad...2366'
    ///         }],
    ///         attester: '0x1D86495b2A7B524D747d2839b3C645Bed32e8CF4',
    ///         deadline: 1673891048
    ///     }])
    function multiAttestByDelegation(
        MultiDelegatedAttestationRequest[] calldata multiDelegatedRequests
    ) external payable returns (bytes32[] memory);

    /// @notice Revokes an existing attestation to a specific schema.
    /// @param request The arguments of the revocation request.
    ///
    /// Example:
    ///     revoke({
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: {
    ///             uid: '0x101032e487642ee04ee17049f99a70590c735b8614079fc9275f9dd57c00966d',
    ///             value: 0
    ///         }
    ///     })
    function revoke(RevocationRequest calldata request) external payable;

    /// @notice Revokes an existing attestation to a specific schema via the provided ECDSA signature.
    /// @param delegatedRequest The arguments of the delegated revocation request.
    ///
    /// Example:
    ///     revokeByDelegation({
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: {
    ///             uid: '0xcbbc12102578c642a0f7b34fe7111e41afa25683b6cd7b5a14caf90fa14d24ba',
    ///             value: 0
    ///         },
    ///         signature: {
    ///             v: 27,
    ///             r: '0xb593...7142',
    ///             s: '0x0f5b...2cce'
    ///         },
    ///         revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992',
    ///         deadline: 1673891048
    ///     })
    function revokeByDelegation(DelegatedRevocationRequest calldata delegatedRequest) external payable;

    /// @notice Revokes existing attestations to multiple schemas.
    /// @param multiRequests The arguments of the multi revocation requests. The requests should be grouped by distinct
    ///     schema ids to benefit from the best batching optimization.
    ///
    /// Example:
    ///     multiRevoke([{
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: [{
    ///             uid: '0x211296a1ca0d7f9f2cfebf0daaa575bea9b20e968d81aef4e743d699c6ac4b25',
    ///             value: 1000
    ///         },
    ///         {
    ///             uid: '0xe160ac1bd3606a287b4d53d5d1d6da5895f65b4b4bab6d93aaf5046e48167ade',
    ///             value: 0
    ///         }],
    ///     },
    ///     {
    ///         schema: '0x5ac273ce41e3c8bfa383efe7c03e54c5f0bff29c9f11ef6ffa930fc84ca32425',
    ///         data: [{
    ///             uid: '0x053d42abce1fd7c8fcddfae21845ad34dae287b2c326220b03ba241bc5a8f019',
    ///             value: 0
    ///         },
    ///     }])
    function multiRevoke(MultiRevocationRequest[] calldata multiRequests) external payable;

    /// @notice Revokes existing attestations to multiple schemas via provided ECDSA signatures.
    /// @param multiDelegatedRequests The arguments of the delegated multi revocation attestation requests. The requests
    ///     should be grouped by distinct schema ids to benefit from the best batching optimization.
    ///
    /// Example:
    ///     multiRevokeByDelegation([{
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: [{
    ///             uid: '0x211296a1ca0d7f9f2cfebf0daaa575bea9b20e968d81aef4e743d699c6ac4b25',
    ///             value: 1000
    ///         },
    ///         {
    ///             uid: '0xe160ac1bd3606a287b4d53d5d1d6da5895f65b4b4bab6d93aaf5046e48167ade',
    ///             value: 0
    ///         }],
    ///         signatures: [{
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         {
    ///             v: 28,
    ///             r: '0x487s...67bb',
    ///             s: '0x12ad...2366'
    ///         }],
    ///         revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992',
    ///         deadline: 1673891048
    ///     }])
    function multiRevokeByDelegation(
        MultiDelegatedRevocationRequest[] calldata multiDelegatedRequests
    ) external payable;

    /// @notice Timestamps the specified bytes32 data.
    /// @param data The data to timestamp.
    /// @return The timestamp the data was timestamped with.
    function timestamp(bytes32 data) external returns (uint64);

    /// @notice Timestamps the specified multiple bytes32 data.
    /// @param data The data to timestamp.
    /// @return The timestamp the data was timestamped with.
    function multiTimestamp(bytes32[] calldata data) external returns (uint64);

    /// @notice Revokes the specified bytes32 data.
    /// @param data The data to timestamp.
    /// @return The timestamp the data was revoked with.
    function revokeOffchain(bytes32 data) external returns (uint64);

    /// @notice Revokes the specified multiple bytes32 data.
    /// @param data The data to timestamp.
    /// @return The timestamp the data was revoked with.
    function multiRevokeOffchain(bytes32[] calldata data) external returns (uint64);

    /// @notice Returns an existing attestation by UID.
    /// @param uid The UID of the attestation to retrieve.
    /// @return The attestation data members.
    function getAttestation(bytes32 uid) external view returns (Attestation memory);

    /// @notice Checks whether an attestation exists.
    /// @param uid The UID of the attestation to retrieve.
    /// @return Whether an attestation exists.
    function isAttestationValid(bytes32 uid) external view returns (bool);

    /// @notice Returns the timestamp that the specified data was timestamped with.
    /// @param data The data to query.
    /// @return The timestamp the data was timestamped with.
    function getTimestamp(bytes32 data) external view returns (uint64);

    /// @notice Returns the timestamp that the specified data was timestamped with.
    /// @param data The data to query.
    /// @return The timestamp the data was timestamped with.
    function getRevokeOffchain(address revoker, bytes32 data) external view returns (uint64);
}


================================================
FILE: contracts/ISchemaRegistry.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { ISemver } from "./ISemver.sol";

import { ISchemaResolver } from "./resolver/ISchemaResolver.sol";

/// @notice A struct representing a record for a submitted schema.
struct SchemaRecord {
    bytes32 uid; // The unique identifier of the schema.
    ISchemaResolver resolver; // Optional schema resolver.
    bool revocable; // Whether the schema allows revocations explicitly.
    string schema; // Custom specification of the schema (e.g., an ABI).
}

/// @title ISchemaRegistry
/// @notice The interface of global attestation schemas for the Ethereum Attestation Service protocol.
interface ISchemaRegistry is ISemver {
    /// @notice Emitted when a new schema has been registered
    /// @param uid The schema UID.
    /// @param registerer The address of the account used to register the schema.
    /// @param schema The schema data.
    event Registered(bytes32 indexed uid, address indexed registerer, SchemaRecord schema);

    /// @notice Submits and reserves a new schema
    /// @param schema The schema data schema.
    /// @param resolver An optional schema resolver.
    /// @param revocable Whether the schema allows revocations explicitly.
    /// @return The UID of the new schema.
    function register(string calldata schema, ISchemaResolver resolver, bool revocable) external returns (bytes32);

    /// @notice Returns an existing schema by UID
    /// @param uid The UID of the schema to retrieve.
    /// @return The schema data members.
    function getSchema(bytes32 uid) external view returns (SchemaRecord memory);
}


================================================
FILE: contracts/ISemver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/// @title ISemver
/// @notice A semver interface.
interface ISemver {
    /// @notice Returns the full semver contract version.
    /// @return Semver contract version as a string.
    function version() external view returns (string memory);
}


================================================
FILE: contracts/Indexer.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { IEAS, Attestation } from "./IEAS.sol";
import { EMPTY_UID } from "./Common.sol";
import { Semver } from "./Semver.sol";

/// @title Indexer
/// @notice Indexing Service for the Ethereum Attestation Service
contract Indexer is Semver {
    error InvalidEAS();
    error InvalidAttestation();
    error InvalidOffset();

    /// @notice Emitted when an attestation has been indexed.
    /// @param uid The UID the attestation.
    event Indexed(bytes32 indexed uid);

    /// A mapping between an account and its received attestations.
    mapping(address account => mapping(bytes32 => bytes32[] uids) receivedAttestations) private _receivedAttestations;

    // A mapping between an account and its sent attestations.
    mapping(address account => mapping(bytes32 => bytes32[] uids) sentAttestations) private _sentAttestations;

    // A mapping between a schema, attester, and recipient.
    mapping(bytes32 schemaUID => mapping(address attester => mapping(address recipient => bytes32[] uids)))
        private _schemaAttesterRecipientAttestations;

    // A mapping between a schema and its attestations.
    mapping(bytes32 schemaUID => bytes32[] uids) private _schemaAttestations;

    // The global mapping of attestation indexing status.
    mapping(bytes32 attestationUID => bool status) private _indexedAttestations;

    // The address of the global EAS contract.
    IEAS private immutable _eas;

    /// @dev Creates a new Indexer instance.
    /// @param eas The address of the global EAS contract.
    constructor(IEAS eas) Semver(1, 4, 0) {
        if (address(eas) == address(0)) {
            revert InvalidEAS();
        }

        _eas = eas;
    }

    /// @notice Returns the EAS.
    function getEAS() external view returns (IEAS) {
        return _eas;
    }

    /// @notice Indexes an existing attestation.
    /// @param attestationUID The UID of the attestation to index.
    function indexAttestation(bytes32 attestationUID) external {
        _indexAttestation(attestationUID);
    }

    /// @notice Indexes multiple existing attestations.
    /// @param attestationUIDs The UIDs of the attestations to index.
    function indexAttestations(bytes32[] calldata attestationUIDs) external {
        uint256 length = attestationUIDs.length;
        for (uint256 i = 0; i < length; ++i) {
            _indexAttestation(attestationUIDs[i]);
        }
    }

    /// @notice Returns whether an existing attestation has been already indexed.
    /// @param attestationUID The UID of the attestation to check.
    /// @return Whether an attestation has been already indexed.
    function isAttestationIndexed(bytes32 attestationUID) external view returns (bool) {
        return _indexedAttestations[attestationUID];
    }

    /// @notice Returns the UIDs of attestations to a specific schema which were attested to/received by a specific
    ///     recipient.
    /// @param recipient The recipient of the attestation.
    /// @param schemaUID The UID of the schema.
    /// @param start The offset to start from.
    /// @param length The number of total members to retrieve.
    /// @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
    /// @return An array of attestation UIDs.
    function getReceivedAttestationUIDs(
        address recipient,
        bytes32 schemaUID,
        uint256 start,
        uint256 length,
        bool reverseOrder
    ) external view returns (bytes32[] memory) {
        return _sliceUIDs(_receivedAttestations[recipient][schemaUID], start, length, reverseOrder);
    }

    /// @notice Returns the total number of attestations to a specific schema which were attested to/received by a
    ///     specific recipient.
    /// @param recipient The recipient of the attestation.
    /// @param schemaUID The UID of the schema.
    /// @return The total number of attestations.
    function getReceivedAttestationUIDCount(address recipient, bytes32 schemaUID) external view returns (uint256) {
        return _receivedAttestations[recipient][schemaUID].length;
    }

    /// @notice Returns the UIDs of attestations to a specific schema which were attested by a specific attester.
    /// @param attester The attester of the attestation.
    /// @param schemaUID The UID of the schema.
    /// @param start The offset to start from.
    /// @param length The number of total members to retrieve.
    /// @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
    /// @return An array of attestation UIDs.
    function getSentAttestationUIDs(
        address attester,
        bytes32 schemaUID,
        uint256 start,
        uint256 length,
        bool reverseOrder
    ) external view returns (bytes32[] memory) {
        return _sliceUIDs(_sentAttestations[attester][schemaUID], start, length, reverseOrder);
    }

    /// @notice Returns the total number of attestations to a specific schema which were attested by a specific
    /// attester.
    /// @param attester The attester of the attestation.
    /// @param schemaUID The UID of the schema.
    /// @return The total number of attestations.
    function getSentAttestationUIDCount(address attester, bytes32 schemaUID) external view returns (uint256) {
        return _sentAttestations[attester][schemaUID].length;
    }

    /// @notice Returns the UIDs of attestations to a specific schema which were attested by a specific attester to a
    ///     specific recipient.
    /// @param schemaUID The UID of the schema.
    /// @param attester The attester of the attestation.
    /// @param recipient The recipient of the attestation.
    /// @param start The offset to start from.
    /// @param length The number of total members to retrieve.
    /// @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
    /// @return An array of attestation UIDs.
    function getSchemaAttesterRecipientAttestationUIDs(
        bytes32 schemaUID,
        address attester,
        address recipient,
        uint256 start,
        uint256 length,
        bool reverseOrder
    ) external view returns (bytes32[] memory) {
        return
            _sliceUIDs(
                _schemaAttesterRecipientAttestations[schemaUID][attester][recipient],
                start,
                length,
                reverseOrder
            );
    }

    /// @notice Returns the total number of UIDs of attestations to a specific schema which were attested by a specific
    ///     attester to a specific recipient.
    /// @param schemaUID The UID of the schema.
    /// @param attester The attester of the attestation.
    /// @param recipient The recipient of the attestation.
    /// @return An array of attestation UIDs.
    function getSchemaAttesterRecipientAttestationUIDCount(
        bytes32 schemaUID,
        address attester,
        address recipient
    ) external view returns (uint256) {
        return _schemaAttesterRecipientAttestations[schemaUID][attester][recipient].length;
    }

    /// @notice Returns the UIDs of attestations to a specific schema.
    /// @param schemaUID The UID of the schema.
    /// @param start The offset to start from.
    /// @param length The number of total members to retrieve.
    /// @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
    /// @return An array of attestation UIDs.
    function getSchemaAttestationUIDs(
        bytes32 schemaUID,
        uint256 start,
        uint256 length,
        bool reverseOrder
    ) external view returns (bytes32[] memory) {
        return _sliceUIDs(_schemaAttestations[schemaUID], start, length, reverseOrder);
    }

    /// @notice Returns the total number of attestations to a specific schema.
    /// @param schemaUID The UID of the schema.
    /// @return An array of attestation UIDs.
    function getSchemaAttestationUIDCount(bytes32 schemaUID) external view returns (uint256) {
        return _schemaAttestations[schemaUID].length;
    }

    /// @dev Indexes an existing attestation.
    /// @param attestationUID The UID of the attestation to index.
    function _indexAttestation(bytes32 attestationUID) private {
        // Skip already indexed attestations.
        if (_indexedAttestations[attestationUID]) {
            return;
        }

        // Check if the attestation exists.
        Attestation memory attestation = _eas.getAttestation(attestationUID);

        bytes32 uid = attestation.uid;
        if (uid == EMPTY_UID) {
            revert InvalidAttestation();
        }

        // Index the attestation.
        address attester = attestation.attester;
        address recipient = attestation.recipient;
        bytes32 schemaUID = attestation.schema;

        _indexedAttestations[attestationUID] = true;
        _schemaAttestations[schemaUID].push(attestationUID);
        _receivedAttestations[recipient][schemaUID].push(attestationUID);
        _sentAttestations[attester][schemaUID].push(attestationUID);
        _schemaAttesterRecipientAttestations[schemaUID][attester][recipient].push(attestationUID);

        emit Indexed({ uid: uid });
    }

    /// @dev Returns a slice in an array of attestation UIDs.
    /// @param uids The array of attestation UIDs.
    /// @param start The offset to start from.
    /// @param length The number of total members to retrieve.
    /// @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
    /// @return An array of attestation UIDs.
    function _sliceUIDs(
        bytes32[] memory uids,
        uint256 start,
        uint256 length,
        bool reverseOrder
    ) private pure returns (bytes32[] memory) {
        uint256 attestationsLength = uids.length;
        if (attestationsLength == 0) {
            return new bytes32[](0);
        }

        if (start >= attestationsLength) {
            revert InvalidOffset();
        }

        unchecked {
            uint256 len = length;
            if (attestationsLength < start + length) {
                len = attestationsLength - start;
            }

            bytes32[] memory res = new bytes32[](len);

            for (uint256 i = 0; i < len; ++i) {
                res[i] = uids[reverseOrder ? attestationsLength - (start + i + 1) : start + i];
            }

            return res;
        }
    }
}


================================================
FILE: contracts/SchemaRegistry.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { ISchemaResolver } from "./resolver/ISchemaResolver.sol";

import { EMPTY_UID } from "./Common.sol";
import { Semver } from "./Semver.sol";
import { ISchemaRegistry, SchemaRecord } from "./ISchemaRegistry.sol";

/// @title SchemaRegistry
/// @notice The global schema registry.
contract SchemaRegistry is ISchemaRegistry, Semver {
    error AlreadyExists();

    // The global mapping between schema records and their IDs.
    mapping(bytes32 uid => SchemaRecord schemaRecord) private _registry;

    /// @dev Creates a new SchemaRegistry instance.
    constructor() Semver(1, 4, 0) {}

    /// @inheritdoc ISchemaRegistry
    function register(string calldata schema, ISchemaResolver resolver, bool revocable) external returns (bytes32) {
        SchemaRecord memory schemaRecord = SchemaRecord({
            uid: EMPTY_UID,
            schema: schema,
            resolver: resolver,
            revocable: revocable
        });

        bytes32 uid = _getUID(schemaRecord);
        if (_registry[uid].uid != EMPTY_UID) {
            revert AlreadyExists();
        }

        schemaRecord.uid = uid;
        _registry[uid] = schemaRecord;

        emit Registered(uid, msg.sender, schemaRecord);

        return uid;
    }

    /// @inheritdoc ISchemaRegistry
    function getSchema(bytes32 uid) external view returns (SchemaRecord memory) {
        return _registry[uid];
    }

    /// @dev Calculates a UID for a given schema.
    /// @param schemaRecord The input schema.
    /// @return schema UID.
    function _getUID(SchemaRecord memory schemaRecord) private pure returns (bytes32) {
        return keccak256(abi.encodePacked(schemaRecord.schema, schemaRecord.resolver, schemaRecord.revocable));
    }
}


================================================
FILE: contracts/Semver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";

import { ISemver } from "./ISemver.sol";

/// @title Semver
/// @notice A simple contract for managing contract versions.
contract Semver is ISemver {
    // Contract's major version number.
    uint256 private immutable _major;

    // Contract's minor version number.
    uint256 private immutable _minor;

    // Contract's patch version number.
    uint256 private immutable _patch;

    /// @dev Create a new Semver instance.
    /// @param major Major version number.
    /// @param minor Minor version number.
    /// @param patch Patch version number.
    constructor(uint256 major, uint256 minor, uint256 patch) {
        _major = major;
        _minor = minor;
        _patch = patch;
    }

    /// @notice Returns the full semver contract version.
    /// @return Semver contract version as a string.
    function version() external view returns (string memory) {
        return
            string(
                abi.encodePacked(Strings.toString(_major), ".", Strings.toString(_minor), ".", Strings.toString(_patch))
            );
    }
}


================================================
FILE: contracts/eip1271/EIP1271Verifier.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import { SignatureChecker } from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import { DeadlineExpired, NO_EXPIRATION_TIME, Signature, InvalidSignature } from "./../Common.sol";

// prettier-ignore
import {
    AttestationRequestData,
    DelegatedAttestationRequest,
    DelegatedRevocationRequest,
    RevocationRequestData
} from "../IEAS.sol";

/// @title EIP1271Verifier
/// @notice EIP1271Verifier typed signatures verifier for EAS delegated attestations.
abstract contract EIP1271Verifier is EIP712 {
    using Address for address;

    error InvalidNonce();

    // The hash of the data type used to relay calls to the attest function. It's the value of
    // keccak256("Attest(address attester,bytes32 schema,address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value,uint256 nonce,uint64 deadline)").
    bytes32 private constant ATTEST_TYPEHASH = 0xfeb2925a02bae3dae48d424a0437a2b6ac939aa9230ddc55a1a76f065d988076;

    // The hash of the data type used to relay calls to the revoke function. It's the value of
    // keccak256("Revoke(address revoker,bytes32 schema,bytes32 uid,uint256 value,uint256 nonce,uint64 deadline)").
    bytes32 private constant REVOKE_TYPEHASH = 0xb5d556f07587ec0f08cf386545cc4362c702a001650c2058002615ee5c9d1e75;

    // The user readable name of the signing domain.
    string private _name;

    // Replay protection nonces.
    mapping(address attester => uint256 nonce) private _nonces;

    /// @notice Emitted when users invalidate nonces by increasing their nonces to (higher) new values.
    /// @param oldNonce The previous nonce.
    /// @param newNonce The new value.
    event NonceIncreased(uint256 oldNonce, uint256 newNonce);

    /// @dev Creates a new EIP1271Verifier instance.
    /// @param version The current major version of the signing domain
    constructor(string memory name, string memory version) EIP712(name, version) {
        _name = name;
    }

    /// @notice Returns the domain separator used in the encoding of the signatures for attest, and revoke.
    /// @return The domain separator used in the encoding of the signatures for attest, and revoke.
    function getDomainSeparator() external view returns (bytes32) {
        return _domainSeparatorV4();
    }

    /// @notice Returns the current nonce per-account.
    /// @param account The requested account.
    /// @return The current nonce.
    function getNonce(address account) external view returns (uint256) {
        return _nonces[account];
    }

    /// @notice Returns the EIP712 type hash for the attest function.
    /// @return The EIP712 type hash for the attest function.
    function getAttestTypeHash() external pure returns (bytes32) {
        return ATTEST_TYPEHASH;
    }

    /// @notice Returns the EIP712 type hash for the revoke function.
    /// @return The EIP712 type hash for the revoke function.
    function getRevokeTypeHash() external pure returns (bytes32) {
        return REVOKE_TYPEHASH;
    }

    /// @notice Returns the EIP712 name.
    /// @return The EIP712 name.
    function getName() external view returns (string memory) {
        return _name;
    }

    /// @notice Provides users an option to invalidate nonces by increasing their nonces to (higher) new values.
    /// @param newNonce The (higher) new value.
    function increaseNonce(uint256 newNonce) external {
        uint256 oldNonce = _nonces[msg.sender];
        if (newNonce <= oldNonce) {
            revert InvalidNonce();
        }

        _nonces[msg.sender] = newNonce;

        emit NonceIncreased({ oldNonce: oldNonce, newNonce: newNonce });
    }

    /// @dev Verifies delegated attestation request.
    /// @param request The arguments of the delegated attestation request.
    function _verifyAttest(DelegatedAttestationRequest memory request) internal {
        if (request.deadline != NO_EXPIRATION_TIME && request.deadline < _time()) {
            revert DeadlineExpired();
        }

        AttestationRequestData memory data = request.data;
        Signature memory signature = request.signature;

        bytes32 hash = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    ATTEST_TYPEHASH,
                    request.attester,
                    request.schema,
                    data.recipient,
                    data.expirationTime,
                    data.revocable,
                    data.refUID,
                    keccak256(data.data),
                    data.value,
                    _nonces[request.attester]++,
                    request.deadline
                )
            )
        );
        if (
            !SignatureChecker.isValidSignatureNow(
                request.attester,
                hash,
                abi.encodePacked(signature.r, signature.s, signature.v)
            )
        ) {
            revert InvalidSignature();
        }
    }

    /// @dev Verifies delegated revocation request.
    /// @param request The arguments of the delegated revocation request.
    function _verifyRevoke(DelegatedRevocationRequest memory request) internal {
        if (request.deadline != NO_EXPIRATION_TIME && request.deadline < _time()) {
            revert DeadlineExpired();
        }

        RevocationRequestData memory data = request.data;
        Signature memory signature = request.signature;

        bytes32 hash = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    REVOKE_TYPEHASH,
                    request.revoker,
                    request.schema,
                    data.uid,
                    data.value,
                    _nonces[request.revoker]++,
                    request.deadline
                )
            )
        );
        if (
            !SignatureChecker.isValidSignatureNow(
                request.revoker,
                hash,
                abi.encodePacked(signature.r, signature.s, signature.v)
            )
        ) {
            revert InvalidSignature();
        }
    }

    /// @dev Returns the current's block timestamp. This method is overridden during tests and used to simulate the
    ///     current block time.
    function _time() internal view virtual returns (uint64) {
        return uint64(block.timestamp);
    }
}


================================================
FILE: contracts/eip712/proxy/EIP712Proxy.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

// prettier-ignore
import {
    AccessDenied,
    DeadlineExpired,
    Signature,
    InvalidEAS,
    InvalidLength,
    InvalidSignature,
    NotFound,
    NO_EXPIRATION_TIME
} from "../../Common.sol";

// prettier-ignore
import {
    AttestationRequest,
    AttestationRequestData,
    IEAS,
    MultiAttestationRequest,
    MultiRevocationRequest,
    RevocationRequest,
    RevocationRequestData
} from "../../IEAS.sol";

import { Semver } from "../../Semver.sol";

/// @notice A struct representing the full arguments of the full delegated attestation request.
struct DelegatedProxyAttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData data; // The arguments of the attestation request.
    Signature signature; // The EIP712 signature data.
    address attester; // The attesting account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the full arguments of the delegated multi attestation request.
struct MultiDelegatedProxyAttestationRequest {
    bytes32 schema; // The unique identifier of the schema.
    AttestationRequestData[] data; // The arguments of the attestation requests.
    Signature[] signatures; // The EIP712 signatures data. Please note that the signatures are assumed to be signed with increasing nonces.
    address attester; // The attesting account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the arguments of the full delegated revocation request.
struct DelegatedProxyRevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData data; // The arguments of the revocation request.
    Signature signature; // The EIP712 signature data.
    address revoker; // The revoking account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @notice A struct representing the full arguments of the delegated multi revocation request.
struct MultiDelegatedProxyRevocationRequest {
    bytes32 schema; // The unique identifier of the schema.
    RevocationRequestData[] data; // The arguments of the revocation requests.
    Signature[] signatures; // The EIP712 signatures data. Please note that the signatures are assumed to be signed with increasing nonces.
    address revoker; // The revoking account.
    uint64 deadline; // The deadline of the signature/request.
}

/// @title EIP712Proxy
/// @notice This utility contract an be used to aggregate delegated attestations without requiring a specific order via
///     nonces. The contract doesn't request nonces and implements replay protection by storing ***immalleable***
///     signatures.
contract EIP712Proxy is Semver, EIP712 {
    error UsedSignature();

    // The hash of the data type used to relay calls to the attest function. It's the value of
    // keccak256("Attest(address attester,bytes32 schema,address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value,uint64 deadline)").
    bytes32 private constant ATTEST_PROXY_TYPEHASH = 0xea02ffba7dcb45f6fc649714d23f315eef12e3b27f9a7735d8d8bf41eb2b1af1;

    // The hash of the data type used to relay calls to the revoke function. It's the value of
    // keccak256("Revoke(address revoker,bytes32 schema,bytes32 uid,uint256 value,uint64 deadline)").
    bytes32 private constant REVOKE_PROXY_TYPEHASH = 0x78a69a78c1a55cdff5cbf949580b410778cd9e4d1ecbe6f06a7fa8dc2441b57d;

    // The global EAS contract.
    IEAS private immutable _eas;

    // The user readable name of the signing domain.
    string private _name;

    // The global mapping between proxy attestations and their attesters, so that we can verify that only the original
    // attester is able to revert attestations by proxy.
    mapping(bytes32 uid => address attester) private _attesters;

    // Replay protection signatures.
    mapping(bytes signature => bool used) private _signatures;

    /// @dev Creates a new EIP1271Verifier instance.
    /// @param eas The address of the global EAS contract.
    /// @param name The user readable name of the signing domain.
    constructor(IEAS eas, string memory name) Semver(1, 4, 0) EIP712(name, "1.4.0") {
        if (address(eas) == address(0)) {
            revert InvalidEAS();
        }

        _eas = eas;
        _name = name;
    }

    /// @notice Returns the EAS.
    function getEAS() external view returns (IEAS) {
        return _eas;
    }

    /// @notice Returns the domain separator used in the encoding of the signatures for attest, and revoke.
    function getDomainSeparator() external view returns (bytes32) {
        return _domainSeparatorV4();
    }

    /// Returns the EIP712 type hash for the attest function.
    function getAttestTypeHash() external pure returns (bytes32) {
        return ATTEST_PROXY_TYPEHASH;
    }

    /// Returns the EIP712 type hash for the revoke function.
    function getRevokeTypeHash() external pure returns (bytes32) {
        return REVOKE_PROXY_TYPEHASH;
    }

    /// Returns the EIP712 name.
    function getName() external view returns (string memory) {
        return _name;
    }

    /// Returns the attester for a given uid.
    function getAttester(bytes32 uid) external view returns (address) {
        return _attesters[uid];
    }

    /// @notice Attests to a specific schema via the provided EIP712 signature.
    /// @param delegatedRequest The arguments of the delegated attestation request.
    /// @return The UID of the new attestation.
    ///
    /// Example:
    ///     attestByDelegation({
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: {
    ///             recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
    ///             expirationTime: 1673891048,
    ///             revocable: true,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x1234',
    ///             value: 0
    ///         },
    ///         signature: {
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         attester: '0xc5E8740aD971409492b1A63Db8d83025e0Fc427e',
    ///         deadline: 1673891048
    ///     })
    function attestByDelegation(
        DelegatedProxyAttestationRequest calldata delegatedRequest
    ) public payable virtual returns (bytes32) {
        _verifyAttest(delegatedRequest);

        bytes32 uid = _eas.attest{ value: msg.value }(
            AttestationRequest({ schema: delegatedRequest.schema, data: delegatedRequest.data })
        );

        _attesters[uid] = delegatedRequest.attester;

        return uid;
    }

    /// @notice Attests to multiple schemas using via provided EIP712 signatures.
    /// @param multiDelegatedRequests The arguments of the delegated multi attestation requests. The requests should be
    ///     grouped by distinct schema ids to benefit from the best batching optimization.
    /// @return The UIDs of the new attestations.
    ///
    /// Example:
    ///     multiAttestByDelegation([{
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: [{
    ///             recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
    ///             expirationTime: 1673891048,
    ///             revocable: true,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x1234',
    ///             value: 0
    ///         },
    ///         {
    ///             recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf',
    ///             expirationTime: 0,
    ///             revocable: false,
    ///             refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
    ///             data: '0x00',
    ///             value: 0
    ///         }],
    ///         signatures: [{
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         {
    ///             v: 28,
    ///             r: '0x487s...67bb',
    ///             s: '0x12ad...2366'
    ///         }],
    ///         attester: '0x1D86495b2A7B524D747d2839b3C645Bed32e8CF4',
    ///         deadline: 1673891048
    ///     }])
    function multiAttestByDelegation(
        MultiDelegatedProxyAttestationRequest[] calldata multiDelegatedRequests
    ) public payable virtual returns (bytes32[] memory) {
        uint256 length = multiDelegatedRequests.length;
        MultiAttestationRequest[] memory multiRequests = new MultiAttestationRequest[](length);

        for (uint256 i = 0; i < length; ++i) {
            MultiDelegatedProxyAttestationRequest calldata multiDelegatedRequest = multiDelegatedRequests[i];
            AttestationRequestData[] calldata data = multiDelegatedRequest.data;

            // Ensure that no inputs are missing.
            uint256 dataLength = data.length;
            if (dataLength == 0 || dataLength != multiDelegatedRequest.signatures.length) {
                revert InvalidLength();
            }

            // Verify EIP712 signatures. Please note that the signatures are assumed to be signed with increasing nonces.
            for (uint256 j = 0; j < dataLength; ++j) {
                _verifyAttest(
                    DelegatedProxyAttestationRequest({
                        schema: multiDelegatedRequest.schema,
                        data: data[j],
                        signature: multiDelegatedRequest.signatures[j],
                        attester: multiDelegatedRequest.attester,
                        deadline: multiDelegatedRequest.deadline
                    })
                );
            }

            multiRequests[i] = MultiAttestationRequest({ schema: multiDelegatedRequest.schema, data: data });
        }

        bytes32[] memory uids = _eas.multiAttest{ value: msg.value }(multiRequests);

        // Store all attesters, according to the order of the attestation requests.
        uint256 uidCounter = 0;

        for (uint256 i = 0; i < length; ++i) {
            MultiDelegatedProxyAttestationRequest calldata multiDelegatedRequest = multiDelegatedRequests[i];
            AttestationRequestData[] calldata data = multiDelegatedRequest.data;

            uint256 dataLength = data.length;
            for (uint256 j = 0; j < dataLength; ++j) {
                _attesters[uids[uidCounter]] = multiDelegatedRequest.attester;

                unchecked {
                    ++uidCounter;
                }
            }
        }

        return uids;
    }

    /// @notice Revokes an existing attestation to a specific schema via the provided EIP712 signature.
    /// @param delegatedRequest The arguments of the delegated revocation request.
    ///
    /// Example:
    ///     revokeByDelegation({
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: {
    ///             uid: '0xcbbc12102578c642a0f7b34fe7111e41afa25683b6cd7b5a14caf90fa14d24ba',
    ///             value: 0
    ///         },
    ///         signature: {
    ///             v: 27,
    ///             r: '0xb593...7142',
    ///             s: '0x0f5b...2cce'
    ///         },
    ///         revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992',
    ///         deadline: 1673891048
    ///     })
    function revokeByDelegation(DelegatedProxyRevocationRequest calldata delegatedRequest) public payable virtual {
        _verifyRevoke(delegatedRequest);

        return
            _eas.revoke{ value: msg.value }(
                RevocationRequest({ schema: delegatedRequest.schema, data: delegatedRequest.data })
            );
    }

    /// @notice Revokes existing attestations to multiple schemas via provided EIP712 signatures.
    /// @param multiDelegatedRequests The arguments of the delegated multi revocation attestation requests. The requests
    ///     should be grouped by distinct schema ids to benefit from the best batching optimization.
    ///
    /// Example:
    ///     multiRevokeByDelegation([{
    ///         schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc',
    ///         data: [{
    ///             uid: '0x211296a1ca0d7f9f2cfebf0daaa575bea9b20e968d81aef4e743d699c6ac4b25',
    ///             value: 1000
    ///         },
    ///         {
    ///             uid: '0xe160ac1bd3606a287b4d53d5d1d6da5895f65b4b4bab6d93aaf5046e48167ade',
    ///             value: 0
    ///         }],
    ///         signatures: [{
    ///             v: 28,
    ///             r: '0x148c...b25b',
    ///             s: '0x5a72...be22'
    ///         },
    ///         {
    ///             v: 28,
    ///             r: '0x487s...67bb',
    ///             s: '0x12ad...2366'
    ///         }],
    ///         revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992',
    ///         deadline: 1673891048
    ///     }])
    function multiRevokeByDelegation(
        MultiDelegatedProxyRevocationRequest[] calldata multiDelegatedRequests
    ) public payable virtual {
        uint256 length = multiDelegatedRequests.length;
        MultiRevocationRequest[] memory multiRequests = new MultiRevocationRequest[](length);

        for (uint256 i = 0; i < length; ++i) {
            MultiDelegatedProxyRevocationRequest memory multiDelegatedRequest = multiDelegatedRequests[i];
            RevocationRequestData[] memory data = multiDelegatedRequest.data;

            // Ensure that no inputs are missing.
            uint256 dataLength = data.length;
            if (dataLength == 0 || dataLength != multiDelegatedRequest.signatures.length) {
                revert InvalidLength();
            }

            // Verify EIP712 signatures. Please note that the signatures are assumed to be signed with increasing nonces.
            for (uint256 j = 0; j < dataLength; ++j) {
                RevocationRequestData memory requestData = data[j];

                _verifyRevoke(
                    DelegatedProxyRevocationRequest({
                        schema: multiDelegatedRequest.schema,
                        data: requestData,
                        signature: multiDelegatedRequest.signatures[j],
                        revoker: multiDelegatedRequest.revoker,
                        deadline: multiDelegatedRequest.deadline
                    })
                );
            }

            multiRequests[i] = MultiRevocationRequest({ schema: multiDelegatedRequest.schema, data: data });
        }

        _eas.multiRevoke{ value: msg.value }(multiRequests);
    }

    /// @dev Verifies delegated attestation request.
    /// @param request The arguments of the delegated attestation request.
    function _verifyAttest(DelegatedProxyAttestationRequest memory request) internal {
        if (request.deadline != NO_EXPIRATION_TIME && request.deadline < _time()) {
            revert DeadlineExpired();
        }

        AttestationRequestData memory data = request.data;
        Signature memory signature = request.signature;

        _verifyUnusedSignature(signature);

        bytes32 digest = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    ATTEST_PROXY_TYPEHASH,
                    request.attester,
                    request.schema,
                    data.recipient,
                    data.expirationTime,
                    data.revocable,
                    data.refUID,
                    keccak256(data.data),
                    data.value,
                    request.deadline
                )
            )
        );

        if (ECDSA.recover(digest, signature.v, signature.r, signature.s) != request.attester) {
            revert InvalidSignature();
        }
    }

    /// @dev Verifies delegated revocation request.
    /// @param request The arguments of the delegated revocation request.
    function _verifyRevoke(DelegatedProxyRevocationRequest memory request) internal {
        if (request.deadline != NO_EXPIRATION_TIME && request.deadline < _time()) {
            revert DeadlineExpired();
        }

        RevocationRequestData memory data = request.data;

        // Allow only original attesters to revoke their attestations.
        address attester = _attesters[data.uid];
        if (attester == address(0)) {
            revert NotFound();
        }

        if (attester != request.revoker) {
            revert AccessDenied();
        }

        Signature memory signature = request.signature;

        _verifyUnusedSignature(signature);

        bytes32 digest = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    REVOKE_PROXY_TYPEHASH,
                    request.revoker,
                    request.schema,
                    data.uid,
                    data.value,
                    request.deadline
                )
            )
        );

        if (ECDSA.recover(digest, signature.v, signature.r, signature.s) != request.revoker) {
            revert InvalidSignature();
        }
    }

    /// @dev Ensures that the provided EIP712 signature wasn't already used.
    /// @param signature The EIP712 signature data.
    function _verifyUnusedSignature(Signature memory signature) internal {
        bytes memory packedSignature = abi.encodePacked(signature.v, signature.r, signature.s);

        if (_signatures[packedSignature]) {
            revert UsedSignature();
        }

        _signatures[packedSignature] = true;
    }

    /// @dev Returns the current's block timestamp. This method is overridden during tests and used to simulate the
    ///     current block time.
    function _time() internal view virtual returns (uint64) {
        return uint64(block.timestamp);
    }
}


================================================
FILE: contracts/eip712/proxy/examples/PermissionedEIP712Proxy.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { Ownable, Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";

// prettier-ignore
import {
    EIP712Proxy,
    DelegatedProxyAttestationRequest,
    DelegatedProxyRevocationRequest,
    MultiDelegatedProxyAttestationRequest,
    MultiDelegatedProxyRevocationRequest
} from "../EIP712Proxy.sol";

import { IEAS } from "../../../IEAS.sol";

import { AccessDenied } from "../../../Common.sol";

/// @title PermissionedEIP712Proxy
/// @notice A sample EIP712 proxy that allows only a specific address to attest.
contract PermissionedEIP712Proxy is EIP712Proxy, Ownable2Step {
    /// @dev Creates a new PermissionedEIP712Proxy instance.
    /// @param eas The address of the global EAS contract.
    /// @param name The user readable name of the signing domain.
    constructor(IEAS eas, string memory name) Ownable(msg.sender) EIP712Proxy(eas, name) {}

    /// @inheritdoc EIP712Proxy
    function attestByDelegation(
        DelegatedProxyAttestationRequest calldata delegatedRequest
    ) public payable override returns (bytes32) {
        // Ensure that only the owner is allowed to delegate attestations.
        _verifyAttester(delegatedRequest.attester);

        return super.attestByDelegation(delegatedRequest);
    }

    /// @inheritdoc EIP712Proxy
    function multiAttestByDelegation(
        MultiDelegatedProxyAttestationRequest[] calldata multiDelegatedRequests
    ) public payable override returns (bytes32[] memory) {
        uint256 length = multiDelegatedRequests.length;
        for (uint256 i = 0; i < length; ++i) {
            // Ensure that only the owner is allowed to delegate attestations.
            _verifyAttester(multiDelegatedRequests[i].attester);
        }

        return super.multiAttestByDelegation(multiDelegatedRequests);
    }

    /// @inheritdoc EIP712Proxy
    function revokeByDelegation(DelegatedProxyRevocationRequest calldata delegatedRequest) public payable override {
        // Ensure that only the owner is allowed to delegate revocations.
        _verifyAttester(delegatedRequest.revoker);

        super.revokeByDelegation(delegatedRequest);
    }

    /// @inheritdoc EIP712Proxy
    function multiRevokeByDelegation(
        MultiDelegatedProxyRevocationRequest[] calldata multiDelegatedRequests
    ) public payable override {
        uint256 length = multiDelegatedRequests.length;
        for (uint256 i = 0; i < length; ++i) {
            // Ensure that only the owner is allowed to delegate revocations.
            _verifyAttester(multiDelegatedRequests[i].revoker);
        }

        super.multiRevokeByDelegation(multiDelegatedRequests);
    }

    /// @dev Ensures that only the allowed attester can attest.
    /// @param attester The attester to verify.
    function _verifyAttester(address attester) private view {
        if (attester != owner()) {
            revert AccessDenied();
        }
    }
}


================================================
FILE: contracts/resolver/ISchemaResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { Attestation } from "./../Common.sol";
import { ISemver } from "./../ISemver.sol";

/// @title ISchemaResolver
/// @notice The interface of an optional schema resolver.
interface ISchemaResolver is ISemver {
    /// @notice Checks if the resolver can be sent ETH.
    /// @return Whether the resolver supports ETH transfers.
    function isPayable() external pure returns (bool);

    /// @notice Processes an attestation and verifies whether it's valid.
    /// @param attestation The new attestation.
    /// @return Whether the attestation is valid.
    function attest(Attestation calldata attestation) external payable returns (bool);

    /// @notice Processes multiple attestations and verifies whether they are valid.
    /// @param attestations The new attestations.
    /// @param values Explicit ETH amounts which were sent with each attestation.
    /// @return Whether all the attestations are valid.
    function multiAttest(
        Attestation[] calldata attestations,
        uint256[] calldata values
    ) external payable returns (bool);

    /// @notice Processes an attestation revocation and verifies if it can be revoked.
    /// @param attestation The existing attestation to be revoked.
    /// @return Whether the attestation can be revoked.
    function revoke(Attestation calldata attestation) external payable returns (bool);

    /// @notice Processes revocation of multiple attestation and verifies they can be revoked.
    /// @param attestations The existing attestations to be revoked.
    /// @param values Explicit ETH amounts which were sent with each revocation.
    /// @return Whether the attestations can be revoked.
    function multiRevoke(
        Attestation[] calldata attestations,
        uint256[] calldata values
    ) external payable returns (bool);
}


================================================
FILE: contracts/resolver/SchemaResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import { AccessDenied, InvalidEAS, InvalidLength } from "./../Common.sol";
import { IEAS, Attestation } from "./../IEAS.sol";
import { Semver } from "./../Semver.sol";
import { ISchemaResolver } from "./ISchemaResolver.sol";

/// @title SchemaResolver
/// @notice The base schema resolver contract.
abstract contract SchemaResolver is ISchemaResolver, Semver {
    error InsufficientValue();
    error NotPayable();

    // The global EAS contract.
    IEAS internal immutable _eas;

    /// @dev Creates a new resolver.
    /// @param eas The address of the global EAS contract.
    constructor(IEAS eas) Semver(1, 4, 0) {
        if (address(eas) == address(0)) {
            revert InvalidEAS();
        }

        _eas = eas;
    }

    /// @dev Ensures that only the EAS contract can make this call.
    modifier onlyEAS() {
        _onlyEAS();

        _;
    }

    /// @inheritdoc ISchemaResolver
    function isPayable() public pure virtual returns (bool) {
        return false;
    }

    /// @dev ETH callback.
    receive() external payable virtual {
        if (!isPayable()) {
            revert NotPayable();
        }
    }

    /// @inheritdoc ISchemaResolver
    function attest(Attestation calldata attestation) external payable onlyEAS returns (bool) {
        return onAttest(attestation, msg.value);
    }

    /// @inheritdoc ISchemaResolver
    function multiAttest(
        Attestation[] calldata attestations,
        uint256[] calldata values
    ) external payable onlyEAS returns (bool) {
        uint256 length = attestations.length;
        if (length != values.length) {
            revert InvalidLength();
        }

        // We are keeping track of the remaining ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 remainingValue = msg.value;

        for (uint256 i = 0; i < length; ++i) {
            // Ensure that the attester/revoker doesn't try to spend more than available.
            uint256 value = values[i];
            if (value > remainingValue) {
                revert InsufficientValue();
            }

            // Forward the attestation to the underlying resolver and return false in case it isn't approved.
            if (!onAttest(attestations[i], value)) {
                return false;
            }

            unchecked {
                // Subtract the ETH amount, that was provided to this attestation, from the global remaining ETH amount.
                remainingValue -= value;
            }
        }

        return true;
    }

    /// @inheritdoc ISchemaResolver
    function revoke(Attestation calldata attestation) external payable onlyEAS returns (bool) {
        return onRevoke(attestation, msg.value);
    }

    /// @inheritdoc ISchemaResolver
    function multiRevoke(
        Attestation[] calldata attestations,
        uint256[] calldata values
    ) external payable onlyEAS returns (bool) {
        uint256 length = attestations.length;
        if (length != values.length) {
            revert InvalidLength();
        }

        // We are keeping track of the remaining ETH amount that can be sent to resolvers and will keep deducting
        // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless
        // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be
        // possible to send too much ETH anyway.
        uint256 remainingValue = msg.value;

        for (uint256 i = 0; i < length; ++i) {
            // Ensure that the attester/revoker doesn't try to spend more than available.
            uint256 value = values[i];
            if (value > remainingValue) {
                revert InsufficientValue();
            }

            // Forward the revocation to the underlying resolver and return false in case it isn't approved.
            if (!onRevoke(attestations[i], value)) {
                return false;
            }

            unchecked {
                // Subtract the ETH amount, that was provided to this attestation, from the global remaining ETH amount.
                remainingValue -= value;
            }
        }

        return true;
    }

    /// @notice A resolver callback that should be implemented by child contracts.
    /// @param attestation The new attestation.
    /// @param value An explicit ETH amount that was sent to the resolver. Please note that this value is verified in
    ///     both attest() and multiAttest() callbacks EAS-only callbacks and that in case of multi attestations, it'll
    ///     usually hold that msg.value != value, since msg.value aggregated the sent ETH amounts for all the
    ///     attestations in the batch.
    /// @return Whether the attestation is valid.
    function onAttest(Attestation calldata attestation, uint256 value) internal virtual returns (bool);

    /// @notice Processes an attestation revocation and verifies if it can be revoked.
    /// @param attestation The existing attestation to be revoked.
    /// @param value An explicit ETH amount that was sent to the resolver. Please note that this value is verified in
    ///     both revoke() and multiRevoke() callbacks EAS-only callbacks and that in case of multi attestations, it'll
    ///     usually hold that msg.value != value, since msg.value aggregated the sent ETH amounts for all the
    ///     attestations in the batch.
    /// @return Whether the attestation can be revoked.
    function onRevoke(Attestation calldata attestation, uint256 value) internal virtual returns (bool);

    /// @dev Ensures that only the EAS contract can make this call.
    function _onlyEAS() private view {
        if (msg.sender != address(_eas)) {
            revert AccessDenied();
        }
    }
}


================================================
FILE: contracts/resolver/examples/AttestationResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title AttestationResolver
/// @notice A sample schema resolver that checks whether an attestations attest to an existing attestation with a
//  specific data field.
contract AttestationResolver is SchemaResolver {
    error OutOfBounds();

    bytes32 private constant MAGIC_DATA = "EA5EA5EA5EA5EA5EA5EA5EA5EA5EA5";

    constructor(IEAS eas) SchemaResolver(eas) {}

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal view override returns (bool) {
        bytes32 uid = _toBytes32(attestation.data, 0);
        Attestation memory targetAttestation = _eas.getAttestation(uid);

        // Make sure that the encoded data is an attestation with the magic data.
        return targetAttestation.data.length == MAGIC_DATA.length && bytes32(targetAttestation.data) == MAGIC_DATA;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }

    function toBytes32(bytes memory data, uint256 start) external pure returns (bytes32) {
        return _toBytes32(data, start);
    }

    function _toBytes32(bytes memory data, uint256 start) private pure returns (bytes32) {
        unchecked {
            if (data.length < start + 32) {
                revert OutOfBounds();
            }
        }

        bytes32 tempBytes32;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            tempBytes32 := mload(add(add(data, 0x20), start))
        }

        return tempBytes32;
    }
}


================================================
FILE: contracts/resolver/examples/AttesterResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title AttesterResolver
/// @notice A sample schema resolver that checks whether the attestation is from a specific attester.
contract AttesterResolver is SchemaResolver {
    address private immutable _targetAttester;

    constructor(IEAS eas, address targetAttester) SchemaResolver(eas) {
        _targetAttester = targetAttester;
    }

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal view override returns (bool) {
        return attestation.attester == _targetAttester;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/resolver/examples/DataResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title DataResolver
/// @notice A sample schema resolver that checks whether an attestation data is either \x00 or \x01.
contract DataResolver is SchemaResolver {
    bytes1 private constant DATA1 = "\x00";
    bytes1 private constant DATA2 = "\x01";

    constructor(IEAS eas) SchemaResolver(eas) {}

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal pure override returns (bool) {
        // Verifies that the data is either 0 or 1.
        return attestation.data.length == 1 && (attestation.data[0] == DATA1 || attestation.data[0] == DATA2);
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/resolver/examples/ExpirationTimeResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title ExpirationTimeResolver
/// @notice A sample schema resolver that checks whether the expiration time is later than a specific timestamp.
contract ExpirationTimeResolver is SchemaResolver {
    uint256 private immutable _validAfter;

    constructor(IEAS eas, uint256 validAfter) SchemaResolver(eas) {
        _validAfter = validAfter;
    }

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal view override returns (bool) {
        return attestation.expirationTime >= _validAfter;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/resolver/examples/PayingResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { Address } from "@openzeppelin/contracts/utils/Address.sol";

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title PayingResolver
/// @notice A sample schema resolver that pays attesters (and expects the payment to be returned during revocations).
contract PayingResolver is SchemaResolver {
    using Address for address payable;

    error InvalidValue();

    uint256 private immutable _incentive;

    constructor(IEAS eas, uint256 incentive) SchemaResolver(eas) {
        _incentive = incentive;
    }

    function isPayable() public pure override returns (bool) {
        return true;
    }

    function onAttest(Attestation calldata attestation, uint256 value) internal override returns (bool) {
        if (value > 0) {
            return false;
        }

        payable(attestation.attester).transfer(_incentive);

        return true;
    }

    function onRevoke(Attestation calldata attestation, uint256 value) internal override returns (bool) {
        if (value < _incentive) {
            return false;
        }

        if (value > _incentive) {
            payable(address(attestation.attester)).sendValue(value - _incentive);
        }

        return true;
    }
}


================================================
FILE: contracts/resolver/examples/RecipientResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title RecipientResolver
/// @notice A sample schema resolver that checks whether the attestation is to a specific recipient.
contract RecipientResolver is SchemaResolver {
    address private immutable _targetRecipient;

    constructor(IEAS eas, address targetRecipient) SchemaResolver(eas) {
        _targetRecipient = targetRecipient;
    }

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal view override returns (bool) {
        return attestation.recipient == _targetRecipient;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/resolver/examples/RevocationResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title RevocationResolver
/// @notice A sample schema resolver that controls revocations.
contract RevocationResolver is SchemaResolver {
    bool private _revocation;

    constructor(IEAS eas) SchemaResolver(eas) {}

    function setRevocation(bool status) external {
        _revocation = status;
    }

    function onAttest(Attestation calldata /*attestation)*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal view override returns (bool) {
        return _revocation;
    }
}


================================================
FILE: contracts/resolver/examples/TokenResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title TokenResolver
/// @notice A sample schema resolver that checks whether a specific amount of tokens was approved to be included in an attestation.
contract TokenResolver is SchemaResolver {
    using SafeERC20 for IERC20;

    error InvalidAllowance();

    IERC20 private immutable _targetToken;
    uint256 private immutable _targetAmount;

    constructor(IEAS eas, IERC20 targetToken, uint256 targetAmount) SchemaResolver(eas) {
        _targetToken = targetToken;
        _targetAmount = targetAmount;
    }

    function onAttest(Attestation calldata attestation, uint256 /*value*/) internal view override returns (bool) {
        if (_targetToken.allowance(attestation.attester, address(this)) < _targetAmount) {
            revert InvalidAllowance();
        }

        return true;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/resolver/examples/ValueResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { SchemaResolver } from "../SchemaResolver.sol";

import { IEAS, Attestation } from "../../IEAS.sol";

/// @title ValueResolver
/// @notice A sample schema resolver that checks whether a specific amount of ETH was sent with an attestation.
contract ValueResolver is SchemaResolver {
    uint256 private immutable _targetValue;

    constructor(IEAS eas, uint256 targetValue) SchemaResolver(eas) {
        _targetValue = targetValue;
    }

    function isPayable() public pure override returns (bool) {
        return true;
    }

    function onAttest(Attestation calldata /*attestation*/, uint256 value) internal view override returns (bool) {
        return value == _targetValue;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/tests/TestEAS.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { EAS } from "../EAS.sol";

import { ISchemaRegistry } from "../ISchemaRegistry.sol";

contract TestEAS is EAS {
    uint64 private constant INITIAL_TIME = 0;

    uint64 private _currentTime = INITIAL_TIME;

    constructor(ISchemaRegistry registry) EAS(registry) {}

    function setTime(uint64 newTime) external {
        _currentTime = newTime;
    }

    function getTime() external view returns (uint64) {
        return _time();
    }

    function _time() internal view override returns (uint64) {
        return _currentTime == INITIAL_TIME ? super._time() : _currentTime;
    }
}


================================================
FILE: contracts/tests/TestERC20Token.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TestERC20Token is ERC20 {
    constructor(string memory name, string memory symbol, uint256 totalSupply) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}


================================================
FILE: contracts/tests/TestSchemaResolver.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { IEAS, Attestation } from "./../IEAS.sol";
import { SchemaResolver } from "./../resolver/SchemaResolver.sol";

contract TestSchemaResolver is SchemaResolver {
    constructor(IEAS eas) SchemaResolver(eas) {}

    function onAttest(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }

    function onRevoke(Attestation calldata /*attestation*/, uint256 /*value*/) internal pure override returns (bool) {
        return true;
    }
}


================================================
FILE: contracts/tests/eip1271/TestEIP1271Signer.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { IERC1271 } from "@openzeppelin/contracts/interfaces/IERC1271.sol";

contract TestEIP1271Signer is IERC1271 {
    bytes4 private constant EIP1271_INVALID_MAGIC_VALUE = 0xffffffff;

    mapping(bytes32 hash => bytes signature) private _validSignatures;

    function mockSignature(bytes32 hash, bytes calldata signature) external {
        _validSignatures[hash] = signature;
    }

    function isValidSignature(bytes32 hash, bytes calldata signature) external view returns (bytes4 magicValue) {
        bytes memory storedSignature = _validSignatures[hash];
        if (storedSignature.length == signature.length && keccak256(storedSignature) == keccak256(signature)) {
            return IERC1271.isValidSignature.selector;
        }

        return EIP1271_INVALID_MAGIC_VALUE;
    }
}


================================================
FILE: contracts/tests/eip1271/TestEIP1271Verifier.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { EIP1271Verifier } from "../../eip1271/EIP1271Verifier.sol";
import { DelegatedAttestationRequest, DelegatedRevocationRequest } from "../../IEAS.sol";
import { Semver } from "../../Semver.sol";

contract TestEIP1271Verifier is Semver, EIP1271Verifier {
    constructor(string memory name) Semver(1, 4, 0) EIP1271Verifier(name, "1.4.0") {}

    function verifyAttest(DelegatedAttestationRequest memory request) external {
        _verifyAttest(request);
    }

    function verifyRevoke(DelegatedRevocationRequest memory request) external {
        _verifyRevoke(request);
    }
}


================================================
FILE: contracts/tests/eip712/proxy/TestEIP712Proxy.sol
================================================
// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import { IEAS } from "../../../IEAS.sol";
import { EIP712Proxy, DelegatedProxyAttestationRequest, DelegatedProxyRevocationRequest } from "../../../eip712/proxy/EIP712Proxy.sol";

contract TestEIP712Proxy is EIP712Proxy {
    constructor(IEAS eas, string memory name) EIP712Proxy(eas, name) {}

    function verifyAttest(DelegatedProxyAttestationRequest memory request) external {
        _verifyAttest(request);
    }

    function verifyRevoke(DelegatedProxyRevocationRequest memory request) external {
        _verifyRevoke(request);
    }
}


================================================
FILE: deployments/arbitrum-nova/.chainId
================================================
42170


================================================
FILE: deployments/arbitrum-nova/.migrations.json
================================================
{
  "000001-registry": 1706812884,
  "000002-eas": 1706812886,
  "000003-register-initial-schemas": 1706812965,
  "000004-name-initial-schemas": 1706813044,
  "000005-eip712-proxy": 1706813046,
  "000006-indexer": 1706813048
}

================================================
FILE: deployments/arbitrum-nova/EAS.json
================================================
{
  "address": "0x6d3dC0Fe5351087E3Af3bDe8eB3F7350ed894fc3",
  "abi": [
    {
      "inputs": [
        {
          "internalType": "contract ISchemaRegistry",
          "name": "registry",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "inputs": [],
      "name": "AccessDenied",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "AlreadyRevoked",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "AlreadyRevokedOffchain",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "AlreadyTimestamped",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "DeadlineExpired",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InsufficientValue",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidAttestation",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidAttestations",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidExpirationTime",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidLength",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidNonce",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidOffset",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidRegistry",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidRevocation",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidRevocations",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidSchema",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidShortString",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidSignature",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidVerifier",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "Irrevocable",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "NotFound",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "NotPayable",
      "type": "error"
    },
    {
      "inputs": [
        {
          "internalType": "string",
          "name": "str",
          "type": "string"
        }
      ],
      "name": "StringTooLong",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "WrongSchema",
      "type": "error"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "recipient",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "attester",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "bytes32",
          "name": "uid",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "internalType": "bytes32",
          "name": "schemaUID",
          "type": "bytes32"
        }
      ],
      "name": "Attested",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [],
      "name": "EIP712DomainChanged",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "oldNonce",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "newNonce",
          "type": "uint256"
        }
      ],
      "name": "NonceIncreased",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "recipient",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "attester",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "bytes32",
          "name": "uid",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "internalType": "bytes32",
          "name": "schemaUID",
          "type": "bytes32"
        }
      ],
      "name": "Revoked",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "revoker",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "internalType": "uint64",
          "name": "timestamp",
          "type": "uint64"
        }
      ],
      "name": "RevokedOffchain",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "internalType": "uint64",
          "name": "timestamp",
          "type": "uint64"
        }
      ],
      "name": "Timestamped",
      "type": "event"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "address",
                  "name": "recipient",
                  "type": "address"
                },
                {
                  "internalType": "uint64",
                  "name": "expirationTime",
                  "type": "uint64"
                },
                {
                  "internalType": "bool",
                  "name": "revocable",
                  "type": "bool"
                },
                {
                  "internalType": "bytes32",
                  "name": "refUID",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes",
                  "name": "data",
                  "type": "bytes"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct AttestationRequestData",
              "name": "data",
              "type": "tuple"
            }
          ],
          "internalType": "struct AttestationRequest",
          "name": "request",
          "type": "tuple"
        }
      ],
      "name": "attest",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "address",
                  "name": "recipient",
                  "type": "address"
                },
                {
                  "internalType": "uint64",
                  "name": "expirationTime",
                  "type": "uint64"
                },
                {
                  "internalType": "bool",
                  "name": "revocable",
                  "type": "bool"
                },
                {
                  "internalType": "bytes32",
                  "name": "refUID",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes",
                  "name": "data",
                  "type": "bytes"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct AttestationRequestData",
              "name": "data",
              "type": "tuple"
            },
            {
              "components": [
                {
                  "internalType": "uint8",
                  "name": "v",
                  "type": "uint8"
                },
                {
                  "internalType": "bytes32",
                  "name": "r",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes32",
                  "name": "s",
                  "type": "bytes32"
                }
              ],
              "internalType": "struct Signature",
              "name": "signature",
              "type": "tuple"
            },
            {
              "internalType": "address",
              "name": "attester",
              "type": "address"
            },
            {
              "internalType": "uint64",
              "name": "deadline",
              "type": "uint64"
            }
          ],
          "internalType": "struct DelegatedAttestationRequest",
          "name": "delegatedRequest",
          "type": "tuple"
        }
      ],
      "name": "attestByDelegation",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "eip712Domain",
      "outputs": [
        {
          "internalType": "bytes1",
          "name": "fields",
          "type": "bytes1"
        },
        {
          "internalType": "string",
          "name": "name",
          "type": "string"
        },
        {
          "internalType": "string",
          "name": "version",
          "type": "string"
        },
        {
          "internalType": "uint256",
          "name": "chainId",
          "type": "uint256"
        },
        {
          "internalType": "address",
          "name": "verifyingContract",
          "type": "address"
        },
        {
          "internalType": "bytes32",
          "name": "salt",
          "type": "bytes32"
        },
        {
          "internalType": "uint256[]",
          "name": "extensions",
          "type": "uint256[]"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "getAttestTypeHash",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "uid",
          "type": "bytes32"
        }
      ],
      "name": "getAttestation",
      "outputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "uid",
              "type": "bytes32"
            },
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "internalType": "uint64",
              "name": "time",
              "type": "uint64"
            },
            {
              "internalType": "uint64",
              "name": "expirationTime",
              "type": "uint64"
            },
            {
              "internalType": "uint64",
              "name": "revocationTime",
              "type": "uint64"
            },
            {
              "internalType": "bytes32",
              "name": "refUID",
              "type": "bytes32"
            },
            {
              "internalType": "address",
              "name": "recipient",
              "type": "address"
            },
            {
              "internalType": "address",
              "name": "attester",
              "type": "address"
            },
            {
              "internalType": "bool",
              "name": "revocable",
              "type": "bool"
            },
            {
              "internalType": "bytes",
              "name": "data",
              "type": "bytes"
            }
          ],
          "internalType": "struct Attestation",
          "name": "",
          "type": "tuple"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "getDomainSeparator",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "getName",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "account",
          "type": "address"
        }
      ],
      "name": "getNonce",
      "outputs": [
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "revoker",
          "type": "address"
        },
        {
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        }
      ],
      "name": "getRevokeOffchain",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "getRevokeTypeHash",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "getSchemaRegistry",
      "outputs": [
        {
          "internalType": "contract ISchemaRegistry",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        }
      ],
      "name": "getTimestamp",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "newNonce",
          "type": "uint256"
        }
      ],
      "name": "increaseNonce",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "uid",
          "type": "bytes32"
        }
      ],
      "name": "isAttestationValid",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "address",
                  "name": "recipient",
                  "type": "address"
                },
                {
                  "internalType": "uint64",
                  "name": "expirationTime",
                  "type": "uint64"
                },
                {
                  "internalType": "bool",
                  "name": "revocable",
                  "type": "bool"
                },
                {
                  "internalType": "bytes32",
                  "name": "refUID",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes",
                  "name": "data",
                  "type": "bytes"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct AttestationRequestData[]",
              "name": "data",
              "type": "tuple[]"
            }
          ],
          "internalType": "struct MultiAttestationRequest[]",
          "name": "multiRequests",
          "type": "tuple[]"
        }
      ],
      "name": "multiAttest",
      "outputs": [
        {
          "internalType": "bytes32[]",
          "name": "",
          "type": "bytes32[]"
        }
      ],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "address",
                  "name": "recipient",
                  "type": "address"
                },
                {
                  "internalType": "uint64",
                  "name": "expirationTime",
                  "type": "uint64"
                },
                {
                  "internalType": "bool",
                  "name": "revocable",
                  "type": "bool"
                },
                {
                  "internalType": "bytes32",
                  "name": "refUID",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes",
                  "name": "data",
                  "type": "bytes"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct AttestationRequestData[]",
              "name": "data",
              "type": "tuple[]"
            },
            {
              "components": [
                {
                  "internalType": "uint8",
                  "name": "v",
                  "type": "uint8"
                },
                {
                  "internalType": "bytes32",
                  "name": "r",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes32",
                  "name": "s",
                  "type": "bytes32"
                }
              ],
              "internalType": "struct Signature[]",
              "name": "signatures",
              "type": "tuple[]"
            },
            {
              "internalType": "address",
              "name": "attester",
              "type": "address"
            },
            {
              "internalType": "uint64",
              "name": "deadline",
              "type": "uint64"
            }
          ],
          "internalType": "struct MultiDelegatedAttestationRequest[]",
          "name": "multiDelegatedRequests",
          "type": "tuple[]"
        }
      ],
      "name": "multiAttestByDelegation",
      "outputs": [
        {
          "internalType": "bytes32[]",
          "name": "",
          "type": "bytes32[]"
        }
      ],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "bytes32",
                  "name": "uid",
                  "type": "bytes32"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct RevocationRequestData[]",
              "name": "data",
              "type": "tuple[]"
            }
          ],
          "internalType": "struct MultiRevocationRequest[]",
          "name": "multiRequests",
          "type": "tuple[]"
        }
      ],
      "name": "multiRevoke",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "bytes32",
                  "name": "uid",
                  "type": "bytes32"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct RevocationRequestData[]",
              "name": "data",
              "type": "tuple[]"
            },
            {
              "components": [
                {
                  "internalType": "uint8",
                  "name": "v",
                  "type": "uint8"
                },
                {
                  "internalType": "bytes32",
                  "name": "r",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes32",
                  "name": "s",
                  "type": "bytes32"
                }
              ],
              "internalType": "struct Signature[]",
              "name": "signatures",
              "type": "tuple[]"
            },
            {
              "internalType": "address",
              "name": "revoker",
              "type": "address"
            },
            {
              "internalType": "uint64",
              "name": "deadline",
              "type": "uint64"
            }
          ],
          "internalType": "struct MultiDelegatedRevocationRequest[]",
          "name": "multiDelegatedRequests",
          "type": "tuple[]"
        }
      ],
      "name": "multiRevokeByDelegation",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32[]",
          "name": "data",
          "type": "bytes32[]"
        }
      ],
      "name": "multiRevokeOffchain",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32[]",
          "name": "data",
          "type": "bytes32[]"
        }
      ],
      "name": "multiTimestamp",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "bytes32",
                  "name": "uid",
                  "type": "bytes32"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct RevocationRequestData",
              "name": "data",
              "type": "tuple"
            }
          ],
          "internalType": "struct RevocationRequest",
          "name": "request",
          "type": "tuple"
        }
      ],
      "name": "revoke",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "schema",
              "type": "bytes32"
            },
            {
              "components": [
                {
                  "internalType": "bytes32",
                  "name": "uid",
                  "type": "bytes32"
                },
                {
                  "internalType": "uint256",
                  "name": "value",
                  "type": "uint256"
                }
              ],
              "internalType": "struct RevocationRequestData",
              "name": "data",
              "type": "tuple"
            },
            {
              "components": [
                {
                  "internalType": "uint8",
                  "name": "v",
                  "type": "uint8"
                },
                {
                  "internalType": "bytes32",
                  "name": "r",
                  "type": "bytes32"
                },
                {
                  "internalType": "bytes32",
                  "name": "s",
                  "type": "bytes32"
                }
              ],
              "internalType": "struct Signature",
              "name": "signature",
              "type": "tuple"
            },
            {
              "internalType": "address",
              "name": "revoker",
              "type": "address"
            },
            {
              "internalType": "uint64",
              "name": "deadline",
              "type": "uint64"
            }
          ],
          "internalType": "struct DelegatedRevocationRequest",
          "name": "delegatedRequest",
          "type": "tuple"
        }
      ],
      "name": "revokeByDelegation",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        }
      ],
      "name": "revokeOffchain",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "data",
          "type": "bytes32"
        }
      ],
      "name": "timestamp",
      "outputs": [
        {
          "internalType": "uint64",
          "name": "",
          "type": "uint64"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "version",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    }
  ],
  "transactionHash": "0xf2f0346e8ed49fb8765ce5b532698f14c0be51a86afb8e43427f869af5204d5b",
  "receipt": {
    "to": null,
    "from": "0x0a83Ac5963660cDcbae0Aa2F7aa6885eA17A4DeA",
    "contractAddress": "0x6d3dC0Fe5351087E3Af3bDe8eB3F7350ed894fc3",
    "transactionIndex": 1,
    "gasUsed": "5745145",
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "blockHash": "0x828ba9acdd5a5e106042b77ccaf0ce41c4cdef226275a9396d7a977a3831b6b7",
    "transactionHash": "0xf2f0346e8ed49fb8765ce5b532698f14c0be51a86afb8e43427f869af5204d5b",
    "logs": [],
    "blockNumber": 44665879,
    "cumulativeGasUsed": "5745145",
    "status": 1,
    "byzantium": true
  },
  "args": [
    "0x49563d0DA8DF38ef2eBF9C1167270334D72cE0AE"
  ],
  "numDeployments": 1,
  "solcInputHash": "5760880ca66b7de425cfa0a331639e8e",
  "metadata": "{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract ISchemaRegistry\",\"name\":\"registry\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AccessDenied\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyRevoked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyRevokedOffchain\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyTimestamped\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeadlineExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAttestation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAttestations\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidExpirationTime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLength\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidOffset\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRegistry\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRevocation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRevocations\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSchema\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidShortString\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidVerifier\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Irrevocable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotFound\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotPayable\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"}],\"name\":\"StringTooLong\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WrongSchema\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"attester\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"schemaUID\",\"type\":\"bytes32\"}],\"name\":\"Attested\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EIP712DomainChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldNonce\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNonce\",\"type\":\"uint256\"}],\"name\":\"NonceIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"attester\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"schemaUID\",\"type\":\"bytes32\"}],\"name\":\"Revoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"revoker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"}],\"name\":\"RevokedOffchain\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"}],\"name\":\"Timestamped\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"expirationTime\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"refUID\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct AttestationRequestData\",\"name\":\"data\",\"type\":\"tuple\"}],\"internalType\":\"struct AttestationRequest\",\"name\":\"request\",\"type\":\"tuple\"}],\"name\":\"attest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"expirationTime\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"refUID\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct AttestationRequestData\",\"name\":\"data\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature\",\"name\":\"signature\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"attester\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"deadline\",\"type\":\"uint64\"}],\"internalType\":\"struct DelegatedAttestationRequest\",\"name\":\"delegatedRequest\",\"type\":\"tuple\"}],\"name\":\"attestByDelegation\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"eip712Domain\",\"outputs\":[{\"internalType\":\"bytes1\",\"name\":\"fields\",\"type\":\"bytes1\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"verifyingContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"extensions\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getAttestTypeHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"}],\"name\":\"getAttestation\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"time\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"expirationTime\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"revocationTime\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"refUID\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"attester\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct Attestation\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getDomainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"revoker\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"name\":\"getRevokeOffchain\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRevokeTypeHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSchemaRegistry\",\"outputs\":[{\"internalType\":\"contract ISchemaRegistry\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"name\":\"getTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newNonce\",\"type\":\"uint256\"}],\"name\":\"increaseNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"}],\"name\":\"isAttestationValid\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"expirationTime\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"refUID\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct AttestationRequestData[]\",\"name\":\"data\",\"type\":\"tuple[]\"}],\"internalType\":\"struct MultiAttestationRequest[]\",\"name\":\"multiRequests\",\"type\":\"tuple[]\"}],\"name\":\"multiAttest\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"expirationTime\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"refUID\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct AttestationRequestData[]\",\"name\":\"data\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature[]\",\"name\":\"signatures\",\"type\":\"tuple[]\"},{\"internalType\":\"address\",\"name\":\"attester\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"deadline\",\"type\":\"uint64\"}],\"internalType\":\"struct MultiDelegatedAttestationRequest[]\",\"name\":\"multiDelegatedRequests\",\"type\":\"tuple[]\"}],\"name\":\"multiAttestByDelegation\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct RevocationRequestData[]\",\"name\":\"data\",\"type\":\"tuple[]\"}],\"internalType\":\"struct MultiRevocationRequest[]\",\"name\":\"multiRequests\",\"type\":\"tuple[]\"}],\"name\":\"multiRevoke\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct RevocationRequestData[]\",\"name\":\"data\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature[]\",\"name\":\"signatures\",\"type\":\"tuple[]\"},{\"internalType\":\"address\",\"name\":\"revoker\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"deadline\",\"type\":\"uint64\"}],\"internalType\":\"struct MultiDelegatedRevocationRequest[]\",\"name\":\"multiDelegatedRequests\",\"type\":\"tuple[]\"}],\"name\":\"multiRevokeByDelegation\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"data\",\"type\":\"bytes32[]\"}],\"name\":\"multiRevokeOffchain\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"data\",\"type\":\"bytes32[]\"}],\"name\":\"multiTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct RevocationRequestData\",\"name\":\"data\",\"type\":\"tuple\"}],\"internalType\":\"struct RevocationRequest\",\"name\":\"request\",\"type\":\"tuple\"}],\"name\":\"revoke\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"schema\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct RevocationRequestData\",\"name\":\"data\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature\",\"name\":\"signature\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"revoker\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"deadline\",\"type\":\"uint64\"}],\"internalType\":\"struct DelegatedRevocationRequest\",\"name\":\"delegatedRequest\",\"type\":\"tuple\"}],\"name\":\"revokeByDelegation\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"name\":\"revokeOffchain\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"name\":\"timestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Attested(address,address,bytes32,bytes32)\":{\"params\":{\"attester\":\"The attesting account.\",\"recipient\":\"The recipient of the attestation.\",\"schemaUID\":\"The UID of the schema.\",\"uid\":\"The UID the revoked attestation.\"}},\"EIP712DomainChanged()\":{\"details\":\"MAY be emitted to signal that the domain could have changed.\"},\"NonceIncreased(uint256,uint256)\":{\"params\":{\"newNonce\":\"The new value.\",\"oldNonce\":\"The previous nonce.\"}},\"Revoked(address,address,bytes32,bytes32)\":{\"params\":{\"attester\":\"The attesting account.\",\"recipient\":\"The recipient of the attestation.\",\"schemaUID\":\"The UID of the schema.\",\"uid\":\"The UID the revoked attestation.\"}},\"RevokedOffchain(address,bytes32,uint64)\":{\"params\":{\"data\":\"The data.\",\"revoker\":\"The address of the revoker.\",\"timestamp\":\"The timestamp.\"}},\"Timestamped(bytes32,uint64)\":{\"params\":{\"data\":\"The data.\",\"timestamp\":\"The timestamp.\"}}},\"kind\":\"dev\",\"methods\":{\"attest((bytes32,(address,uint64,bool,bytes32,bytes,uint256)))\":{\"params\":{\"request\":\"The arguments of the attestation request.\"},\"returns\":{\"_0\":\"The UID of the new attestation. Example:     attest({         schema: \\\"0facc36681cbe2456019c1b0d1e7bedd6d1d40f6f324bf3dd3a4cef2999200a0\\\",         data: {             recipient: \\\"0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf\\\",             expirationTime: 0,             revocable: true,             refUID: \\\"0x0000000000000000000000000000000000000000000000000000000000000000\\\",             data: \\\"0xF00D\\\",             value: 0         }     })\"}},\"attestByDelegation((bytes32,(address,uint64,bool,
Download .txt
gitextract_0o9h11kw/

├── .github/
│   └── workflows/
│       └── ci.yml
├── .gitignore
├── .prettierrc
├── .solcover.ts
├── .solhint.json
├── LICENSE
├── README.md
├── components/
│   └── Contracts.ts
├── contracts/
│   ├── Common.sol
│   ├── EAS.sol
│   ├── IEAS.sol
│   ├── ISchemaRegistry.sol
│   ├── ISemver.sol
│   ├── Indexer.sol
│   ├── SchemaRegistry.sol
│   ├── Semver.sol
│   ├── eip1271/
│   │   └── EIP1271Verifier.sol
│   ├── eip712/
│   │   └── proxy/
│   │       ├── EIP712Proxy.sol
│   │       └── examples/
│   │           └── PermissionedEIP712Proxy.sol
│   ├── resolver/
│   │   ├── ISchemaResolver.sol
│   │   ├── SchemaResolver.sol
│   │   └── examples/
│   │       ├── AttestationResolver.sol
│   │       ├── AttesterResolver.sol
│   │       ├── DataResolver.sol
│   │       ├── ExpirationTimeResolver.sol
│   │       ├── PayingResolver.sol
│   │       ├── RecipientResolver.sol
│   │       ├── RevocationResolver.sol
│   │       ├── TokenResolver.sol
│   │       └── ValueResolver.sol
│   └── tests/
│       ├── TestEAS.sol
│       ├── TestERC20Token.sol
│       ├── TestSchemaResolver.sol
│       ├── eip1271/
│       │   ├── TestEIP1271Signer.sol
│       │   └── TestEIP1271Verifier.sol
│       └── eip712/
│           └── proxy/
│               └── TestEIP712Proxy.sol
├── deployments/
│   ├── arbitrum-nova/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── arbitrum-one/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   ├── arbitrum-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── EAS.ts
│   │       │           ├── Indexer.ts
│   │       │           ├── SchemaRegistry.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── EAS__factory.ts
│   │                       ├── Indexer__factory.ts
│   │                       ├── SchemaRegistry__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── base/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── base-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── base-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── celo/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── hardhat/
│   │   └── .chainId
│   ├── ink/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── Indexer__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── ink-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   ├── solcInputs/
│   │   │   └── ab2e55c92b39ec3be86af0608f634927.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── linea/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── linea-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── mainnet/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   ├── optimism/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── optimism-goerli/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── optimism-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── polygon/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── polygon-amoy/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── scroll/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── scroll-sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── sepolia/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   ├── Indexer.ts
│   │       │   ├── SchemaRegistry.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               ├── Indexer__factory.ts
│   │               ├── SchemaRegistry__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── soneium/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── Indexer.ts
│   │       │   └── eip712/
│   │       │       └── proxy/
│   │       │           └── EIP712Proxy.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── Indexer__factory.ts
│   │               └── eip712/
│   │                   └── proxy/
│   │                       └── EIP712Proxy__factory.ts
│   ├── telos/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── EAS.ts
│   │       │           ├── Indexer.ts
│   │       │           ├── SchemaRegistry.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       └── factories/
│   │           └── @ethereum-attestation-service/
│   │               └── eas-contracts/
│   │                   └── contracts/
│   │                       ├── EAS__factory.ts
│   │                       ├── Indexer__factory.ts
│   │                       ├── SchemaRegistry__factory.ts
│   │                       └── eip712/
│   │                           └── proxy/
│   │                               └── EIP712Proxy__factory.ts
│   ├── unichain/
│   │   ├── .chainId
│   │   ├── .migrations.json
│   │   ├── EAS.json
│   │   ├── EIP712Proxy.json
│   │   ├── Indexer.json
│   │   ├── SchemaRegistry.json
│   │   └── types/
│   │       ├── @ethereum-attestation-service/
│   │       │   └── eas-contracts/
│   │       │       └── contracts/
│   │       │           ├── Indexer.ts
│   │       │           └── eip712/
│   │       │               └── proxy/
│   │       │                   └── EIP712Proxy.ts
│   │       ├── contracts/
│   │       │   ├── EAS.ts
│   │       │   └── SchemaRegistry.ts
│   │       └── factories/
│   │           ├── @ethereum-attestation-service/
│   │           │   └── eas-contracts/
│   │           │       └── contracts/
│   │           │           ├── Indexer__factory.ts
│   │           │           └── eip712/
│   │           │               └── proxy/
│   │           │                   └── EIP712Proxy__factory.ts
│   │           └── contracts/
│   │               ├── EAS__factory.ts
│   │               └── SchemaRegistry__factory.ts
│   └── zksync/
│       ├── .chainId
│       ├── .migrations.json
│       ├── EAS.json
│       ├── EIP712Proxy.json
│       ├── Indexer.json
│       ├── SchemaRegistry.json
│       └── types/
│           ├── contracts/
│           │   ├── EAS.ts
│           │   ├── Indexer.ts
│           │   ├── SchemaRegistry.ts
│           │   └── eip712/
│           │       └── proxy/
│           │           └── EIP712Proxy.ts
│           └── factories/
│               └── contracts/
│                   ├── EAS__factory.ts
│                   ├── Indexer__factory.ts
│                   ├── SchemaRegistry__factory.ts
│                   └── eip712/
│                       └── proxy/
│                           └── EIP712Proxy__factory.ts
├── eslint.config.mjs
├── foundry.toml
├── funding.json
├── hardhat.config.ts
├── package.json
├── test/
│   ├── EAS.ts
│   ├── Indexer.ts
│   ├── SchemaRegistry.ts
│   ├── eip1271/
│   │   └── EIP1271Verifier.ts
│   ├── eip712/
│   │   └── proxy/
│   │       ├── EIP712Proxy.ts
│   │       └── PermissionedEIP712Proxy.ts
│   ├── helpers/
│   │   ├── Chai.ts
│   │   ├── EAS.ts
│   │   ├── EIP712ProxyUtils.ts
│   │   ├── EIP712Utils.ts
│   │   ├── Time.ts
│   │   ├── Transaction.ts
│   │   └── Wallet.ts
│   └── resolver/
│       ├── AttestationResolver.ts
│       ├── AttesterResolver.ts
│       ├── DataResolver.ts
│       ├── ExpirationTimeResolver.ts
│       ├── PayingResolver.ts
│       ├── RecipientResolver.ts
│       ├── RevocationResolver.ts
│       ├── SchemaResolver.ts
│       ├── TokenResolver.ts
│       └── ValueResoler.ts
├── tsconfig.json
├── tsconfig.release.json
└── utils/
    ├── Constants.ts
    ├── EAS.ts
    ├── Logger.ts
    └── Time.ts
Download .txt
Showing preview only (252K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2807 symbols across 184 files)

FILE: components/Contracts.ts
  type AsyncReturnType (line 27) | type AsyncReturnType<T extends (...args: any) => any> = T extends (...ar...
  type Contract (line 33) | type Contract<F extends ContractFactory> = AsyncReturnType<F['deploy']>;
  type ContractBuilder (line 35) | interface ContractBuilder<F extends ContractFactory> {
  type FactoryConstructor (line 43) | type FactoryConstructor<F extends ContractFactory> = {

FILE: deployments/arbitrum-nova/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/arbitrum-nova/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/arbitrum-nova/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/arbitrum-nova/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/arbitrum-nova/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/arbitrum-nova/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/arbitrum-nova/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/arbitrum-nova/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/arbitrum-one/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 456) | interface AttestedEventObject {
  type AttestedEvent (line 462) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 467) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 469) | interface RevokedEventObject {
  type RevokedEvent (line 475) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 480) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 482) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 487) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 492) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 494) | interface TimestampedEventObject {
  type TimestampedEvent (line 498) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 503) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 505) | interface EAS extends BaseContract {

FILE: deployments/arbitrum-one/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/arbitrum-one/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1033) | type EASConstructorParams =
  class EAS__factory (line 1041) | class EAS__factory extends ContractFactory {
    method constructor (line 1042) | constructor(...args: EASConstructorParams) {
    method deploy (line 1050) | override deploy(
    method getDeployTransaction (line 1056) | override getDeployTransaction(
    method attach (line 1062) | override attach(address: string): EAS {
    method connect (line 1065) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1071) | static createInterface(): EASInterface {
    method connect (line 1074) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/arbitrum-one/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/EAS__factory.ts
  type EASConstructorParams (line 1202) | type EASConstructorParams =
  class EAS__factory (line 1210) | class EAS__factory extends ContractFactory {
    method constructor (line 1211) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1219) | override getDeployTransaction(
    method deploy (line 1225) | override deploy(
    method connect (line 1235) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1241) | static createInterface(): EASInterface {
    method connect (line 1244) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 390) | type IndexerConstructorParams =
  class Indexer__factory (line 398) | class Indexer__factory extends ContractFactory {
    method constructor (line 399) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 407) | override getDeployTransaction(
    method deploy (line 413) | override deploy(
    method connect (line 423) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 429) | static createInterface(): IndexerInterface {
    method connect (line 432) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 596) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 604) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 605) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 613) | override getDeployTransaction(
    method deploy (line 620) | override deploy(
    method connect (line 631) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 637) | static createInterface(): EIP712ProxyInterface {
    method connect (line 640) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/base-goerli/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 460) | interface AttestedEventObject {
  type AttestedEvent (line 466) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 471) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 473) | interface RevokedEventObject {
  type RevokedEvent (line 479) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 484) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 486) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 491) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 496) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 498) | interface TimestampedEventObject {
  type TimestampedEvent (line 502) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 507) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 509) | interface EAS extends BaseContract {

FILE: deployments/base-goerli/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/base-goerli/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/base-goerli/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/base-goerli/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1046) | type EASConstructorParams =
  class EAS__factory (line 1054) | class EAS__factory extends ContractFactory {
    method constructor (line 1055) | constructor(...args: EASConstructorParams) {
    method deploy (line 1063) | override deploy(
    method getDeployTransaction (line 1069) | override getDeployTransaction(
    method attach (line 1075) | override attach(address: string): EAS {
    method connect (line 1078) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1084) | static createInterface(): EASInterface {
    method connect (line 1087) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/base-goerli/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/base-goerli/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/base-goerli/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/base-sepolia/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 460) | interface AttestedEventObject {
  type AttestedEvent (line 466) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 471) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 473) | interface RevokedEventObject {
  type RevokedEvent (line 479) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 484) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 486) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 491) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 496) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 498) | interface TimestampedEventObject {
  type TimestampedEvent (line 502) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 507) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 509) | interface EAS extends BaseContract {

FILE: deployments/base-sepolia/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/base-sepolia/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/base-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/base-sepolia/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1046) | type EASConstructorParams =
  class EAS__factory (line 1054) | class EAS__factory extends ContractFactory {
    method constructor (line 1055) | constructor(...args: EASConstructorParams) {
    method deploy (line 1063) | override deploy(
    method getDeployTransaction (line 1069) | override getDeployTransaction(
    method attach (line 1075) | override attach(address: string): EAS {
    method connect (line 1078) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1084) | static createInterface(): EASInterface {
    method connect (line 1087) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/base-sepolia/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/base-sepolia/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/base-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/base/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/base/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/base/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/base/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/celo/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/celo/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/celo/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/celo/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/celo/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/celo/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/celo/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/celo/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/ink-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/ink-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/ink-sepolia/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 460) | interface AttestedEventObject {
  type AttestedEvent (line 466) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 471) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 473) | interface RevokedEventObject {
  type RevokedEvent (line 479) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 484) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 486) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 491) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 496) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 498) | interface TimestampedEventObject {
  type TimestampedEvent (line 502) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 507) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 509) | interface EAS extends BaseContract {

FILE: deployments/ink-sepolia/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/ink-sepolia/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/ink-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/ink-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 390) | type IndexerConstructorParams =
  class Indexer__factory (line 398) | class Indexer__factory extends ContractFactory {
    method constructor (line 399) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 407) | override getDeployTransaction(
    method deploy (line 413) | override deploy(
    method connect (line 423) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 429) | static createInterface(): IndexerInterface {
    method connect (line 432) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/ink-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 596) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 604) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 605) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 613) | override getDeployTransaction(
    method deploy (line 620) | override deploy(
    method connect (line 631) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 637) | static createInterface(): EIP712ProxyInterface {
    method connect (line 640) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/ink-sepolia/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1046) | type EASConstructorParams =
  class EAS__factory (line 1054) | class EAS__factory extends ContractFactory {
    method constructor (line 1055) | constructor(...args: EASConstructorParams) {
    method deploy (line 1063) | override deploy(
    method getDeployTransaction (line 1069) | override getDeployTransaction(
    method attach (line 1075) | override attach(address: string): EAS {
    method connect (line 1078) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1084) | static createInterface(): EASInterface {
    method connect (line 1087) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/ink-sepolia/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/ink-sepolia/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/ink-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/ink/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/ink/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/ink/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 390) | type IndexerConstructorParams =
  class Indexer__factory (line 398) | class Indexer__factory extends ContractFactory {
    method constructor (line 399) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 407) | override getDeployTransaction(
    method deploy (line 413) | override deploy(
    method connect (line 423) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 429) | static createInterface(): IndexerInterface {
    method connect (line 432) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/ink/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 596) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 604) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 605) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 613) | override getDeployTransaction(
    method deploy (line 620) | override deploy(
    method connect (line 631) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 637) | static createInterface(): EIP712ProxyInterface {
    method connect (line 640) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/linea-goerli/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/linea-goerli/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/linea-goerli/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/linea-goerli/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/linea-goerli/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/linea-goerli/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/linea/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/linea/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/linea/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/linea/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/linea/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/linea/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/mainnet/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 456) | interface AttestedEventObject {
  type AttestedEvent (line 462) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 467) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 469) | interface RevokedEventObject {
  type RevokedEvent (line 475) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 480) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 482) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 487) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 492) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 494) | interface TimestampedEventObject {
  type TimestampedEvent (line 498) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 503) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 505) | interface EAS extends BaseContract {

FILE: deployments/mainnet/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/mainnet/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1033) | type EASConstructorParams =
  class EAS__factory (line 1041) | class EAS__factory extends ContractFactory {
    method constructor (line 1042) | constructor(...args: EASConstructorParams) {
    method deploy (line 1050) | override deploy(
    method getDeployTransaction (line 1056) | override getDeployTransaction(
    method attach (line 1062) | override attach(address: string): EAS {
    method connect (line 1065) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1071) | static createInterface(): EASInterface {
    method connect (line 1074) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/mainnet/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/optimism-goerli/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 460) | interface AttestedEventObject {
  type AttestedEvent (line 466) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 471) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 473) | interface RevokedEventObject {
  type RevokedEvent (line 479) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 484) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 486) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 491) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 496) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 498) | interface TimestampedEventObject {
  type TimestampedEvent (line 502) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 507) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 509) | interface EAS extends BaseContract {

FILE: deployments/optimism-goerli/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/optimism-goerli/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/optimism-goerli/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/optimism-goerli/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1046) | type EASConstructorParams =
  class EAS__factory (line 1054) | class EAS__factory extends ContractFactory {
    method constructor (line 1055) | constructor(...args: EASConstructorParams) {
    method deploy (line 1063) | override deploy(
    method getDeployTransaction (line 1069) | override getDeployTransaction(
    method attach (line 1075) | override attach(address: string): EAS {
    method connect (line 1078) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1084) | static createInterface(): EASInterface {
    method connect (line 1087) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/optimism-goerli/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/optimism-goerli/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/optimism-goerli/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/optimism-sepolia/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 460) | interface AttestedEventObject {
  type AttestedEvent (line 466) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 471) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 473) | interface RevokedEventObject {
  type RevokedEvent (line 479) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 484) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 486) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 491) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 496) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 498) | interface TimestampedEventObject {
  type TimestampedEvent (line 502) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 507) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 509) | interface EAS extends BaseContract {

FILE: deployments/optimism-sepolia/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/optimism-sepolia/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/optimism-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/optimism-sepolia/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1046) | type EASConstructorParams =
  class EAS__factory (line 1054) | class EAS__factory extends ContractFactory {
    method constructor (line 1055) | constructor(...args: EASConstructorParams) {
    method deploy (line 1063) | override deploy(
    method getDeployTransaction (line 1069) | override getDeployTransaction(
    method attach (line 1075) | override attach(address: string): EAS {
    method connect (line 1078) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1084) | static createInterface(): EASInterface {
    method connect (line 1087) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/optimism-sepolia/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/optimism-sepolia/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 134) | constructor(...args: SchemaRegistryConstructorParams) {
    method deploy (line 142) | override deploy(
    method getDeployTransaction (line 147) | override getDeployTransaction(
    method attach (line 152) | override attach(address: string): SchemaRegistry {
    method connect (line 155) | override connect(signer: Signer): SchemaRegistry__factory {
    method createInterface (line 161) | static createInterface(): SchemaRegistryInterface {
    method connect (line 164) | static connect(

FILE: deployments/optimism-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/optimism/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/optimism/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/optimism/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/optimism/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/polygon-amoy/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/polygon-amoy/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/polygon-amoy/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/polygon-amoy/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/polygon-amoy/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1199) | type EASConstructorParams =
  class EAS__factory (line 1207) | class EAS__factory extends ContractFactory {
    method constructor (line 1208) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1216) | override getDeployTransaction(
    method deploy (line 1222) | override deploy(
    method connect (line 1232) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1238) | static createInterface(): EASInterface {
    method connect (line 1241) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/polygon-amoy/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/polygon-amoy/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/polygon-amoy/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 596) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 604) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 605) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 613) | override getDeployTransaction(
    method deploy (line 620) | override deploy(
    method connect (line 631) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 637) | static createInterface(): EIP712ProxyInterface {
    method connect (line 640) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/polygon/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/polygon/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/polygon/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/polygon/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/polygon/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/polygon/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/polygon/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/polygon/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/scroll-sepolia/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/scroll-sepolia/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/scroll-sepolia/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/scroll-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/scroll-sepolia/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/scroll-sepolia/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/scroll-sepolia/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/scroll-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/scroll/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 51) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 56) | type AttestationRequestStructOutput = [
  type SignatureStruct (line 61) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 63) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedAttestationRequestStruct (line 69) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 77) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 91) | type AttestationStruct = {
  type AttestationStructOutput (line 104) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 128) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 133) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 138) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 146) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 160) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 165) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiRevocationRequestStruct (line 170) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 175) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 180) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 188) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 220) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 234) | interface EASInterface extends Interface {
  type InputTuple (line 454) | type InputTuple = [
  type OutputTuple (line 460) | type OutputTuple = [
  type OutputObject (line 466) | interface OutputObject {
  type Event (line 472) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 473) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 474) | type Log = TypedEventLog<Event>;
  type LogDescription (line 475) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 479) | type InputTuple = [];
  type OutputTuple (line 480) | type OutputTuple = [];
  type OutputObject (line 481) | interface OutputObject {}
  type Event (line 482) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 483) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 484) | type Log = TypedEventLog<Event>;
  type LogDescription (line 485) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 489) | type InputTuple = [oldNonce: BigNumberish, newNonce: BigNumberish];
  type OutputTuple (line 490) | type OutputTuple = [oldNonce: bigint, newNonce: bigint];
  type OutputObject (line 491) | interface OutputObject {
  type Event (line 495) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 496) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 497) | type Log = TypedEventLog<Event>;
  type LogDescription (line 498) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 502) | type InputTuple = [
  type OutputTuple (line 508) | type OutputTuple = [
  type OutputObject (line 514) | interface OutputObject {
  type Event (line 520) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 521) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 522) | type Log = TypedEventLog<Event>;
  type LogDescription (line 523) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 527) | type InputTuple = [
  type OutputTuple (line 532) | type OutputTuple = [revoker: string, data: string, timestamp: bigint];
  type OutputObject (line 533) | interface OutputObject {
  type Event (line 538) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 539) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 540) | type Log = TypedEventLog<Event>;
  type LogDescription (line 541) | type LogDescription = TypedLogDescription<Event>;
  type InputTuple (line 545) | type InputTuple = [data: BytesLike, timestamp: BigNumberish];
  type OutputTuple (line 546) | type OutputTuple = [data: string, timestamp: bigint];
  type OutputObject (line 547) | interface OutputObject {
  type Event (line 551) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 552) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 553) | type Log = TypedEventLog<Event>;
  type LogDescription (line 554) | type LogDescription = TypedLogDescription<Event>;
  type EAS (line 557) | interface EAS extends BaseContract {

FILE: deployments/scroll/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/scroll/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 25) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 32) | type SchemaRecordStructOutput = [
  type SchemaRegistryInterface (line 39) | interface SchemaRegistryInterface extends Interface {
  type InputTuple (line 62) | type InputTuple = [
  type OutputTuple (line 67) | type OutputTuple = [
  type OutputObject (line 72) | interface OutputObject {
  type Event (line 77) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 78) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 79) | type Log = TypedEventLog<Event>;
  type LogDescription (line 80) | type LogDescription = TypedLogDescription<Event>;
  type SchemaRegistry (line 83) | interface SchemaRegistry extends BaseContract {

FILE: deployments/scroll/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/scroll/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1183) | type EASConstructorParams =
  class EAS__factory (line 1191) | class EAS__factory extends ContractFactory {
    method constructor (line 1192) | constructor(...args: EASConstructorParams) {
    method getDeployTransaction (line 1200) | override getDeployTransaction(
    method deploy (line 1206) | override deploy(
    method connect (line 1216) | override connect(runner: ContractRunner | null): EAS__factory {
    method createInterface (line 1222) | static createInterface(): EASInterface {
    method connect (line 1225) | static connect(address: string, runner?: ContractRunner | null): EAS {

FILE: deployments/scroll/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/scroll/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 163) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 171) | class SchemaRegistry__factory extends ContractFactory {
    method constructor (line 172) | constructor(...args: SchemaRegistryConstructorParams) {
    method getDeployTransaction (line 180) | override getDeployTransaction(
    method deploy (line 185) | override deploy(overrides?: NonPayableOverrides & { from?: string }) {
    method connect (line 192) | override connect(runner: ContractRunner | null): SchemaRegistry__facto...
    method createInterface (line 198) | static createInterface(): SchemaRegistryInterface {
    method connect (line 201) | static connect(

FILE: deployments/scroll/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts
  type EIP712ProxyConstructorParams (line 569) | type EIP712ProxyConstructorParams =
  class EIP712Proxy__factory (line 577) | class EIP712Proxy__factory extends ContractFactory {
    method constructor (line 578) | constructor(...args: EIP712ProxyConstructorParams) {
    method getDeployTransaction (line 586) | override getDeployTransaction(
    method deploy (line 593) | override deploy(
    method connect (line 604) | override connect(runner: ContractRunner | null): EIP712Proxy__factory {
    method createInterface (line 610) | static createInterface(): EIP712ProxyInterface {
    method connect (line 613) | static connect(address: string, runner?: ContractRunner | null): EIP71...

FILE: deployments/sepolia/types/contracts/EAS.ts
  type AttestationRequestDataStruct (line 31) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 40) | type AttestationRequestDataStructOutput = [
  type AttestationRequestStruct (line 56) | type AttestationRequestStruct = {
  type AttestationRequestStructOutput (line 61) | type AttestationRequestStructOutput = [
  type EIP712SignatureStruct (line 66) | type EIP712SignatureStruct = {
  type EIP712SignatureStructOutput (line 72) | type EIP712SignatureStructOutput = [number, string, string] & {
  type DelegatedAttestationRequestStruct (line 78) | type DelegatedAttestationRequestStruct = {
  type DelegatedAttestationRequestStructOutput (line 85) | type DelegatedAttestationRequestStructOutput = [
  type AttestationStruct (line 97) | type AttestationStruct = {
  type AttestationStructOutput (line 110) | type AttestationStructOutput = [
  type MultiAttestationRequestStruct (line 134) | type MultiAttestationRequestStruct = {
  type MultiAttestationRequestStructOutput (line 139) | type MultiAttestationRequestStructOutput = [
  type MultiDelegatedAttestationRequestStruct (line 144) | type MultiDelegatedAttestationRequestStruct = {
  type MultiDelegatedAttestationRequestStructOutput (line 151) | type MultiDelegatedAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 163) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 168) | type RevocationRequestDataStructOutput = [string, BigNumber] & {
  type MultiRevocationRequestStruct (line 173) | type MultiRevocationRequestStruct = {
  type MultiRevocationRequestStructOutput (line 178) | type MultiRevocationRequestStructOutput = [
  type MultiDelegatedRevocationRequestStruct (line 183) | type MultiDelegatedRevocationRequestStruct = {
  type MultiDelegatedRevocationRequestStructOutput (line 190) | type MultiDelegatedRevocationRequestStructOutput = [
  type RevocationRequestStruct (line 202) | type RevocationRequestStruct = {
  type RevocationRequestStructOutput (line 207) | type RevocationRequestStructOutput = [
  type DelegatedRevocationRequestStruct (line 212) | type DelegatedRevocationRequestStruct = {
  type DelegatedRevocationRequestStructOutput (line 219) | type DelegatedRevocationRequestStructOutput = [
  type EASInterface (line 231) | interface EASInterface extends utils.Interface {
  type AttestedEventObject (line 456) | interface AttestedEventObject {
  type AttestedEvent (line 462) | type AttestedEvent = TypedEvent<
  type AttestedEventFilter (line 467) | type AttestedEventFilter = TypedEventFilter<AttestedEvent>;
  type RevokedEventObject (line 469) | interface RevokedEventObject {
  type RevokedEvent (line 475) | type RevokedEvent = TypedEvent<
  type RevokedEventFilter (line 480) | type RevokedEventFilter = TypedEventFilter<RevokedEvent>;
  type RevokedOffchainEventObject (line 482) | interface RevokedOffchainEventObject {
  type RevokedOffchainEvent (line 487) | type RevokedOffchainEvent = TypedEvent<
  type RevokedOffchainEventFilter (line 492) | type RevokedOffchainEventFilter = TypedEventFilter<RevokedOffchainEvent>;
  type TimestampedEventObject (line 494) | interface TimestampedEventObject {
  type TimestampedEvent (line 498) | type TimestampedEvent = TypedEvent<
  type TimestampedEventFilter (line 503) | type TimestampedEventFilter = TypedEventFilter<TimestampedEvent>;
  type EAS (line 505) | interface EAS extends BaseContract {

FILE: deployments/sepolia/types/contracts/Indexer.ts
  type IndexerInterface (line 26) | interface IndexerInterface extends Interface {
  type InputTuple (line 149) | type InputTuple = [uid: BytesLike];
  type OutputTuple (line 150) | type OutputTuple = [uid: string];
  type OutputObject (line 151) | interface OutputObject {
  type Event (line 154) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 155) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 156) | type Log = TypedEventLog<Event>;
  type LogDescription (line 157) | type LogDescription = TypedLogDescription<Event>;
  type Indexer (line 160) | interface Indexer extends BaseContract {

FILE: deployments/sepolia/types/contracts/SchemaRegistry.ts
  type SchemaRecordStruct (line 29) | type SchemaRecordStruct = {
  type SchemaRecordStructOutput (line 36) | type SchemaRecordStructOutput = [string, string, boolean, string] & {
  type SchemaRegistryInterface (line 43) | interface SchemaRegistryInterface extends utils.Interface {
  type RegisteredEventObject (line 79) | interface RegisteredEventObject {
  type RegisteredEvent (line 83) | type RegisteredEvent = TypedEvent<
  type RegisteredEventFilter (line 88) | type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
  type SchemaRegistry (line 90) | interface SchemaRegistry extends BaseContract {

FILE: deployments/sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts
  type AttestationRequestDataStruct (line 26) | type AttestationRequestDataStruct = {
  type AttestationRequestDataStructOutput (line 35) | type AttestationRequestDataStructOutput = [
  type SignatureStruct (line 51) | type SignatureStruct = { v: BigNumberish; r: BytesLike; s: BytesLike };
  type SignatureStructOutput (line 53) | type SignatureStructOutput = [v: bigint, r: string, s: string] & {
  type DelegatedProxyAttestationRequestStruct (line 59) | type DelegatedProxyAttestationRequestStruct = {
  type DelegatedProxyAttestationRequestStructOutput (line 67) | type DelegatedProxyAttestationRequestStructOutput = [
  type MultiDelegatedProxyAttestationRequestStruct (line 81) | type MultiDelegatedProxyAttestationRequestStruct = {
  type MultiDelegatedProxyAttestationRequestStructOutput (line 89) | type MultiDelegatedProxyAttestationRequestStructOutput = [
  type RevocationRequestDataStruct (line 103) | type RevocationRequestDataStruct = {
  type RevocationRequestDataStructOutput (line 108) | type RevocationRequestDataStructOutput = [uid: string, value: bigint] & {
  type MultiDelegatedProxyRevocationRequestStruct (line 113) | type MultiDelegatedProxyRevocationRequestStruct = {
  type MultiDelegatedProxyRevocationRequestStructOutput (line 121) | type MultiDelegatedProxyRevocationRequestStructOutput = [
  type DelegatedProxyRevocationRequestStruct (line 135) | type DelegatedProxyRevocationRequestStruct = {
  type DelegatedProxyRevocationRequestStructOutput (line 143) | type DelegatedProxyRevocationRequestStructOutput = [
  type EIP712ProxyInterface (line 157) | interface EIP712ProxyInterface extends Interface {
  type InputTuple (line 258) | type InputTuple = [];
  type OutputTuple (line 259) | type OutputTuple = [];
  type OutputObject (line 260) | interface OutputObject {}
  type Event (line 261) | type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
  type Filter (line 262) | type Filter = TypedDeferredTopicFilter<Event>;
  type Log (line 263) | type Log = TypedEventLog<Event>;
  type LogDescription (line 264) | type LogDescription = TypedLogDescription<Event>;
  type EIP712Proxy (line 267) | interface EIP712Proxy extends BaseContract {

FILE: deployments/sepolia/types/factories/contracts/EAS__factory.ts
  type EASConstructorParams (line 1033) | type EASConstructorParams =
  class EAS__factory (line 1041) | class EAS__factory extends ContractFactory {
    method constructor (line 1042) | constructor(...args: EASConstructorParams) {
    method deploy (line 1050) | override deploy(
    method getDeployTransaction (line 1056) | override getDeployTransaction(
    method attach (line 1062) | override attach(address: string): EAS {
    method connect (line 1065) | override connect(signer: Signer): EAS__factory {
    method createInterface (line 1071) | static createInterface(): EASInterface {
    method connect (line 1074) | static connect(address: string, signerOrProvider: Signer | Provider): ...

FILE: deployments/sepolia/types/factories/contracts/Indexer__factory.ts
  type IndexerConstructorParams (line 387) | type IndexerConstructorParams =
  class Indexer__factory (line 395) | class Indexer__factory extends ContractFactory {
    method constructor (line 396) | constructor(...args: IndexerConstructorParams) {
    method getDeployTransaction (line 404) | override getDeployTransaction(
    method deploy (line 410) | override deploy(
    method connect (line 420) | override connect(runner: ContractRunner | null): Indexer__factory {
    method createInterface (line 426) | static createInterface(): IndexerInterface {
    method connect (line 429) | static connect(address: string, runner?: ContractRunner | null): Index...

FILE: deployments/sepolia/types/factories/contracts/SchemaRegistry__factory.ts
  type SchemaRegistryConstructorParams (line 125) | type SchemaRegistryConstructorParams =
  class SchemaRegistry__factory (line 133) | class SchemaRegis
Copy disabled (too large) Download .json
Condensed preview — 382 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (16,227K chars).
[
  {
    "path": ".github/workflows/ci.yml",
    "chars": 1024,
    "preview": "name: CI\n\non:\n  workflow_dispatch:\n  push:\n    branches:\n      - master\n  pull_request:\n\njobs:\n  test:\n    name: Test\n\n "
  },
  {
    "path": ".gitignore",
    "chars": 1097,
    "preview": ".DS_Store\n.vscode/\n*/**/.DS_Store\n\n/node_modules\n\ndist\ncache\nartifacts\ntypechain-types\ncache-zk\nartifacts-zk\ndeployments"
  },
  {
    "path": ".prettierrc",
    "chars": 467,
    "preview": "{\n  \"plugins\": [\"@ianvs/prettier-plugin-sort-imports\", \"prettier-package-json\", \"prettier-plugin-solidity\"],\n  \"override"
  },
  {
    "path": ".solcover.ts",
    "chars": 45,
    "preview": "module.exports = {\n  skipFiles: ['tests']\n};\n"
  },
  {
    "path": ".solhint.json",
    "chars": 449,
    "preview": "{\n  \"extends\": \"solhint:recommended\",\n  \"rules\": {\n    \"avoid-throw\": \"off\",\n    \"avoid-suicide\": \"error\",\n    \"avoid-sh"
  },
  {
    "path": "LICENSE",
    "chars": 1070,
    "preview": "MIT License\n\nCopyright (c) 2020 Leonid Beder\n\nPermission is hereby granted, free of charge, to any person obtaining a co"
  },
  {
    "path": "README.md",
    "chars": 28201,
    "preview": "# Ethereum Attestation Service\n\n[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://eas.eth.link)\n[!["
  },
  {
    "path": "components/Contracts.ts",
    "chars": 3761,
    "preview": "import { ContractFactory, Signer } from 'ethers';\nimport { ethers } from 'hardhat';\nimport {\n  AttestationResolver__fact"
  },
  {
    "path": "contracts/Common.sol",
    "chars": 1323,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// A representation of an empty/uninitialized UID.\nbytes32 con"
  },
  {
    "path": "contracts/EAS.sol",
    "chars": 29265,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { Address } from \"@openzeppelin/contracts/utils/Address"
  },
  {
    "path": "contracts/IEAS.sol",
    "chars": 16921,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport { ISchemaRegistry } from \"./ISchemaRegistry.sol\";\nimpor"
  },
  {
    "path": "contracts/ISchemaRegistry.sol",
    "chars": 1613,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport { ISemver } from \"./ISemver.sol\";\n\nimport { ISchemaReso"
  },
  {
    "path": "contracts/ISemver.sol",
    "chars": 304,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title ISemver\n/// @notice A semver interface.\ninterface I"
  },
  {
    "path": "contracts/Indexer.sol",
    "chars": 10440,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { IEAS, Attestation } from \"./IEAS.sol\";\nimport { EMPTY"
  },
  {
    "path": "contracts/SchemaRegistry.sol",
    "chars": 1781,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { ISchemaResolver } from \"./resolver/ISchemaResolver.so"
  },
  {
    "path": "contracts/Semver.sol",
    "chars": 1183,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport { Strings } from \"@openzeppelin/contracts/utils/Strings"
  },
  {
    "path": "contracts/eip1271/EIP1271Verifier.sol",
    "chars": 6526,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { Address } from \"@openzeppelin/contracts/utils/Address"
  },
  {
    "path": "contracts/eip712/proxy/EIP712Proxy.sol",
    "chars": 18137,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { EIP712 } from \"@openzeppelin/contracts/utils/cryptogr"
  },
  {
    "path": "contracts/eip712/proxy/examples/PermissionedEIP712Proxy.sol",
    "chars": 2960,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { Ownable, Ownable2Step } from \"@openzeppelin/contracts"
  },
  {
    "path": "contracts/resolver/ISchemaResolver.sol",
    "chars": 1871,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport { Attestation } from \"./../Common.sol\";\nimport { ISemve"
  },
  {
    "path": "contracts/resolver/SchemaResolver.sol",
    "chars": 6125,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport { AccessDenied, InvalidEAS, InvalidLength } from \"./../"
  },
  {
    "path": "contracts/resolver/examples/AttestationResolver.sol",
    "chars": 1706,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/AttesterResolver.sol",
    "chars": 839,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/DataResolver.sol",
    "chars": 907,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/ExpirationTimeResolver.sol",
    "chars": 848,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/PayingResolver.sol",
    "chars": 1323,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { Address } from \"@openzeppelin/contracts/utils/Address"
  },
  {
    "path": "contracts/resolver/examples/RecipientResolver.sol",
    "chars": 846,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/RevocationResolver.sol",
    "chars": 782,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/resolver/examples/TokenResolver.sol",
    "chars": 1283,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IE"
  },
  {
    "path": "contracts/resolver/examples/ValueResolver.sol",
    "chars": 904,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { SchemaResolver } from \"../SchemaResolver.sol\";\n\nimpor"
  },
  {
    "path": "contracts/tests/TestEAS.sol",
    "chars": 655,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { EAS } from \"../EAS.sol\";\n\nimport { ISchemaRegistry } "
  },
  {
    "path": "contracts/tests/TestERC20Token.sol",
    "chars": 314,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC"
  },
  {
    "path": "contracts/tests/TestSchemaResolver.sol",
    "chars": 570,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { IEAS, Attestation } from \"./../IEAS.sol\";\nimport { Sc"
  },
  {
    "path": "contracts/tests/eip1271/TestEIP1271Signer.sol",
    "chars": 855,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { IERC1271 } from \"@openzeppelin/contracts/interfaces/I"
  },
  {
    "path": "contracts/tests/eip1271/TestEIP1271Verifier.sol",
    "chars": 646,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { EIP1271Verifier } from \"../../eip1271/EIP1271Verifier"
  },
  {
    "path": "contracts/tests/eip712/proxy/TestEIP712Proxy.sol",
    "chars": 602,
    "preview": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.28;\n\nimport { IEAS } from \"../../../IEAS.sol\";\nimport { EIP712Proxy"
  },
  {
    "path": "deployments/arbitrum-nova/.chainId",
    "chars": 6,
    "preview": "42170\n"
  },
  {
    "path": "deployments/arbitrum-nova/.migrations.json",
    "chars": 226,
    "preview": "{\n  \"000001-registry\": 1706812884,\n  \"000002-eas\": 1706812886,\n  \"000003-register-initial-schemas\": 1706812965,\n  \"00000"
  },
  {
    "path": "deployments/arbitrum-nova/EAS.json",
    "chars": 281129,
    "preview": "{\n  \"address\": \"0x6d3dC0Fe5351087E3Af3bDe8eB3F7350ed894fc3\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-nova/EIP712Proxy.json",
    "chars": 171749,
    "preview": "{\n  \"address\": \"0xEbf2DeeD690F8A68b8248d6a12231ee70ED2154A\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-nova/Indexer.json",
    "chars": 103082,
    "preview": "{\n  \"address\": \"0x7182Be5e84aFEe9Dc29C69D081F8A0FA834d6CB8\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-nova/SchemaRegistry.json",
    "chars": 51178,
    "preview": "{\n  \"address\": \"0x49563d0DA8DF38ef2eBF9C1167270334D72cE0AE\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/arbitrum-nova/types/contracts/EAS.ts",
    "chars": 25404,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-nova/types/contracts/Indexer.ts",
    "chars": 10898,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-nova/types/contracts/SchemaRegistry.ts",
    "chars": 4872,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-nova/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-nova/types/factories/contracts/EAS__factory.ts",
    "chars": 65930,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-nova/types/factories/contracts/Indexer__factory.ts",
    "chars": 17540,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-nova/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 10174,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-nova/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37040,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-one/.chainId",
    "chars": 6,
    "preview": "42161\n"
  },
  {
    "path": "deployments/arbitrum-one/.migrations.json",
    "chars": 157,
    "preview": "{\n  \"000001-registry\": 1677352373,\n  \"000002-eas\": 1677352375,\n  \"000003-register-initial-schemas\": 1677352432,\n  \"00000"
  },
  {
    "path": "deployments/arbitrum-one/EAS.json",
    "chars": 248409,
    "preview": "{\n  \"address\": \"0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-one/SchemaRegistry.json",
    "chars": 25056,
    "preview": "{\n  \"address\": \"0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"name\": \"Already"
  },
  {
    "path": "deployments/arbitrum-one/types/contracts/EAS.ts",
    "chars": 31316,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-one/types/contracts/SchemaRegistry.ts",
    "chars": 5431,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-one/types/factories/contracts/EAS__factory.ts",
    "chars": 64046,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/arbitrum-one/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 7925,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/arbitrum-sepolia/.chainId",
    "chars": 7,
    "preview": "421614\n"
  },
  {
    "path": "deployments/arbitrum-sepolia/.migrations.json",
    "chars": 112,
    "preview": "{\n  \"000001-registry\": 1737155407,\n  \"000002-eas\": 1737155413,\n  \"000003-register-initial-schemas\": 1737155813\n}"
  },
  {
    "path": "deployments/arbitrum-sepolia/EAS.json",
    "chars": 286213,
    "preview": "{\n  \"address\": \"0x2521021fc8BF070473E1e1801D3c7B4aB701E1dE\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-sepolia/EIP712Proxy.json",
    "chars": 179725,
    "preview": "{\n  \"address\": \"0x8E807011c16E538B2dEEf1dc652EFe7724E09397\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-sepolia/Indexer.json",
    "chars": 106592,
    "preview": "{\n  \"address\": \"0x501D6d86240De5A57E91414356ad4B1778F0AB18\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/arbitrum-sepolia/SchemaRegistry.json",
    "chars": 54716,
    "preview": "{\n  \"address\": \"0x45CB6Fa0870a8Af06796Ac15915619a0f22cd475\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/EAS.ts",
    "chars": 25410,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts",
    "chars": 10904,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/SchemaRegistry.ts",
    "chars": 4878,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12217,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/EAS__factory.ts",
    "chars": 66185,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts",
    "chars": 17685,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/SchemaRegistry__factory.ts",
    "chars": 10326,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/arbitrum-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37317,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base/.chainId",
    "chars": 5,
    "preview": "8453\n"
  },
  {
    "path": "deployments/base/.migrations.json",
    "chars": 226,
    "preview": "{\n  \"000001-registry\": 1682454805,\n  \"000002-eas\": 1682454812,\n  \"000003-register-initial-schemas\": 1694192651,\n  \"00000"
  },
  {
    "path": "deployments/base/EAS.json",
    "chars": 27429,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base/EIP712Proxy.json",
    "chars": 170582,
    "preview": "{\n  \"address\": \"0xF095fE4b23958b08D38e52d5d5674bBF0C03cbF6\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base/Indexer.json",
    "chars": 102083,
    "preview": "{\n  \"address\": \"0x37AC6006646f2e687B7fB379F549Dc7634dF5b84\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base/SchemaRegistry.json",
    "chars": 3232,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/base/types/contracts/Indexer.ts",
    "chars": 10850,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base/types/factories/contracts/Indexer__factory.ts",
    "chars": 17516,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 36958,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base-goerli/.chainId",
    "chars": 5,
    "preview": "84531"
  },
  {
    "path": "deployments/base-goerli/.migrations.json",
    "chars": 261,
    "preview": "{\n  \"000001-registry\": 1684880484,\n  \"000002-eas\": 1684880493,\n  \"000003-register-initial-schemas\": 1697138912,\n  \"00000"
  },
  {
    "path": "deployments/base-goerli/EAS.json",
    "chars": 27429,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-goerli/EIP712Proxy.json",
    "chars": 170583,
    "preview": "{\n  \"address\": \"0x37AC6006646f2e687B7fB379F549Dc7634dF5b84\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-goerli/Indexer.json",
    "chars": 102084,
    "preview": "{\n  \"address\": \"0xE0893F47009776D6aEC3De8455Cb0ed325Eea74a\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-goerli/SchemaRegistry.json",
    "chars": 3232,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/base-goerli/types/contracts/EAS.ts",
    "chars": 31833,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-goerli/types/contracts/Indexer.ts",
    "chars": 10850,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-goerli/types/contracts/SchemaRegistry.ts",
    "chars": 5431,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-goerli/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-goerli/types/factories/contracts/EAS__factory.ts",
    "chars": 58082,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/base-goerli/types/factories/contracts/Indexer__factory.ts",
    "chars": 17516,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base-goerli/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 8011,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/base-goerli/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 36958,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base-sepolia/.chainId",
    "chars": 6,
    "preview": "84532\n"
  },
  {
    "path": "deployments/base-sepolia/.migrations.json",
    "chars": 260,
    "preview": "{\n  \"000001-registry\": 1684880484,\n  \"000002-eas\": 1684880493,\n  \"000003-register-initial-schemas\": 1706273944,\n  \"00000"
  },
  {
    "path": "deployments/base-sepolia/EAS.json",
    "chars": 27429,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-sepolia/EIP712Proxy.json",
    "chars": 171748,
    "preview": "{\n  \"address\": \"0xAd64A04c20dDBbA7cBb0EcAe4823095B4adA5c57\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-sepolia/Indexer.json",
    "chars": 103080,
    "preview": "{\n  \"address\": \"0x2C7BCE69D5Ee84EF73CC9286416F68E60F9A61b3\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/base-sepolia/SchemaRegistry.json",
    "chars": 3232,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/base-sepolia/types/contracts/EAS.ts",
    "chars": 31833,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-sepolia/types/contracts/Indexer.ts",
    "chars": 10898,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-sepolia/types/contracts/SchemaRegistry.ts",
    "chars": 5431,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/base-sepolia/types/factories/contracts/EAS__factory.ts",
    "chars": 58082,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/base-sepolia/types/factories/contracts/Indexer__factory.ts",
    "chars": 17540,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/base-sepolia/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 8011,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/base-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37040,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/celo/.chainId",
    "chars": 5,
    "preview": "42220"
  },
  {
    "path": "deployments/celo/.migrations.json",
    "chars": 226,
    "preview": "{\n  \"000001-registry\": 1710900693,\n  \"000002-eas\": 1710900707,\n  \"000003-register-initial-schemas\": 1710901215,\n  \"00000"
  },
  {
    "path": "deployments/celo/EAS.json",
    "chars": 281130,
    "preview": "{\n  \"address\": \"0x72E1d8ccf5299fb36fEfD8CC4394B8ef7e98Af92\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/celo/EIP712Proxy.json",
    "chars": 171749,
    "preview": "{\n  \"address\": \"0x6792B6AE17c6416016b943585e957a29bc452806\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/celo/Indexer.json",
    "chars": 103081,
    "preview": "{\n  \"address\": \"0x76591b332d0F099E89FA335fC827D44C47705D2f\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/celo/SchemaRegistry.json",
    "chars": 51180,
    "preview": "{\n  \"address\": \"0x5ece93bE4BDCF293Ed61FA78698B594F2135AF34\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/celo/types/contracts/EAS.ts",
    "chars": 25404,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/celo/types/contracts/Indexer.ts",
    "chars": 10898,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/celo/types/contracts/SchemaRegistry.ts",
    "chars": 4872,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/celo/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/celo/types/factories/contracts/EAS__factory.ts",
    "chars": 65930,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/celo/types/factories/contracts/Indexer__factory.ts",
    "chars": 17540,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/celo/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 10174,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/celo/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37040,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/hardhat/.chainId",
    "chars": 6,
    "preview": "31337\n"
  },
  {
    "path": "deployments/ink/.chainId",
    "chars": 6,
    "preview": "57073\n"
  },
  {
    "path": "deployments/ink/.migrations.json",
    "chars": 226,
    "preview": "{\n  \"000001-registry\": 1682454805,\n  \"000002-eas\": 1682454812,\n  \"000003-register-initial-schemas\": 1739761699,\n  \"00000"
  },
  {
    "path": "deployments/ink/EAS.json",
    "chars": 24554,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/ink/EIP712Proxy.json",
    "chars": 179723,
    "preview": "{\n  \"address\": \"0x6511967899445c5944f555Fe2B2D5EC4D74d2579\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/ink/Indexer.json",
    "chars": 106590,
    "preview": "{\n  \"address\": \"0xd87dCB0E5E0044Ba5Aa57D383cd3f8D0509a42b9\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/ink/SchemaRegistry.json",
    "chars": 2496,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/ink/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts",
    "chars": 10904,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12217,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts",
    "chars": 17685,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/ink/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37317,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/ink-sepolia/.chainId",
    "chars": 7,
    "preview": "763373\n"
  },
  {
    "path": "deployments/ink-sepolia/.migrations.json",
    "chars": 261,
    "preview": "{\n  \"000001-registry\": 1682454805,\n  \"000002-eas\": 1682454812,\n  \"000003-register-initial-schemas\": 1732802675,\n  \"00000"
  },
  {
    "path": "deployments/ink-sepolia/EAS.json",
    "chars": 24554,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/ink-sepolia/EIP712Proxy.json",
    "chars": 179723,
    "preview": "{\n  \"address\": \"0x79369eEe29e7e191F5a6278185eA4a0D906b9b9F\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/ink-sepolia/Indexer.json",
    "chars": 106590,
    "preview": "{\n  \"address\": \"0x367A20665BAB1bb4DB6D80A4CF20db5Be1568d1e\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/ink-sepolia/SchemaRegistry.json",
    "chars": 2496,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/ink-sepolia/solcInputs/ab2e55c92b39ec3be86af0608f634927.json",
    "chars": 153552,
    "preview": "{\n  \"language\": \"Solidity\",\n  \"sources\": {\n    \"@ethereum-attestation-service/eas-contracts/contracts/Common.sol\": {\n   "
  },
  {
    "path": "deployments/ink-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/Indexer.ts",
    "chars": 10904,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12217,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/contracts/EAS.ts",
    "chars": 31833,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/contracts/Indexer.ts",
    "chars": 10898,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/contracts/SchemaRegistry.ts",
    "chars": 5431,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/Indexer__factory.ts",
    "chars": 17685,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/@ethereum-attestation-service/eas-contracts/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37317,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/contracts/EAS__factory.ts",
    "chars": 62560,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/contracts/Indexer__factory.ts",
    "chars": 17540,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 7925,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/ink-sepolia/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 37040,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea/.chainId",
    "chars": 6,
    "preview": "59144\n"
  },
  {
    "path": "deployments/linea/.migrations.json",
    "chars": 194,
    "preview": "{\n  \"000001-registry\": 1694032880,\n  \"000002-eas\": 1694032891,\n  \"000003-register-initial-schemas\": 1694033445,\n  \"00000"
  },
  {
    "path": "deployments/linea/EAS.json",
    "chars": 280105,
    "preview": "{\n  \"address\": \"0xaEF4103A04090071165F78D45D83A0C0782c2B2a\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/linea/EIP712Proxy.json",
    "chars": 170581,
    "preview": "{\n  \"address\": \"0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/linea/SchemaRegistry.json",
    "chars": 50511,
    "preview": "{\n  \"address\": \"0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/linea/types/contracts/EAS.ts",
    "chars": 25404,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea/types/contracts/SchemaRegistry.ts",
    "chars": 4872,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea/types/factories/contracts/EAS__factory.ts",
    "chars": 65834,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 10174,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 36958,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea-goerli/.chainId",
    "chars": 5,
    "preview": "59140"
  },
  {
    "path": "deployments/linea-goerli/.migrations.json",
    "chars": 194,
    "preview": "{\n  \"000001-registry\": 1693926089,\n  \"000002-eas\": 1693926148,\n  \"000003-register-initial-schemas\": 1693927856,\n  \"00000"
  },
  {
    "path": "deployments/linea-goerli/EAS.json",
    "chars": 280106,
    "preview": "{\n  \"address\": \"0xaEF4103A04090071165F78D45D83A0C0782c2B2a\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/linea-goerli/EIP712Proxy.json",
    "chars": 170582,
    "preview": "{\n  \"address\": \"0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/linea-goerli/SchemaRegistry.json",
    "chars": 50511,
    "preview": "{\n  \"address\": \"0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/linea-goerli/types/contracts/EAS.ts",
    "chars": 25404,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea-goerli/types/contracts/SchemaRegistry.ts",
    "chars": 4872,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea-goerli/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/linea-goerli/types/factories/contracts/EAS__factory.ts",
    "chars": 65834,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea-goerli/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 10174,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/linea-goerli/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 36958,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/mainnet/.chainId",
    "chars": 2,
    "preview": "1\n"
  },
  {
    "path": "deployments/mainnet/.migrations.json",
    "chars": 157,
    "preview": "{\n  \"000001-registry\": 1677952935,\n  \"000002-eas\": 1677952957,\n  \"000003-register-initial-schemas\": 1677953511,\n  \"00000"
  },
  {
    "path": "deployments/mainnet/EAS.json",
    "chars": 248408,
    "preview": "{\n  \"address\": \"0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/mainnet/SchemaRegistry.json",
    "chars": 25056,
    "preview": "{\n  \"address\": \"0xA7b39296258348C78294F95B872b282326A97BDF\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"name\": \"Already"
  },
  {
    "path": "deployments/mainnet/types/contracts/EAS.ts",
    "chars": 31316,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/mainnet/types/contracts/SchemaRegistry.ts",
    "chars": 5431,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/mainnet/types/factories/contracts/EAS__factory.ts",
    "chars": 64046,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/mainnet/types/factories/contracts/SchemaRegistry__factory.ts",
    "chars": 7925,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport { Signer, utils, Contra"
  },
  {
    "path": "deployments/optimism/.chainId",
    "chars": 3,
    "preview": "10\n"
  },
  {
    "path": "deployments/optimism/.migrations.json",
    "chars": 226,
    "preview": "{\n  \"000001-registry\": 1682454805,\n  \"000002-eas\": 1682454812,\n  \"000003-register-initial-schemas\": 1690557621,\n  \"00000"
  },
  {
    "path": "deployments/optimism/EAS.json",
    "chars": 24554,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/optimism/EIP712Proxy.json",
    "chars": 170584,
    "preview": "{\n  \"address\": \"0xE132c2E90274B44FfD8090b58399D04ddc060AE1\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/optimism/Indexer.json",
    "chars": 102085,
    "preview": "{\n  \"address\": \"0x6dd0CB3C3711c8B5d03b3790e5339Bbc2Bbcf934\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/optimism/SchemaRegistry.json",
    "chars": 2496,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/optimism/types/contracts/Indexer.ts",
    "chars": 10850,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/optimism/types/contracts/eip712/proxy/EIP712Proxy.ts",
    "chars": 12211,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport type {\n  BaseContract,\n"
  },
  {
    "path": "deployments/optimism/types/factories/contracts/Indexer__factory.ts",
    "chars": 17516,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/optimism/types/factories/contracts/eip712/proxy/EIP712Proxy__factory.ts",
    "chars": 36958,
    "preview": "/* Autogenerated file. Do not edit manually. */\n/* tslint:disable */\n/* eslint-disable */\nimport {\n  Contract,\n  Contrac"
  },
  {
    "path": "deployments/optimism-goerli/.chainId",
    "chars": 3,
    "preview": "420"
  },
  {
    "path": "deployments/optimism-goerli/.migrations.json",
    "chars": 261,
    "preview": "{\n  \"000001-registry\": 1682454805,\n  \"000002-eas\": 1682454812,\n  \"000003-register-initial-schemas\": 1690031840,\n  \"00000"
  },
  {
    "path": "deployments/optimism-goerli/EAS.json",
    "chars": 24554,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000021\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  },
  {
    "path": "deployments/optimism-goerli/EIP712Proxy.json",
    "chars": 170583,
    "preview": "{\n  \"address\": \"0x88D1bd62AC014424b987CE5ABf311BD7749e426B\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/optimism-goerli/Indexer.json",
    "chars": 102084,
    "preview": "{\n  \"address\": \"0xa42428D1bf904d762adD02b27ADac26d53643782\",\n  \"abi\": [\n    {\n      \"inputs\": [\n        {\n          \"int"
  },
  {
    "path": "deployments/optimism-goerli/SchemaRegistry.json",
    "chars": 2496,
    "preview": "{\n  \"address\": \"0x4200000000000000000000000000000000000020\",\n  \"abi\": [\n    {\n      \"inputs\": [],\n      \"stateMutability"
  }
]

// ... and 182 more files (download for full content)

About this extraction

This page contains the full source code of the ethereum-attestation-service/eas-contracts GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 382 files (14.6 MB), approximately 3.9M tokens, and a symbol index with 2807 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!