@ensdomains/ensjs 3.0.0-alpha.25 → 3.0.0-alpha.27

package/README.md

@@ -50,7 +50,7 @@ The batch function is a large part of this library, and there are plenty of situ
 
 ```js
 /* Batch functions can be called like so, with the function as the first item in an array, with the following items being the function's arguments */
-const batched = await batch(
+const batched = await ENSInstance.batch(
   ENSInstance.getText.batch('test.eth', 'foo'),
   ENSInstance.getAddr.batch('test.eth'),
   ENSInstance.getOwner.batch('test.eth'),

package/dist/cjs/contracts/getContractAddress.js

@@ -37,19 +37,19 @@ const addresses = {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",
     "4": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
-    "5": "0x4a16c6Bbee697b66706E7dc0101BfCA1d60cdE76"
+    "5": "0x9C51161bA2FB02Cc0a403332B607117685f34831"
   },
   Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
   NameWrapper: {
     "1": "0x0000000000000000000000000000000000000000",
     "3": "0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C",
     "4": "0x0000000000000000000000000000000000000000",
-    "5": "0x9c4C40960B53e9A01af429D3f90aEf02Bd0c4c72"
+    "5": "0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8"
   },
   PublicResolver: {
     "1": "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41",
     "3": "0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837",
-    "5": "0x58e4627848223BF59F8Ce34265c426E7B05E8625"
+    "5": "0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852"
   },
   ENSRegistryWithFallback: {
     "1": "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e",
@@ -66,7 +66,7 @@ const addresses = {
     "1": "0x580AF46E06DaaD47eb5940526FD64d95b815Cb70",
     "3": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
     "4": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
-    "5": "0x9380F1974D2B7064eA0c0EC251968D8c69f0Ae31"
+    "5": "0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0"
   },
   BulkRenewal: {
     "1": "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035",

package/dist/cjs/functions/batchWrappers.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var batchWrappers_exports = {};
 __export(batchWrappers_exports, {
@@ -23,22 +29,23 @@ __export(batchWrappers_exports, {
   universalWrapper: () => universalWrapper
 });
 module.exports = __toCommonJS(batchWrappers_exports);
+var import_ccip = __toESM(require("../utils/ccip"));
 var import_hexEncodedName = require("../utils/hexEncodedName");
 const universalWrapper = {
   raw: async ({ contracts }, name, data) => {
     const universalResolver = await contracts?.getUniversalResolver();
     return {
       to: universalResolver.address,
-      data: universalResolver.interface.encodeFunctionData("resolve", [
-        (0, import_hexEncodedName.hexEncodeName)(name),
-        data
-      ])
+      data: universalResolver.interface.encodeFunctionData(
+        "resolve(bytes,bytes)",
+        [(0, import_hexEncodedName.hexEncodeName)(name), data]
+      )
     };
   },
   decode: async ({ contracts }, data) => {
     const universalResolver = await contracts?.getUniversalResolver();
     const response = universalResolver.interface.decodeFunctionResult(
-      "resolve",
+      "resolve(bytes,bytes)",
       data
     );
     if (!response || !response[0]) {
@@ -84,7 +91,7 @@ const multicallWrapper = {
       ])
     };
   },
-  async decode({ contracts }, data) {
+  async decode({ contracts, provider }, data, transactions) {
     if (!data)
       return;
     const multicall = await contracts?.getMulticall();
@@ -93,9 +100,35 @@ const multicallWrapper = {
         "tryAggregate",
         data
       );
-      return result;
+      const ccipChecked = await Promise.all(
+        result.map(
+          async ([success, returnData], i) => {
+            let newArr = [success, returnData];
+            if (!success && returnData.startsWith("0x556f1830")) {
+              try {
+                const newData = await (0, import_ccip.default)(
+                  provider,
+                  transactions[i],
+                  returnData
+                );
+                if (newData) {
+                  newArr = [true, newData];
+                }
+              } catch {
+              }
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1]
+            };
+          }
+        )
+      );
+      return ccipChecked;
     } catch (e) {
-      return e;
+      console.error(e);
+      return;
     }
   }
 };

package/dist/cjs/functions/deleteSubname.js

@@ -25,11 +25,8 @@ 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");
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`);
   }
   const label = labels.shift();
   const labelhash = import_ethers.ethers.utils.solidityKeccak256(["string"], [label]);

package/dist/cjs/functions/getName.js

@@ -27,7 +27,7 @@ const raw = async ({ contracts }, address) => {
   const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
   return {
     to: universalResolver.address,
-    data: universalResolver.interface.encodeFunctionData("reverse", [
+    data: universalResolver.interface.encodeFunctionData("reverse(bytes)", [
       (0, import_hexEncodedName.hexEncodeName)(reverseNode)
     ])
   };
@@ -38,7 +38,7 @@ const decode = async ({ contracts }, data, address) => {
   const universalResolver = await contracts?.getUniversalResolver();
   try {
     const result = universalResolver.interface.decodeFunctionResult(
-      "reverse",
+      "reverse(bytes)",
       data
     );
     return {

package/dist/cjs/functions/getOwner.js

@@ -88,7 +88,7 @@ const raw = async ({ contracts, multicallWrapper }, name, contract) => {
 };
 const singleContractOwnerDecode = (data) => import_ethers.ethers.utils.defaultAbiCoder.decode(["address"], data)[0];
 const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
-  if (data === null)
+  if (!data)
     return;
   const labels = name.split(".");
   if (contract || labels.length === 1) {
@@ -108,7 +108,7 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     };
   }
   const result = await multicallWrapper.decode(data);
-  if (result === null)
+  if (!result)
     return;
   const nameWrapper = await contracts?.getNameWrapper();
   const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
@@ -132,7 +132,7 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
       };
     }
     if (labels.length > 2 && import_ethers.ethers.utils.hexStripZeros(registryOwner) !== "0x") {
-      if (registryOwner === nameWrapper.address && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+      if (registryOwner === nameWrapper.address && nameWrapperOwner && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: "nameWrapper"
@@ -145,7 +145,7 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     }
     return;
   }
-  if (registryOwner === nameWrapper.address && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+  if (registryOwner === nameWrapper.address && nameWrapperOwner && import_ethers.ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: "nameWrapper"

package/dist/cjs/functions/getProfile.js

@@ -23,6 +23,7 @@ __export(getProfile_exports, {
 module.exports = __toCommonJS(getProfile_exports);
 var import_address_encoder = require("@ensdomains/address-encoder");
 var import_ethers = require("ethers");
+var import_utils = require("ethers/lib/utils");
 var import_contentHash = require("../utils/contentHash");
 var import_hexEncodedName = require("../utils/hexEncodedName");
 var import_normalise = require("../utils/normalise");
@@ -30,8 +31,7 @@ var import_validation = require("../utils/validation");
 const makeMulticallData = async ({
   _getAddr,
   _getContentHash,
-  _getText,
-  resolverMulticallWrapper
+  _getText
 }, name, options) => {
   let calls = [];
   if (options.texts)
@@ -60,7 +60,7 @@ const makeMulticallData = async ({
     calls.push({
       key: "contentHash",
       data: await _getContentHash.raw(name),
-      type: "contenthash"
+      type: "contentHash"
     });
   }
   if (!calls.find((x) => x.key === "60")) {
@@ -70,17 +70,17 @@ const makeMulticallData = async ({
       type: "addr"
     });
   }
-  const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
-  return { data: prRawData.data, calls };
+  return { data: calls.map((x) => x.data.data), calls };
 };
 const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolverAddress) => {
   const callsWithResolver = calls.map((call) => ({
     to: resolverAddress,
     data: call.data.data
   }));
-  return (await multicallWrapper(callsWithResolver)).map(
-    (x) => x[1]
-  );
+  const results = await multicallWrapper(callsWithResolver);
+  if (!results || !results.length)
+    return [];
+  return results.map((x) => x[1]);
 };
 const formatRecords = async ({
   _getText,
@@ -94,7 +94,7 @@ const formatRecords = async ({
         key: calls[i].key,
         type: calls[i].type
       };
-      if (itemRet.type === "contenthash") {
+      if (itemRet.type === "contentHash") {
         ;
         [decodedFromAbi] = import_ethers.ethers.utils.defaultAbiCoder.decode(
           ["bytes"],
@@ -128,7 +128,7 @@ const formatRecords = async ({
           } catch {
             return;
           }
-        case "contenthash":
+        case "contentHash":
           try {
             itemRet = {
               ...itemRet,
@@ -155,7 +155,7 @@ const formatRecords = async ({
     }
   } else if (options.contentHash) {
     const foundRecord = returnedRecords.find(
-      (item) => item.type === "contenthash"
+      (item) => item.type === "contentHash"
     );
     returnedResponse.contentHash = foundRecord ? foundRecord.value : null;
   }
@@ -176,57 +176,64 @@ const getDataForName = async ({
   _getAddr,
   _getContentHash,
   _getText,
-  resolverMulticallWrapper,
   multicallWrapper
-}, name, options, fallbackResolver, specificResolver) => {
+}, name, options, specificResolver) => {
   const universalResolver = await contracts?.getUniversalResolver();
   const { data, calls } = await makeMulticallData(
-    { _getAddr, _getContentHash, _getText, resolverMulticallWrapper },
+    { _getAddr, _getContentHash, _getText },
     name,
     options
   );
-  let resolvedData;
-  let useFallbackResolver = false;
-  try {
-    if (specificResolver) {
+  let recordData;
+  let resolverAddress = specificResolver;
+  if (specificResolver) {
+    try {
       const publicResolver = await contracts?.getPublicResolver(
         void 0,
         specificResolver
       );
-      resolvedData = await publicResolver?.callStatic.multicall(
-        calls.map((x) => x.data)
+      recordData = await publicResolver?.callStatic.multicall(data);
+    } catch (e) {
+      console.error("getProfile error:", e);
+      recordData = await fetchWithoutResolverMulticall(
+        { multicallWrapper },
+        calls,
+        resolverAddress
       );
-    } else {
-      resolvedData = await universalResolver?.resolve((0, import_hexEncodedName.hexEncodeName)(name), data);
     }
-  } catch {
-    useFallbackResolver = true;
-  }
-  let resolverAddress;
-  let recordData;
-  if (useFallbackResolver) {
-    resolverAddress = specificResolver || fallbackResolver;
-    recordData = await fetchWithoutResolverMulticall(
-      { multicallWrapper },
-      calls,
-      resolverAddress
-    );
   } else {
-    resolverAddress = specificResolver || resolvedData["1"];
-    if (specificResolver) {
-      recordData = resolvedData;
-    } else {
-      ;
-      [recordData] = await resolverMulticallWrapper.decode(resolvedData["0"]);
+    const resolvedData = await universalResolver["resolve(bytes,bytes[])"](
+      (0, import_hexEncodedName.hexEncodeName)(name),
+      data,
+      {
+        ccipReadEnabled: true
+      }
+    );
+    recordData = [...resolvedData["0"]];
+    resolverAddress = resolvedData["1"];
+    for (let i = 0; i < recordData.length; i += 1) {
+      if (recordData[i].startsWith("0x0d1947a9")) {
+        calls[i] = null;
+        recordData[i] = null;
+      }
     }
   }
-  const matchAddress = recordData[calls.findIndex((x) => x.key === "60")];
+  if (!resolverAddress || !recordData || (0, import_utils.hexStripZeros)(resolverAddress) === "0x") {
+    return {
+      address: null,
+      records: {},
+      resolverAddress: null
+    };
+  }
+  const filteredCalls = calls.filter((x) => x);
+  const filteredRecordData = recordData.filter((x) => x);
+  const matchAddress = filteredRecordData[filteredCalls.findIndex((x) => x.key === "60")];
   return {
     address: matchAddress && await _getAddr.decode(matchAddress),
     records: await formatRecords(
       { _getAddr, _getContentHash, _getText },
-      recordData,
-      calls,
+      filteredRecordData,
+      filteredCalls,
       options
     ),
     resolverAddress
@@ -245,7 +252,6 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress)
           addr {
             id
           }
-          address
         }
       }
     }
@@ -285,14 +291,8 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress)
     return;
   const { isMigrated, createdAt } = domain;
   const returnedRecords = {};
-  if (!resolverResponse)
+  if (!resolverResponse || !wantedRecords)
     return { isMigrated, createdAt };
-  if (!wantedRecords)
-    return {
-      isMigrated,
-      createdAt,
-      graphResolverAddress: resolverResponse.address || resolverAddress
-    };
   Object.keys(wantedRecords).forEach((key) => {
     const data = wantedRecords[key];
     if (typeof data === "boolean" && data) {
@@ -306,8 +306,7 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress)
   return {
     ...returnedRecords,
     isMigrated,
-    createdAt,
-    graphResolverAddress: resolverResponse.address || resolverAddress
+    createdAt
   };
 };
 const getProfileFromName = async ({
@@ -319,7 +318,7 @@ const getProfileFromName = async ({
   resolverMulticallWrapper,
   multicallWrapper
 }, name, options) => {
-  const { resolverAddress, ..._options } = options || {};
+  const { resolverAddress, fallback, ..._options } = options || {};
   const optsLength = Object.keys(_options).length;
   let usingOptions;
   if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
@@ -334,32 +333,57 @@ const getProfileFromName = async ({
     usingOptions,
     resolverAddress
   );
-  if (!graphResult)
-    return;
-  const {
-    isMigrated,
-    createdAt,
-    graphResolverAddress,
-    ...wantedRecords
-  } = graphResult;
-  if (!graphResolverAddress && !options?.resolverAddress)
-    return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
-  const result = await getDataForName(
-    {
-      contracts,
-      _getAddr,
-      _getContentHash,
-      _getText,
-      resolverMulticallWrapper,
-      multicallWrapper
-    },
-    name,
-    usingOptions ? wantedRecords : options,
-    graphResolverAddress,
-    options?.resolverAddress
-  );
-  if (!result)
-    return { isMigrated, createdAt, message: "Records fetch didn't complete" };
+  let isMigrated = null;
+  let createdAt = null;
+  let result = null;
+  if (!graphResult) {
+    if (!fallback)
+      return;
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper
+      },
+      name,
+      fallback,
+      void 0
+    );
+  } else {
+    const {
+      isMigrated: _isMigrated,
+      createdAt: _createdAt,
+      ...wantedRecords
+    } = graphResult;
+    isMigrated = _isMigrated;
+    createdAt = _createdAt;
+    let recordsWithFallback = usingOptions ? wantedRecords : _options;
+    if ((Object.keys(recordsWithFallback).length === 0 || !recordsWithFallback.coinTypes && !recordsWithFallback.texts && Object.keys(recordsWithFallback.contentHash || {}).length === 0) && fallback) {
+      recordsWithFallback = fallback;
+    }
+    result = await getDataForName(
+      {
+        contracts,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper
+      },
+      name,
+      recordsWithFallback,
+      options?.resolverAddress
+    );
+  }
+  if (!result?.resolverAddress)
+    return {
+      isMigrated,
+      createdAt,
+      message: !result ? "Records fetch didn't complete" : "Name doesn't have a resolver"
+    };
   return { ...result, isMigrated, createdAt, message: void 0 };
 };
 const getProfileFromAddress = async ({
@@ -404,6 +428,12 @@ const getProfileFromAddress = async ({
     message: void 0
   };
 };
+const mapCoinTypes = (coin) => {
+  if (!Number.isNaN(parseInt(coin))) {
+    return coin;
+  }
+  return `${import_address_encoder.formatsByName[coin.toUpperCase()].coinType}`;
+};
 async function getProfile_default({
   contracts,
   gqlInstance,
@@ -414,13 +444,13 @@ async function getProfile_default({
   resolverMulticallWrapper,
   multicallWrapper
 }, nameOrAddress, options) {
-  if (options && options.coinTypes && typeof options.coinTypes !== "boolean") {
-    options.coinTypes = options.coinTypes.map((coin) => {
-      if (!Number.isNaN(parseInt(coin))) {
-        return coin;
-      }
-      return `${import_address_encoder.formatsByName[coin.toUpperCase()].coinType}`;
-    });
+  if (options) {
+    if (options.coinTypes && typeof options.coinTypes !== "boolean") {
+      options.coinTypes = options.coinTypes.map(mapCoinTypes);
+    }
+    if (options.fallback && options.fallback.coinTypes) {
+      options.fallback.coinTypes = options.fallback.coinTypes.map(mapCoinTypes);
+    }
   }
   const inputType = (0, import_validation.parseInputType)(nameOrAddress);
   if (inputType.type === "unknown" || inputType.info === "unsupported") {

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

@@ -598,6 +598,19 @@ const _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {