@ensdomains/ensjs 3.0.0-alpha.33 → 3.0.0-alpha.35

package/dist/cjs/functions/getAvailable.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getAvailable_exports = {};
+__export(getAvailable_exports, {
+  default: () => getAvailable_default
+});
+module.exports = __toCommonJS(getAvailable_exports);
+var import_labels = require("../utils/labels");
+const raw = async ({ contracts }, name) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth names can be checked for availability");
+  }
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData("available", [
+      (0, import_labels.labelhash)(labels[0])
+    ])
+  };
+};
+const decode = async ({ contracts }, data) => {
+  if (data === null)
+    return;
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      "available",
+      data
+    );
+    return result["0"];
+  } catch {
+    return;
+  }
+};
+var getAvailable_default = {
+  raw,
+  decode
+};

package/dist/cjs/functions/getDNSOwner.js

@@ -31,18 +31,21 @@ __export(getDNSOwner_exports, {
 });
 module.exports = __toCommonJS(getDNSOwner_exports);
 var packet = __toESM(require("dns-packet"));
+var import_utils = require("ethers/lib/utils");
 function encodeURLParams(p) {
   return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
 }
 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 url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: "application/dns-udpwireformat",
+    dns: packet.encode(q)?.toString("base64"),
+    ts: Date.now().toString()
+  })}`;
+  const response = await (0, import_utils._fetchData)(url, void 0);
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset
   );
-  const arrayBuffer = await response.arrayBuffer();
   const fromArrayBuffer = Buffer.from(arrayBuffer);
   return packet.decode(fromArrayBuffer);
 };

package/dist/cjs/functions/transferName.js

@@ -25,7 +25,8 @@ var import_ethers = require("ethers");
 var import_normalise = require("../utils/normalise");
 async function transferName_default({ contracts, signer }, name, {
   newOwner,
-  contract
+  contract,
+  reclaim
 }) {
   const address = await signer.getAddress();
   switch (contract) {
@@ -41,11 +42,11 @@ async function transferName_default({ contracts, signer }, name, {
       if (labels.length > 2 || labels[labels.length - 1] !== "eth") {
         throw new Error("Invalid name for baseRegistrar");
       }
-      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](
-        address,
-        newOwner,
-        import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]])
-      );
+      const tokenId = import_ethers.ethers.utils.solidityKeccak256(["string"], [labels[0]]);
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner);
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](address, newOwner, tokenId);
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);

package/dist/cjs/index.js

@@ -261,6 +261,10 @@ class ENS {
     "getDNSOwner",
     []
   );
+  getAvailable = this.generateRawFunction(
+    "getAvailable",
+    ["contracts"]
+  );
   universalWrapper = this.generateRawFunction(
     "initialGetters",
     ["contracts"],

package/dist/esm/functions/getAvailable.mjs

@@ -0,0 +1,36 @@
+// src/functions/getAvailable.ts
+import { labelhash } from "../utils/labels.mjs";
+var raw = async ({ contracts }, name) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const labels = name.split(".");
+  if (labels.length !== 2 || labels[1] !== "eth") {
+    throw new Error("Currently only .eth names can be checked for availability");
+  }
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData("available", [
+      labelhash(labels[0])
+    ])
+  };
+};
+var decode = async ({ contracts }, data) => {
+  if (data === null)
+    return;
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      "available",
+      data
+    );
+    return result["0"];
+  } catch {
+    return;
+  }
+};
+var getAvailable_default = {
+  raw,
+  decode
+};
+export {
+  getAvailable_default as default
+};

package/dist/esm/functions/getDNSOwner.mjs

@@ -1,17 +1,20 @@
 // src/functions/getDNSOwner.ts
 import * as packet from "dns-packet";
+import { _fetchData } from "ethers/lib/utils.js";
 function encodeURLParams(p) {
   return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
 }
 var 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 url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: "application/dns-udpwireformat",
+    dns: packet.encode(q)?.toString("base64"),
+    ts: Date.now().toString()
+  })}`;
+  const response = await _fetchData(url, void 0);
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset
   );
-  const arrayBuffer = await response.arrayBuffer();
   const fromArrayBuffer = Buffer.from(arrayBuffer);
   return packet.decode(fromArrayBuffer);
 };

package/dist/esm/functions/transferName.mjs

@@ -3,7 +3,8 @@ import { ethers } from "ethers";
 import { namehash } from "../utils/normalise.mjs";
 async function transferName_default({ contracts, signer }, name, {
   newOwner,
-  contract
+  contract,
+  reclaim
 }) {
   const address = await signer.getAddress();
   switch (contract) {
@@ -19,11 +20,11 @@ async function transferName_default({ contracts, signer }, name, {
       if (labels.length > 2 || labels[labels.length - 1] !== "eth") {
         throw new Error("Invalid name for baseRegistrar");
       }
-      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](
-        address,
-        newOwner,
-        ethers.utils.solidityKeccak256(["string"], [labels[0]])
-      );
+      const tokenId = ethers.utils.solidityKeccak256(["string"], [labels[0]]);
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner);
+      }
+      return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256)"](address, newOwner, tokenId);
     }
     case "nameWrapper": {
       const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);

package/dist/esm/index.mjs

@@ -233,6 +233,10 @@ var ENS = class {
     "getDNSOwner",
     []
   );
+  getAvailable = this.generateRawFunction(
+    "getAvailable",
+    ["contracts"]
+  );
   universalWrapper = this.generateRawFunction(
     "initialGetters",
     ["contracts"],

package/dist/types/functions/getAvailable.d.ts

@@ -0,0 +1,9 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+};
+export default _default;

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

@@ -42,14 +42,14 @@ export declare const _getText: {
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<string | undefined>;
 };
 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>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<string | undefined>;
 };
 export declare const _getAddr: {
     raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{

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

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, reclaim, }: {
     newOwner: string;
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
+    reclaim?: boolean;
 }): Promise<ethers.PopulatedTransaction>;

package/dist/types/index.d.ts

@@ -7,7 +7,7 @@ import type burnFuses from './functions/burnFuses';
 import type commitName from './functions/commitName';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
-import importDNSSECName from './functions/importDNSSECName';
+import type importDNSSECName from './functions/importDNSSECName';
 import type registerName from './functions/registerName';
 import type { default as renewNames, renewNameWithData } from './functions/renewNames';
 import type setName from './functions/setName';
@@ -69,6 +69,12 @@ interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunct
 }
 export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
 }
+interface GeneratedBatchFunction<F extends RawFunction> extends Function, RawFunction {
+    <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<{
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U> ? Awaited<ReturnType<U['decode']>> : never;
+    } | undefined>;
+    batch: BatchFunction<F>;
+}
 export declare class ENS {
     [x: string]: any;
     protected options?: ENSOptions;
@@ -135,7 +141,7 @@ export declare class ENS {
      * @returns {ENS} - A new ENS instance with the given provider
      */
     withProvider: (provider: ethers.providers.JsonRpcProvider) => ENS;
-    batch: GeneratedRawFunction<{
+    batch: GeneratedBatchFunction<{
         raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
             to: string;
             data: string;
@@ -330,14 +336,14 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<any>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<string | undefined>;
     }>;
     _getText: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<string | undefined>;
     }>;
     getOwner: GeneratedRawFunction<{
         raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
@@ -421,6 +427,13 @@ export declare class ENS {
         } | undefined>;
     }>;
     getDNSOwner: (dnsName: string) => Promise<any>;
+    getAvailable: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+    }>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.33",
+  "version": "3.0.0-alpha.35",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/functions/getAvailable.test.ts

@@ -0,0 +1,21 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getAvailable', () => {
+  it('should return false for a name that is unavailable', async () => {
+    const result = await ensInstance.getAvailable('test123.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(false)
+  })
+  it('should return true for a name that is available', async () => {
+    const result = await ensInstance.getAvailable('available-name.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(true)
+  })
+})

package/src/functions/getAvailable.ts

@@ -0,0 +1,37 @@
+import { ENSArgs } from '..'
+import { labelhash } from '../utils/labels'
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth') {
+    throw new Error('Currently only .eth names can be checked for availability')
+  }
+
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData('available', [
+      labelhash(labels[0]),
+    ]),
+  }
+}
+
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+  if (data === null) return
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      'available',
+      data,
+    )
+    return result['0'] as boolean
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getDNSOwner.test.ts

@@ -1,5 +1,4 @@
 import nock from 'nock'
-import fetch from 'node-fetch'
 import getDNSOwner, { encodeURLParams } from './getDNSOwner'
 
 function hexDecode(string: string) {
@@ -24,12 +23,6 @@ describe('encodeURLParams', () => {
 })
 
 describe('getDNSOwner', () => {
-  beforeAll(() => {
-    global.fetch = fetch as any
-  })
-  afterAll(() => {
-    global.fetch = undefined as any
-  })
   it('should return the address from the result of a dnsQuery', async () => {
     const dnsName = 'brantly.xyz'
 

package/src/functions/getDNSOwner.ts

@@ -1,4 +1,5 @@
 import * as packet from 'dns-packet'
+import { _fetchData } from 'ethers/lib/utils'
 
 export function encodeURLParams(p: { [key: string]: string }): string {
   return Object.entries(p)
@@ -7,15 +8,16 @@ export function encodeURLParams(p: { [key: string]: string }): string {
 }
 
 export const getDNS = async (q: packet.Packet): Promise<packet.Packet> => {
-  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 url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: 'application/dns-udpwireformat',
+    dns: packet.encode(q)?.toString('base64'),
+    ts: Date.now().toString(),
+  })}`
+  const response = await _fetchData(url, undefined)
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset,
   )
-  const arrayBuffer = await response.arrayBuffer()
-  // @ts-ignore:next-line
   const fromArrayBuffer = Buffer.from(arrayBuffer)
   return packet.decode(fromArrayBuffer)
 }

package/src/functions/getSpecificRecord.ts

@@ -87,7 +87,7 @@ export const _getText = {
     if (!response) {
       return
     }
-    return response
+    return response as string
   },
 }
 

package/src/functions/transferName.ts

@@ -8,9 +8,11 @@ export default async function (
   {
     newOwner,
     contract,
+    reclaim,
   }: {
     newOwner: string
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar'
+    reclaim?: boolean
   },
 ) {
   const address = await signer.getAddress()
@@ -28,13 +30,16 @@ export default async function (
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
+      const tokenId = ethers.utils.solidityKeccak256(['string'], [labels[0]])
+
+      // reclaim if sending manager on unwrapped name
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner)
+      }
+
       return baseRegistrar.populateTransaction[
         'safeTransferFrom(address,address,uint256)'
-      ](
-        address,
-        newOwner,
-        ethers.utils.solidityKeccak256(['string'], [labels[0]]),
-      )
+      ](address, newOwner, tokenId)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)

package/src/index.ts

@@ -13,6 +13,7 @@ import type burnFuses from './functions/burnFuses'
 import type commitName from './functions/commitName'
 import type createSubname from './functions/createSubname'
 import type deleteSubname from './functions/deleteSubname'
+import type getAvailable from './functions/getAvailable'
 import type getDNSOwner from './functions/getDNSOwner'
 import type getExpiry from './functions/getExpiry'
 import type { getHistory } from './functions/getHistory'
@@ -33,7 +34,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 import type getWrapperData from './functions/getWrapperData'
-import importDNSSECName from './functions/importDNSSECName'
+import type importDNSSECName from './functions/importDNSSECName'
 import type registerName from './functions/registerName'
 import type {
   // eslint-disable-next-line import/no-named-default
@@ -165,6 +166,20 @@ export interface GenericGeneratedRawFunction
   extends Function,
     RawFunctionWithBatch {}
 
+interface GeneratedBatchFunction<F extends RawFunction>
+  extends Function,
+    RawFunction {
+  <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<
+    | {
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U>
+          ? Awaited<ReturnType<U['decode']>>
+          : never
+      }
+    | undefined
+  >
+  batch: BatchFunction<F>
+}
+
 export class ENS {
   [x: string]: any
 
@@ -417,7 +432,7 @@ export class ENS {
     'initialGetters',
     ['multicallWrapper'],
     'batch',
-  )
+  ) as GeneratedBatchFunction<typeof batch>
 
   public getProfile = this.generateFunction<typeof getProfile>(
     'initialGetters',
@@ -533,6 +548,11 @@ export class ENS {
     [],
   )
 
+  public getAvailable = this.generateRawFunction<typeof getAvailable>(
+    'getAvailable',
+    ['contracts'],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],