@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.2

package/dist/cjs/functions/getSpecificRecord.js

@@ -0,0 +1,268 @@
+"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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,154 @@
+"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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,40 @@
+"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

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

package/dist/cjs/functions/setName.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1({ contracts, provider }, name, address, resolver, options) {
+    const signerAddress = await provider
+        ?.getSigner(options?.addressOrIndex)
+        .getAddress();
+    if (!signerAddress) {
+        throw new Error('No signer found');
+    }
+    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(provider?.getSigner());
+    if (address) {
+        const publicResolver = await contracts?.getPublicResolver();
+        return reverseRegistrar?.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
+    }
+    return reverseRegistrar?.setName(name);
+}
+exports.default = default_1;

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

@@ -0,0 +1,3 @@
+import { ENSArgs } from '..';
+import { RecordOptions } from '../utils/recordHelpers';
+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

@@ -0,0 +1,22 @@
+"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, }, name, records) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    const resolverAddress = await getResolver(name);
+    if (!resolverAddress) {
+        throw new Error('No resolver found for input address');
+    }
+    const address = await provider?.getSigner().getAddress();
+    if (!address) {
+        throw new Error('No signer found');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
+    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

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

package/dist/cjs/functions/setResolver.js

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

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

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

package/dist/cjs/functions/transferName.js

@@ -0,0 +1,34 @@
+"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)
+        .getAddress();
+    if (!address) {
+        throw new Error('No signer found');
+    }
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
+            return registry.setOwner((0, normalise_1.namehash)(name), newOwner);
+        }
+        case 'baseRegistrar': {
+            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
+            const labels = name.split('.');
+            if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
+                throw new Error('Invalid name for baseRegistrar');
+            }
+            return baseRegistrar['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            return nameWrapper.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

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

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

package/dist/cjs/functions/transferSubname.js

@@ -0,0 +1,28 @@
+"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) {
+        throw new Error('No signer found');
+    }
+    const labels = name.split('.');
+    const label = labels.shift();
+    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
+    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.setSubnodeOwner(parentNodehash, labelhash, address);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

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

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