@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.1

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

@@ -1,73 +0,0 @@
-import { ENSArgs } from '..';
-export declare const _getContentHash: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
-        protocolType?: undefined;
-        decoded?: undefined;
-        error?: undefined;
-    } | {
-        protocolType: null;
-        decoded: any;
-        error?: undefined;
-    } | {
-        protocolType: string | undefined;
-        decoded: any;
-        error: any;
-    } | undefined>;
-};
-export declare const getContentHash: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<{
-        protocolType?: undefined;
-        decoded?: undefined;
-        error?: undefined;
-    } | {
-        protocolType: null;
-        decoded: any;
-        error?: undefined;
-    } | {
-        protocolType: string | undefined;
-        decoded: any;
-        error: any;
-    } | undefined>;
-};
-export declare const _getText: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, key: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
-};
-export declare const getText: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, key: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
-};
-export declare const _getAddr: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-        coin: string;
-        addr: string;
-    } | undefined>;
-};
-export declare const getAddr: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-        coin: string;
-        addr: string;
-    } | undefined>;
-};

package/dist/cjs/functions/getSpecificRecord.js

@@ -1,268 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddr = exports._getAddr = exports.getText = exports._getText = exports.getContentHash = exports._getContentHash = void 0;
-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', [
-                (0, normalise_1.namehash)(name),
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
-        if (!response) {
-            return;
-        }
-        const decodedContent = (0, contentHash_1.decodeContenthash)(response);
-        if (!decodedContent ||
-            (ethers_1.ethers.utils.isBytesLike(decodedContent.decoded) &&
-                ethers_1.ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
-            Object.keys(decodedContent).length === 0) {
-            return;
-        }
-        return decodedContent;
-    },
-};
-exports.getContentHash = {
-    raw: async ({ contracts, universalWrapper }, name) => {
-        const prData = await exports._getContentHash.raw({ contracts }, name);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getContentHash.decode({ contracts }, urData.data);
-    },
-};
-exports._getText = {
-    raw: async ({ contracts }, name, key) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        return {
-            to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('text', [
-                (0, normalise_1.namehash)(name),
-                key,
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const [response] = publicResolver.interface.decodeFunctionResult('text', data);
-        if (!response) {
-            return;
-        }
-        return response;
-    },
-};
-exports.getText = {
-    raw: async ({ contracts, universalWrapper }, name, key) => {
-        const prData = await exports._getText.raw({ contracts }, name, key);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getText.decode({ contracts }, urData.data);
-    },
-};
-exports._getAddr = {
-    raw: async ({ contracts }, name, coinType, bypassFormat) => {
-        if (!coinType) {
-            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)', [(0, normalise_1.namehash)(name), coinType]),
-            };
-        }
-        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
-            ? address_encoder_1.formatsByName[coinType]
-            : address_encoder_1.formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
-        if (!formatter) {
-            throw new Error(`No formatter found for coin: ${coinType}`);
-        }
-        return {
-            to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), formatter.coinType]),
-        };
-    },
-    decode: async ({ contracts }, data, _name, coinType) => {
-        let returnCoinType = true;
-        if (!coinType) {
-            coinType = 60;
-            returnCoinType = false;
-        }
-        const publicResolver = await contracts?.getPublicResolver();
-        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
-            ? address_encoder_1.formatsByName[coinType]
-            : address_encoder_1.formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
-        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') {
-            return;
-        }
-        const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'));
-        if (!decodedAddr) {
-            return;
-        }
-        if (!returnCoinType) {
-            return decodedAddr;
-        }
-        return { coin: formatter.name, addr: decodedAddr };
-    },
-};
-exports.getAddr = {
-    raw: async ({ contracts, universalWrapper }, name, coinType) => {
-        const prData = await exports._getAddr.raw({ contracts }, name, coinType);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getAddr.decode({ contracts }, urData.data, _name, coinType);
-    },
-};
-// export async function getAddr(
-//   { contracts }: ENSArgs<'contracts'>,
-//   name: string,
-//   coinType?: string | number,
-// ) {
-//   if (!coinType) {
-//     coinType = 60
-//   }
-//   const universalResolver = await contracts?.getUniversalResolver()
-//   const publicResolver = await contracts?.getPublicResolver()
-//   const formatter =
-//     typeof coinType === 'string'
-//       ? formatsByName[coinType]
-//       : formatsByCoinType[coinType]
-//   if (!formatter) {
-//     throw new Error(`Coin type ${coinType} is not supported`)
-//   }
-//   const data = publicResolver?.interface.encodeFunctionData(
-//     'addr(bytes32,uint256)',
-//     [ethers.utils.namehash(name), formatter.coinType],
-//   )
-//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
-//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
-//     ['bytes'],
-//     result['0'],
-//   )
-//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
-//     return
-//   }
-//   const decodedAddr = formatter.encoder(
-//     Buffer.from(encodedAddr.slice(2), 'hex'),
-//   )
-//   if (!decodedAddr) {
-//     return
-//   }
-//   return decodedAddr
-// }
-// export const getContentHash = {
-//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const prData = publicResolver.interface.encodeFunctionData(
-//       'contenthash(bytes32)',
-//       [ethers.utils.namehash(name)],
-//     )
-//     const urData = universalResolver.interface.encodeFunctionData(
-//       'resolve(bytes,bytes)',
-//       [hexEncodeName(name), prData],
-//     )
-//     return {
-//       to: universalResolver.address,
-//       data: urData,
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-//     if (!response || !response[1]) {
-//       return
-//     }
-//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
-//       'contenthash(bytes32)',
-//       response[0],
-//     )
-//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
-//       return
-//     }
-//     return decodeContenthash(encodedContentHash)
-//   },
-// }
-// const getText = {
-//   raw: async (
-//     { contracts }: ENSArgs<'contracts'>,
-//     name: string,
-//     key: string,
-//   ) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const data = publicResolver.interface.encodeFunctionData(
-//       'text(bytes32,string)',
-//       [ethers.utils.namehash(name), key],
-//     )
-//     return {
-//       to: universalResolver.address,
-//       data: universalResolver.interface.encodeFunctionData(
-//         'resolve(bytes,bytes)',
-//         [hexEncodeName(name), data],
-//       ),
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-//     if (!response || !response[1]) {
-//       return
-//     }
-//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
-//       'text(bytes32,string)',
-//       response[0],
-//     )
-//     if (decodedText === '') {
-//       return
-//     }
-//     return decodedText
-//   },
-// }

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

@@ -1,26 +0,0 @@
-import { ENSArgs } from '..';
-declare type Subname = {
-    id: string;
-    labelName: string | null;
-    truncatedName?: string;
-    labelhash: string;
-    isMigrated: boolean;
-    name: string;
-    owner: {
-        id: string;
-    };
-};
-declare type Params = {
-    name: string;
-    page?: number;
-    pageSize?: number;
-    orderDirection?: 'asc' | 'desc';
-    orderBy?: 'createdAt' | 'labelName';
-    lastSubnames: Array<any>;
-    isLargeQuery?: boolean;
-};
-declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
-    subnames: Subname[];
-    subnameCount: number;
-}>;
-export default getSubnames;

package/dist/cjs/functions/getSubnames.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 `
-    query getSubnames(
-      $id: ID! 
-      $first: Int
-      $lastCreatedAt: BigInt
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomainCount
-        subdomains(
-          first: $first
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
-        ) {
-          id
-          labelName
-          labelhash
-          isMigrated
-          name
-          subdomainCount
-          createdAt
-          owner {
-            id
-          }
-        }
-      }
-    }
-  `;
-    let queryVars = {
-        id: (0, normalise_1.namehash)(name),
-        first: pageSize,
-        lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
-        orderBy,
-        orderDirection,
-    };
-    const { domain } = await client.request(finalQuery, queryVars);
-    const subdomains = domain.subdomains.map((subname) => {
-        const decrypted = (0, labels_1.decryptName)(subname.name);
-        return {
-            ...subname,
-            name: decrypted,
-            truncatedName: (0, format_1.truncateFormat)(decrypted),
-        };
-    });
-    return {
-        subnames: subdomains,
-        subnameCount: domain.subdomainCount,
-    };
-};
-const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
-    const client = gqlInstance.client;
-    const subdomainsGql = `
-  id
-  labelName
-  labelhash
-  isMigrated
-  name
-  subdomainCount
-  createdAt
-  owner {
-    id
-  }
-`;
-    let queryVars = {};
-    let finalQuery = '';
-    if (typeof page !== 'number') {
-        finalQuery = gqlInstance.gql `
-    query getSubnames(
-      $id: ID! 
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `;
-        queryVars = {
-            id: (0, normalise_1.namehash)(name),
-            orderBy,
-            orderDirection,
-        };
-    }
-    else {
-        finalQuery = gqlInstance.gql `
-    query getSubnames(
-      $id: ID! 
-      $first: Int
-      $skip: Int
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomainCount
-        subdomains(
-          first: $first
-          skip: $skip
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `;
-        queryVars = {
-            id: (0, normalise_1.namehash)(name),
-            first: pageSize,
-            skip: (page || 0) * pageSize,
-            orderBy,
-            orderDirection,
-        };
-    }
-    const { domain } = await client.request(finalQuery, queryVars);
-    const subdomains = domain.subdomains.map((subname) => {
-        const decrypted = (0, labels_1.decryptName)(subname.name);
-        return {
-            ...subname,
-            name: decrypted,
-            truncatedName: (0, format_1.truncateFormat)(decrypted),
-        };
-    });
-    return {
-        subnames: subdomains,
-        subnameCount: domain.subdomainCount,
-    };
-};
-const getSubnames = (injected, functionArgs) => {
-    if (functionArgs.isLargeQuery) {
-        return largeQuery(injected, functionArgs);
-    }
-    return smallQuery(injected, functionArgs);
-};
-exports.default = getSubnames;

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

@@ -1,11 +0,0 @@
-export { default as batch } from './batch';
-export * from './batchWrappers';
-export { default as getExpiry } from './getExpiry';
-export { default as getName } from './getName';
-export { default as getNames } from './getNames';
-export { default as getOwner } from './getOwner';
-export { default as getPrice } from './getPrice';
-export { default as getProfile } from './getProfile';
-export { default as getRecords } from './getRecords';
-export * from './getSpecificRecord';
-export { default as getSubnames } from './getSubnames';

package/dist/cjs/functions/initialGetters.js

@@ -1,40 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubnames = exports.getRecords = exports.getProfile = exports.getPrice = exports.getOwner = exports.getNames = exports.getName = exports.getExpiry = exports.batch = void 0;
-var batch_1 = require("./batch");
-Object.defineProperty(exports, "batch", { enumerable: true, get: function () { return __importDefault(batch_1).default; } });
-__exportStar(require("./batchWrappers"), exports);
-var getExpiry_1 = require("./getExpiry");
-Object.defineProperty(exports, "getExpiry", { enumerable: true, get: function () { return __importDefault(getExpiry_1).default; } });
-var getName_1 = require("./getName");
-Object.defineProperty(exports, "getName", { enumerable: true, get: function () { return __importDefault(getName_1).default; } });
-var getNames_1 = require("./getNames");
-Object.defineProperty(exports, "getNames", { enumerable: true, get: function () { return __importDefault(getNames_1).default; } });
-var getOwner_1 = require("./getOwner");
-Object.defineProperty(exports, "getOwner", { enumerable: true, get: function () { return __importDefault(getOwner_1).default; } });
-var getPrice_1 = require("./getPrice");
-Object.defineProperty(exports, "getPrice", { enumerable: true, get: function () { return __importDefault(getPrice_1).default; } });
-var getProfile_1 = require("./getProfile");
-Object.defineProperty(exports, "getProfile", { enumerable: true, get: function () { return __importDefault(getProfile_1).default; } });
-var getRecords_1 = require("./getRecords");
-Object.defineProperty(exports, "getRecords", { enumerable: true, get: function () { return __importDefault(getRecords_1).default; } });
-__exportStar(require("./getSpecificRecord"), exports);
-var getSubnames_1 = require("./getSubnames");
-Object.defineProperty(exports, "getSubnames", { enumerable: true, get: function () { return __importDefault(getSubnames_1).default; } });

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

@@ -1,5 +0,0 @@
-import { ENSArgs } from '..';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
-    address?: string;
-    resolver?: string;
-}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/setName.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1({ contracts, signer }, name, { address, resolver, } = {}) {
-    const signerAddress = await signer.getAddress();
-    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(signer);
-    if (address) {
-        const publicResolver = await contracts?.getPublicResolver();
-        return reverseRegistrar.populateTransaction.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
-    }
-    return reverseRegistrar.populateTransaction.setName(name);
-}
-exports.default = default_1;

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

@@ -1,18 +0,0 @@
-import { ENSArgs } from '..';
-import { RecordInput, RecordTypes } from '../utils/recordHelpers';
-declare type BaseInput = {
-    resolverAddress?: string;
-};
-declare type ContentHashInput = {
-    record: RecordInput<'contentHash'>;
-    type: 'contentHash';
-};
-declare type AddrOrTextInput = {
-    record: RecordInput<'addr' | 'text'>;
-    type: 'addr' | 'text';
-};
-export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
-    to: string;
-    data: string;
-}>;
-export {};

package/dist/cjs/functions/setRecord.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const normalise_1 = require("../utils/normalise");
-const recordHelpers_1 = require("../utils/recordHelpers");
-async function default_1({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
-    if (!name.includes('.')) {
-        throw new Error('Input is not an ENS name');
-    }
-    let resolverToUse;
-    if (resolverAddress) {
-        resolverToUse = resolverAddress;
-    }
-    else {
-        resolverToUse = await getResolver(name);
-    }
-    if (!resolverToUse) {
-        throw new Error('No resolver found for input address');
-    }
-    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
-    const hash = (0, normalise_1.namehash)(name);
-    const call = (0, recordHelpers_1.generateSingleRecordCall)(hash, resolver, type)(record);
-    return {
-        to: resolver.address,
-        data: call,
-    };
-}
-exports.default = default_1;

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

@@ -1,6 +0,0 @@
-import { ENSArgs } from '..';
-import { RecordOptions } from '../utils/recordHelpers';
-export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
-    records: RecordOptions;
-    resolverAddress?: string;
-}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/setRecords.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const normalise_1 = require("../utils/normalise");
-const recordHelpers_1 = require("../utils/recordHelpers");
-async function default_1({ contracts, provider, getResolver, signer, }, name, { records, resolverAddress, }) {
-    if (!name.includes('.')) {
-        throw new Error('Input is not an ENS name');
-    }
-    let resolverToUse;
-    if (resolverAddress) {
-        resolverToUse = resolverAddress;
-    }
-    else {
-        resolverToUse = await getResolver(name);
-    }
-    if (!resolverToUse) {
-        throw new Error('No resolver found for input address');
-    }
-    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
-    const hash = (0, normalise_1.namehash)(name);
-    const calls = (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver);
-    return resolver.populateTransaction.multicall(calls);
-}
-exports.default = default_1;

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

@@ -1,5 +0,0 @@
-import { ENSArgs } from '..';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
-    contract: 'registry' | 'nameWrapper';
-    resolver?: string;
-}): Promise<import("ethers").PopulatedTransaction>;