@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/esm/functions/getPrice.mjs

@@ -0,0 +1,106 @@
+// src/functions/getPrice.ts
+import { BigNumber, utils } from "ethers";
+var raw = async ({ contracts, multicallWrapper }, nameOrNames, duration, legacy) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal();
+    const baseCall2 = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+        names,
+        duration
+      ])
+    };
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall2,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData("rentPrice", [
+            names,
+            0
+          ])
+        }
+      ]);
+    }
+    return baseCall2;
+  }
+  const controller = await contracts?.getEthRegistrarController();
+  const baseCall = {
+    to: controller.address,
+    data: controller.interface.encodeFunctionData("rentPrice", [
+      names[0],
+      duration
+    ])
+  };
+  if (legacy) {
+    return multicallWrapper.raw([
+      baseCall,
+      {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData("rentPrice", [
+          names[0],
+          0
+        ])
+      }
+    ]);
+  }
+  return baseCall;
+};
+var decode = async ({ contracts, multicallWrapper }, data, _nameOrNames, _duration, legacy) => {
+  if (data === null)
+    return;
+  try {
+    let base;
+    let premium;
+    const isBulkRenewal = Array.isArray(_nameOrNames) && _nameOrNames.length > 1;
+    if (isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else if (isBulkRenewal) {
+      const bulkRenewal = await contracts?.getBulkRenewal();
+      const result = bulkRenewal.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base] = result;
+      premium = BigNumber.from(0);
+    } else if (!isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else {
+      const controller = await contracts?.getEthRegistrarController();
+      const result = controller.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+      [base, premium] = result[0];
+    }
+    return {
+      base,
+      premium
+    };
+  } catch {
+    return;
+  }
+};
+var getPrice_default = { raw, decode };
+export {
+  getPrice_default as default
+};

package/dist/esm/functions/getProfile.mjs

@@ -0,0 +1,469 @@
+// 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";
+import { parseInputType } from "../utils/validation.mjs";
+var makeMulticallData = async ({
+  _getAddr,
+  _getContentHash,
+  _getText
+}, 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"
+    });
+  }
+  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
+  }));
+  const results = await multicallWrapper(callsWithResolver);
+  if (!results || !results.length)
+    return [];
+  return results.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,
+  multicallWrapper
+}, name, options, specificResolver) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  const { data, calls } = await makeMulticallData(
+    { _getAddr, _getContentHash, _getText },
+    name,
+    options
+  );
+  let recordData;
+  let resolverAddress = specificResolver;
+  if (specificResolver) {
+    try {
+      const publicResolver = await contracts?.getPublicResolver(
+        void 0,
+        specificResolver
+      );
+      recordData = await publicResolver?.callStatic.multicall(data);
+    } catch (e) {
+      console.error("getProfile error:", e);
+      recordData = await fetchWithoutResolverMulticall(
+        { multicallWrapper },
+        calls,
+        resolverAddress
+      );
+    }
+  } else {
+    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;
+      }
+    }
+  }
+  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 },
+      filteredRecordData,
+      filteredCalls,
+      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
+          }
+        }
+      }
+    }
+  `;
+  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 || !wantedRecords)
+    return { isMigrated, createdAt };
+  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
+  };
+};
+var getProfileFromName = async ({
+  contracts,
+  gqlInstance,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper,
+  multicallWrapper
+}, name, options) => {
+  const { resolverAddress, fallback, ..._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
+  );
+  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 ({
+  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
+  };
+};
+var mapCoinTypes = (coin) => {
+  if (!Number.isNaN(parseInt(coin))) {
+    return coin;
+  }
+  return `${formatsByName[coin.toUpperCase()].coinType}`;
+};
+async function getProfile_default({
+  contracts,
+  gqlInstance,
+  getName,
+  _getAddr,
+  _getContentHash,
+  _getText,
+  resolverMulticallWrapper,
+  multicallWrapper
+}, nameOrAddress, options) {
+  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") {
+    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
+};