@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.19

package/dist/esm/functions/getProfile.mjs

@@ -0,0 +1,439 @@
+// src/functions/getProfile.ts
+import { formatsByName } from "@ensdomains/address-encoder";
+import { ethers } from "ethers";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+import { namehash } from "../utils/normalise.mjs";
+import { parseInputType } from "../utils/validation.mjs";
+var makeMulticallData = async ({
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper
+}, name, options) => {
+  let calls = [];
+  if (options.texts)
+    calls = [
+      ...calls,
+      ...await Promise.all(
+        options.texts.map(async (x) => ({
+          key: x,
+          data: await _getText.raw(name, x),
+          type: "text"
+        }))
+      )
+    ];
+  if (options.coinTypes)
+    calls = [
+      ...calls,
+      ...await Promise.all(
+        options.coinTypes.map(async (x) => ({
+          key: x,
+          data: await _getAddr.raw(name, x, true),
+          type: "addr"
+        }))
+      )
+    ];
+  if (typeof options.contentHash === "boolean" && options.contentHash) {
+    calls.push({
+      key: "contentHash",
+      data: await _getContentHash.raw(name),
+      type: "contenthash"
+    });
+  }
+  if (!calls.find((x) => x.key === "60")) {
+    calls.push({
+      key: "60",
+      data: await _getAddr.raw(name, "60", true),
+      type: "addr"
+    });
+  }
+  const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
+  return { data: prRawData.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]
+  );
+};
+var formatRecords = async ({
+  _getText,
+  _getAddr,
+  _getContentHash
+}, data, calls, options) => {
+  const returnedRecords = (await Promise.all(
+    data.map(async (item, i) => {
+      let decodedFromAbi;
+      let itemRet = {
+        key: calls[i].key,
+        type: calls[i].type
+      };
+      if (itemRet.type === "contenthash") {
+        ;
+        [decodedFromAbi] = ethers.utils.defaultAbiCoder.decode(
+          ["bytes"],
+          item
+        );
+        if (ethers.utils.hexStripZeros(decodedFromAbi) === "0x") {
+          return;
+        }
+      }
+      switch (calls[i].type) {
+        case "text":
+          itemRet = {
+            ...itemRet,
+            value: await _getText.decode(item)
+          };
+          if (itemRet.value === "" || itemRet.value === void 0)
+            return;
+          break;
+        case "addr":
+          try {
+            const addr = await _getAddr.decode(item, "", calls[i].key);
+            if (addr) {
+              itemRet = {
+                ...itemRet,
+                ...addr
+              };
+              break;
+            } else {
+              return;
+            }
+          } catch {
+            return;
+          }
+        case "contenthash":
+          try {
+            itemRet = {
+              ...itemRet,
+              value: await _getContentHash.decode(item)
+            };
+            break;
+          } catch {
+            return;
+          }
+      }
+      return itemRet;
+    })
+  )).filter((x) => {
+    return typeof x === "object";
+  }).filter((x) => x);
+  const returnedResponse = {};
+  if (typeof options.contentHash === "string" || typeof options.contentHash === "object") {
+    if (typeof options.contentHash === "string" && ethers.utils.hexStripZeros(options.contentHash) === "0x") {
+      returnedResponse.contentHash = null;
+    } else if (ethers.utils.isBytesLike(options.contentHash.decoded) && ethers.utils.hexStripZeros(options.contentHash.decoded) === "0x") {
+      returnedResponse.contentHash = null;
+    } else {
+      returnedResponse.contentHash = options.contentHash;
+    }
+  } else if (options.contentHash) {
+    const foundRecord = returnedRecords.find(
+      (item) => item.type === "contenthash"
+    );
+    returnedResponse.contentHash = foundRecord ? foundRecord.value : null;
+  }
+  if (options.texts) {
+    returnedResponse.texts = returnedRecords.filter(
+      (x) => x.type === "text"
+    );
+  }
+  if (options.coinTypes) {
+    returnedResponse.coinTypes = returnedRecords.filter(
+      (x) => x.type === "addr"
+    );
+  }
+  return returnedResponse;
+};
+var getDataForName = async ({
+  contracts,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper,
+  multicallWrapper
+}, name, options, fallbackResolver, specificResolver) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  const { data, calls } = await makeMulticallData(
+    { _getAddr, _getContentHash, _getText, resolverMulticallWrapper },
+    name,
+    options
+  );
+  let resolvedData;
+  let useFallbackResolver = false;
+  try {
+    if (specificResolver) {
+      const publicResolver = await contracts?.getPublicResolver(
+        void 0,
+        specificResolver
+      );
+      resolvedData = await publicResolver?.callStatic.multicall(
+        calls.map((x) => x.data)
+      );
+    } 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 matchAddress = recordData[calls.findIndex((x) => x.key === "60")];
+  return {
+    address: matchAddress && await _getAddr.decode(matchAddress),
+    records: await formatRecords(
+      { _getAddr, _getContentHash, _getText },
+      recordData,
+      calls,
+      options
+    ),
+    resolverAddress
+  };
+};
+var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) => {
+  const query = gqlInstance.gql`
+    query getRecords($id: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+        resolver {
+          texts
+          coinTypes
+          contentHash
+          addr {
+            id
+          }
+          address
+        }
+      }
+    }
+  `;
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
+  `;
+  const { client } = gqlInstance;
+  const id = namehash(name);
+  let domain;
+  let resolverResponse;
+  if (!resolverAddress) {
+    ;
+    ({ domain } = await client.request(query, { id }));
+    resolverResponse = domain?.resolver;
+  } else {
+    const resolverId = `${resolverAddress.toLowerCase()}-${id}`;
+    ({ resolver: resolverResponse, domain } = await client.request(
+      customResolverQuery,
+      { id, resolverId }
+    ));
+  }
+  if (!domain)
+    return;
+  const { isMigrated, createdAt } = domain;
+  const returnedRecords = {};
+  if (!resolverResponse)
+    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) {
+      if (key === "contentHash") {
+        returnedRecords[key] = decodeContenthash(resolverResponse.contentHash);
+      } else {
+        returnedRecords[key] = resolverResponse[key];
+      }
+    }
+  });
+  return {
+    ...returnedRecords,
+    isMigrated,
+    createdAt,
+    graphResolverAddress: resolverResponse.address || resolverAddress
+  };
+};
+var getProfileFromName = async ({
+  contracts,
+  gqlInstance,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper,
+  multicallWrapper
+}, name, options) => {
+  const { resolverAddress, ..._options } = options || {};
+  const optsLength = Object.keys(_options).length;
+  let usingOptions;
+  if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
+    if (optsLength)
+      usingOptions = _options;
+    else
+      usingOptions = { contentHash: true, texts: true, coinTypes: true };
+  }
+  const graphResult = await graphFetch(
+    { gqlInstance },
+    name,
+    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" };
+  return { ...result, isMigrated, createdAt, message: void 0 };
+};
+var getProfileFromAddress = async ({
+  contracts,
+  gqlInstance,
+  getName,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper,
+  multicallWrapper
+}, address, options) => {
+  let name;
+  try {
+    name = await getName(address);
+  } catch (e) {
+    return;
+  }
+  if (!name || !name.name || name.name === "")
+    return;
+  if (!name.match)
+    return { ...name, isMigrated: null, createdAt: null };
+  const result = await getProfileFromName(
+    {
+      contracts,
+      gqlInstance,
+      _getAddr,
+      _getContentHash,
+      _getText,
+      resolverMulticallWrapper,
+      multicallWrapper
+    },
+    name.name,
+    options
+  );
+  if (!result || result.message)
+    return;
+  delete result.address;
+  return {
+    ...result,
+    ...name,
+    message: void 0
+  };
+};
+async function getProfile_default({
+  contracts,
+  gqlInstance,
+  getName,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  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}`;
+    });
+  }
+  const inputType = parseInputType(nameOrAddress);
+  if (inputType.type === "unknown" || inputType.info === "unsupported") {
+    throw new Error("Invalid input type");
+  }
+  if (inputType.type === "address") {
+    return getProfileFromAddress(
+      {
+        contracts,
+        gqlInstance,
+        getName,
+        _getAddr,
+        _getContentHash,
+        _getText,
+        resolverMulticallWrapper,
+        multicallWrapper
+      },
+      nameOrAddress,
+      options
+    );
+  }
+  return getProfileFromName(
+    {
+      contracts,
+      gqlInstance,
+      _getAddr,
+      _getContentHash,
+      _getText,
+      resolverMulticallWrapper,
+      multicallWrapper
+    },
+    nameOrAddress,
+    options
+  );
+}
+export {
+  getProfile_default as default
+};

package/dist/esm/functions/getRecords.mjs

@@ -0,0 +1,12 @@
+// src/functions/getRecords.ts
+import { parseInputType } from "../utils/validation.mjs";
+async function getRecords_default({ getProfile }, name, options) {
+  const inputType = parseInputType(name);
+  if (inputType.type !== "name" && inputType.type !== "label") {
+    throw new Error("Input must be an ENS name");
+  }
+  return getProfile(name, options);
+}
+export {
+  getRecords_default as default
+};

package/dist/esm/functions/getResolver.mjs

@@ -0,0 +1,27 @@
+// src/functions/getResolver.ts
+import { ethers } from "ethers";
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+var raw = async ({ contracts }, name) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("findResolver", [
+      hexEncodeName(name)
+    ])
+  };
+};
+var decode = async ({ contracts }, data) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  const response = universalResolver.interface.decodeFunctionResult(
+    "findResolver",
+    data
+  );
+  if (!response || !response[0] || ethers.utils.hexStripZeros(response[0]) === "0x") {
+    return;
+  }
+  return response[0];
+};
+var getResolver_default = { raw, decode };
+export {
+  getResolver_default as default
+};

package/dist/esm/functions/getSpecificRecord.mjs

@@ -0,0 +1,176 @@
+// src/functions/getSpecificRecord.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { ethers } from "ethers";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+import { namehash } from "../utils/normalise.mjs";
+var _getContentHash = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("contenthash", [
+        namehash(name)
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    let response;
+    const publicResolver = await contracts?.getPublicResolver();
+    try {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "contenthash",
+        data
+      );
+    } catch {
+      return;
+    }
+    if (!response) {
+      return;
+    }
+    const decodedContent = decodeContenthash(response);
+    if (!decodedContent || ethers.utils.isBytesLike(decodedContent.decoded) && ethers.utils.hexStripZeros(decodedContent.decoded) === "0x" || Object.keys(decodedContent).length === 0) {
+      return;
+    }
+    return decodedContent;
+  }
+};
+var getContentHash = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getContentHash.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getContentHash.decode({ contracts }, urData.data);
+  }
+};
+var _getText = {
+  raw: async ({ contracts }, name, key) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("text", [
+        namehash(name),
+        key
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [response] = publicResolver.interface.decodeFunctionResult(
+      "text",
+      data
+    );
+    if (!response) {
+      return;
+    }
+    return response;
+  }
+};
+var getText = {
+  raw: async ({ contracts, universalWrapper }, name, key) => {
+    const prData = await _getText.raw({ contracts }, name, key);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getText.decode({ contracts }, urData.data);
+  }
+};
+var _getAddr = {
+  raw: async ({ contracts }, name, coinType, bypassFormat) => {
+    if (!coinType) {
+      coinType = 60;
+    }
+    const publicResolver = await contracts?.getPublicResolver();
+    if (coinType === 60 || coinType === "60") {
+      return {
+        to: "0x0000000000000000000000000000000000000000",
+        data: publicResolver.interface.encodeFunctionData("addr(bytes32)", [
+          namehash(name)
+        ])
+      };
+    }
+    if (bypassFormat) {
+      return {
+        to: "0x0000000000000000000000000000000000000000",
+        data: publicResolver.interface.encodeFunctionData(
+          "addr(bytes32,uint256)",
+          [namehash(name), coinType]
+        )
+      };
+    }
+    const formatter = typeof coinType === "string" && Number.isNaN(parseInt(coinType)) ? formatsByName[coinType] : formatsByCoinType[typeof coinType === "number" ? coinType : parseInt(coinType)];
+    if (!formatter) {
+      throw new Error(`No formatter found for coin: ${coinType}`);
+    }
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData(
+        "addr(bytes32,uint256)",
+        [namehash(name), formatter.coinType]
+      )
+    };
+  },
+  decode: async ({ contracts }, data, _name, coinType) => {
+    let returnCoinType = true;
+    if (!coinType) {
+      coinType = 60;
+      returnCoinType = false;
+    }
+    const publicResolver = await contracts?.getPublicResolver();
+    const formatter = typeof coinType === "string" && Number.isNaN(parseInt(coinType)) ? formatsByName[coinType] : formatsByCoinType[typeof coinType === "number" ? coinType : parseInt(coinType)];
+    let response;
+    if (coinType === 60 || coinType === "60") {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "addr(bytes32)",
+        data
+      );
+    } else {
+      ;
+      [response] = publicResolver.interface.decodeFunctionResult(
+        "addr(bytes32,uint256)",
+        data
+      );
+    }
+    if (!response)
+      return;
+    if (ethers.utils.hexStripZeros(response) === "0x") {
+      return;
+    }
+    const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), "hex"));
+    if (!decodedAddr) {
+      return;
+    }
+    if (!returnCoinType) {
+      return decodedAddr;
+    }
+    return { coin: formatter.name, addr: decodedAddr };
+  }
+};
+var getAddr = {
+  raw: async ({ contracts, universalWrapper }, name, coinType) => {
+    const prData = await _getAddr.raw({ contracts }, name, coinType);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getAddr.decode({ contracts }, urData.data, _name, coinType);
+  }
+};
+export {
+  _getAddr,
+  _getContentHash,
+  _getText,
+  getAddr,
+  getContentHash,
+  getText
+};