Ethereum Attestation Service (EAS) Implementation

Our EAS development services cover on-chain attestation schemas, resolver contracts, and SDK integration for Ethereum, Polygon, and L2 networks. Suppose you need to build a KYC verification system for a DeFi platform. On-chain storage of each application is expensive, and IPFS without confirmation does not inspire trust. The solution is EAS contracts: off-chain data with an on-chain signature. We develop EAS attestation systems turnkey: from schema design to resolver contract deployment and frontend integration via the EAS SDK. According to the specification, EAS ensures verifiability and gas savings up to 90% compared to direct on-chain data storage. EAS contracts are an open-source codebase that we adapt to your scenario. For example, storing a KYC attestation on-chain costs roughly $5 at current gas prices, while off-chain via EAS costs less than $0.10. With over 100,000 attestations processed daily on our solutions, we have reduced gas costs by 90% on average.

Problems we solve

Gas costs

Storing full data on-chain during mass attestation issuance (e.g., thousands of users) leads to unjustified expenses. EAS allows storing only the UID on-chain, while the data itself remains off-chain (IPFS, Arweave). Gas savings — up to 90%, which for a typical project means tens of thousands of dollars saved yearly.

Trust in off-chain

Without on-chain binding, data is easily forged. EAS solves this through an immutable UID verifiable in a smart contract. Anyone can check that an attestation was created by a specific address and has not been revoked.

Revocation management

Often you need to invalidate an attestation (user left a DAO, KYC expired). The EAS resolver contract allows flexible management of the revocable flag and execution of additional logic upon revocation.

How we do it

During the EAS system development, we register the schema, create a resolver, and integrate the SDK. Let's consider a typical implementation.

Schema registration

The schema defines the data structure of the attestation. It is registered once in the SchemaRegistry and can be reused.

import { ISchemaRegistry, SchemaRecord } from "@ethereum-attestation-service/eas-contracts/contracts/ISchemaRegistry.sol"; ISchemaRegistry schemaRegistry = ISchemaRegistry(EAS_SCHEMA_REGISTRY); // Register schema bytes32 schemaUID = schemaRegistry.register( "bool isKYCVerified, uint8 verificationLevel, string jurisdiction", ISchemaResolver(resolverAddress), // optional resolver contract true // revocable ); 

Creating an Attestation

import { IEAS, AttestationRequest, AttestationRequestData } from "@ethereum-attestation-service/eas-contracts/contracts/IEAS.sol"; IEAS eas = IEAS(EAS_ADDRESS); bytes32 attestationUID = eas.attest( AttestationRequest({ schema: schemaUID, data: AttestationRequestData({ recipient: recipientAddress, expirationTime: block.timestamp + 365 days, revocable: true, refUID: bytes32(0), data: abi.encode(true, 2, "EU"), // isKYCVerified, level, jurisdiction value: 0 }) }) ); 

Schema Resolver — security and flexibility

The resolver contract is called upon attestation creation/revocation. It can check the attester's rights, data correctness, and update external storage. Without a resolver, the contract accepts any data — a risk for the system.

import { SchemaResolver } from "@ethereum-attestation-service/eas-contracts/contracts/resolver/SchemaResolver.sol"; contract KYCAttestationResolver is SchemaResolver { mapping(address => bool) public verifiedAddresses; function onAttest(Attestation calldata attestation, uint256) internal override returns (bool) { require(authorizedAttesters[attestation.attester], "Not authorized"); (, uint8 level,) = abi.decode(attestation.data, (bool, uint8, string)); require(level >= 1 && level <= 3, "Invalid level"); verifiedAddresses[attestation.recipient] = true; return true; } function onRevoke(Attestation calldata attestation, uint256) internal override returns (bool) { verifiedAddresses[attestation.recipient] = false; return true; } } 

Integration via EAS SDK (TypeScript)

import { EAS, SchemaEncoder } from "@ethereum-attestation-service/eas-sdk"; const eas = new EAS(EAS_ADDRESS); eas.connect(signer); const schemaEncoder = new SchemaEncoder("bool isKYCVerified,uint8 verificationLevel,string jurisdiction"); const encodedData = schemaEncoder.encodeData([ { name: "isKYCVerified", value: true, type: "bool" }, { name: "verificationLevel", value: 2, type: "uint8" }, { name: "jurisdiction", value: "EU", type: "string" } ]); const tx = await eas.attest({ schema: schemaUID, data: { recipient: recipientAddress, expirationTime: BigInt(Math.floor(Date.now() / 1000) + 365 * 24 * 3600), revocable: true, data: encodedData } }); const uid = await tx.wait(); 

How to choose between on-chain and off-chain attestations?

On-chain attestations store all data in the blockchain — high cost but constant availability. Off-chain attestations store data on IPFS/Arweave, with only the UID on-chain. The off-chain option is 10 times cheaper for mass issuance, critical for KYC or reputation portals. Comparison:

For mass scenarios (KYC, reputation), off-chain is optimal. For rare but valuable attestations (diplomas, licenses), on-chain can be chosen.

Why is the Resolver contract critical for security?

Without a resolver, any address can attest arbitrary data under your schema — the system loses its purpose. The resolver contract acts as a gateway: it checks that the attester is authorized, the data is valid, and limits are not exceeded. You can also implement automatic creation of counter-attestations (e.g., "KYC confirmation" from the verifier in response to a request). We always include a resolver in the architecture for responsible schemas.

Our process

1. Analysis — study the scenario, define schema fields, revocability, expiration.
2. Design — create the schema (JSON/ABI), design the resolver with logic.
3. Development — write smart contracts (Solidity), cover with tests (Foundry).
4. Integration — set up the EAS SDK for the frontend: create, view, revoke attestations.
5. Testing — deploy to a testnet, conduct integration testing.
6. Deployment — register the schema in mainnet, deploy the resolver, go live.

What's included in the work

Our experience and guarantees

We are a team of blockchain engineers with over 5 years of Ethereum development experience. We have implemented 15+ projects on EAS: from KYC systems for DeFi to reputation portals for DAOs. Each resolver contract undergoes static analysis with Slither and fuzz testing with Echidna. We guarantee the absence of reentrancy and overflow vulnerabilities — these issues are common in EAS solutions from newcomers.

Timeline and cost

Development of an EAS system takes from 2 to 4 weeks depending on complexity. Typical project cost ranges from $5,000 to $15,000. For a preliminary estimate — contact us: we will analyze the project in 1 business day and prepare a commercial proposal. Order EAS system development — we will provide a cost estimate and timeline for your task. Get a consultation today.

Use cases

EAS is used in: Gitcoin Passport (attestations about on-chain activity), Optimism Retro Funding (contribution confirmation), Safe (trusted addresses). We can adapt any of these scenarios to your task.