@ensdomains/ensjs 3.0.0-alpha.20 → 3.0.0-alpha.22

package/dist/cjs/{functions/renewName.js → contracts/bulkRenewal.js}

@@ -16,18 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var renewName_exports = {};
-__export(renewName_exports, {
-  default: () => renewName_default
+var bulkRenewal_exports = {};
+__export(bulkRenewal_exports, {
+  default: () => bulkRenewal_default
 });
-module.exports = __toCommonJS(renewName_exports);
-async function renewName_default({ contracts }, name, {
-  duration,
-  value
-}) {
-  const labels = name.split(".");
-  if (labels.length !== 2 || labels[1] !== "eth")
-    throw new Error("Currently only .eth TLD renewals are supported");
-  const controller = await contracts.getEthRegistrarController();
-  return controller.populateTransaction.renew(labels[0], duration, { value });
-}
+module.exports = __toCommonJS(bulkRenewal_exports);
+var import_BulkRenewal_factory = require("../generated/factories/BulkRenewal__factory");
+var bulkRenewal_default = (provider, address) => import_BulkRenewal_factory.BulkRenewal__factory.connect(address, provider);

package/dist/cjs/contracts/getContractAddress.js

@@ -51,7 +51,8 @@ const addresses = {
   UniversalResolver: {
     "1": "0x580AF46E06DaaD47eb5940526FD64d95b815Cb70",
     "4": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376"
-  }
+  },
+  BulkRenewal: "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035"
 };
 const getContractAddress = (networkId) => (contractName) => {
   try {

package/dist/cjs/contracts/index.js

@@ -35,6 +35,7 @@ var import_publicResolver = __toESM(require("./publicResolver"));
 var import_registry = __toESM(require("./registry"));
 var import_reverseRegistrar = __toESM(require("./reverseRegistrar"));
 var import_universalResolver = __toESM(require("./universalResolver"));
+var import_bulkRenewal = __toESM(require("./bulkRenewal"));
 class ContractManager {
   provider;
   fetchAddress;
@@ -78,4 +79,8 @@ class ContractManager {
     import_ethRegistrarController.default
   );
   getMulticall = this.generateContractGetter("Multicall", import_multicall.default);
+  getBulkRenewal = this.generateContractGetter(
+    "BulkRenewal",
+    import_bulkRenewal.default
+  );
 }

package/dist/cjs/functions/deleteSubname.js

@@ -21,12 +21,44 @@ __export(deleteSubname_exports, {
   default: () => deleteSubname_default
 });
 module.exports = __toCommonJS(deleteSubname_exports);
-async function deleteSubname_default({ transferSubname, signer }, name, {
-  contract
-}) {
-  return transferSubname.populateTransaction(name, {
-    contract,
-    owner: "0x0000000000000000000000000000000000000000",
-    signer
-  });
+var import_ethers = require("ethers");
+var import_normalise = require("../utils/normalise");
+async function deleteSubname_default({ contracts, signer }, name, { contract }) {
+  const labels = name.split(".");
+  if (labels.length !== 3) {
+    throw new Error("ENS.js currently only supports deleting 2LDs, not TLDs");
+  }
+  if (labels[2] !== "eth") {
+    throw new Error("ENS.js currently only supports deleting .eth 2LDs");
+  }
+  const label = labels.shift();
+  const labelhash = import_ethers.ethers.utils.solidityKeccak256(["string"], [label]);
+  const parentNodehash = (0, import_normalise.namehash)(labels.join("."));
+  switch (contract) {
+    case "registry": {
+      const registry = (await contracts.getRegistry()).connect(signer);
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0
+      );
+    }
+    case "nameWrapper": {
+      const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        0,
+        0,
+        0
+      );
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`);
+    }
+  }
 }

package/dist/cjs/functions/getPrice.js

@@ -22,12 +22,36 @@ __export(getPrice_exports, {
 });
 module.exports = __toCommonJS(getPrice_exports);
 var import_ethers = require("ethers");
-const raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
+const raw = async ({ contracts, multicallWrapper }, nameOrNames, duration, legacy) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal();
+    const baseCall2 = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+        names,
+        duration
+      ])
+    };
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall2,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+            names,
+            0
+          ])
+        }
+      ]);
+    }
+    return baseCall2;
+  }
   const controller = await contracts?.getEthRegistrarController();
   const baseCall = {
     to: controller.address,
     data: controller.interface.encodeFunctionData("rentPrice", [
-      name,
+      names[0],
       duration
     ])
   };
@@ -36,20 +60,42 @@ const raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
       baseCall,
       {
         to: controller.address,
-        data: controller.interface.encodeFunctionData("rentPrice", [name, 0])
+        data: controller.interface.encodeFunctionData("rentPrice", [
+          names[0],
+          0
+        ])
       }
     ]);
   }
   return baseCall;
 };
-const decode = async ({ contracts, multicallWrapper }, data, _name, _number, legacy) => {
+const decode = async ({ contracts, multicallWrapper }, data, _nameOrNames, _duration, legacy) => {
   if (data === null)
     return;
-  const controller = await contracts?.getEthRegistrarController();
   try {
     let base;
     let premium;
-    if (legacy) {
+    const isBulkRenewal = Array.isArray(_nameOrNames) && _nameOrNames.length > 1;
+    if (isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = import_ethers.utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = import_ethers.utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else if (isBulkRenewal) {
+      const bulkRenewal = await contracts?.getBulkRenewal();
+      const result = bulkRenewal.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base] = result;
+      premium = import_ethers.BigNumber.from(0);
+    } else if (!isBulkRenewal && legacy) {
       const result = await multicallWrapper.decode(data);
       const [price] = import_ethers.utils.defaultAbiCoder.decode(
         ["uint256"],
@@ -61,11 +107,12 @@ const decode = async ({ contracts, multicallWrapper }, data, _name, _number, leg
       );
       base = price.sub(premium);
     } else {
-      ;
-      [[base, premium]] = controller.interface.decodeFunctionResult(
+      const controller = await contracts?.getEthRegistrarController();
+      const result = controller.interface.decodeFunctionResult(
         "rentPrice",
         data
       );
+      [base, premium] = result[0];
     }
     return {
       base,

package/dist/cjs/functions/getSubnames.js

@@ -24,15 +24,36 @@ module.exports = __toCommonJS(getSubnames_exports);
 var import_format = require("../utils/format");
 var import_labels = require("../utils/labels");
 var import_normalise = require("../utils/normalise");
-const largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection, orderBy, lastSubnames = [] }) => {
+const largeQuery = async ({ gqlInstance }, {
+  name,
+  pageSize = 10,
+  orderDirection,
+  orderBy,
+  lastSubnames = [],
+  search = ""
+}) => {
   const { client } = gqlInstance;
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1];
+  const lastCreatedAt = lastSubname?.createdAt;
+  const lastLabelName = lastSubname?.labelName;
+  let whereFilter = "";
+  if (orderBy === "createdAt" && lastCreatedAt) {
+    whereFilter += orderDirection === "asc" ? "createdAt_gt: $lastCreatedAt" : "createdAt_lt: $lastCreatedAt";
+  } else if (orderBy === "labelName" && lastLabelName) {
+    whereFilter += orderDirection === "asc" ? "labelName_gt: $lastLabelName" : "labelName_lt: $lastLabelName";
+  }
+  if (search) {
+    whereFilter += " labelName_contains: $search";
+  }
   const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
       $lastCreatedAt: BigInt
+      $lastLabelName: String
       $orderBy: Domain_orderBy 
       $orderDirection: OrderDirection
+      $search: String
     ) {
       domain(
         id: $id
@@ -42,7 +63,9 @@ const largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -61,9 +84,11 @@ const largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection
   const queryVars = {
     id: (0, import_normalise.namehash)(name),
     first: pageSize,
-    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    lastCreatedAt,
+    lastLabelName,
     orderBy,
-    orderDirection
+    orderDirection,
+    search: search?.toLowerCase()
   };
   const { domain } = await client.request(finalQuery, queryVars);
   const subdomains = domain.subdomains.map((subname) => {
@@ -79,96 +104,7 @@ const largeQuery = async ({ gqlInstance }, { name, pageSize = 10, orderDirection
     subnameCount: domain.subdomainCount
   };
 };
-const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
-  const { client } = gqlInstance;
-  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, import_normalise.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, import_normalise.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, import_labels.decryptName)(subname.name);
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: (0, import_format.truncateFormat)(decrypted)
-    };
-  });
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount
-  };
-};
 const getSubnames = (injected, functionArgs) => {
-  if (functionArgs.isLargeQuery) {
-    return largeQuery(injected, functionArgs);
-  }
-  return smallQuery(injected, functionArgs);
+  return largeQuery(injected, functionArgs);
 };
 var getSubnames_default = getSubnames;

package/dist/cjs/functions/renewNames.js

@@ -0,0 +1,42 @@
+"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 renewNames_exports = {};
+__export(renewNames_exports, {
+  default: () => renewNames_default
+});
+module.exports = __toCommonJS(renewNames_exports);
+async function renewNames_default({ contracts }, nameOrNames, {
+  duration,
+  value
+}) {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  const labels = names.map((name) => {
+    const label = name.split(".");
+    if (label.length !== 2 || label[1] !== "eth") {
+      throw new Error("Currently only .eth TLD renewals are supported");
+    }
+    return label[0];
+  });
+  if (labels.length === 1) {
+    const controller = await contracts.getEthRegistrarController();
+    return controller.populateTransaction.renew(labels[0], duration, { value });
+  }
+  const bulkRenewal = await contracts.getBulkRenewal();
+  return bulkRenewal.populateTransaction.renewAll(labels, duration, { value });
+}

package/dist/cjs/generated/BulkRenewal.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 BulkRenewal_exports = {};
+module.exports = __toCommonJS(BulkRenewal_exports);

package/dist/cjs/generated/factories/BulkRenewal__factory.js

@@ -0,0 +1,120 @@
+"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 BulkRenewal_factory_exports = {};
+__export(BulkRenewal_factory_exports, {
+  BulkRenewal__factory: () => BulkRenewal__factory
+});
+module.exports = __toCommonJS(BulkRenewal_factory_exports);
+var import_ethers = require("ethers");
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "contract ENS",
+        name: "_ens",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "ens",
+    outputs: [
+      {
+        internalType: "contract ENS",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string[]",
+        name: "names",
+        type: "string[]"
+      },
+      {
+        internalType: "uint256",
+        name: "duration",
+        type: "uint256"
+      }
+    ],
+    name: "renewAll",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string[]",
+        name: "names",
+        type: "string[]"
+      },
+      {
+        internalType: "uint256",
+        name: "duration",
+        type: "uint256"
+      }
+    ],
+    name: "rentPrice",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "total",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceID",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+class BulkRenewal__factory {
+  static abi = _abi;
+  static createInterface() {
+    return new import_ethers.utils.Interface(_abi);
+  }
+  static connect(address, signerOrProvider) {
+    return new import_ethers.Contract(address, _abi, signerOrProvider);
+  }
+}

package/dist/cjs/generated/factories/index.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var factories_exports = {};
 __export(factories_exports, {
   BaseRegistrarImplementation__factory: () => import_BaseRegistrarImplementation_factory.BaseRegistrarImplementation__factory,
+  BulkRenewal__factory: () => import_BulkRenewal_factory.BulkRenewal__factory,
   DNSRegistrar__factory: () => import_DNSRegistrar_factory.DNSRegistrar__factory,
   DNSSECImpl__factory: () => import_DNSSECImpl_factory.DNSSECImpl__factory,
   DefaultReverseResolver__factory: () => import_DefaultReverseResolver_factory.DefaultReverseResolver__factory,
@@ -41,6 +42,7 @@ __export(factories_exports, {
 });
 module.exports = __toCommonJS(factories_exports);
 var import_BaseRegistrarImplementation_factory = require("./BaseRegistrarImplementation__factory");
+var import_BulkRenewal_factory = require("./BulkRenewal__factory");
 var import_DNSRegistrar_factory = require("./DNSRegistrar__factory");
 var import_DNSSECImpl_factory = require("./DNSSECImpl__factory");
 var import_DefaultReverseResolver_factory = require("./DefaultReverseResolver__factory");

package/dist/cjs/generated/index.js

@@ -25,6 +25,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var generated_exports = {};
 __export(generated_exports, {
   BaseRegistrarImplementation__factory: () => import_BaseRegistrarImplementation_factory.BaseRegistrarImplementation__factory,
+  BulkRenewal__factory: () => import_BulkRenewal_factory.BulkRenewal__factory,
   DNSRegistrar__factory: () => import_DNSRegistrar_factory.DNSRegistrar__factory,
   DNSSECImpl__factory: () => import_DNSSECImpl_factory.DNSSECImpl__factory,
   DefaultReverseResolver__factory: () => import_DefaultReverseResolver_factory.DefaultReverseResolver__factory,
@@ -68,3 +69,4 @@ var import_Multicall_factory = require("./factories/Multicall__factory");
 var import_NameWrapper_factory = require("./factories/NameWrapper__factory");
 var import_StaticMetadataService_factory = require("./factories/StaticMetadataService__factory");
 var import_UniversalResolver_factory = require("./factories/UniversalResolver__factory");
+var import_BulkRenewal_factory = require("./factories/BulkRenewal__factory");

package/dist/cjs/index.js

@@ -308,7 +308,7 @@ class ENS {
   );
   deleteSubname = this.generateWriteFunction(
     "deleteSubname",
-    ["transferSubname"]
+    ["contracts"]
   );
   transferSubname = this.generateWriteFunction(
     "transferSubname",
@@ -322,7 +322,8 @@ class ENS {
     "registerName",
     ["contracts"]
   );
-  renewName = this.generateWriteFunction("renewName", [
-    "contracts"
-  ]);
+  renewNames = this.generateWriteFunction(
+    "renewNames",
+    ["contracts"]
+  );
 }

package/dist/cjs/utils/registerHelpers.js

@@ -36,6 +36,7 @@ var import_generateFuseInput = __toESM(require("./generateFuseInput"));
 var import_labels = require("./labels");
 var import_normalise = require("./normalise");
 var import_recordHelpers = require("./recordHelpers");
+const MAX_INT_64 = 2n ** 64n - 1n;
 const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32);
   return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
@@ -74,7 +75,7 @@ const makeCommitmentData = ({
     secret,
     !!reverseRecord,
     fuseData,
-    wrapperExpiry || Math.floor(Date.now() / 1e3) + duration
+    wrapperExpiry || MAX_INT_64
   ];
 };
 const makeRegistrationData = (params) => {

package/dist/esm/contracts/bulkRenewal.mjs

@@ -0,0 +1,6 @@
+// src/contracts/bulkRenewal.ts
+import { BulkRenewal__factory } from "../generated/factories/BulkRenewal__factory.mjs";
+var bulkRenewal_default = (provider, address) => BulkRenewal__factory.connect(address, provider);
+export {
+  bulkRenewal_default as default
+};

package/dist/esm/contracts/getContractAddress.mjs

@@ -29,7 +29,8 @@ var addresses = {
   UniversalResolver: {
     "1": "0x580AF46E06DaaD47eb5940526FD64d95b815Cb70",
     "4": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376"
-  }
+  },
+  BulkRenewal: "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035"
 };
 var getContractAddress = (networkId) => (contractName) => {
   try {

package/dist/esm/contracts/index.mjs

@@ -7,6 +7,7 @@ import getPublicResolver from "./publicResolver.mjs";
 import getRegistry from "./registry.mjs";
 import getReverseRegistrar from "./reverseRegistrar.mjs";
 import getUniversalResolver from "./universalResolver.mjs";
+import getBulkRenewal from "./bulkRenewal.mjs";
 var ContractManager = class {
   provider;
   fetchAddress;
@@ -50,6 +51,10 @@ var ContractManager = class {
     getEthRegistrarController
   );
   getMulticall = this.generateContractGetter("Multicall", getMulticall);
+  getBulkRenewal = this.generateContractGetter(
+    "BulkRenewal",
+    getBulkRenewal
+  );
 };
 export {
   ContractManager as default