28 posts tagged with "product-updates"

The Enscribe homepage has been redesigned. The new layout uses three feature cards for clearer navigation, and the search now resolves ENS names in your browser before making any backend calls.

Why We Changed It​

As Enscribe added the new feature Batch Naming, the text-heavy homepage made it hard for new users to find what they needed.

The search bar also created unnecessary load. Users would search for an ENS name, navigate to a details page, and only then discover the name didn't resolve or pointed somewhere unexpected or they were on the wrong chain. This meant:

• Wasted API calls for typos and invalid names
• Extra clicks to discover resolution failures
• Backend queries for exploratory searches

The redesign fixes both issues.

Card-Based Navigation​

The homepage now shows three feature cards:

📄 Name Contract​

Name existing smart contracts with ENS names. Set forward and reverse resolution for contracts you've already deployed.

🚀 Deploy Contract​

Deploy and name contracts in one flow. Skip the extra step of naming after deployment.

📚 Batch Naming​

Name multiple contracts under a single parent domain.

Client-Side ENS Resolution​

The search bar is now a modal that resolves ENS names before you navigate.

How It Works​

1. Click "Explore Contract or Wallet"
2. Type an ENS name like vitalik.eth or 0x1234...5678
3. See the resolved address: vitalik.eth → 0x1234...5678 on the desired chain
4. Verify it's correct and resolves to an address, then click to view details

If the name doesn't resolve, you see it immediately — no wasted navigation.

Why This Matters​

For users:

• Catch typos before navigating
• Verify resolution and chain before committing

For the platform:

• ENS resolution happens in the browser using viem
• Only validated searches hit the backend

The new design is live at Enscribe. We'd like to hear what you think:

• Does the card layout help you find what you need?
• Is the search modal helpful?
• What would you like to see in the future?

Reach out on Discord, Telegram, or X.

Happy naming! 🚀

Enscribe has shipped Contract Batch Naming feature for our Enscribe UI app. Teams and projects can now name multiple smart contracts at once under a single parent domain. This reduces the contract naming process for projects with multiple deployed contracts from hours to minutes.

Why Batch Naming?​

Managing multiple smart contracts across different chains has always been a challenge and time-consuming. Whether you're a DAO with governance contracts, a DeFi with multiple vault, protocol, core and utility contracts, or an infrastructure project with contracts deployed across chains, naming each contract individually means repeating the same steps: creating subnames, setting forward resolutions, and setting reverse resolutions. Each step costs gas.

When we worked with Nouns DAO to name their contracts, we saw this problem firsthand. They had to create subnames, set forward resolutions, and set reverse resolutions for each contract as a new step and their governance only allows maximum 10 transaction in a single proposal. This was their first proposal: ENS x Nouns, Name our Smart Contracts which didn't get through because of this issue.

Thus we built the Enscribe V2 contract to support batch naming with multi-chain support. This contract is now live on Ethereum mainnet and Sepolia testnet. You can read more about it in this blog post. Using the Enscribe V2 contract, you can name multiple contracts in one transaction.

We are now adding this batch naming feature support to our Enscribe UI app.

How Batch Naming Works​

Batch naming uses the Enscribe V2 contract's setNameBatch() function. This involves a single transaction for creating subnames under the same parent domain and setting forward resolutions for all contracts at once. For example, if you're naming 10 contracts under myproject.eth, you just need one transaction to create 10 subnames and forward resolutions for all 10 contracts.

But for setting primary names, you need to execute one transaction for each compatible contract (contracts that are ownable/ERC-173 compliant) to set reverse resolution. Here's what happens under the hood:

The Technical Flow​

1. Operator Access: First, Enscribe requests operator approval for your parent ENS domain. This is a one-time permission that allows the Enscribe contract to create subnames under your domain.

2. Batch Creation: All contract addresses and their corresponding names are sent in a single transaction to the Enscribe V2 contract. This creates subnames and sets forward resolutions for all contracts at once.

3. Reverse Resolution (L1): For contracts which are ownable/ERC-173 compliant and owned by your wallet, Enscribe sets up reverse resolution on Ethereum mainnet (or testnet), enabling address-to-name lookups.

4. L2 Primary Names: If you've selected L2 chains, Enscribe automatically switches to each chain and sets up primary names for the contracts there, ensuring consistent naming across all networks.

5. Operator Revocation: Finally, operator access is revoked, returning full control of your ENS domain to you.

All of this happens in one modal flow, with clear progress indicators for each step.

Parent Subdomains Support​

Batch naming supports automatic parent subdomain creation. If you're naming contracts hierarchically (e.g., vault1.defi.myproject.eth, vault2.defi.myproject.eth), Enscribe automatically creates the intermediate parent (defi.myproject.eth) with no forward resolution. This keeps your namespace organized.

Note that each new level of parent subdomain requires a new batch naming transaction. For example, if you're naming three contracts under myproject.eth (app1.myproject.eth, app2.myproject.eth, app3.myproject.eth) and two more contracts under defi.myproject.eth (vault1.defi.myproject.eth, vault2.defi.myproject.eth), you need two separate batch naming transactions:

1. First transaction: app1.myproject.eth, app2.myproject.eth, app3.myproject.eth, defi.myproject.eth
2. Second transaction: vault1.defi.myproject.eth, vault2.defi.myproject.eth

Step-by-Step Guide: Batch Naming Your Contracts​

Let's walk through naming multiple contracts using batch naming.

1. Navigate to Batch Naming​

Head to app.enscribe.xyz and click on "Batch Naming" from the homepage.

2. Choose Your Parent Domain​

Select the parent ENS domain under which all your contracts will be named. You can use:

• Your project's ENS domain (e.g., myproject.eth)
• The default Enscribe parent (deployd.eth)

3. Add Your Contracts​

Enter your contract addresses and their desired names. You can:

• Add contracts one by one using the "Add Entry" button or use Upload CSV to import a CSV file with contract addresses and names.
• You can also download a template CSV file to get started with the format. It has two columns - address and name.
• Use hierarchical names with dots (e.g., vault1.defi, vault2.defi)
• Mix different types of contracts in the same batch

Validation Features:

• Real-time validation of contract addresses
• Duplicate address detection
• Duplicate name detection
• Invalid label format warnings
• Auto-generated parent subdomains highlighted

4. Advanced Options: L2 Chain Selection​

Expand the Advanced Options section to configure L2 primary names.

Click "Choose L2 Chains" to select which Layer 2 networks you want to set up primary names on:

• Optimism
• Arbitrum
• Base
• Scroll
• Linea

The system will add the corresponding coin types and create additional transaction steps to switch to each chain and set primary names.

If you only want to set up L2 primary names without L1 forward/reverse resolution, enable "Skip L1 Naming" in the Advanced Options.

5. Review and Submit​

Once you've added all contracts and configured your options, click "Name Your Contracts". The system will:

• Validate all entries
• Verify contract ownership (for reverse resolution)
• Add steps for naming process

6. Execute Transaction Steps​

A modal will guide you through each step of the process:

Step Progress:

• ✅ Grant operator access
• ✅ Create subnames and set forward resolution (batched)
• ✅ Set reverse records (for owned contracts)
• ✅ Switch to L2 chains and set primary names
• ✅ Revoke operator access

Once all steps complete, you'll see a success screen showing:

• Your parent domain
• An expandable list of all named contracts with their addresses
• Share buttons for X/Twitter and Farcaster
• POAP claiming button (for mainnet deployments)

Limitations and Considerations​

Prerequisites​

• You must connect from an L1 chain (Ethereum mainnet or Sepolia)
• You need to give operator access for the parent domain (granted during the flow)
• For reverse resolution, you must own the contract (also contract must be ownable/ERC173 compatible)

Gas Considerations​

Batch naming is more gas-efficient than individual naming, but naming many contracts still requires significant gas. The transaction cost will depend on:

• Number of contracts in the batch
• Number of L2 chains selected

Maximum recommended batch size: 50 contracts (gas limits may reach for larger batches)

Try Batch Naming Today​

Ready to name multiple contracts? Visit app.enscribe.xyz, connect your wallet to Ethereum mainnet or Sepolia, navigate to "Batch Naming", and start naming.

We'd love to hear about your batch naming experience:

• Share your use cases and suggestions on Discord
• Join the conversation on Telegram
• Follow us on X/Twitter

Happy batch naming! 🚀

Enscribe is now available as a native Safe app. You can add Enscribe directly to your Safe environment and name contracts using your multisig wallet without leaving the Safe interface.

This update makes it easier for teams and DAOs to manage contract naming through their existing Safe workflows.

Why This Matters​

If you manage contracts through a Safe multisig, you can now:

• Name contracts directly from the Safe interface
• Deploy new contracts with ENS names set using your Safe wallet
• Queue naming transactions for other signers to review
• Execute contract naming once your signing threshold is met
• Keep all contract management in one place

Previously, connecting Enscribe to Safe required WalletConnect, which added friction to the process. With native Safe SDK integration, Enscribe works as a custom Safe app. Add it once, and it's available whenever you need it.

When you use Enscribe inside Safe, the contract naming process creates multiple transactions. These transactions are visible for you to review before signing, added to your Safe's transaction queue, shareable with other signers in your Safe, and executable by any signer once the signing threshold is reached. This workflow matches how Safe handles all multisig operations, making contract naming part of your standard governance process.

Adding Enscribe to Your Safe​

Here's how to add Enscribe as a custom app to your Safe:

Quick Add via Link​

Use this link to add Enscribe directly to your Safe.

If the link doesn't work, follow the manual steps below.

Manual Installation​

Step 1: Open Your Safe​

Navigate to app.safe.global and select the Safe you want to use.

Step 2: Access the Apps Menu​

Click on "Apps" in the left sidebar of your Safe interface.

Step 3: Add Custom App​

1. Click "Add custom app" in the top right
2. Enter the Enscribe app URL: https://app.enscribe.xyz
3. Confirm the app details
4. Click "Add"

Enscribe will now appear in your Safe's app list.

Step 4: Open Enscribe​

Click on Enscribe from your apps list to launch it within Safe.

Naming a Contract from Safe​

Once Enscribe is added to your Safe, you can name contracts using the same interface you're familiar with:

Step 1: Connect to Enscribe​

Open the Enscribe app from your Safe. The app will detect your Safe wallet automatically and connect.

Step 2: Choose Your Chain​

Select the network where your contract is deployed. Enscribe supports Ethereum Mainnet, Base, Linea, Optimism, Arbitrum, Scroll, and their testnets.

Step 3: Enter Contract Details​

Provide the contract address and choose the ENS name you want to assign. Enscribe will guide you through the naming process.

Step 4: Review Transactions​

Enscribe will show you the transactions needed to complete the naming process. This typically includes:

• Creating ENS subname
• Setting forward resolution for your contract
• Setting the primary name

Step 5: Sign and Queue​

When you sign these transactions in Safe:

• They're added to your Safe's transaction queue
• Other signers can review them
• Transactions show up in the "Queue" tab of your Safe
• You can share the queue with your team

Step 6: Execute After Threshold​

Once enough signers approve the transactions (based on your Safe's signing threshold), any signer can execute them. The contract naming completes when all transactions are confirmed onchain.

Managing Multiple Contracts​

If you're naming multiple contracts, you can queue all the transactions before executing any of them. This gives your team time to review everything together.

Each contract naming operation creates its own set of transactions in the queue. Signers can approve them individually or in batches, depending on your workflow.

Once all the transactions are approved or signed by the required number of signers, you can execute them all at once in a batched transaction, this will save you gas and time.

Feedback and Community​

Enscribe makes smart contracts easier to identify by giving them human-readable names. With native Safe support, teams can now manage contract naming through their existing multisig workflows.

If you have feedback or feature requests for the Safe app experience, reach out through our socials - X, Discord and Telegram

Happy naming! 🚀

Enscribe V2 is now deployed on Ethereum mainnet. This upgrade brings batch operations, multi-chain support, and gas optimizations that make naming large numbers of contracts practical.

Contract Addresses​

Ethereum Mainnet:

• Enscribe V2: 0x9B95a964DB0ab154A587cC667b4964BD5dD8dE81
• ENS Name: v2.app.enscribe.eth

Testnet (Sepolia):

• Enscribe V2: 0xeA80b94a8B339c592c4F08bcCC87De7b57384BDD
• ENS Name: v2.enscribe.named.eth

The Problem: Naming Contracts at Scale​

Projects deploying multiple smart contracts face a challenge: each contract needs a separate ENS transaction to get a human-readable name. For a project with 10, 20, or 100+ contracts, this means:

• Dozens of individual transactions
• High cumulative gas costs
• Hours of manual execution
• Complex workflow coordination

A DAO deploying governance contracts, treasury modules, and token contracts previously needed separate ENS transactions for each — monitoring every transaction and managing a complex deployment process.

Enscribe V2 solves this.

What's New​

Batch Contract Naming​

Name multiple existing contracts in a single transaction.

// Name 10 contracts at once
address[] memory contracts = [
    0x1234..., // governance.dao.eth
    0x5678..., // treasury.dao.eth
    0x9abc..., // token.dao.eth
    0x0000.... // 0x0 address to reserve the subname
];

string[] memory labels = ["governance", "treasury", "token", "reserve"];

enscribeV2.setNameBatch(
    contracts,
    labels,
    "dao.eth",
    [60, 2147492101] // Ethereum and Base cointypes
);

Note: The reserve subname is created with the address(0) address. This is useful when you just want to create the subname but not set an address yet.

ENSIP-19 Multi-Chain Support​

Set forward resolution for multiple chains at once:

uint256[] memory coinTypes = [
    60,    // Ethereum
    2147492101,   // Base
    42161, // Arbitrum
    10     // Optimism
];

enscribeV2.setName(
    contractAddress,
    "bridge",
    "protocol.eth",
    coinTypes
);

This matters for cross-chain protocols and multi-chain deployments where the same contract needs to resolve on different networks.

Simpler API​

Before V2:

bytes32 parentNode = namehash("myproject.eth"); // Manual computation
enscribe.setName(addr, "app", "myproject.eth", parentNode);

With V2:

enscribe.setName(addr, "app", "myproject.eth"); // Computed automatically

The contract now computes parent nodes using ENS's NameCoder library.

Reserve Names Without Addresses​

Create subnames without setting an address:

address[] memory contracts = [
    0x1234...,    // Active contract
    address(0),   // Reserve "staging", 0x0000000000000000000000000000000000000000 address
    0x5678...     // Active contract
];

enscribeV2.setNameBatch(
    contracts,
    ["prod", "staging", "analytics"],
    "myproject.eth"
);

As demontrated in Batch Contract Naming section also, using address(0) creates the subname but skips forward resolution — useful for just creating the subname.

Projects can now:

• Name dozens of contracts in one transaction
• Save gas through batch operations and new gas optimizations
• Can name contracts on multiple chains at once
• Fully ENSIP-19 compatible

Technical Improvements​

V2 includes several optimizations:

• ENS NameCoder Integration: Uses official ENS library gas savings per operation
• OpenZeppelin Create2: Deterministic contract deployment with industry-standard implementation
• Custom Errors and Events: ~50% gas savings on reverts compared to string messages
• Internal Optimizations: Automatic subname existence checking and address validation

What's Next​

Enscribe V2 contracts are live and ready to use via web3 libraries or transaction builders like Gnosis Safe.

Coming Soon:

• UI updates for batch operations and multi-chain support on Enscribe app
• EnscribeV2 integration to our Enscribe library
• EnscribeV2 for Basenames

Building Contract Identity​

Enscribe makes smart contracts easier to trust by giving them human-readable names. Earlier this year, we proposed an ENSIP for contract metadata standards. V2's batch capabilities and multi-chain support lay the groundwork for that vision — making it practical for projects to build complete, discoverable contract identities.

Whether you're deploying a DeFi protocol, launching a DAO, or building any multi-contract system, Enscribe V2 helps you establish clear contract identity from day one.

Questions? Join our Discord, Telegram or reach out on X.

Happy naming! 🚀

We created the Enscribe App to make it as simple as possible for teams to name their smart contracts. However, this approach is not always compatible with naming DAO contracts.

What we’ve noticed is that DAOs often use a high-level function wrapper that needs to call multiple transactions required to name a contract.

This requires multi-sig high level transaction calling a method such as execute() or executeTransactions() which wraps over executing multiple transactions, each represented by a calldata – an encoded form of a function call along with its arguments.

To make this kind of name setting easy, we’ve shipped a small feature in Enscribe that enables displaying call-data previews.

How to View Calldata?​

In the Enscribe App, there is now a new collapsable Advanced Options section. Open it and you’ll see a calldata section that shows a list of the transactions Enscribe will execute for your naming flow — including items such as subname creation, forward resolution, and reverse resolution.

To try this out yourself, when you paste a contract address, pick a parent (e.g. myapp.eth), and type a name, Enscribe now shows the exact encoded function calls of the transactions that will be sent on-chain as individual transactions.

Each entry shows the target, selector, and ABI-encoded calldata:

You can copy the individual calldata using the copy button displayed against it or you can also copy the entire calldata list in different forms by clicking on the Copy All button at the top of the list on the right side.

Realtime Updates​

This isn’t a static blob. Change any of the inputs — address, label, or parent, and the calldata recomputes instantly. If you switch from router.myapp.eth to vault.myapp.eth, you’ll watch the encoded arguments update in place.

L2 Calldata​

We also moved the Choose L2 Chains button into the Advanced Options section. L2 forward/reverse steps sometimes add extra calls (or different targets), and keeping them alongside the call-data preview makes it obvious what will happen. The calldata displayed also includes transactions that will execute on the L2 chain.

TLDR;​

• Enter your contract address.
• Pick a parent (e.g., myapp.eth) and type a label (e.g., router).
• Expand the Advanced Options section
• Expand the Call data section
• Copy the calldata

So head over to the Enscribe App, enter the details about the contract you want to name and inspect the calldata generated in the Advanced Options section.

Happy naming! 🚀

As part of our mission to fix Ethereum UX, educating users on everything to do with naming smart contracts and ENS is a key part of this.

While we have a lot of technical documentation on our site, what's been missing is guides that tie together the content in an easy to follow manner. We're launching a new Guides section to help developers deploy and name smart contracts with Enscribe on L1 and L2 networks. Think of it as a hands-on companion to our technical documentation.

What's New​

The Guides section focuses on practical tutorials you can follow along. While our documentation covers technical details, these guides walk you through real workflows step by step.

The new Guides section

What You'll Find​

Quick Start Guides​

We organized the most common use cases:

• Deploy & Name New Contract — Deploy fresh smart contracts with ENS naming during deployment
• Name Existing Contract — Add ENS names to contracts that are already deployed
• L2 Contract Naming — Name contracts on Layer 2 networks

Conceptual Guides​

For developers who want to understand the underlying concepts:

• ENS Primary Names Explained — Forward vs. reverse resolution
• L2 Primary Names Explained — Cross-chain ENS identity

We will be expanding the guides and add more real world examples and use cases shortly.

Share Your Feedback​

What guides would help your development workflow? Join our Discord, Telegram, or X to share ideas and connect with other developers using Enscribe.

Visit the Guides section to start naming your smart contracts.

Happy naming! 🚀

Historically the Enscribe App only supported creating subnames for naming smart contracts. This has changed with our latest release!

We recognise that some people may want to name their contracts directly with a 2LD such as mymultisig.eth or use a subname they have already created such as treasury.mytoken.eth.

We’re excited to introduce a revamped naming UX, where we’ve not only simplified the naming experience further for users, but now provide a second option when naming your contract via the Use Existing Name button.

This required us to think over the current naming flow and so we redesigned our Name Contract page all the while still keeping everything simple.

Creating a New Subname​

We now have a button called Create Subname that lets you create a new subname. We show the same UI elements as before but with a few changes. We’ve simplified selecting a parent domain by replacing the Parent Name drop-down with a text field instead.

We’ve added a Select Domain button that lets you select either one of your existing domains or the one provided by Enscribe –

You can also create a new domain using the ENS app by clicking on the Purchase New Domain button. Clicking on this button will show a dialog that will confirm if you want to go to the ENS app.

Using an Existing Name​

When you click on the Use Existing Name button, we show a Contract Name text field alongside the Select Name button to select one of the several names you already own.

Clicking on this button will show a dialog showing your names that can be selected.

When you select one of these names, it will be chosen as the name you want to set to your contract.

You can also enter an existing name in the text field.

This way, you don’t have to mint a new subname (and save gas!) and simply pick whichever name you would love to set for your contract

Simplifying Naming​

With the ability to use an existing name, we’ve cut down the effort it takes to name a contract when you already own a primary ENS name.

Our goal is for every contract on Ethereum to be named. Adding an option to use an existing name simplifies the naming process, giving users the choice to either create a new subname or simply use an existing name

It’s one more step in our broader mission to retire hex addresses for good from the Ethereum UX.

Head to Enscribe App and try to name your contract with an existing name.

Happy Naming! 🚀

With Enscribe, our mission has always been simple yet ambitious — to eliminate hex contract addresses from the Ethereum user experience. Hex strings like 0x123abc… are cryptic, intimidating and unfriendly to users.

ENS transforms these meaningless identifiers into human-readable names like vitalik.eth just like DNS resolves domain names on the internet to IP addresses.

With our latest update, we’re eliminating these annoying hex addresses from URLs, further enhancing Enscribe’s UX.

A Friendlier Way to Explore Contracts and Accounts​

Previously, if you wanted to explore details about an account or contract on Enscribe, you had to navigate using its hexadecimal address:

https://app.enscribe.xyz/explore/1/0xd8da6bf26964af9d7eed9e03e53415d37aa96045

Where 1 is the chain-id (Ethereum) and 0xd8da6bf26964af9d7eed9e03e53415d37aa96045 is an EOA on Ethereum.

Now, we’ve enhanced the experience so you can simply use ENS names instead:

https://app.enscribe.xyz/explore/1/vitalik.eth

Whether it’s an EOA (Externally Owned Account) or a smart contract, Enscribe will resolve the ENS name and fetch its details.

This doesn’t just work for the mainnet. Thanks to the support for resolving names on Layer 2 chains, we can also use a Layer 2 chain-id and the name with it, such as

https://app.enscribe.xyz/explore/8453/greg.base.eth

Why This Matters

Ethereum’s UX still leans heavily on raw addresses, making the ecosystem less approachable for everyday users. Our goal at Enscribe is to flip that narrative, to make names the default, and hex addresses optional. By supporting ENS names everywhere we display or consume on-chain data, we’re moving toward an Ethereum experience that’s:

• Human-friendly → Users interact with alice.eth, not 0x4b2...9f7.
• Consistent → Works across EOAs and contracts alike.
• Aligned with ENS adoption → Encouraging the ecosystem to name their contracts and improve discoverability.

Enscribe isn’t just about contract naming — we’re helping reshape Ethereum’s UX around names, not hex.

You can try it out now in the Enscribe app, check out vitalik.eth at

https://app.enscribe.xyz/explore/1/vitalik.eth

Happy Naming! 🚀

With Enscribe, we’re always looking for ways to make viewing smart contracts details simpler and safer for users. Our latest update to the Contract Details page introduces two subtle yet impactful changes designed to improve clarity and usability for our users.

Spot Your Primary Contracts at a Glance​

When looking at contract information, it can be a little overwhelming when trying to identify what the primary name of the contract is. To simplify this, we’ve introduced a blue tick next to primary contract names.

Now, when you view the Contract Details page for a particular contract, you can easily see if a primary name is set for the contract.

We’ve also shown a tooltip that tells you you are looking at a primary name:

For contracts that have no primary name set but do have at least one forward resolution name set, we now also show that name:

However, to make sure that we differentiate between primary and forward resolution names, we show the usual cautionary warning sign as well as explain it in the tooltip:

Introducing the “Name It!” Button​

Contracts without names can make browsing blockchain data cumbersome. That’s why we’ve added the Name It! button next to contract addresses that:

• Don’t yet have a primary name set, or
• Have at least one forward resolution name available.

Here’s a proxy contract that has no name set:

Here’s a contract that doesn’t have a primary name set but has a forward resolution name set:

Clicking the button takes you straight to the Name Contract page on Enscribe, with the contract address pre-filled. This saves you time, reduces manual input and ensures you can seamlessly add meaningful, human-readable names to your contracts.

By making it easier to name your contracts, we’re helping you keep your on-chain activity clear and structured.

Why These Changes Matter​

With these enhancements, we’re continuing our mission to make on-chain data more accessible and user-friendly. Whether you’re a developer, an ENS enthusiast, or just someone managing multiple contracts for a project, these updates simplify contract name identification and improve overall interaction experience on Enscribe

Go check your contract on the Contract Details page today and let us know what you think about them on our X/Telegram/Discord channels.

Happy naming! 🚀