@enscribe/hardhat-enscribe 0.1.1

package/dist/src/internal/config/contracts.js

@@ -0,0 +1,168 @@
+// ENS Contract addresses for different networks
+export const ENS_CONTRACTS = {
+    // Mainnet addresses
+    mainnet: {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "0xF29100983E058B709F3D539b0c765937B804AC15",
+        NAME_WRAPPER: "0xD4416b13d2b3a9aBae7AcD5D6C2BbDBE25686401",
+        REVERSE_REGISTRAR: "0xa58E81fe9b61B5c3fE2AFD33CF304c454AbFc7Cb",
+        L2_REVERSE_REGISTRAR: "",
+    },
+    // Sepolia testnet addresses
+    sepolia: {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "0xE99638b40E4Fff0129D56f03b55b6bbC4BBE49b5",
+        NAME_WRAPPER: "0x0635513f179D50A207757E05759CbD106d7dFcE8",
+        REVERSE_REGISTRAR: "0xA0a1AbcDAe1a2a4A2EF8e9113Ff0e02DD81DC0C6",
+        L2_REVERSE_REGISTRAR: "",
+    },
+    // Linea mainnet addresses
+    linea: {
+        ENS_REGISTRY: "0x50130b669B28C339991d8676FA73CF122a121267",
+        PUBLIC_RESOLVER: "0x86c5AED9F27837074612288610fB98ccC1733126",
+        NAME_WRAPPER: "0xA53cca02F98D590819141Aa85C891e2Af713C223",
+        REVERSE_REGISTRAR: "0x08D3fF6E65f680844fd2465393ff6f0d742b67D5",
+        L2_REVERSE_REGISTRAR: "0x0000000000D8e504002cC26E3Ec46D81971C1664",
+    },
+    // Linea Sepolia testnet addresses
+    "linea-sepolia": {
+        ENS_REGISTRY: "0x5B2636F0f2137B4aE722C01dd5122D7d3e9541f7",
+        PUBLIC_RESOLVER: "0xA2008916Ed2d7ED0Ecd747a8a5309267e42cf1f1",
+        NAME_WRAPPER: "0xF127De9E039a789806fEd4C6b1C0f3aFfeA9425e",
+        REVERSE_REGISTRAR: "0x4aAA964D8EB65508ca3DA3b0A3C060c16059E613",
+        L2_REVERSE_REGISTRAR: "0x00000BeEF055f7934784D6d81b6BC86665630dbA",
+    },
+    // Base mainnet addresses
+    base: {
+        ENS_REGISTRY: "0xB94704422c2a1E396835A571837Aa5AE53285a95",
+        PUBLIC_RESOLVER: "0xC6d566A56A1aFf6508b41f6c90ff131615583BCD",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "0x79EA96012eEa67A83431F1701B3dFf7e37F9E282",
+        L2_REVERSE_REGISTRAR: "0x0000000000D8e504002cC26E3Ec46D81971C1664",
+    },
+    // Base Sepolia testnet addresses
+    "base-sepolia": {
+        ENS_REGISTRY: "0x1493b2567056c2181630115660963E13A8E32735",
+        PUBLIC_RESOLVER: "0x6533C94869D28fAA8dF77cc63f9e2b2D6Cf77eBA",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "0xa0A8401ECF248a9375a0a71C4dedc263dA18dCd7",
+        L2_REVERSE_REGISTRAR: "0x00000BeEF055f7934784D6d81b6BC86665630dbA",
+    },
+    // Optimism mainnet addresses
+    optimism: {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x0000000000D8e504002cC26E3Ec46D81971C1664",
+    },
+    // Optimism Sepolia testnet addresses
+    "optimism-sepolia": {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x00000BeEF055f7934784D6d81b6BC86665630dbA",
+    },
+    // Arbitrum mainnet addresses
+    arbitrum: {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x0000000000D8e504002cC26E3Ec46D81971C1664",
+    },
+    // Arbitrum Sepolia testnet addresses
+    "arbitrum-sepolia": {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x00000BeEF055f7934784D6d81b6BC86665630dbA",
+    },
+    // Scroll mainnet addresses
+    scroll: {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x0000000000D8e504002cC26E3Ec46D81971C1664",
+    },
+    // Scroll Sepolia testnet addresses
+    "scroll-sepolia": {
+        ENS_REGISTRY: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "0x00000BeEF055f7934784D6d81b6BC86665630dbA",
+    },
+    // Local development addresses (will be set during deployment)
+    localhost: {
+        ENS_REGISTRY: "0x0000000000000000000000000000000000000000", // Placeholder for local development
+        PUBLIC_RESOLVER: "",
+        NAME_WRAPPER: "",
+        REVERSE_REGISTRAR: "",
+        L2_REVERSE_REGISTRAR: "",
+    },
+};
+// Helper function to get contract addresses for a given network
+export function getContractAddresses(networkName) {
+    const addresses = ENS_CONTRACTS[networkName];
+    if (!addresses) {
+        throw new Error(`Unsupported network: ${networkName}`);
+    }
+    return addresses;
+}
+// Helper function to get network name from chain ID
+export function getNetworkNameFromChainId(chainId) {
+    switch (chainId) {
+        case 1:
+            return "mainnet";
+        case 11155111:
+            return "sepolia";
+        case 59144:
+            return "linea";
+        case 59141:
+            return "linea-sepolia";
+        case 8453:
+            return "base";
+        case 84532:
+            return "base-sepolia";
+        case 10:
+            return "optimism";
+        case 11155420:
+            return "optimism-sepolia";
+        case 42161:
+            return "arbitrum";
+        case 421614:
+            return "arbitrum-sepolia";
+        case 534352:
+            return "scroll";
+        case 534351:
+            return "scroll-sepolia";
+        case 31337:
+            return "localhost";
+        default:
+            throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+}
+// Helper function to validate contract addresses
+export function validateContractAddresses(addresses) {
+    const requiredContracts = ["ENS_REGISTRY"]; // Only ENS_REGISTRY is always required
+    const optionalContracts = ["PUBLIC_RESOLVER", "NAME_WRAPPER", "REVERSE_REGISTRAR", "L2_REVERSE_REGISTRAR"];
+    // Validate required contracts
+    for (const contract of requiredContracts) {
+        if (!addresses[contract]) {
+            throw new Error(`Missing contract address for ${contract}`);
+        }
+        if (!addresses[contract].match(/^0x[a-fA-F0-9]{40}$/)) {
+            throw new Error(`Invalid contract address format for ${contract}: ${addresses[contract]}`);
+        }
+    }
+    // Validate optional contracts (if provided, must be valid format)
+    for (const contract of optionalContracts) {
+        if (addresses[contract] && addresses[contract] !== "" && !addresses[contract].match(/^0x[a-fA-F0-9]{40}$/)) {
+            throw new Error(`Invalid contract address format for ${contract}: ${addresses[contract]}`);
+        }
+    }
+}

package/dist/src/internal/constants.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "hardhat-enscribe";

package/dist/src/internal/constants.js

@@ -0,0 +1 @@
+export const PLUGIN_ID = "hardhat-enscribe";

package/dist/src/internal/tasks/name.d.ts

@@ -0,0 +1,9 @@
+import type { NewTaskActionFunction } from "hardhat/types/tasks";
+import "@nomicfoundation/hardhat-viem";
+interface TaskNameArguments {
+    name: string;
+    contract?: string;
+    chain?: string;
+}
+declare const taskName: NewTaskActionFunction<TaskNameArguments>;
+export default taskName;

package/dist/src/internal/tasks/name.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/internal/tasks/name.integration.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { namehash } from "viem/ens";
+import { keccak256, toBytes } from "viem";
+import { parseNormalizedName } from "../utils.js";
+// Mock Hardhat Runtime Environment for testing
+const mockHRE = {
+    network: {
+        connect: vi.fn().mockResolvedValue({
+            viem: {
+                getWalletClients: vi.fn().mockResolvedValue([
+                    {
+                        account: {
+                            address: "0x1234567890123456789012345678901234567890",
+                        },
+                        chain: {
+                            id: 31337, // Hardhat local network ID
+                        },
+                    },
+                ]),
+                getContractAt: vi.fn(),
+            },
+        }),
+    },
+    userConfig: {
+        networks: {},
+    },
+};
+describe("ENS Primary Name Setting Integration Tests", () => {
+    let ensRegistry;
+    let publicResolver;
+    let nameWrapper;
+    let reverseRegistrar;
+    let testWallet;
+    beforeEach(async () => {
+        // This would be set up in a real Hardhat test environment
+        // For now, we'll create mock contracts
+        ensRegistry = {
+            recordExists: vi.fn(),
+            setSubnodeRecord: vi.fn(),
+        };
+        publicResolver = {
+            addr: vi.fn(),
+            setAddr: vi.fn(),
+        };
+        nameWrapper = {
+            isWrapped: vi.fn(),
+            setSubnodeRecord: vi.fn(),
+        };
+        reverseRegistrar = {
+            setNameForAddr: vi.fn(),
+        };
+        testWallet = {
+            account: {
+                address: "0x1234567890123456789012345678901234567890",
+            },
+            chain: {
+                id: 31337,
+            },
+        };
+    });
+    describe("parseNormalizedName utility", () => {
+        it("should correctly parse ENS names for contract naming", () => {
+            const testCases = [
+                {
+                    input: "mynft.abhi.eth",
+                    expected: { label: "mynft", parent: "abhi.eth" },
+                },
+                {
+                    input: "contract.example.eth",
+                    expected: { label: "contract", parent: "example.eth" },
+                },
+                {
+                    input: "sub.domain.example.eth",
+                    expected: { label: "sub", parent: "domain.example.eth" },
+                },
+            ];
+            testCases.forEach(({ input, expected }) => {
+                const result = parseNormalizedName(input);
+                expect(result).toEqual(expected);
+            });
+        });
+    });
+    describe("ENS name creation flow", () => {
+        it("should create subname when parent domain is wrapped", async () => {
+            // Mock that parent is wrapped
+            nameWrapper.isWrapped.mockResolvedValue(true);
+            // Mock that name doesn't exist yet
+            ensRegistry.recordExists.mockResolvedValue(false);
+            const normalizedName = "testcontract.abhi.eth";
+            const { label, parent } = parseNormalizedName(normalizedName);
+            const parentNode = namehash(parent);
+            const fullNameNode = namehash(normalizedName);
+            // Verify the flow would call correct functions
+            expect(label).toBe("testcontract");
+            expect(parent).toBe("abhi.eth");
+            expect(parentNode).toBeDefined();
+            expect(fullNameNode).toBeDefined();
+        });
+        it("should create subname when parent domain is not wrapped", async () => {
+            // Mock that parent is not wrapped
+            nameWrapper.isWrapped.mockResolvedValue(false);
+            // Mock that name doesn't exist yet
+            ensRegistry.recordExists.mockResolvedValue(false);
+            const normalizedName = "testcontract.example.eth";
+            const { label, parent } = parseNormalizedName(normalizedName);
+            const parentNode = namehash(parent);
+            const labelHash = keccak256(toBytes(label));
+            // Verify the flow would call correct functions
+            expect(label).toBe("testcontract");
+            expect(parent).toBe("example.eth");
+            expect(parentNode).toBeDefined();
+            expect(labelHash).toBeDefined();
+        });
+        it("should skip subname creation if name already exists", async () => {
+            // Mock that name already exists
+            ensRegistry.recordExists.mockResolvedValue(true);
+            const normalizedName = "existing.abhi.eth";
+            const fullNameNode = namehash(normalizedName);
+            // Should skip creation
+            expect(fullNameNode).toBeDefined();
+        });
+    });
+    describe("Forward resolution setting", () => {
+        it("should set forward resolution when current address differs", async () => {
+            const contractAddress = "0x9876543210987654321098765432109876543210";
+            const currentAddr = "0x1111111111111111111111111111111111111111";
+            const normalizedName = "testcontract.abhi.eth";
+            const fullNameNode = namehash(normalizedName);
+            // Mock current resolution
+            publicResolver.addr.mockResolvedValue(currentAddr);
+            // Should set new resolution
+            expect(currentAddr.toLowerCase()).not.toBe(contractAddress.toLowerCase());
+        });
+        it("should skip forward resolution when already set correctly", async () => {
+            const contractAddress = "0x9876543210987654321098765432109876543210";
+            const currentAddr = "0x9876543210987654321098765432109876543210";
+            const normalizedName = "testcontract.abhi.eth";
+            const fullNameNode = namehash(normalizedName);
+            // Mock current resolution matches
+            publicResolver.addr.mockResolvedValue(currentAddr);
+            // Should skip setting
+            expect(currentAddr.toLowerCase()).toBe(contractAddress.toLowerCase());
+        });
+    });
+    describe("Reverse resolution setting", () => {
+        it("should set reverse resolution for contract", async () => {
+            const contractAddress = "0x9876543210987654321098765432109876543210";
+            const normalizedName = "testcontract.abhi.eth";
+            const ownerAddress = testWallet.account.address;
+            // Verify reverse resolution would be set
+            expect(contractAddress).toBeDefined();
+            expect(normalizedName).toBeDefined();
+            expect(ownerAddress).toBeDefined();
+        });
+    });
+    describe("Complete naming flow integration", () => {
+        it("should execute complete flow for new contract naming", async () => {
+            const normalizedName = "newcontract.abhi.eth";
+            const contractAddress = "0x9876543210987654321098765432109876543210";
+            // Parse the name
+            const { label, parent } = parseNormalizedName(normalizedName);
+            // Generate required hashes
+            const parentNode = namehash(parent);
+            const fullNameNode = namehash(normalizedName);
+            const labelHash = keccak256(toBytes(label));
+            // Verify all components are ready
+            expect(label).toBe("newcontract");
+            expect(parent).toBe("abhi.eth");
+            expect(parentNode).toBeDefined();
+            expect(fullNameNode).toBeDefined();
+            expect(labelHash).toBeDefined();
+            // This test verifies the data preparation for the complete flow
+            // In a real integration test, we would:
+            // 1. Deploy ENS contracts to local Hardhat network
+            // 2. Set up parent domain ownership
+            // 3. Execute the actual contract calls
+            // 4. Verify the results on-chain
+        });
+    });
+});

package/dist/src/internal/tasks/name.js

@@ -0,0 +1,265 @@
+import "@nomicfoundation/hardhat-viem";
+import { namehash, normalize } from "viem/ens";
+import { readContract, writeContract, waitForTransactionReceipt } from "viem/actions";
+import { keccak256, toBytes } from "viem";
+import ensRegistryABI from "../abi/ENSRegistry.js";
+import ownableContractABI from "../abi/Ownable.js";
+import nameWrapperABI from "../abi/NameWrapper.js";
+import publicResolverABI from "../abi/PublicResolver.js";
+import reverseRegistrarABI from "../abi/ReverseRegistrar.js";
+import { isAddressEmpty, isAddressValid, parseNormalizedName, logMetric, } from "../utils.js";
+import { getContractAddresses } from "../config/contracts.js";
+import { v4 as uuid } from 'uuid';
+// Global contracts object - will be initialized based on chain
+let contracts = {};
+const opType = 'hh-enscribe-nameexisting';
+const corelationId = uuid();
+const taskName = async (args, hre) => {
+    // console.log(args);
+    if (args.contract == null) {
+        console.log("need to pass a contract address");
+        return;
+    }
+    // Determine network from chain parameter or default to sepolia
+    const networkName = args.chain || "sepolia";
+    // Initialize global contracts object based on network
+    contracts = getContractAddresses(networkName);
+    const { viem } = await hre.network.connect(networkName);
+    // console.log(hre.userConfig.networks);
+    const [senderClient, recvrClient] = await viem.getWalletClients();
+    // console.log(senderClient.account);
+    const nameNormalized = normalize(args.name);
+    console.log(`normalized name is ${nameNormalized}`);
+    await setPrimaryName(nameNormalized, args.contract, senderClient);
+};
+const isOwnable = async (address, walletClient) => {
+    if (isAddressEmpty(address) || !isAddressValid(address)) {
+        return false;
+    }
+    try {
+        const _ = (await readContract(walletClient, {
+            address: address,
+            abi: ownableContractABI,
+            functionName: "owner",
+            args: [],
+        }));
+        console.log("contract implements Ownable");
+    }
+    catch (err) {
+        return false;
+    }
+    return true;
+};
+const isReverseClaimable = async (address, walletClient) => {
+    if (isAddressEmpty(address) || !isAddressValid(address)) {
+        return;
+    }
+    try {
+        const addrLabel = address.slice(2).toLowerCase();
+        const reversedNode = namehash(addrLabel + '.' + 'addr.reverse');
+        const resolvedAddr = (await readContract(walletClient, {
+            address: contracts.ENS_REGISTRY,
+            abi: ensRegistryABI,
+            functionName: 'owner',
+            args: [reversedNode],
+        }));
+        console.log('resolvedaddr is ' + resolvedAddr);
+        if (resolvedAddr.toLowerCase() === walletClient.account?.address.toLowerCase()) {
+            console.log('contract implements Reverseclaimable');
+            return true;
+        }
+        else {
+            console.log('contract does not implement reverseclaimable');
+            return false;
+        }
+    }
+    catch (err) {
+        console.log('there was an error checking if the contract was reverse claimer');
+        return false;
+    }
+};
+const isContractOwner = async (address, walletClient) => {
+    if (isAddressEmpty(address) || !isAddressValid(address) || !walletClient) {
+        return false;
+    }
+    try {
+        const ownerAddress = (await readContract(walletClient, {
+            address: address,
+            abi: ownableContractABI,
+            functionName: 'owner',
+            args: [],
+        }));
+        return ownerAddress.toLowerCase() == walletClient.account?.address.toLowerCase();
+    }
+    catch (err) {
+        // console.log('err ' + err);
+        const addrLabel = address.slice(2).toLowerCase();
+        const reversedNode = namehash(addrLabel + '.' + 'addr.reverse');
+        const resolvedAddr = (await readContract(walletClient, {
+            address: contracts.ENS_REGISTRY,
+            abi: ensRegistryABI,
+            functionName: 'owner',
+            args: [reversedNode],
+        }));
+        return resolvedAddr.toLowerCase() == walletClient.account?.address.toLowerCase();
+    }
+};
+const setPrimaryName = async (normalizedName, contractAddress, walletClient) => {
+    const { label, parent } = parseNormalizedName(normalizedName);
+    const parentNode = namehash(parent);
+    const labelHash = keccak256(toBytes(label));
+    const fullNameNode = namehash(normalizedName);
+    const nameExists = (await readContract(walletClient, {
+        address: contracts.ENS_REGISTRY,
+        abi: ensRegistryABI,
+        functionName: "recordExists",
+        args: [fullNameNode],
+    }));
+    let contractType = 'Unknown';
+    if (await isReverseClaimable(contractAddress, walletClient)) {
+        contractType = 'ReverseClaimer';
+    }
+    if (await isOwnable(contractAddress, walletClient)) {
+        contractType = 'Ownable';
+    }
+    // create subname
+    if (!nameExists) {
+        process.stdout.write(`creating subname ... `);
+        let txn;
+        const isWrapped = await readContract(walletClient, {
+            address: contracts.NAME_WRAPPER,
+            abi: nameWrapperABI,
+            functionName: "isWrapped",
+            args: [parentNode],
+        });
+        if (isWrapped) {
+            // console.log(
+            //   "create subname::writeContract calling setSubnodeRecord on NAME_WRAPPER",
+            // );
+            txn = await writeContract(walletClient, {
+                address: contracts.NAME_WRAPPER,
+                abi: nameWrapperABI,
+                functionName: "setSubnodeRecord",
+                args: [
+                    parentNode,
+                    label,
+                    walletClient.account?.address,
+                    contracts.PUBLIC_RESOLVER,
+                    0,
+                    0,
+                    0,
+                ],
+                account: walletClient.account,
+                chain: walletClient.chain,
+            });
+            // console.log(`create subname txn: ${txn}`);
+            await waitForTransactionReceipt(walletClient, { hash: txn });
+            process.stdout.write(`done with txn: ${txn}\n`);
+            await logMetric(corelationId, Date.now(), walletClient.chain?.id, contractAddress, walletClient.account?.address, normalizedName, 'subname::setSubnodeRecord', txn, contractType, opType);
+        }
+        else {
+            // console.log(
+            //   "create subname::writeContract calling setSubnodeRecord on ENS_REGISTRY",
+            // );
+            txn = await writeContract(walletClient, {
+                address: contracts.ENS_REGISTRY,
+                abi: ensRegistryABI,
+                functionName: "setSubnodeRecord",
+                args: [
+                    parentNode,
+                    labelHash,
+                    walletClient.account?.address,
+                    contracts.PUBLIC_RESOLVER,
+                    0,
+                ],
+                account: walletClient.account,
+                chain: walletClient.chain,
+            });
+            // console.log(`create subname txn: ${txn}`);
+            await waitForTransactionReceipt(walletClient, { hash: txn });
+            process.stdout.write(`done with txn: ${txn}\n`);
+            await logMetric(corelationId, Date.now(), walletClient.chain?.id, contractAddress, walletClient.account?.address, normalizedName, 'subname::setSubnodeRecord', txn, contractType, opType);
+        }
+    }
+    else {
+        process.stdout.write(`${normalizedName} already exists. skipping subname creation.\n`);
+    }
+    // Wait for subname creation to be confirmed before proceeding
+    // set fwd res
+    process.stdout.write(`setting forward resolution ... `);
+    const currentAddr = (await readContract(walletClient, {
+        address: contracts.PUBLIC_RESOLVER,
+        abi: publicResolverABI,
+        functionName: "addr",
+        args: [fullNameNode],
+    }));
+    if (currentAddr.toLowerCase() !== contractAddress.toLowerCase()) {
+        // console.log("set fwdres::writeContract calling setAddr on PUBLIC_RESOLVER");
+        let txn = await writeContract(walletClient, {
+            address: contracts.PUBLIC_RESOLVER,
+            abi: publicResolverABI,
+            functionName: "setAddr",
+            args: [fullNameNode, contractAddress],
+            account: walletClient.account,
+            chain: walletClient.chain,
+        });
+        await waitForTransactionReceipt(walletClient, { hash: txn });
+        process.stdout.write(`done with txn: ${txn}\n`);
+        await logMetric(corelationId, Date.now(), walletClient.chain?.id, contractAddress, walletClient.account?.address, normalizedName, 'fwdres::setAddr', txn, contractType, opType);
+    }
+    else {
+        process.stdout.write("forward resolution already set.\n");
+    }
+    // set rev res
+    process.stdout.write(`setting reverse resolution ... `);
+    if (await isContractOwner(contractAddress, walletClient)) {
+        let txn;
+        if (contractType === 'ReverseClaimer') {
+            const addrLabel = contractAddress.slice(2).toLowerCase();
+            const reversedNode = namehash(addrLabel + '.' + 'addr.reverse');
+            // console.log('reversedNode is ' + reversedNode + '\n');
+            // console.log('pub res is ' + contracts.PUBLIC_RESOLVER + '\n');
+            txn = await writeContract(walletClient, {
+                address: contracts.PUBLIC_RESOLVER,
+                abi: publicResolverABI,
+                functionName: 'setName',
+                args: [
+                    reversedNode,
+                    normalizedName,
+                ],
+                account: walletClient.account,
+                chain: walletClient.chain,
+            });
+            await waitForTransactionReceipt(walletClient, { hash: txn });
+            process.stdout.write(`done with txn: ${txn}\n`);
+            await logMetric(corelationId, Date.now(), walletClient.chain?.id, contractAddress, walletClient.account?.address, normalizedName, 'revres::setName', txn, 'ReverseClaimer', opType);
+        }
+        else if (contractType === 'Ownable') {
+            txn = await writeContract(walletClient, {
+                address: contracts.REVERSE_REGISTRAR,
+                abi: reverseRegistrarABI,
+                functionName: "setNameForAddr",
+                args: [
+                    contractAddress,
+                    walletClient.account?.address,
+                    contracts.PUBLIC_RESOLVER,
+                    normalizedName,
+                ],
+                account: walletClient.account,
+                chain: walletClient.chain,
+            });
+            await waitForTransactionReceipt(walletClient, { hash: txn });
+            process.stdout.write(`done with txn: ${txn}\n`);
+            await logMetric(corelationId, Date.now(), walletClient.chain?.id, contractAddress, walletClient.account?.address, normalizedName, 'revres::setNameForAddr', txn, 'Ownable', opType);
+        }
+        else {
+            console.log(`Only Ownable, ERC173 and ReverseClaimer contracts can be named.`);
+            return;
+        }
+    }
+    else {
+        console.log(`You are not the owner of this contract. Skipping reverse resolution.\n`);
+    }
+    console.log(`✨ Contract named: https://app.enscribe.xyz/explore/${walletClient.chain?.id}/${normalizedName}`);
+};
+export default taskName;

package/dist/src/internal/tasks/name.test.d.ts

@@ -0,0 +1 @@
+export {};