@ensdomains/ensjs 3.0.0-alpha.26 → 3.0.0-alpha.28

package/dist/esm/functions/getOwner.mjs

@@ -66,7 +66,7 @@ var raw = async ({ contracts, multicallWrapper }, name, contract) => {
 };
 var singleContractOwnerDecode = (data) => ethers.utils.defaultAbiCoder.decode(["address"], data)[0];
 var decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
-  if (data === null)
+  if (!data)
     return;
   const labels = name.split(".");
   if (contract || labels.length === 1) {
@@ -86,7 +86,7 @@ var 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(
@@ -110,7 +110,7 @@ var decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
       };
     }
     if (labels.length > 2 && ethers.utils.hexStripZeros(registryOwner) !== "0x") {
-      if (registryOwner === nameWrapper.address && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+      if (registryOwner === nameWrapper.address && nameWrapperOwner && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: "nameWrapper"
@@ -123,7 +123,7 @@ var decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
     }
     return;
   }
-  if (registryOwner === nameWrapper.address && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+  if (registryOwner === nameWrapper.address && nameWrapperOwner && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: "nameWrapper"

package/dist/esm/functions/getProfile.mjs

@@ -1,6 +1,7 @@
 // src/functions/getProfile.ts
 import { formatsByName } from "@ensdomains/address-encoder";
 import { ethers } from "ethers";
+import { hexStripZeros } from "ethers/lib/utils.js";
 import { decodeContenthash } from "../utils/contentHash.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
 import { namehash } from "../utils/normalise.mjs";
@@ -8,8 +9,7 @@ import { parseInputType } from "../utils/validation.mjs";
 var makeMulticallData = async ({
   _getAddr,
   _getContentHash,
-  _getText,
-  resolverMulticallWrapper
+  _getText
 }, name, options) => {
   let calls = [];
   if (options.texts)
@@ -38,7 +38,7 @@ var makeMulticallData = async ({
     calls.push({
       key: "contentHash",
       data: await _getContentHash.raw(name),
-      type: "contenthash"
+      type: "contentHash"
     });
   }
   if (!calls.find((x) => x.key === "60")) {
@@ -48,17 +48,17 @@ var 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 };
 };
 var 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]);
 };
 var formatRecords = async ({
   _getText,
@@ -72,7 +72,7 @@ var formatRecords = async ({
         key: calls[i].key,
         type: calls[i].type
       };
-      if (itemRet.type === "contenthash") {
+      if (itemRet.type === "contentHash") {
         ;
         [decodedFromAbi] = ethers.utils.defaultAbiCoder.decode(
           ["bytes"],
@@ -106,7 +106,7 @@ var formatRecords = async ({
           } catch {
             return;
           }
-        case "contenthash":
+        case "contentHash":
           try {
             itemRet = {
               ...itemRet,
@@ -133,7 +133,7 @@ var formatRecords = async ({
     }
   } else if (options.contentHash) {
     const foundRecord = returnedRecords.find(
-      (item) => item.type === "contenthash"
+      (item) => item.type === "contentHash"
     );
     returnedResponse.contentHash = foundRecord ? foundRecord.value : null;
   }
@@ -154,57 +154,64 @@ var 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(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[])"](
+      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 || 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
@@ -223,7 +230,6 @@ var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) =
           addr {
             id
           }
-          address
         }
       }
     }
@@ -263,14 +269,8 @@ var 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) {
@@ -284,8 +284,7 @@ var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) =
   return {
     ...returnedRecords,
     isMigrated,
-    createdAt,
-    graphResolverAddress: resolverResponse.address || resolverAddress
+    createdAt
   };
 };
 var getProfileFromName = async ({
@@ -297,7 +296,7 @@ var 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) {
@@ -312,32 +311,57 @@ var 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 };
 };
 var getProfileFromAddress = async ({
@@ -382,6 +406,12 @@ var getProfileFromAddress = async ({
     message: void 0
   };
 };
+var mapCoinTypes = (coin) => {
+  if (!Number.isNaN(parseInt(coin))) {
+    return coin;
+  }
+  return `${formatsByName[coin.toUpperCase()].coinType}`;
+};
 async function getProfile_default({
   contracts,
   gqlInstance,
@@ -392,13 +422,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 `${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 = parseInputType(nameOrAddress);
   if (inputType.type === "unknown" || inputType.info === "unsupported") {

package/dist/esm/functions/getWrapperData.mjs

@@ -1,6 +1,6 @@
 // src/functions/getWrapperData.ts
 import { BigNumber } from "ethers";
-import { fuseEnum } from "../utils/fuses.mjs";
+import { decodeFuses } from "../utils/fuses.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var raw = async ({ contracts }, name) => {
   const nameWrapper = await contracts?.getNameWrapper();
@@ -17,17 +17,7 @@ var decode = async ({ contracts }, data) => {
       data
     );
     const fuses = BigNumber.from(_fuses);
-    const fuseObj = Object.fromEntries(
-      Object.keys(fuseEnum).map((fuse) => [
-        fuse,
-        fuses.and(fuseEnum[fuse]).gt(0)
-      ])
-    );
-    if (fuses.eq(0)) {
-      fuseObj.CAN_DO_EVERYTHING = true;
-    } else {
-      fuseObj.CAN_DO_EVERYTHING = false;
-    }
+    const fuseObj = decodeFuses(fuses);
     const expiryDate = new Date(expiry * 1e3);
     return {
       fuseObj,

package/dist/esm/generated/factories/NameWrapper__factory.mjs

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