@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/cjs/index.js

@@ -31,6 +31,7 @@ const contracts_1 = __importDefault(require("./contracts"));
 const getContractAddress_1 = require("./contracts/getContractAddress");
 const GqlManager_1 = __importDefault(require("./GqlManager"));
 const singleCall_1 = __importDefault(require("./utils/singleCall"));
+const writeTx_1 = __importDefault(require("./utils/writeTx"));
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -89,15 +90,30 @@ class ENS {
             await thisRef.checkInitialProvider();
             // import the module dynamically
             const mod = await Promise.resolve().then(() => __importStar(require(
-            /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+            /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
             `./functions/${path}`)));
             // if combine isn't specified, run normally
             // otherwise, create a function from the raw and decode functions
             if (subFunc !== 'combine') {
+                const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
                 // get the function to call
-                const func = subFunc ? mod[exportName][subFunc] : mod[exportName];
+                const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
                 // get the dependencies to forward to the function as the first arg
-                const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                // if func is write func, inject signer into dependencies
+                if (writeable) {
+                    const options = (args[1] || {});
+                    const signer = options.signer ||
+                        thisRef.provider?.getSigner(options.addressOrIndex);
+                    const populate = subFunc === 'populateTransaction';
+                    if (!signer) {
+                        throw new Error('No signer specified');
+                    }
+                    delete options.addressOrIndex;
+                    delete options.signer;
+                    dependenciesToForward = { ...dependenciesToForward, signer };
+                    return func(dependenciesToForward, args[0], options).then((0, writeTx_1.default)(signer, populate));
+                }
                 // return the function with the dependencies forwarded
                 return func(dependenciesToForward, ...args);
             }
@@ -114,6 +130,9 @@ class ENS {
             mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
             mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
         }
+        else if (subFunc === 'write') {
+            mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
+        }
         return mainFunc;
     };
     /**
@@ -124,6 +143,14 @@ class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
+    /**
+     * Generates a write wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    generateWriteFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'write');
     /**
      * Generates a wrapped function from raw and decode exports
      * @param {string} path - The path of the exported function
@@ -166,6 +193,7 @@ class ENS {
         'gqlInstance',
         'getName',
         'resolverMulticallWrapper',
+        'multicallWrapper',
         '_getAddr',
         '_getContentHash',
         '_getText',
@@ -193,31 +221,27 @@ class ENS {
     universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
     resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
     multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-    setName = this.generateFunction('setName', [
+    setName = this.generateWriteFunction('setName', [
         'contracts',
-        'provider',
     ]);
-    setRecords = this.generateFunction('setRecords', [
+    setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setRecord = this.generateWriteFunction('setRecord', [
         'contracts',
         'provider',
         'getResolver',
     ]);
-    setResolver = this.generateFunction('setResolver', ['contracts', 'provider']);
-    transferName = this.generateFunction('transferName', ['contracts', 'provider']);
-    wrapName = this.generateFunction('wrapName', [
+    setResolver = this.generateWriteFunction('setResolver', ['contracts']);
+    transferName = this.generateWriteFunction('transferName', ['contracts']);
+    wrapName = this.generateWriteFunction('wrapName', [
         'contracts',
-        'provider',
     ]);
-    unwrapName = this.generateFunction('unwrapName', [
+    unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
+    burnFuses = this.generateWriteFunction('burnFuses', [
         'contracts',
-        'provider',
-    ]);
-    burnFuses = this.generateFunction('burnFuses', [
-        'contracts',
-        'provider',
     ]);
-    createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
-    deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
-    transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts']);
+    deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
 }
 exports.ENS = ENS;

package/dist/cjs/utils/labels.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkLocalStorageSize = exports.truncateUndecryptedName = exports.decryptName = exports.checkIsDecrypted = exports.parseName = exports.encodeLabel = exports.checkLabel = exports.saveName = exports.saveLabel = exports.isEncodedLabelhash = exports.encodeLabelhash = exports.decodeLabelhash = exports.keccakFromString = exports.labelhash = void 0;
 const utils_1 = require("ethers/lib/utils");
 const format_1 = require("./format");
+const hasLocalStorage = typeof localStorage !== 'undefined';
 const labelhash = (input) => (0, utils_1.solidityKeccak256)(['string'], [input]);
 exports.labelhash = labelhash;
 const keccakFromString = (input) => (0, exports.labelhash)(input);
@@ -14,7 +15,7 @@ function decodeLabelhash(hash) {
     if (hash.length !== 66) {
         throw Error('Expected encoded labelhash to have a length of 66');
     }
-    return `${hash.slice(1, -1)}`;
+    return `0x${hash.slice(1, -1)}`;
 }
 exports.decodeLabelhash = decodeLabelhash;
 function encodeLabelhash(hash) {
@@ -32,12 +33,12 @@ function isEncodedLabelhash(hash) {
 }
 exports.isEncodedLabelhash = isEncodedLabelhash;
 function getLabels() {
-    return localStorage
+    return hasLocalStorage
         ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
         : {};
 }
 function _saveLabel(hash, label) {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return hash;
     const labels = getLabels();
     localStorage.setItem('ensjs:labels', JSON.stringify({
@@ -97,7 +98,7 @@ exports.decryptName = decryptName;
 const truncateUndecryptedName = (name) => (0, format_1.truncateFormat)(name);
 exports.truncateUndecryptedName = truncateUndecryptedName;
 function checkLocalStorageSize() {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return 'Empty (0 KB)';
     let allStrings = '';
     for (const key in window.localStorage) {

package/dist/cjs/utils/makeHashIndexes.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeNamehashIndexes = exports.makeOtherIndexes = void 0;
-const ethers_1 = require("ethers");
+const normalise_1 = require("./normalise");
 const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
 exports.makeOtherIndexes = makeOtherIndexes;
-const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(ethers_1.ethers.utils.namehash(name).substring(2))).map((x) => x.index / 2 - 1);
+const makeNamehashIndexes = (data, name) => Array.from(data.matchAll((0, normalise_1.namehash)(name).substring(2))).map((x) => x.index / 2 - 1);
 exports.makeNamehashIndexes = makeNamehashIndexes;

package/dist/cjs/utils/normalise.d.ts

@@ -1 +1,2 @@
 export declare const normalise: (name: string) => any;
+export declare const namehash: (name: string) => string;

package/dist/cjs/utils/normalise.js

@@ -3,7 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalise = void 0;
+exports.namehash = exports.normalise = void 0;
+const utils_1 = require("ethers/lib/utils");
 const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+const labels_1 = require("./labels");
+const zeros = new Uint8Array(32);
+zeros.fill(0);
 const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
 exports.normalise = normalise;
+const namehash = (name) => {
+    let result = zeros;
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            let labelSha;
+            if ((0, labels_1.isEncodedLabelhash)(labels[i])) {
+                labelSha = (0, labels_1.decodeLabelhash)(labels[i]);
+            }
+            else {
+                const normalised = (0, exports.normalise)(labels[i]);
+                labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(normalised));
+            }
+            result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
+        }
+    }
+    else {
+        result = (0, utils_1.hexlify)(zeros);
+    }
+    return result;
+};
+exports.namehash = namehash;

package/dist/cjs/utils/recordHelpers.d.ts

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/cjs/utils/recordHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRecordCallArray = exports.generateSetAddr = void 0;
+exports.generateRecordCallArray = exports.generateSingleRecordCall = exports.generateSetAddr = void 0;
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const contentHash_1 = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
@@ -16,28 +16,55 @@ const generateSetAddr = (namehash, coinType, address, resolver) => {
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
 exports.generateSetAddr = generateSetAddr;
+function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = (0, contentHash_1.encodeContenthash)(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return (0, exports.generateSetAddr)(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+exports.generateSingleRecordCall = generateSingleRecordCall;
 const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.encodeContenthash)(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
         data && calls.push(data);
     }
     if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
     }
     if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = (0, exports.generateSetAddr)(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/dist/cjs/utils/registerHelpers.js

@@ -7,6 +7,7 @@ exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
 const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
 const recordHelpers_1 = require("./recordHelpers");
 const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
@@ -15,11 +16,9 @@ const randomSecret = () => {
 exports.randomSecret = randomSecret;
 const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
     const label = (0, labels_1.labelhash)(name.split('.')[0]);
-    const namehash = ethers_1.utils.namehash(name);
+    const hash = (0, normalise_1.namehash)(name);
     const resolverAddress = resolver.address;
-    const data = records
-        ? (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver)
-        : [];
+    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
     const secret = (0, exports.randomSecret)();
     const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
     const commitment = (0, exports._makeCommitment)({

package/dist/cjs/utils/writeTx.d.ts

@@ -0,0 +1,4 @@
+import { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+export default _default;

package/dist/cjs/utils/writeTx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/dist/esm/GqlManager.d.ts

@@ -1,3 +1,6 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/esm/GqlManager.js

@@ -1,11 +1,67 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise';
+const generateSelection = (selection) => ({
+    kind: 'Field',
+    name: {
+        kind: 'Name',
+        value: selection,
+    },
+    arguments: [],
+    directives: [],
+    alias: undefined,
+    selectionSet: undefined,
+});
+export const enter = (node) => {
+    if (node.kind === 'SelectionSet') {
+        const id = node.selections.find((x) => x.name && x.name.value === 'id');
+        const name = node.selections.find((x) => x.name && x.name.value === 'name');
+        if (!id && name) {
+            node.selections = [...node.selections, generateSelection('id')];
+            return node;
+        }
+    }
+};
+export const requestMiddleware = (visit, parse) => (request) => {
+    const requestBody = JSON.parse(request.body);
+    const rawQuery = requestBody.query;
+    const parsedQuery = parse(rawQuery);
+    const updatedQuery = visit(parsedQuery, { enter });
+    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    return {
+        ...request,
+        body: JSON.stringify(updatedBody),
+    };
+};
+export const responseMiddleware = (traverse) => (response) => {
+    traverse(response).forEach(function (responseItem) {
+        if (responseItem instanceof Object && responseItem.name) {
+            //Name already in hashed form
+            if (responseItem.name && responseItem.name.includes('[')) {
+                return;
+            }
+            const hashedName = namehash(responseItem.name);
+            if (responseItem.id !== hashedName) {
+                this.update({ ...responseItem, name: hashedName, invalidName: true });
+            }
+        }
+    });
+    return response;
+};
 export default class GqlManager {
     constructor() {
         this.gql = () => null;
         this.client = null;
         this.setUrl = async (url) => {
             if (url) {
-                const imported = await import('graphql-request');
-                this.client = new imported.GraphQLClient(url);
+                const [imported, traverse, { visit, parse }] = await Promise.all([
+                    import('graphql-request'),
+                    import('traverse'),
+                    import('graphql/language'),
+                ]);
+                this.client = new imported.GraphQLClient(url, {
+                    requestMiddleware: requestMiddleware(visit, parse),
+                    responseMiddleware: responseMiddleware(traverse.default),
+                });
                 this.gql = imported.gql;
             }
             else {

package/dist/esm/functions/burnFuses.d.ts

@@ -1,4 +1,5 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
+    fusesToBurn: FuseOptions;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/burnFuses.js

@@ -1,12 +1,8 @@
-import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
-export default async function ({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const namehash = ethers.utils.namehash(name);
+    const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);
-    return nameWrapper.burnFuses(namehash, encodedFuses);
+    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
 }

package/dist/esm/functions/createSubname.d.ts

@@ -2,18 +2,14 @@ import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
 declare type BaseArgs = {
-    name: string;
     owner: string;
     resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

package/dist/esm/functions/createSubname.js

@@ -1,10 +1,7 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
-export default async function ({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
@@ -17,18 +14,18 @@ export default async function ({ contracts, provider }, { name, owner, resolverA
     }
     const label = labels.shift();
     const labelhash = ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = namehash(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+            return registry.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
             const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
                 ? generateFuseInput(wrapperArgs.fuses)
                 : '0';
-            return nameWrapper.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/deleteSubname.d.ts

@@ -1,4 +1,4 @@
 import { ENSArgs } from '..';
-export default function ({ contracts, provider, transferSubname, }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>, name: string, contract: 'registry' | 'nameWrapper', options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction>;
+export default function ({ transferSubname }: ENSArgs<'transferSubname'>, name: string, { contract, }: {
+    contract: 'registry' | 'nameWrapper';
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/deleteSubname.js

@@ -1,3 +1,6 @@
-export default async function ({ contracts, provider, transferSubname, }, name, contract, options) {
-    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+export default async function ({ transferSubname }, name, { contract, }) {
+    return transferSubname.populateTransaction(name, {
+        contract,
+        address: '0x0000000000000000000000000000000000000000',
+    });
 }

package/dist/esm/functions/getDNSOwner.d.ts

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;

package/dist/esm/functions/getDNSOwner.js

@@ -0,0 +1,51 @@
+import * as packet from 'dns-packet';
+export function encodeURLParams(p) {
+    return Object.entries(p)
+        .map((kv) => kv.map(encodeURIComponent).join('='))
+        .join('&');
+}
+export const getDNS = async (q) => {
+    const response = await global.fetch(`https://cloudflare-dns.com/dns-query?${encodeURLParams({
+        ct: 'application/dns-udpwireformat',
+        dns: packet.encode(q)?.toString('base64'),
+        ts: Date.now().toString(),
+    })}`);
+    const arrayBuffer = await response.arrayBuffer();
+    // @ts-ignore:next-line
+    const fromArrayBuffer = Buffer.from(arrayBuffer);
+    return packet.decode(fromArrayBuffer);
+};
+export const dnsQuery = async (qtype, qname) => {
+    const query = {
+        type: 'query',
+        id: 1,
+        flags: packet.RECURSION_DESIRED,
+        questions: [
+            {
+                type: qtype,
+                class: 'IN',
+                name: qname,
+            },
+        ],
+        additionals: [
+            {
+                type: 'OPT',
+                class: 'IN',
+                name: '.',
+                udpPayloadSize: 4096,
+                flags: packet.DNSSEC_OK,
+            },
+        ],
+        answers: [],
+    };
+    const response = await getDNS(query);
+    if (response.rcode !== 'NOERROR') {
+        throw new Error(`DNS query failed: ${response.rcode}`);
+    }
+    return response;
+};
+export default async function (_, dnsName) {
+    const result = await dnsQuery('TXT', `_ens.${dnsName}`);
+    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
+    return address;
+}

package/dist/esm/functions/getFuses.js

@@ -1,5 +1,6 @@
-import { ethers, utils } from 'ethers';
+import { utils } from 'ethers';
 import { testable as fuseEnums } from '../utils/fuses';
+import { namehash } from '../utils/normalise';
 const NameSafety = [
     'Safe',
     'RegistrantNotWrapped',
@@ -12,7 +13,7 @@ const raw = async ({ contracts }, name) => {
     return {
         to: nameWrapper.address,
         data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            ethers.utils.namehash(name),
+            namehash(name),
         ]),
     };
 };
@@ -36,7 +37,7 @@ const decode = async ({ contracts }, data, name) => {
         if (utils.hexStripZeros(vulnerableNode) !== '0x') {
             name.split('.').forEach((label, index, arr) => {
                 const node = arr.slice(index).join('.');
-                const nodehash = utils.namehash(node);
+                const nodehash = namehash(node);
                 if (nodehash === vulnerableNode) {
                     returnVulnerableNode = node;
                 }

package/dist/esm/functions/getOwner.js

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers';
 import { labelhash } from '../utils/labels';
+import { namehash as makeNamehash } from '../utils/normalise';
 const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
     switch (contract) {
         case 'nameWrapper': {
@@ -28,10 +29,10 @@ const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels)
     }
 };
 const raw = async ({ contracts, multicallWrapper }, name, contract) => {
-    const namehash = ethers.utils.namehash(name);
+    const namehash = makeNamehash(name);
     const labels = name.split('.');
-    if (contract) {
-        return await singleContractOwnerRaw({ contracts }, contract, namehash, labels);
+    if (contract || labels.length === 1) {
+        return await singleContractOwnerRaw({ contracts }, contract || 'registry', namehash, labels);
     }
     const registryData = await singleContractOwnerRaw({ contracts }, 'registry', namehash, labels);
     const nameWrapperData = await singleContractOwnerRaw({ contracts }, 'nameWrapper', namehash, labels);
@@ -46,10 +47,11 @@ const singleContractOwnerDecode = (data) => ethers.utils.defaultAbiCoder.decode(
 const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
     if (data === null)
         return;
-    if (contract) {
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
         const singleOwner = singleContractOwnerDecode(data);
         let obj = {
-            ownershipLevel: contract,
+            ownershipLevel: contract || 'registry',
         };
         if (contract === 'registrar') {
             return {
@@ -74,7 +76,6 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     const registryOwner = decodedData[0][0];
     const nameWrapperOwner = decodedData[1][0];
     const registrarOwner = decodedData[2]?.[0];
-    const labels = name.split('.');
     // check for only .eth names
     if (labels[labels.length - 1] === 'eth') {
         // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner