The ens-offchain-registrar repository and its associated gateway packages serve as the reference implementation for EIP-3668 (CCIP-Read) offchain resolution. This codebase is the foundation that operators use to serve name data from environments where onchain storage is impractical or cost-prohibitive, including Layer 2 networks, sidechains, and centralized databases. The gateway acts as a bridge between a client's CCIP-Read-capable library—such as ethers.js or viem—and the offchain data source, translating storage proofs and database queries into the signed responses that clients verify onchain.

CCIP-Read Gateway Reference Implementations
Introduction
The CCIP-Read gateway reference implementations provide the canonical offchain server code that enables ENS and other name services to resolve data from L2s, appchains, and traditional databases.
Operational compatibility is the primary risk surface. Client libraries evolve their CCIP-Read handling to enforce stricter response validation, adjust gas limit estimation for callback transactions, and change how they interpret gateway errors. A gateway running an outdated version of the reference implementation may produce responses that newer client versions reject silently, causing end-user name resolution to fail without visible errors. This is particularly dangerous for wallets and exchanges where failed resolution can block asset transfers or display incorrect destination addresses.
The reference implementation defines the expected behavior for response signing, error formatting, and ABI-encoded callback data. When gateway operators deviate from this canonical behavior—whether through custom modifications or by lagging behind versioned releases—they introduce fragmentation into the resolution ecosystem. Chainscore Labs reviews gateway deployments against the current reference implementation to identify compatibility gaps, validate response signing logic, and ensure that resolution behavior remains consistent across all client libraries that users depend on.
Quick Facts
Operational impact of versioned releases in the ens-offchain-registrar and related gateway codebases.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
Gateway API | Response format or endpoint behavior may change between major versions. | Wallet developers, dapp front-ends, L2 resolver operators. | Review release notes for breaking API changes before upgrading gateway instances. |
EIP-3668 Compliance | Updates to align with evolving client handling of CCIP-Read in ethers.js, viem, and other libraries. | Library maintainers, wallet teams, gateway operators. | Test resolution flows against the latest client versions to confirm compatibility. |
Database Schema | Storage layout for offchain name data may require migration scripts. | Gateway operators managing their own database backends. | Run provided migration scripts in a staging environment before applying to production databases. |
Configuration Format | Environment variables or config file structure may be deprecated or renamed. | Infrastructure teams, DevOps engineers. | Audit configuration management code and update deployment manifests to match the new schema. |
Dependency Upgrades | Underlying frameworks or signing libraries may be updated, introducing transitive risks. | Security engineers, gateway operators. | Verify checksums of new dependencies and scan for known vulnerabilities in the updated supply chain. |
Signing Logic | Changes to how gateway responses are signed could invalidate client-side verification. | Wallet teams, resolver library integrators. | Confirm that the signing address and scheme remain compatible with client verification logic. |
DNS Record Requirements | Gateway discovery via DNS TXT records may require updated record formats. | Domain administrators, infrastructure teams. | Update DNS records as specified in the release to ensure uninterrupted gateway discovery. |
Caching Headers | Adjustments to cache-control directives may alter CDN or client-side caching behavior. | CDN operators, gateway operators. | Monitor cache hit ratios and resolution latency after deployment to detect unintended changes. |
Technical Mechanism
How the CCIP-Read gateway reference implementations translate onchain queries into offchain data responses for ENS names.
The ens-offchain-registrar repository provides the canonical reference implementation for building a CCIP-Read (EIP-3668) gateway. This gateway acts as an HTTP intermediary that receives compressed calldata from a client—typically a wallet or dapp using ethers.js or viem—and translates it into a backend database lookup. For ENS, this mechanism is the foundation for resolving names registered on L2s and offchain databases, where the ENS registry on L1 stores only a pointer to the gateway's URL and a resolver address. The gateway must correctly decode the resolve calldata, query its local data store for the corresponding record, and return a signed or unsigned response that the client can verify against the onchain resolver contract.
The operational integrity of this mechanism depends on strict compatibility between the gateway's ABI encoding and the client library's expectations. The reference implementation defines the exact function signatures, response encoding formats, and error handling patterns that gateways must follow. A mismatch in the ABI-encoded response—such as an incorrectly formatted DNS-encoded name or a malformed text() record—causes the client's callback transaction to revert silently. Operators of L2 and offchain name services must track versioned releases of this codebase to ensure their gateways remain compatible with the latest CCIP-Read handling in major libraries. Incompatible gateways cause silent resolution failures for end users, where a name appears registered but returns empty data or a revert.
The gateway also implements the discovery mechanism defined in EIP-3668: the ENS registry entry for an offchain name contains a URL template that clients use to locate the gateway. The reference implementation expects this URL to point to an HTTPS endpoint serving the /{sender}/{data} path pattern. Gateway operators must ensure this endpoint is correctly configured with valid TLS certificates, proper CORS headers for browser-based wallets, and DNS records that match the URL stored onchain. Any mismatch between the onchain URL and the actual gateway endpoint breaks resolution for all users of that name. Chainscore Labs reviews gateway deployments for ABI compatibility, response signing correctness, and endpoint configuration to prevent these failure modes before they reach production.
Affected Actors
Gateway Operators
Operators running ens-offchain-registrar or custom CCIP-Read gateways must track reference implementation releases to maintain compatibility with evolving client libraries. A breaking change in response encoding or endpoint discovery can cause silent resolution failures for all users relying on the gateway.
Action items:
- Monitor the reference implementation changelog for ABI changes in gateway responses.
- Test gateway responses against the latest versions of ethers.js and viem before deploying updates.
- Verify that DNS TXT records for endpoint discovery remain correctly formatted after any configuration migration.
- Implement health checks that validate end-to-end resolution through a CCIP-Read-aware client, not just HTTP status codes.
Chainscore Labs can review your gateway upgrade path and test suite to catch compatibility regressions before they affect production users.
Implementation Impact
Releases of the CCIP-Read gateway reference implementation directly affect resolution reliability for offchain names. Operators must assess compatibility, security, and monitoring changes with each version.
Client Library Compatibility
New gateway releases may alter response formats or introduce stricter adherence to EIP-3668. This can cause silent resolution failures in client libraries like ethers.js and viem if they do not handle updated offchain lookup flows correctly. Wallet and dapp teams must regression-test resolution against the latest gateway version to ensure their users do not experience broken name resolution after an operator upgrades. Verify behavior with both standard and wildcard resolution calls.
Gateway Response Signing
Reference implementations may update signing algorithms or key management patterns for gateway responses. Operators must ensure their signing infrastructure is compatible with the new release to prevent clients from rejecting valid responses due to signature verification failures. A mismatch in expected signing schemes can make all names served by a gateway unresolvable. Review the release notes for any changes to the resolve callback signature or ABI encoding of signed data.
DNS Record and Endpoint Discovery
Changes to the gateway's ENS text record format or the discovery mechanism can break the client's ability to locate the gateway endpoint. Operators must update their DNS TXT records if the reference implementation changes the expected record key or value structure. Failure to update discovery records means clients will not find the gateway, leading to a complete resolution outage for all associated names.
Caching and Rate Limiting
New gateway versions may introduce or alter caching headers and rate-limiting logic. Operators need to configure these parameters based on their infrastructure capacity and expected query volume. Aggressive caching can serve stale data, while insufficient rate limiting can lead to denial-of-service. Integrators should monitor the Cache-Control headers returned by gateways to ensure their local resolution caches respect the intended freshness policies.
Wildcard Resolution Handling
Reference implementations that change how wildcard queries are processed can break resolution for entire subname trees like *.project.eth. Operators of subname registrars must verify that the new version correctly handles resolve calls for non-existent subnames by returning the appropriate wildcard proof. A logic error here can cause all subdomains under a wildcard parent to stop resolving.
Compatibility and Risk Matrix
Evaluates the operational impact of versioned releases of the offchain gateway codebase. Operators must verify compatibility with client libraries and resolve potential breaking changes to prevent silent resolution failures.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
ABI Encoding | Changes to the encoding or decoding of gateway response data structures. | Gateway operators, Library maintainers (ethers.js, viem) | Verify offchain response handling against the latest EIP-3668 client implementations. |
Gateway Endpoint Discovery | Updates to the DNS TXT record format or ENS text record used for endpoint discovery. | Gateway operators, Wallet developers | Update DNS records and verify that client-side discovery logic resolves the new endpoint format. |
Response Signing | Introduction or modification of data signing requirements for gateway responses. | Gateway operators, L2 resolvers | Implement new signing schemes and ensure clients are configured to verify the updated signature format. |
Error Handling | New error codes or changes to the structure of error responses from the gateway. | Wallet developers, dApp frontends | Update error parsing logic to handle new failure modes and prevent misleading user-facing errors. |
Batch Request Handling | Changes to how the gateway processes or responds to batched resolution requests. | Gateway operators, Library maintainers | Test batch resolution flows to ensure atomicity and correct response ordering are maintained. |
Callback Gas Estimation | Modifications affecting the gas cost of the CCIP-Read callback transaction. | Wallet developers, dApp integrators | Re-evaluate gas limit buffers for callback transactions to prevent out-of-gas failures. |
Database Schema | Schema migrations required by the reference implementation for storing offchain data. | Gateway operators | Execute database migrations as documented in the release notes to prevent data corruption. |
Operator Migration Checklist
A structured checklist for operators upgrading their offchain gateway instances to a new release of the reference implementation. Each step confirms compatibility with EIP-3668 handling in clients like ethers.js and viem, preventing silent resolution failures for end users.
What to check: Confirm that the new gateway version's HTTP response body matches the expected ABI-encoded format for CCIP-Read callbacks.
Why it matters: Client libraries strictly decode the response based on the function signature. A mismatch in encoding, even a single byte, causes the entire resolution callback transaction to revert silently, breaking name resolution for all users.
Readiness signal: Run the gateway's included test suite against a local instance and validate that resolveName calls return data that can be successfully decoded by the latest versions of both ethers.js and viem.
Source Resources
Primary references for teams operating or integrating CCIP-Read gateways for ENS and offchain name resolution. Use these sources to verify protocol behavior, reference implementation changes, and client-library compatibility before production deployment.
Looking to build on a specific blockchain?
We build smart contracts, DeFi applications, wallets, tokenization platforms, and blockchain infrastructure across the major ecosystems teams choose today. That includes Ethereum, Arbitrum, Optimism, Polygon, Avalanche, Solana, Sui, Aptos, Hedera, Stellar, and NEAR, with support for additional EVM and non-EVM networks based on your product requirements.
EVM ecosystems
- Ethereum
- Arbitrum
- Optimism
- Polygon
- Avalanche
- Cronos

Non-EVM ecosystems
- Solana
- Sui
- Aptos
- Hedera
- Stellar
- NEAR
Additional ecosystems
- Polkadot
- Cosmos
- TON
- Cardano
- Algorand
- Tempo
Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.
Frequently Asked Questions
Common operational questions from teams running or integrating with the ens-offchain-registrar and other CCIP-Read gateway implementations.
Client libraries like ethers.js and viem implement EIP-3668 handling with specific expectations for response formats, ABI encoding, and error propagation. To verify compatibility:
- Run the gateway's integration test suite against the latest versions of ethers.js and viem. The reference
ens-offchain-registrarrepository includes tests that simulate client-side CCIP-Read flows. - Check the
datafield encoding in your gateway'sresolvecallback. Clients expect a tightly packed ABI-encoded tuple matching the resolver function's return type. A mismatch causes silent resolution failures where the client receives data it cannot decode. - Validate error handling behavior. When your gateway returns a revert reason, clients should surface a meaningful error rather than a generic 'resolution failed' message. Test with intentionally malformed requests.
- Monitor the gateway's
/health endpoint if exposed. Some client SDKs use this to detect gateway availability before sending resolution requests.
Incompatible gateways produce no onchain revert—the transaction simply fails during the callback phase, leaving users with broken name resolution and no clear error message.
Delivering blockchain solutions for 5+ years.
We have partnered with 50+ leading DeFi protocols, NFT ecosystems, and fintech innovators to build secure, scalable, and capital-efficient blockchain products.
Selected Partners & Clients
“I've been working with Chainscore Labs for last 3+ years, they've consistently delivered with strong ownership across multiple projects. The team is reliable and detail-oriented.”
How to get started?
If you're looking for blockchain integration, ChainScore Labs has 5+ years of experience helping teams build and integrate exchanges, wallets, smart contracts, tokenization solutions, and protocol-connected products, we can help you choose the right path, integrate securely, and get to production faster. Our team consists of experienced blockchain developers and architects who can help you with your blockchain integration needs.
Exploration & Strategy
Define your product goals and choose the right blockchain architecture for your use case.
Architecture & Design
Design the smart contracts, tokenomics, and security parameters of your system.
Development & Integration
Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.
Security & Launch
Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.
Discover our
blockchain development services.
We build production-grade blockchain solutions for top-tier projects across DeFi and Web3.
Need a blockchain engineering team?
Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.


