Nischal Sharma

We’re excited to announce a new update to the “My Contracts” page on Enscribe. If you’ve ever deployed smart contracts and wished for a clearer, more structured way to manage and track them — especially across ENS names — this update is built just for you.

In this release, we’ve reimagined how developers interact with their deployed contracts by dividing the view into two clear categories:

1. Named Contracts - Contracts deployed by the user which have an ENS Primary Name
2. Unnamed Contracts - Contracts deployed by the user which doesn't have ENS Primary name

This makes it easy to monitor which of your contracts have verifiable identities through ENS, and which ones are still waiting to be named.

A Smarter Way to See Your Deployed Contracts​

Historically, developers had to use blockchain explorers such as Etherscan, or keep their own records as which contracts they've deployed. With Enscribe we're changing that.

The “My Contracts” page automatically surfaces all contracts directly deployed by your connected wallet. This includes both contracts deployed through standard Ethereum transactions (where the transaction "to" is null) and contracts deployed using CREATE2 via Enscribe.

One thing to note: we currently do not track indirect deployments — such as contracts created through another factory contract (internal contract creation calls). This is a planned improvement and is on our roadmap for upcoming releases.

Named vs Unnamed​

The page is now split into two tabs:

Named Contracts​

In the Named Contracts tab, you’ll find all contracts that have been deployed by your wallet and already have a Primary ENS Name. Each contract entry displays its ENS name, contract address, the transaction hash for creation, and direct links to tools like Etherscan, Chainlens, and the ENS App. This makes it easy to verify and share your named contracts.

We support Ethereum, Base and Linea mainnets and testnets.

Unnamed Contracts​

The Unnamed Contracts tab, helps you track contracts you’ve deployed that haven’t yet been named with ENS. Each entry includes the contract address and creation transaction hash, along with a contextual action button. Depending on the contract’s structure, this button will either prompt you to “Name Contract” (if it supports Primary Name assignment through Ownable/ERC-173/ReverseClaimer) or “Forward Resolve” (if only forward resolution is possible).

We’ve also added smart visual cues to guide you:

• A "yellow exclamation" icon indicates contracts that support only ENS forward resolution.
• A "green info" icon marks contracts that are eligible for full ENS primary name assignment.

Clicking on the action button takes you directly to the naming interface with the contract address pre-filled — allowing you to easily upgrade your unnamed contracts into trusted, named entities.

Fully On-Chain, Fully Trustless​

One of the most powerful aspects of our DApp is that it’s completely trustless. Enscribe doesn’t use a centralized database. All contract discovery, naming info, and status checks are done on-chain, directly from your connected wallet via RPC calls. This means no vendor lock-in, no stale cache, no single point of failure — just accurate, permissionless data every time you load the page.

Because we query the chain live, loading the full list of contracts happens asynchronously and can take a bit of time. While your contracts are being processed, you’ll see a spinner at the bottom of the table. Once loading is complete, the spinner disappears, indicating the tables are now fully up to date. This will be optimised soon.

See It in Action​

We’ve recorded a short walkthrough showing how the updated “My Contracts” page works and how you can use it to name your existing or new contracts instantly.

Watch the demo here.

The Takeaway​

This update turns Enscribe into more than just a naming tool — it’s now your command center for managing smart contract identity across Ethereum and Layer 2s. Whether you’re shipping production contracts or deploying testnet experiments, the new “My Contracts” page gives you a structured, intuitive way to understand what you’ve deployed and what still needs to be named.

Naming your contracts helps users trust them. It makes them recognizable in wallets, block explorers, and dApps. And now, managing that naming process is easier than ever.

For more details, visit our site, and don't hesitate to join our Discord community and Telegram group to share your feedback and experiences.

Happy Naming! 🚀

We’re thrilled to announce that Enscribe is now officially live on mainnet — across Ethereum, Linea, and Base networks.

Enscribe is a smart contract deployment and naming service purpose-built to bring human-readable identity to on-chain contracts. It allows developers to deploy contracts and assign ENS names — including subname creation, forward resolution, and reverse resolution (primary name) — all in a single, atomic transaction.

Until now, naming smart contracts using ENS was a fragmented and manual process that required interacting with multiple ENS contracts post-deployment. Enscribe abstracts that complexity entirely.

And yes — we’ve used Enscribe itself to name our production deployments.

Mainnet Deployments and ENS Names​

Ethereum Mainnet​

• Contract Address: 0xD14360D477EF49182B5141952FE67b007688725A
• ENS Name: v0.app.enscribe.eth
• Verified On:
  • Sourcify
  • Etherscan

Linea Mainnet​

• Contract Address: 0x6d8Ac46BFC1bD0b6022f997108e9800Fd84fdD44
• ENS Name: v0.app.enscribe.linea.eth
• Verified On:
  • Sourcify
  • Etherscan

Base Mainnet​

• Contract Address: 0x8429c428F93754449C4b955F2Ae9fde17eF4e95a
• ENS Name: v0.app.enscribe.base.eth
• Verified On:
  • Sourcify
  • Etherscan

We Enscribed Ourselves — Watch It in Action​

We used Enscribe to name our own mainnet deployments — and captured the entire flow.

Ethereum Mainnet​

Linea Mainnet​

Base Mainnet​

Name Your Contracts — Today​

This is a major step toward bringing trust and transparency to on-chain contracts through meaningful naming and identity. We’re excited to see what you build with it. Enscribe your contracts. Make them recognizable.

For more details, visit our site, and don't hesitate to join our Discord community to share your feedback and experiences.

Happy deploying! 🚀

We’re excited to announce a major refresh to the Enscribe Documentation — built to help developers and users better understand how ENS naming works for smart contracts and how Enscribe makes that process seamless.

Whether you’re deploying new contracts or assigning ENS names to existing ones, the updated docs walk you through every part of the experience with clear explanations, examples, and new video walkthroughs.

What's New?​

The updated Enscribe docs are now structured to cover both technical depth and usability, giving you exactly what you need depending on your goal.

The Enscribe docs are now divided into three major sections:

Introduction​

Get oriented. Learn what Enscribe is, why it exists, and how it bridges the gap between ENS and smart contract UX.

• What is Enscribe? - A high-level overview of the problem we’re solving.
• Overview of ENS - Understand how the ENS protocol works: Registry, Resolvers, Reverse Resolution, and more.
• Naming Smart Contracts - Why naming smart contracts is hard, and how Enscribe makes it simple.
• Supported Networks - Live Enscribe contract addresses across L1 and L2 chains like Sepolia, Base, and Linea.

Getting Started​

Everything you need to know to go from “I have a contract” to “My contract has a beautiful ENS name.”

• Contract Deployment Service - Learn how to deploy a contract with ENS naming in a single transaction.
• Naming Existing Contracts - Assign names and reverse resolution to contracts that already exist on-chain.
• Deployment History - Track previous deployments and view assigned names.
• Bytecode and ABIs - Understand how contract bytecode and constructor arguments are handled in Enscribe.
• The Operator Role in ENS, Why and How? - Get clarity on why operator permission is needed and how it’s securely managed by Enscribe.

This section is packed with video walkthroughs, UI screenshots, and interactive examples to help you get hands-on quickly.

Advanced (Coming Soon)​

For those looking to dive deeper into ENS internals, smart contract design, and Layer 2 nuances — the Advanced section will soon include:

• ENS Terminology - A glossary of ENS-specific concepts for developers and power users.
• ENS on L1 vs L2 chains - A detailed breakdown of how ENS behaves differently across Ethereum mainnet, Base, Linea, and other L2s.
• Design and Architecture - A full overview of the Enscribe contract system, including sequence diagrams, CREATE2 deployment flow, and ENS contract interactions.

Learn More & Dive In​

You can explore the updated docs and start deploying contracts with names you can actually remember.

For more details, visit our site, and don't hesitate to join our Discord community to share your feedback and experiences.

Happy deploying! 🚀

Deploying smart contracts with constructor arguments just got a whole lot easier with Enscribe.

Previously, if your contract required constructor arguments, Enscribe expected you to manually encode those arguments, append them to your compiled bytecode using external tools like Remix or Hardhat, and then paste that full bytecode into the UI. This approach was complex, error-prone, and completely unintuitive — especially for contracts with more than a simple string or uint.

We're excited to announce that Enscribe now supports native constructor arguments input in the UI. Now no manual bytecode editing is required.

What's New?​

With the latest update, users can now provide constructor arguments directly within the Enscribe UI.

There are two ways to do this. You can manually enter the argument types and values using a set of dropdowns and input fields, giving you full control over the structure and content. Alternatively, you can provide your contract's ABI. When you do, Enscribe automatically detects the number of constructor arguments, their names, and their types, and then generates the appropriate input fields for you to input the parameter values.

This streamlined experience allows you to focus on your contract logic, while Enscribe handles all the underlying ABI encoding and bytecode composition for deployment.

Manual Mode: Add Any Type, In Any Order​

You can add any number and type of arguments manually. Enscribe provides a dropdown list for all common Solidity types: string, uint8, uint256, address, bool, bytes, bytes32, string[], and uint256[]. Just add the argument, choose its type, and input its value.

For more advanced use cases, select Custom Type from the dropdown. This is where Enscribe really shines — giving you full control for struct-based inputs, tuples, arrays, and combinations of them.

Example: Arrays of Structs (Using Custom Type)

Let's say your constructor looks like this:

struct Person {
  string name;
  uint256 age;
  address wallet;
}

constructor(Person[] memory people)

Here's how you'd fill it out in Enscribe:

• Custom Type: tuple(string,uint256,address)[]
• Value: [["Nick", 30, "0x1bA43Becc3Ea96c37343b7CB18de7386bA29445B"], ["Jane", 25, "0x7cF7816d45398A1b37bBE517ca24d8CdFb8D042D"]]

Enscribe will automatically ABI-encode this value and append it to the deployment bytecode.

ABI Mode: Let Enscribe Do the Work​

If you paste or upload your contract's ABI, Enscribe will:

• Detect the constructor function
• Extract the parameter types and names
• Generate the input form fields automatically, where you just need to input parameter values

This is the recommended path for most users, as it:

• Reduces manual effort
• Prevents input format mistakes
• Makes the argument fields easier to understand

If your contract constructor is: constructor(string memory greet, uint256 initialCount)

Then Enscribe will automatically show two input fields: greet(string) and initialCount (uint256), and you just need to input parameter values.

Under the Hood: ABI Encoding and Bytecode Generation​

When you click Deploy, Enscribe automatically takes care of everything behind the scenes. It ABI-encodes your constructor arguments, appends them to the compiled contract bytecode, and sends the final result to the blockchain as a single atomic transaction. You don't need to worry about encoding formats, data padding, or bytecode structure — Enscribe ensures that everything is correctly formatted and deployment-ready.

Learn More & Get Involved​

Ready to deploy your contract with constructor arguments and assign it a primary ENS name? Try it now in the Enscribe UI and experience seamless contract deployment with human-readable identity.

For more details, visit our documentation, and don't hesitate to join our Discord community to share your feedback and experiences.

Happy deploying! 🚀