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

package/README.md

@@ -9,6 +9,8 @@ We also use undeployed contracts under the hood, so this **will not** work on an
 
 Given the current development status, we're actively seeking feedback so feel free to create an issue or PR if you notice something!
 
+If you are looking for documentation for **version 2**, it an be found [here](https://github.com/ensdomains/ensjs#readme).
+
 ## Features
 
 - Dynamically load **everything**

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

@@ -1,4 +1,3 @@
-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, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<import("ethers").ContractTransaction>;

package/dist/cjs/functions/burnFuses.js

@@ -3,16 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, name, fusesToBurn) {
     const signer = provider?.getSigner();
     if (!signer) {
         throw new Error('No signer found');
     }
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const namehash = ethers_1.ethers.utils.namehash(name);
+    const hash = (0, normalise_1.namehash)(name);
     const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
-    return nameWrapper.burnFuses(namehash, encodedFuses);
+    return nameWrapper.burnFuses(hash, encodedFuses);
 }
 exports.default = default_1;

package/dist/cjs/functions/createSubname.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
     const signer = provider?.getSigner(options?.addressOrIndex);
     if (!signer) {
@@ -22,7 +23,7 @@ async function default_1({ contracts, provider }, { name, owner, resolverAddress
     }
     const label = labels.shift();
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);

package/dist/cjs/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/cjs/functions/getDNSOwner.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dnsQuery = exports.getDNS = exports.encodeURLParams = void 0;
+const packet = __importStar(require("dns-packet"));
+function encodeURLParams(p) {
+    return Object.entries(p)
+        .map((kv) => kv.map(encodeURIComponent).join('='))
+        .join('&');
+}
+exports.encodeURLParams = encodeURLParams;
+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);
+};
+exports.getDNS = getDNS;
+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 (0, exports.getDNS)(query);
+    if (response.rcode !== 'NOERROR') {
+        throw new Error(`DNS query failed: ${response.rcode}`);
+    }
+    return response;
+};
+exports.dnsQuery = dnsQuery;
+async function default_1(_, dnsName) {
+    const result = await (0, exports.dnsQuery)('TXT', `_ens.${dnsName}`);
+    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
+    return address;
+}
+exports.default = default_1;

package/dist/cjs/functions/getFuses.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const fuses_1 = require("../utils/fuses");
+const normalise_1 = require("../utils/normalise");
 const NameSafety = [
     'Safe',
     'RegistrantNotWrapped',
@@ -14,7 +15,7 @@ const raw = async ({ contracts }, name) => {
     return {
         to: nameWrapper.address,
         data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            ethers_1.ethers.utils.namehash(name),
+            (0, normalise_1.namehash)(name),
         ]),
     };
 };
@@ -38,7 +39,7 @@ const decode = async ({ contracts }, data, name) => {
         if (ethers_1.utils.hexStripZeros(vulnerableNode) !== '0x') {
             name.split('.').forEach((label, index, arr) => {
                 const node = arr.slice(index).join('.');
-                const nodehash = ethers_1.utils.namehash(node);
+                const nodehash = (0, normalise_1.namehash)(node);
                 if (nodehash === vulnerableNode) {
                     returnVulnerableNode = node;
                 }

package/dist/cjs/functions/getOwner.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const labels_1 = require("../utils/labels");
+const normalise_1 = require("../utils/normalise");
 const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
     switch (contract) {
         case 'nameWrapper': {
@@ -30,10 +31,10 @@ const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels)
     }
 };
 const raw = async ({ contracts, multicallWrapper }, name, contract) => {
-    const namehash = ethers_1.ethers.utils.namehash(name);
+    const namehash = (0, normalise_1.namehash)(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);
@@ -48,10 +49,11 @@ const singleContractOwnerDecode = (data) => ethers_1.ethers.utils.defaultAbiCode
 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 {
@@ -76,7 +78,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

package/dist/cjs/functions/getProfile.d.ts

@@ -26,5 +26,5 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

package/dist/cjs/functions/getProfile.js

@@ -42,23 +42,39 @@ const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolver
     const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
     return { data: prRawData.data, calls };
 };
-const makeHashIndexes = (data, name) => [...data.matchAll(ethers_1.ethers.utils.namehash(name).substring(2))].map((x) => x.index / 2 - 1);
-const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolverAddress) => {
+    const callsWithResolver = calls.map((call) => ({
+        to: resolverAddress,
+        data: call.data.data,
+    }));
+    return (await multicallWrapper(callsWithResolver)).map((x) => x[1]);
+};
+const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options, fallbackResolver) => {
     const universalResolver = await contracts?.getUniversalResolver();
     const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
-    let resolver;
+    let resolvedData;
+    let useFallbackResolver = false;
     try {
-        resolver = await universalResolver?.resolve((0, hexEncodedName_1.hexEncodeName)(name), data);
+        resolvedData = await universalResolver?.resolve((0, hexEncodedName_1.hexEncodeName)(name), data);
     }
     catch {
-        return;
+        useFallbackResolver = true;
+    }
+    let resolverAddress;
+    let recordData;
+    if (useFallbackResolver) {
+        resolverAddress = fallbackResolver;
+        recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
+    }
+    else {
+        resolverAddress = resolvedData['1'];
+        [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
     }
-    const [recordData] = await resolverMulticallWrapper.decode(resolver['0']);
     const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
     return {
         address: matchAddress && (await _getAddr.decode(matchAddress)),
         records: await formatRecords({ _getAddr, _getContentHash, _getText }, recordData, calls, options),
-        resolverAddress: resolver['1'],
+        resolverAddress,
     };
 };
 const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, calls, options) => {
@@ -68,7 +84,7 @@ const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, cal
             key: calls[i].key,
             type: calls[i].type,
         };
-        if (itemRet.type === 'addr' || itemRet.type === 'contenthash') {
+        if (itemRet.type === 'contenthash') {
             decodedFromAbi = ethers_1.ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
             if (ethers_1.ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
                 return;
@@ -157,6 +173,7 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
           addr {
             id
           }
+          address
         }
       }
     }
@@ -167,8 +184,14 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
         return;
     const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains;
     let returnedRecords = {};
-    if (!wantedRecords)
+    if (!resolverResponse)
         return { isMigrated, createdAt };
+    if (!wantedRecords)
+        return {
+            isMigrated,
+            createdAt,
+            graphResolverAddress: resolverResponse.address,
+        };
     Object.keys(wantedRecords).forEach((key) => {
         const data = wantedRecords[key];
         if (typeof data === 'boolean' && data) {
@@ -180,28 +203,36 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
             }
         }
     });
-    return { ...returnedRecords, isMigrated, createdAt };
+    return {
+        ...returnedRecords,
+        isMigrated,
+        createdAt,
+        graphResolverAddress: resolverResponse.address,
+    };
 };
-const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
     const usingOptions = !options || options?.texts === true || options?.coinTypes === true
         ? options || { contentHash: true, texts: true, coinTypes: true }
         : undefined;
     const graphResult = await graphFetch({ gqlInstance }, name, usingOptions);
     if (!graphResult)
         return;
-    const { isMigrated, createdAt, ...wantedRecords } = graphResult;
+    const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
+    if (!graphResolverAddress)
+        return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
     const result = await getDataForName({
         contracts,
         _getAddr,
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
-    }, name, usingOptions ? wantedRecords : options);
+        multicallWrapper,
+    }, name, usingOptions ? wantedRecords : options, graphResolverAddress);
     if (!result)
         return { isMigrated, createdAt, message: "Records fetch didn't complete" };
     return { ...result, isMigrated, createdAt, message: undefined };
 };
-const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, address, options) => {
+const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, address, options) => {
     let name;
     try {
         name = await getName(address);
@@ -220,6 +251,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, name.name, options);
     if (!result || result.message)
         return;
@@ -230,7 +262,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         message: undefined,
     };
 };
-async function default_1({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, nameOrAddress, options) {
+async function default_1({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, nameOrAddress, options) {
     if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
         options.coinTypes = options.coinTypes.map((coin) => {
             if (!isNaN(parseInt(coin))) {
@@ -254,6 +286,7 @@ async function default_1({ contracts, gqlInstance, getName, _getAddr, _getConten
             _getContentHash,
             _getText,
             resolverMulticallWrapper,
+            multicallWrapper,
         }, nameOrAddress, options);
     }
     return getProfileFromName({
@@ -263,6 +296,7 @@ async function default_1({ contracts, gqlInstance, getName, _getAddr, _getConten
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, nameOrAddress, options);
 }
 exports.default = default_1;

package/dist/cjs/functions/getSpecificRecord.js

@@ -4,13 +4,14 @@ exports.getAddr = exports._getAddr = exports.getText = exports._getText = export
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const ethers_1 = require("ethers");
 const contentHash_1 = require("../utils/contentHash");
+const normalise_1 = require("../utils/normalise");
 exports._getContentHash = {
     raw: async ({ contracts }, name) => {
         const publicResolver = await contracts?.getPublicResolver();
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('contenthash', [
-                ethers_1.ethers.utils.namehash(name),
+                (0, normalise_1.namehash)(name),
             ]),
         };
     },
@@ -48,7 +49,7 @@ exports._getText = {
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('text', [
-                ethers_1.ethers.utils.namehash(name),
+                (0, normalise_1.namehash)(name),
                 key,
             ]),
         };
@@ -80,10 +81,18 @@ exports._getAddr = {
             coinType = 60;
         }
         const publicResolver = await contracts?.getPublicResolver();
+        if (coinType === 60 || coinType === '60') {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+                    (0, normalise_1.namehash)(name),
+                ]),
+            };
+        }
         if (bypassFormat) {
             return {
                 to: '0x0000000000000000000000000000000000000000',
-                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers_1.ethers.utils.namehash(name), coinType]),
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), coinType]),
             };
         }
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
@@ -94,7 +103,7 @@ exports._getAddr = {
         }
         return {
             to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers_1.ethers.utils.namehash(name), formatter.coinType]),
+            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), formatter.coinType]),
         };
     },
     decode: async ({ contracts }, data, _name, coinType) => {
@@ -107,7 +116,15 @@ exports._getAddr = {
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
             ? address_encoder_1.formatsByName[coinType]
             : address_encoder_1.formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
-        const [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        let response;
+        if (coinType === 60 || coinType === '60') {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32)', data);
+        }
+        else {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        }
         if (!response)
             return;
         if (ethers_1.ethers.utils.hexStripZeros(response) === '0x') {

package/dist/cjs/functions/getSubnames.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("ethers/lib/utils");
 const format_1 = require("../utils/format");
 const labels_1 = require("../utils/labels");
+const normalise_1 = require("../utils/normalise");
 const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }) => {
     const client = gqlInstance.client;
     let finalQuery = gqlInstance.gql `
@@ -38,7 +38,7 @@ const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
     let queryVars = {
-        id: (0, utils_1.namehash)(name),
+        id: (0, normalise_1.namehash)(name),
         first: pageSize,
         lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
         orderBy,
@@ -55,7 +55,7 @@ const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
@@ -94,7 +94,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
         queryVars = {
-            id: (0, utils_1.namehash)(name),
+            id: (0, normalise_1.namehash)(name),
             orderBy,
             orderDirection,
         };
@@ -124,7 +124,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     }
   `;
         queryVars = {
-            id: (0, utils_1.namehash)(name),
+            id: (0, normalise_1.namehash)(name),
             first: pageSize,
             skip: (page || 0) * pageSize,
             orderBy,
@@ -142,7 +142,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const getSubnames = (injected, functionArgs) => {

package/dist/cjs/functions/setRecords.d.ts

@@ -1,4 +1,3 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { RecordOptions } from '../utils/recordHelpers';
-export default function ({ contracts, provider, getResolver, }: ENSArgs<'contracts' | 'provider' | 'getResolver'>, name: string, records: RecordOptions): Promise<ethers.ContractTransaction | undefined>;
+export default function ({ contracts, provider, getResolver, }: ENSArgs<'contracts' | 'provider' | 'getResolver'>, name: string, records: RecordOptions): Promise<import("ethers").ContractTransaction | undefined>;

package/dist/cjs/functions/setRecords.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 const recordHelpers_1 = require("../utils/recordHelpers");
 async function default_1({ contracts, provider, getResolver, }, name, records) {
     if (!name.includes('.')) {
@@ -15,8 +15,8 @@ async function default_1({ contracts, provider, getResolver, }, name, records) {
         throw new Error('No signer found');
     }
     const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
-    const namehash = ethers_1.ethers.utils.namehash(name);
-    const calls = (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver);
+    const hash = (0, normalise_1.namehash)(name);
+    const calls = (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver);
     return resolver?.multicall(calls);
 }
 exports.default = default_1;

package/dist/cjs/functions/setResolver.d.ts

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

package/dist/cjs/functions/setResolver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, name, contract, resolver, options) {
     const address = await provider
         ?.getSigner(options?.addressOrIndex)
@@ -14,11 +14,11 @@ async function default_1({ contracts, provider }, name, contract, resolver, opti
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+            return registry.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+            return nameWrapper.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/cjs/functions/transferName.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, name, newOwner, contract, options) {
     const address = await provider
         ?.getSigner(options?.addressOrIndex)
@@ -11,7 +12,7 @@ async function default_1({ contracts, provider }, name, newOwner, contract, opti
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setOwner(ethers_1.ethers.utils.namehash(name), newOwner);
+            return registry.setOwner((0, normalise_1.namehash)(name), newOwner);
         }
         case 'baseRegistrar': {
             const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
@@ -23,7 +24,7 @@ async function default_1({ contracts, provider }, name, newOwner, contract, opti
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.safeTransferFrom(address, newOwner, ethers_1.ethers.utils.namehash(name), 1, '0x');
+            return nameWrapper.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/cjs/functions/transferSubname.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, name, contract, address, options) {
     const signer = provider?.getSigner(options?.addressOrIndex);
     if (!signer) {
@@ -9,7 +10,7 @@ async function default_1({ contracts, provider }, name, contract, address, optio
     const labels = name.split('.');
     const label = labels.shift();
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);

package/dist/cjs/functions/unwrapName.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 async function default_1({ contracts, provider }, name, newController, newRegistrant, options) {
     const signer = provider?.getSigner(options?.addressOrIndex);
     const address = await signer?.getAddress();
@@ -9,7 +10,7 @@ async function default_1({ contracts, provider }, name, newController, newRegist
     }
     const labels = name.split('.');
     const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = ethers_1.utils.namehash(labels.slice(1).join('.'));
+    const parentNodehash = (0, normalise_1.namehash)(labels.slice(1).join('.'));
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     if (labels.length === 2 && labels[1] === 'eth') {
         if (!newRegistrant) {

package/dist/cjs/index.d.ts

@@ -466,5 +466,6 @@ export declare class ENS {
     transferSubname: (name: string, contract: "nameWrapper" | "registry", address: string, options?: {
         addressOrIndex?: string | number | undefined;
     } | undefined) => Promise<ethers.ContractTransaction>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
 }
 export {};

package/dist/cjs/index.js

@@ -166,6 +166,7 @@ class ENS {
         'gqlInstance',
         'getName',
         'resolverMulticallWrapper',
+        'multicallWrapper',
         '_getAddr',
         '_getContentHash',
         '_getText',
@@ -219,5 +220,6 @@ class ENS {
     createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
     deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
     transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
 }
 exports.ENS = ENS;