@ensdomains/ensjs 3.0.0-alpha.43 → 3.0.0-alpha.44

package/dist/cjs/contracts/getContractAddress.js

@@ -37,19 +37,19 @@ const addresses = {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",
     "4": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
-    "5": "0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70"
+    "5": "0x603A4F2e7615d0099244496883062bA2eFBbeaf0"
   },
   Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
   NameWrapper: {
     "1": "0x0000000000000000000000000000000000000000",
     "3": "0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C",
     "4": "0x0000000000000000000000000000000000000000",
-    "5": "0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39"
+    "5": "0x060f1546642E67c485D56248201feA2f9AB1803C"
   },
   PublicResolver: {
     "1": "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41",
     "3": "0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837",
-    "5": "0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E"
+    "5": "0x19c2d5D0f035563344dBB7bE5fD09c8dad62b001"
   },
   ENSRegistry: {
     "1": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",

package/dist/cjs/functions/batch.js

@@ -30,16 +30,24 @@ const raw = async ({ multicallWrapper }, ...items) => {
       return rawRef(...args);
     })
   );
-  return multicallWrapper.raw(rawDataArr);
+  const response = await multicallWrapper.raw(rawDataArr);
+  return { ...response, passthrough: rawDataArr };
 };
-const decode = async ({ multicallWrapper }, data, ...items) => {
-  const response = await multicallWrapper.decode(data);
+const decode = async ({ multicallWrapper }, data, passthrough, ...items) => {
+  const response = await multicallWrapper.decode(data, passthrough);
   if (!response)
     return;
   return Promise.all(
-    response.map(
-      (ret, i) => items[i].decode(ret.returnData, ...items[i].args)
-    )
+    response.map((ret, i) => {
+      if (passthrough[i].passthrough) {
+        return items[i].decode(
+          ret.returnData,
+          passthrough[i].passthrough,
+          ...items[i].args
+        );
+      }
+      return items[i].decode(ret.returnData, ...items[i].args);
+    })
   );
 };
 var batch_default = {

package/dist/cjs/functions/getExpiry.js

@@ -23,6 +23,7 @@ __export(getExpiry_exports, {
 module.exports = __toCommonJS(getExpiry_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
+var import_validation = require("../utils/validation");
 const getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
   if (labels.length > 2 || labels[1] !== "eth") {
     throw new Error("Only .eth names have expiry dates on the registrar");
@@ -56,7 +57,7 @@ const getWrapperExpiry = async ({ contracts }, labels) => {
 const getContractToUse = (contract, labels) => {
   if (contract)
     return contract;
-  if (labels.length === 2 && labels[1] === "eth") {
+  if ((0, import_validation.checkIsDotEth)(labels)) {
     return "registrar";
   }
   return "nameWrapper";

package/dist/cjs/functions/getHistory.js

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(getHistory_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
 var import_bytes = require("@ethersproject/bytes");
 var import_contentHash = require("../utils/contentHash");
-var import_labels = require("../utils/labels");
 var import_normalise = require("../utils/normalise");
+var import_validation = require("../utils/validation");
 const eventFormat = {
   Domain: {
     NewOwner: (args) => ({ owner: args.owner.id }),
@@ -106,7 +106,7 @@ const mapEvents = (eventArray, type) => eventArray.map(
 async function getHistory({ gqlInstance }, name) {
   const { client } = gqlInstance;
   const query = gqlInstance.gql`
-      query getHistory($namehash: String!, $labelhash: String!) {
+      query getHistory($namehash: String!) {
         domain(id: $namehash) {
           events {
             id
@@ -226,32 +226,39 @@ async function getHistory({ gqlInstance }, name) {
         }
       }
       `;
-  const label = name.split(".")[0];
   const nameHash = (0, import_normalise.namehash)(name);
-  const labelHash = (0, import_labels.labelhash)(label);
+  const labels = name.split(".");
+  const is2ldEth = (0, import_validation.checkIsDotEth)(labels);
   const response = await client.request(query, {
-    namehash: nameHash,
-    labelhash: labelHash
+    namehash: nameHash
   });
   const domain = response == null ? void 0 : response.domain;
   if (!domain)
     return;
   const {
     events: domainEvents,
-    registration: { events: registrationEvents },
     resolver: { events: resolverEvents }
   } = domain;
   const domainHistory = mapEvents(domainEvents, "Domain");
-  const registrationHistory = mapEvents(registrationEvents, "Registration");
   const resolverHistory = mapEvents(
     resolverEvents.filter(
       (event) => !event.coinType || event.coinType !== "60"
     ),
     "Resolver"
   );
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents }
+    } = domain;
+    const registrationHistory = mapEvents(registrationEvents, "Registration");
+    return {
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory
+    };
+  }
   return {
     domain: domainHistory,
-    registration: registrationHistory,
     resolver: resolverHistory
   };
 }

package/dist/cjs/functions/getOwner.js

@@ -25,6 +25,7 @@ var import_abi = require("@ethersproject/abi");
 var import_bytes = require("@ethersproject/bytes");
 var import_labels = require("../utils/labels");
 var import_normalise = require("../utils/normalise");
+var import_validation = require("../utils/validation");
 const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
   switch (contract) {
     case "nameWrapper": {
@@ -82,7 +83,7 @@ const raw = async ({ contracts, multicallWrapper }, name, contract) => {
     labels
   );
   const data = [registryData, nameWrapperData];
-  if (labels.length === 2 && labels[1] === "eth") {
+  if ((0, import_validation.checkIsDotEth)(labels)) {
     data.push(registrarData);
   }
   return multicallWrapper.raw(data);

package/dist/cjs/functions/getWrapperData.js

@@ -39,7 +39,7 @@ const decode = async ({ contracts }, data) => {
       data
     );
     const fuseObj = (0, import_fuses.decodeFuses)(fuses);
-    const expiryDate = expiry.gt(0) && expiry.lt(import_bignumber.BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toString()) : void 0;
+    const expiryDate = expiry.gt(0) && expiry.lt(import_bignumber.BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toNumber()) : void 0;
     return {
       ...fuseObj,
       expiryDate,

package/dist/cjs/functions/unwrapName.js

@@ -23,6 +23,7 @@ __export(unwrapName_exports, {
 module.exports = __toCommonJS(unwrapName_exports);
 var import_solidity = require("@ethersproject/solidity");
 var import_normalise = require("../utils/normalise");
+var import_validation = require("../utils/validation");
 async function unwrapName_default({ contracts, signer }, name, {
   newController,
   newRegistrant
@@ -31,7 +32,7 @@ async function unwrapName_default({ contracts, signer }, name, {
   const labelhash = (0, import_solidity.keccak256)(["string"], [labels[0]]);
   const parentNodehash = (0, import_normalise.namehash)(labels.slice(1).join("."));
   const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-  if (labels.length === 2 && labels[1] === "eth") {
+  if ((0, import_validation.checkIsDotEth)(labels)) {
     if (!newRegistrant) {
       throw new Error("newRegistrant must be specified for .eth names");
     }

package/dist/cjs/functions/wrapName.js

@@ -25,6 +25,7 @@ var import_abi = require("@ethersproject/abi");
 var import_solidity = require("@ethersproject/solidity");
 var import_fuses = require("../utils/fuses");
 var import_hexEncodedName = require("../utils/hexEncodedName");
+var import_validation = require("../utils/validation");
 var import_wrapper = require("../utils/wrapper");
 async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
   const nameWrapper = await (contracts == null ? void 0 : contracts.getNameWrapper());
@@ -67,7 +68,7 @@ async function wrapName_default({ contracts, signer }, name, {
     resolverAddress = publicResolver.address;
   const labels = name.split(".");
   (0, import_wrapper.wrappedLabelLengthCheck)(labels[0]);
-  if (labels.length === 2 && labels[1] === "eth") {
+  if ((0, import_validation.checkIsDotEth)(labels)) {
     switch (typeof fuseOptions) {
       case "object": {
         decodedFuses = (0, import_fuses.encodeFuses)(fuseOptions);

package/dist/cjs/index.js

@@ -281,7 +281,7 @@ class ENS {
     this.getDecryptedName = this.generateRawFunction("getDecryptedName", ["contracts", "gqlInstance"]);
     this.universalWrapper = this.generateRawFunction("initialGetters", ["contracts"], "universalWrapper");
     this.resolverMulticallWrapper = this.generateRawFunction("initialGetters", ["contracts"], "resolverMulticallWrapper");
-    this.multicallWrapper = this.generateRawFunction("initialGetters", ["contracts"], "multicallWrapper");
+    this.multicallWrapper = this.generateRawFunction("initialGetters", ["contracts", "provider"], "multicallWrapper");
     this.setName = this.generateWriteFunction(
       "setName",
       ["contracts"]

package/dist/cjs/utils/ccip.js

@@ -115,7 +115,7 @@ const ccipLookup = async (provider, transaction, result) => {
       throw new Error("CCIP Read disabled or provided no URLs");
     }
     const tx = {
-      to: sender,
+      to: txSender,
       data: (0, import_bytes.hexConcat)([
         callbackSelector,
         encodeBytes([ccipResult, extraData])

package/dist/cjs/utils/fuses.js

@@ -74,6 +74,7 @@ const userSettableFuseEnum = {
 };
 const fullFuseEnum = {
   ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
   CAN_DO_EVERYTHING
 };
 const unnamedChildFuses = [
@@ -256,14 +257,14 @@ const decodeNamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
     arr.map((fuse) => [
       fuse,
-      (fuses & userSettableFuseEnum[fuse]) > 0
+      (fuses & fullFuseEnum[fuse]) === fullFuseEnum[fuse]
     ])
   );
   return fuseObj;
 };
 const decodeUnnamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
-    arr.map((fuse) => [fuse, (fuses & fuse) > 0])
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse])
   );
   return fuseObj;
 };

package/dist/cjs/utils/singleCall.js

@@ -21,4 +21,12 @@ __export(singleCall_exports, {
   default: () => singleCall_default
 });
 module.exports = __toCommonJS(singleCall_exports);
-var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+var singleCall_default = async (provider, ensData, func, ...data) => {
+  const { passthrough, ...rawData } = await func.raw(ensData, ...data);
+  const result = await provider.call({ ...rawData, ccipReadEnabled: true }).catch(() => null);
+  if (!result)
+    return;
+  if (passthrough)
+    return func.decode(ensData, result, passthrough, ...data);
+  return func.decode(ensData, result, ...data);
+};

package/dist/cjs/utils/validation.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var validation_exports = {};
 __export(validation_exports, {
+  checkIsDotEth: () => checkIsDotEth,
   parseInputType: () => parseInputType,
   validateName: () => validateName,
   validateTLD: () => validateTLD
@@ -84,3 +85,4 @@ const parseInputType = (input) => {
     type: "label"
   };
 };
+const checkIsDotEth = (labels) => labels.length === 2 && labels[1] === "eth";

package/dist/esm/contracts/getContractAddress.mjs

@@ -15,19 +15,19 @@ var addresses = {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",
     "4": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
-    "5": "0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70"
+    "5": "0x603A4F2e7615d0099244496883062bA2eFBbeaf0"
   },
   Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
   NameWrapper: {
     "1": "0x0000000000000000000000000000000000000000",
     "3": "0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C",
     "4": "0x0000000000000000000000000000000000000000",
-    "5": "0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39"
+    "5": "0x060f1546642E67c485D56248201feA2f9AB1803C"
   },
   PublicResolver: {
     "1": "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41",
     "3": "0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837",
-    "5": "0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E"
+    "5": "0x19c2d5D0f035563344dBB7bE5fD09c8dad62b001"
   },
   ENSRegistry: {
     "1": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",

package/dist/esm/functions/batch.mjs

@@ -8,16 +8,24 @@ var raw = async ({ multicallWrapper }, ...items) => {
       return rawRef(...args);
     })
   );
-  return multicallWrapper.raw(rawDataArr);
+  const response = await multicallWrapper.raw(rawDataArr);
+  return { ...response, passthrough: rawDataArr };
 };
-var decode = async ({ multicallWrapper }, data, ...items) => {
-  const response = await multicallWrapper.decode(data);
+var decode = async ({ multicallWrapper }, data, passthrough, ...items) => {
+  const response = await multicallWrapper.decode(data, passthrough);
   if (!response)
     return;
   return Promise.all(
-    response.map(
-      (ret, i) => items[i].decode(ret.returnData, ...items[i].args)
-    )
+    response.map((ret, i) => {
+      if (passthrough[i].passthrough) {
+        return items[i].decode(
+          ret.returnData,
+          passthrough[i].passthrough,
+          ...items[i].args
+        );
+      }
+      return items[i].decode(ret.returnData, ...items[i].args);
+    })
   );
 };
 var batch_default = {

package/dist/esm/functions/getExpiry.mjs

@@ -1,6 +1,7 @@
 // src/functions/getExpiry.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
 var getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
   if (labels.length > 2 || labels[1] !== "eth") {
     throw new Error("Only .eth names have expiry dates on the registrar");
@@ -34,7 +35,7 @@ var getWrapperExpiry = async ({ contracts }, labels) => {
 var getContractToUse = (contract, labels) => {
   if (contract)
     return contract;
-  if (labels.length === 2 && labels[1] === "eth") {
+  if (checkIsDotEth(labels)) {
     return "registrar";
   }
   return "nameWrapper";

package/dist/esm/functions/getHistory.mjs

@@ -2,8 +2,8 @@
 import { formatsByCoinType } from "@ensdomains/address-encoder";
 import { hexStripZeros } from "@ethersproject/bytes";
 import { decodeContenthash } from "../utils/contentHash.mjs";
-import { labelhash } from "../utils/labels.mjs";
 import { namehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
 var eventFormat = {
   Domain: {
     NewOwner: (args) => ({ owner: args.owner.id }),
@@ -84,7 +84,7 @@ var mapEvents = (eventArray, type) => eventArray.map(
 async function getHistory({ gqlInstance }, name) {
   const { client } = gqlInstance;
   const query = gqlInstance.gql`
-      query getHistory($namehash: String!, $labelhash: String!) {
+      query getHistory($namehash: String!) {
         domain(id: $namehash) {
           events {
             id
@@ -204,32 +204,39 @@ async function getHistory({ gqlInstance }, name) {
         }
       }
       `;
-  const label = name.split(".")[0];
   const nameHash = namehash(name);
-  const labelHash = labelhash(label);
+  const labels = name.split(".");
+  const is2ldEth = checkIsDotEth(labels);
   const response = await client.request(query, {
-    namehash: nameHash,
-    labelhash: labelHash
+    namehash: nameHash
   });
   const domain = response?.domain;
   if (!domain)
     return;
   const {
     events: domainEvents,
-    registration: { events: registrationEvents },
     resolver: { events: resolverEvents }
   } = domain;
   const domainHistory = mapEvents(domainEvents, "Domain");
-  const registrationHistory = mapEvents(registrationEvents, "Registration");
   const resolverHistory = mapEvents(
     resolverEvents.filter(
       (event) => !event.coinType || event.coinType !== "60"
     ),
     "Resolver"
   );
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents }
+    } = domain;
+    const registrationHistory = mapEvents(registrationEvents, "Registration");
+    return {
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory
+    };
+  }
   return {
     domain: domainHistory,
-    registration: registrationHistory,
     resolver: resolverHistory
   };
 }

package/dist/esm/functions/getOwner.mjs

@@ -3,6 +3,7 @@ import { defaultAbiCoder } from "@ethersproject/abi";
 import { hexStripZeros } from "@ethersproject/bytes";
 import { labelhash } from "../utils/labels.mjs";
 import { namehash as makeNamehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
 var singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
   switch (contract) {
     case "nameWrapper": {
@@ -60,7 +61,7 @@ var raw = async ({ contracts, multicallWrapper }, name, contract) => {
     labels
   );
   const data = [registryData, nameWrapperData];
-  if (labels.length === 2 && labels[1] === "eth") {
+  if (checkIsDotEth(labels)) {
     data.push(registrarData);
   }
   return multicallWrapper.raw(data);

package/dist/esm/functions/getWrapperData.mjs

@@ -17,7 +17,7 @@ var decode = async ({ contracts }, data) => {
       data
     );
     const fuseObj = decodeFuses(fuses);
-    const expiryDate = expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toString()) : void 0;
+    const expiryDate = expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toNumber()) : void 0;
     return {
       ...fuseObj,
       expiryDate,

package/dist/esm/functions/unwrapName.mjs

@@ -1,6 +1,7 @@
 // src/functions/unwrapName.ts
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { namehash } from "../utils/normalise.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
 async function unwrapName_default({ contracts, signer }, name, {
   newController,
   newRegistrant
@@ -9,7 +10,7 @@ async function unwrapName_default({ contracts, signer }, name, {
   const labelhash = solidityKeccak256(["string"], [labels[0]]);
   const parentNodehash = namehash(labels.slice(1).join("."));
   const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-  if (labels.length === 2 && labels[1] === "eth") {
+  if (checkIsDotEth(labels)) {
     if (!newRegistrant) {
       throw new Error("newRegistrant must be specified for .eth names");
     }

package/dist/esm/functions/wrapName.mjs

@@ -3,6 +3,7 @@ import { defaultAbiCoder } from "@ethersproject/abi";
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
 import { encodeFuses } from "../utils/fuses.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+import { checkIsDotEth } from "../utils/validation.mjs";
 import { wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
 async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
   const nameWrapper = await contracts?.getNameWrapper();
@@ -45,7 +46,7 @@ async function wrapName_default({ contracts, signer }, name, {
     resolverAddress = publicResolver.address;
   const labels = name.split(".");
   wrappedLabelLengthCheck(labels[0]);
-  if (labels.length === 2 && labels[1] === "eth") {
+  if (checkIsDotEth(labels)) {
     switch (typeof fuseOptions) {
       case "object": {
         decodedFuses = encodeFuses(fuseOptions);

package/dist/esm/index.mjs

@@ -258,7 +258,7 @@ var ENS = class {
   getDecryptedName = this.generateRawFunction("getDecryptedName", ["contracts", "gqlInstance"]);
   universalWrapper = this.generateRawFunction("initialGetters", ["contracts"], "universalWrapper");
   resolverMulticallWrapper = this.generateRawFunction("initialGetters", ["contracts"], "resolverMulticallWrapper");
-  multicallWrapper = this.generateRawFunction("initialGetters", ["contracts"], "multicallWrapper");
+  multicallWrapper = this.generateRawFunction("initialGetters", ["contracts", "provider"], "multicallWrapper");
   setName = this.generateWriteFunction(
     "setName",
     ["contracts"]

package/dist/esm/utils/ccip.mjs

@@ -97,7 +97,7 @@ var ccipLookup = async (provider, transaction, result) => {
       throw new Error("CCIP Read disabled or provided no URLs");
     }
     const tx = {
-      to: sender,
+      to: txSender,
       data: hexConcat([
         callbackSelector,
         encodeBytes([ccipResult, extraData])

package/dist/esm/utils/fuses.mjs

@@ -34,6 +34,7 @@ var userSettableFuseEnum = {
 };
 var fullFuseEnum = {
   ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
   CAN_DO_EVERYTHING
 };
 var unnamedChildFuses = [
@@ -216,14 +217,14 @@ var decodeNamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
     arr.map((fuse) => [
       fuse,
-      (fuses & userSettableFuseEnum[fuse]) > 0
+      (fuses & fullFuseEnum[fuse]) === fullFuseEnum[fuse]
     ])
   );
   return fuseObj;
 };
 var decodeUnnamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
-    arr.map((fuse) => [fuse, (fuses & fuse) > 0])
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse])
   );
   return fuseObj;
 };

package/dist/esm/utils/singleCall.mjs

@@ -1,5 +1,13 @@
 // src/utils/singleCall.ts
-var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+var singleCall_default = async (provider, ensData, func, ...data) => {
+  const { passthrough, ...rawData } = await func.raw(ensData, ...data);
+  const result = await provider.call({ ...rawData, ccipReadEnabled: true }).catch(() => null);
+  if (!result)
+    return;
+  if (passthrough)
+    return func.decode(ensData, result, passthrough, ...data);
+  return func.decode(ensData, result, ...data);
+};
 export {
   singleCall_default as default
 };

package/dist/esm/utils/validation.mjs

@@ -60,7 +60,9 @@ var parseInputType = (input) => {
     type: "label"
   };
 };
+var checkIsDotEth = (labels) => labels.length === 2 && labels[1] === "eth";
 export {
+  checkIsDotEth,
   parseInputType,
   validateName,
   validateTLD

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

@@ -1,9 +1,16 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { BatchFunctionResult, ENSArgs, RawFunction } from '..';
 declare const _default: {
     raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+        passthrough: {
+            to: string;
+            data: string;
+        }[];
         to: string;
         data: string;
     }>;
-    decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+    decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, passthrough: TransactionRequest & {
+        passthrough?: any;
+    }[], ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
 };
 export default _default;

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

@@ -24,5 +24,21 @@ export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name
         id: string;
         data: object;
     }[];
+} | {
+    domain: {
+        type: DomainEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    resolver: {
+        type: ResolverEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    registration?: undefined;
 } | undefined>;
 export {};

package/dist/types/index.d.ts

@@ -133,10 +133,16 @@ export declare class ENS {
     withProvider: (provider: JsonRpcProvider) => ENS;
     batch: GeneratedBatchFunction<{
         raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+            passthrough: {
+                to: string;
+                data: string;
+            }[];
             to: string;
             data: string;
         }>;
-        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, passthrough: import("@ethersproject/abstract-provider").TransactionRequest & {
+            passthrough?: any;
+        }[], ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
     getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
@@ -306,6 +312,22 @@ export declare class ENS {
             id: string;
             data: object;
         }[];
+    } | {
+        domain: {
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "ExpiryExtended" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        resolver: {
+            type: "AddrChanged" | "ContenthashChanged" | "InterfaceChanged" | "NameChanged" | "PubkeyChanged" | "TextChanged" | "VersionChanged" | "MulticoinAddrChanged" | "AbiChanged" | "AuthorisationChanged";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
+        }[];
+        registration?: undefined;
     } | undefined>;
     getContentHash: GeneratedRawFunction<{
         raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{

package/dist/types/utils/fuses.d.ts

@@ -30,6 +30,7 @@ export declare const userSettableFuseEnum: {
 };
 export declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
+    IS_DOT_ETH: 131072;
     PARENT_CANNOT_CONTROL: number;
     CAN_EXTEND_EXPIRY: number;
     CANNOT_UNWRAP: 1;

package/dist/types/utils/singleCall.d.ts

@@ -3,6 +3,7 @@ declare const _default: (provider: Provider, ensData: any, func: {
     raw: (...args: any[]) => Promise<{
         to: string;
         data: string;
+        passthrough?: any;
     }>;
     decode: (...args: any[]) => Promise<any>;
 }, ...data: any[]) => Promise<any>;

package/dist/types/utils/validation.d.ts

@@ -5,4 +5,5 @@ declare type InputType = {
     info?: 'short' | 'supported' | 'unsupported';
 };
 export declare const parseInputType: (input: string) => InputType;
+export declare const checkIsDotEth: (labels: string[]) => boolean;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.43",
+  "version": "3.0.0-alpha.44",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -69,7 +69,7 @@
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.16",
+    "@ensdomains/ens-contracts": "^0.0.17",
     "@ensdomains/ens-test-env": "0.3.7",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70',
+    '5': '0x603A4F2e7615d0099244496883062bA2eFBbeaf0',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39',
+    '5': '0x060f1546642E67c485D56248201feA2f9AB1803C',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E',
+    '5': '0x19c2d5D0f035563344dBB7bE5fD09c8dad62b001',
   },
   ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',

package/src/functions/batch.ts

@@ -1,3 +1,4 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider'
 import { BatchFunctionResult, ENSArgs, RawFunction } from '..'
 
 const raw = async (
@@ -12,21 +13,30 @@ const raw = async (
       return rawRef(...args)
     }),
   )
-  return multicallWrapper.raw(rawDataArr)
+  const response = await multicallWrapper.raw(rawDataArr)
+  return { ...response, passthrough: rawDataArr }
 }
 
 const decode = async (
   { multicallWrapper }: ENSArgs<'multicallWrapper'>,
   data: string,
+  passthrough: TransactionRequest & { passthrough?: any }[],
   ...items: BatchFunctionResult<RawFunction>[]
 ): Promise<any[] | undefined> => {
-  const response = await multicallWrapper.decode(data)
+  const response = await multicallWrapper.decode(data, passthrough)
   if (!response) return
 
   return Promise.all(
-    response.map((ret: any, i: number) =>
-      items[i].decode(ret.returnData, ...items[i].args),
-    ),
+    response.map((ret: any, i: number) => {
+      if (passthrough[i].passthrough) {
+        return items[i].decode(
+          ret.returnData,
+          passthrough[i].passthrough,
+          ...items[i].args,
+        )
+      }
+      return items[i].decode(ret.returnData, ...items[i].args)
+    }),
   )
 }
 

package/src/functions/ccip.test.ts

@@ -0,0 +1,62 @@
+import dotenv from 'dotenv'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+dotenv.config()
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup(true))
+})
+
+jest.setTimeout(20000)
+
+describe('CCIP', () => {
+  describe('getProfile', () => {
+    it('should return a profile from a ccip-read name', async () => {
+      const result = await ensInstance.getProfile('1.offchainexample.eth', {
+        fallback: {
+          texts: ['email', 'description'],
+          contentHash: true,
+          coinTypes: ['LTC', '60'],
+        },
+      })
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.address).toBe(
+          '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
+        )
+      }
+    })
+  })
+  describe('batch', () => {
+    it('allows batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ensInstance.getAddr.batch('1.offchainexample.eth', 'LTC'),
+        ensInstance.getText.batch('1.offchainexample.eth', 'email'),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+        expect(result[1]).toStrictEqual({
+          coin: 'LTC',
+          addr: 'MQMcJhpWHYVeQArcZR3sBgyPZxxRtnH441',
+        })
+        expect(result[2]).toBe('nick@ens.domains')
+      }
+    })
+    it('allows nested batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.batch.batch(
+          ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]![0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+      }
+    })
+  })
+})

package/src/functions/getExpiry.ts

@@ -2,6 +2,7 @@ import { BigNumber } from '@ethersproject/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 type ContractOption = 'registrar' | 'nameWrapper'
 
@@ -56,7 +57,7 @@ const getContractToUse = (
   labels: string[],
 ) => {
   if (contract) return contract
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     return 'registrar'
   }
   return 'nameWrapper'

package/src/functions/getHistory.test.ts

@@ -35,4 +35,15 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
+  it('should return the history of a subname', async () => {
+    const result = await ensInstance.getHistory(
+      'test.wrapped-with-subnames.eth',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).not.toHaveProperty('registration')
+    }
+  })
 })

package/src/functions/getHistory.ts

@@ -2,7 +2,6 @@ import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
-import { labelhash } from '../utils/labels'
 import { namehash } from '../utils/normalise'
 import {
   AbiChanged,
@@ -28,6 +27,7 @@ import {
   VersionChanged,
   WrappedTransfer,
 } from '../utils/subgraph-types'
+import { checkIsDotEth } from '../utils/validation'
 
 type DomainEvent =
   | 'NewOwner'
@@ -154,7 +154,7 @@ export async function getHistory(
 ) {
   const { client } = gqlInstance
   const query = gqlInstance.gql`
-      query getHistory($namehash: String!, $labelhash: String!) {
+      query getHistory($namehash: String!) {
         domain(id: $namehash) {
           events {
             id
@@ -275,14 +275,12 @@ export async function getHistory(
       }
       `
 
-  const label = name.split('.')[0]
-
   const nameHash = namehash(name)
-  const labelHash = labelhash(label)
+  const labels = name.split('.')
+  const is2ldEth = checkIsDotEth(labels)
 
   const response = await client.request(query, {
     namehash: nameHash,
-    labelhash: labelHash,
   })
   const domain = response?.domain
 
@@ -290,12 +288,10 @@ export async function getHistory(
 
   const {
     events: domainEvents,
-    registration: { events: registrationEvents },
     resolver: { events: resolverEvents },
   } = domain
 
   const domainHistory = mapEvents(domainEvents, 'Domain')
-  const registrationHistory = mapEvents(registrationEvents, 'Registration')
   const resolverHistory = mapEvents(
     // remove duplicate events for ETH cointype
     resolverEvents.filter(
@@ -304,9 +300,20 @@ export async function getHistory(
     'Resolver',
   )
 
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents },
+    } = domain
+    const registrationHistory = mapEvents(registrationEvents, 'Registration')
+    return {
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory,
+    }
+  }
+
   return {
     domain: domainHistory,
-    registration: registrationHistory,
     resolver: resolverHistory,
   }
 }

package/src/functions/getOwner.ts

@@ -4,6 +4,7 @@ import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 type Owner = {
   registrant?: string
@@ -87,7 +88,7 @@ const raw = async (
 
   const data: { to: string; data: string }[] = [registryData, nameWrapperData]
 
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     data.push(registrarData)
   }
 

package/src/functions/getWrapperData.test.ts

@@ -52,13 +52,16 @@ describe('getWrapperData', () => {
       expect(result.child.CANNOT_UNWRAP).toBe(true)
       expect(result.child.CANNOT_CREATE_SUBDOMAIN).toBe(true)
       expect(result.child.CANNOT_SET_TTL).toBe(true)
+      expect(result.parent.IS_DOT_ETH).toBe(true)
     }
   })
   it('should return correct expiry', async () => {
     const result = await ensInstance.getWrapperData('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
+      console.log(result.expiryDate)
       expect(result.expiryDate).toBeInstanceOf(Date)
+      expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
     }
   })
 })

package/src/functions/getWrapperData.ts

@@ -23,7 +23,7 @@ const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
 
     const expiryDate =
       expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32))
-        ? new Date(expiry.mul(1000).toString())
+        ? new Date(expiry.mul(1000).toNumber())
         : undefined
 
     return {

package/src/functions/unwrapName.ts

@@ -2,6 +2,7 @@ import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 export default async function (
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
@@ -20,7 +21,7 @@ export default async function (
 
   const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
 
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     if (!newRegistrant) {
       throw new Error('newRegistrant must be specified for .eth names')
     }

package/src/functions/wrapName.ts

@@ -4,6 +4,7 @@ import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { checkIsDotEth } from '../utils/validation'
 import { Expiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
 async function wrapETH(
@@ -84,7 +85,7 @@ export default async function (
   const labels = name.split('.')
   wrappedLabelLengthCheck(labels[0])
 
-  if (labels.length === 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     switch (typeof fuseOptions) {
       case 'object': {
         decodedFuses = encodeFuses(fuseOptions)

package/src/index.ts

@@ -562,7 +562,7 @@ export class ENS {
 
   public multicallWrapper = this.generateRawFunction<
     FunctionTypes['multicallWrapper']
-  >('initialGetters', ['contracts'], 'multicallWrapper')
+  >('initialGetters', ['contracts', 'provider'], 'multicallWrapper')
 
   public setName = this.generateWriteFunction<FunctionTypes['setName']>(
     'setName',

package/src/utils/ccip.ts

@@ -133,7 +133,7 @@ const ccipLookup = async (
     }
 
     const tx = {
-      to: sender,
+      to: txSender,
       data: hexConcat([
         callbackSelector,
         encodeBytes([ccipResult, extraData!]),

package/src/utils/fuses.ts

@@ -45,6 +45,7 @@ export const userSettableFuseEnum = {
 
 export const fullFuseEnum = {
   ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
   CAN_DO_EVERYTHING,
 }
 
@@ -303,9 +304,8 @@ const decodeNamedFuses = (fuses: number, arr: readonly string[]) => {
   const fuseObj = Object.fromEntries(
     arr.map((fuse) => [
       fuse,
-      (fuses &
-        userSettableFuseEnum[fuse as keyof typeof userSettableFuseEnum]) >
-        0,
+      (fuses & fullFuseEnum[fuse as keyof typeof fullFuseEnum]) ===
+        fullFuseEnum[fuse as keyof typeof fullFuseEnum],
     ]),
   )
 
@@ -314,7 +314,7 @@ const decodeNamedFuses = (fuses: number, arr: readonly string[]) => {
 
 const decodeUnnamedFuses = (fuses: number, arr: readonly number[]) => {
   const fuseObj = Object.fromEntries(
-    arr.map((fuse) => [fuse, (fuses & fuse) > 0]),
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse]),
   )
 
   return fuseObj

package/src/utils/singleCall.ts

@@ -4,13 +4,18 @@ export default async (
   provider: Provider,
   ensData: any,
   func: {
-    raw: (...args: any[]) => Promise<{ to: string; data: string }>
+    raw: (
+      ...args: any[]
+    ) => Promise<{ to: string; data: string; passthrough?: any }>
     decode: (...args: any[]) => Promise<any>
   },
   ...data: any[]
-) =>
-  func
-    .raw(ensData, ...data)
-    .then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true }))
+) => {
+  const { passthrough, ...rawData } = await func.raw(ensData, ...data)
+  const result = await provider
+    .call({ ...rawData, ccipReadEnabled: true })
     .catch(() => null)
-    .then((ret) => func.decode(ensData, ret, ...data))
+  if (!result) return
+  if (passthrough) return func.decode(ensData, result, passthrough, ...data)
+  return func.decode(ensData, result, ...data)
+}

package/src/utils/validation.ts

@@ -70,3 +70,6 @@ export const parseInputType = (input: string): InputType => {
     type: 'label',
   }
 }
+
+export const checkIsDotEth = (labels: string[]) =>
+  labels.length === 2 && labels[1] === 'eth'

package/src/functions/getProfile-ccip.test.ts

@@ -1,29 +0,0 @@
-import dotenv from 'dotenv'
-import { ENS } from '..'
-import setup from '../tests/setup'
-
-dotenv.config()
-
-let ensInstance: ENS
-
-beforeAll(async () => {
-  ;({ ensInstance } = await setup(true))
-})
-
-jest.setTimeout(20000)
-
-describe('getProfile', () => {
-  it('should return a profile from a ccip-read name', async () => {
-    const result = await ensInstance.getProfile('1.offchainexample.eth', {
-      fallback: {
-        texts: ['email', 'description'],
-        contentHash: true,
-        coinTypes: ['0', '60'],
-      },
-    })
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.address).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
-    }
-  })
-})