@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/cjs/functions/getRecords.js

@@ -1,11 +1,31 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validation_1 = require("../utils/validation");
-async function default_1({ getProfile }, name, options) {
-    const inputType = (0, validation_1.parseInputType)(name);
-    if (inputType.type !== 'name' && inputType.type !== 'label') {
-        throw new Error('Input must be an ENS name');
-    }
-    return await getProfile(name, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getRecords_exports = {};
+__export(getRecords_exports, {
+  default: () => getRecords_default
+});
+module.exports = __toCommonJS(getRecords_exports);
+var import_validation = require("../utils/validation");
+async function getRecords_default({ getProfile }, name, options) {
+  const inputType = (0, import_validation.parseInputType)(name);
+  if (inputType.type !== "name" && inputType.type !== "label") {
+    throw new Error("Input must be an ENS name");
+  }
+  return getProfile(name, options);
 }
-exports.default = default_1;

package/dist/cjs/functions/getResolver.js

@@ -1,24 +1,46 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const hexEncodedName_1 = require("../utils/hexEncodedName");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getResolver_exports = {};
+__export(getResolver_exports, {
+  default: () => getResolver_default
+});
+module.exports = __toCommonJS(getResolver_exports);
+var import_ethers = require("ethers");
+var import_hexEncodedName = require("../utils/hexEncodedName");
 const raw = async ({ contracts }, name) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    return {
-        to: universalResolver.address,
-        data: universalResolver.interface.encodeFunctionData('findResolver', [
-            (0, hexEncodedName_1.hexEncodeName)(name),
-        ]),
-    };
+  const universalResolver = await contracts?.getUniversalResolver();
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("findResolver", [
+      (0, import_hexEncodedName.hexEncodeName)(name)
+    ])
+  };
 };
 const decode = async ({ contracts }, data) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    const response = universalResolver.interface.decodeFunctionResult('findResolver', data);
-    if (!response ||
-        !response[0] ||
-        ethers_1.ethers.utils.hexStripZeros(response[0]) === '0x') {
-        return;
-    }
-    return response[0];
+  const universalResolver = await contracts?.getUniversalResolver();
+  const response = universalResolver.interface.decodeFunctionResult(
+    "findResolver",
+    data
+  );
+  if (!response || !response[0] || import_ethers.ethers.utils.hexStripZeros(response[0]) === "0x") {
+    return;
+  }
+  return response[0];
 };
-exports.default = { raw, decode };
+var getResolver_default = { raw, decode };

package/dist/cjs/functions/getSpecificRecord.js

@@ -1,268 +1,195 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddr = exports._getAddr = exports.getText = exports._getText = exports.getContentHash = exports._getContentHash = void 0;
-const address_encoder_1 = require("@ensdomains/address-encoder");
-const ethers_1 = require("ethers");
-const contentHash_1 = require("../utils/contentHash");
-const normalise_1 = require("../utils/normalise");
-exports._getContentHash = {
-    raw: async ({ contracts }, name) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        return {
-            to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('contenthash', [
-                (0, normalise_1.namehash)(name),
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
-        if (!response) {
-            return;
-        }
-        const decodedContent = (0, contentHash_1.decodeContenthash)(response);
-        if (!decodedContent ||
-            (ethers_1.ethers.utils.isBytesLike(decodedContent.decoded) &&
-                ethers_1.ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
-            Object.keys(decodedContent).length === 0) {
-            return;
-        }
-        return decodedContent;
-    },
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.getContentHash = {
-    raw: async ({ contracts, universalWrapper }, name) => {
-        const prData = await exports._getContentHash.raw({ contracts }, name);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getContentHash.decode({ contracts }, urData.data);
-    },
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports._getText = {
-    raw: async ({ contracts }, name, key) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        return {
-            to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('text', [
-                (0, normalise_1.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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getSpecificRecord_exports = {};
+__export(getSpecificRecord_exports, {
+  _getAddr: () => _getAddr,
+  _getContentHash: () => _getContentHash,
+  _getText: () => _getText,
+  getAddr: () => getAddr,
+  getContentHash: () => getContentHash,
+  getText: () => getText
+});
+module.exports = __toCommonJS(getSpecificRecord_exports);
+var import_address_encoder = require("@ensdomains/address-encoder");
+var import_ethers = require("ethers");
+var import_contentHash = require("../utils/contentHash");
+var import_normalise = require("../utils/normalise");
+const _getContentHash = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("contenthash", [
+        (0, import_normalise.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 = (0, import_contentHash.decodeContenthash)(response);
+    if (!decodedContent || import_ethers.ethers.utils.isBytesLike(decodedContent.decoded) && import_ethers.ethers.utils.hexStripZeros(decodedContent.decoded) === "0x" || Object.keys(decodedContent).length === 0) {
+      return;
+    }
+    return decodedContent;
+  }
 };
-exports.getText = {
-    raw: async ({ contracts, universalWrapper }, name, key) => {
-        const prData = await exports._getText.raw({ contracts }, name, key);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getText.decode({ contracts }, urData.data);
-    },
+const 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);
+  }
 };
-exports._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)', [
-                    (0, normalise_1.namehash)(name),
-                ]),
-            };
-        }
-        if (bypassFormat) {
-            return {
-                to: '0x0000000000000000000000000000000000000000',
-                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [(0, normalise_1.namehash)(name), coinType]),
-            };
-        }
-        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
-            ? address_encoder_1.formatsByName[coinType]
-            : address_encoder_1.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)', [(0, normalise_1.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' && isNaN(parseInt(coinType))
-            ? address_encoder_1.formatsByName[coinType]
-            : address_encoder_1.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_1.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 };
-    },
+const _getText = {
+  raw: async ({ contracts }, name, key) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("text", [
+        (0, import_normalise.namehash)(name),
+        key
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [response] = publicResolver.interface.decodeFunctionResult(
+      "text",
+      data
+    );
+    if (!response) {
+      return;
+    }
+    return response;
+  }
 };
-exports.getAddr = {
-    raw: async ({ contracts, universalWrapper }, name, coinType) => {
-        const prData = await exports._getAddr.raw({ contracts }, name, coinType);
-        return await universalWrapper.raw(name, prData.data);
-    },
-    decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
-        const urData = await universalWrapper.decode(data);
-        if (!urData)
-            return;
-        return await exports._getAddr.decode({ contracts }, urData.data, _name, coinType);
-    },
+const 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);
+  }
+};
+const _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)", [
+          (0, import_normalise.namehash)(name)
+        ])
+      };
+    }
+    if (bypassFormat) {
+      return {
+        to: "0x0000000000000000000000000000000000000000",
+        data: publicResolver.interface.encodeFunctionData(
+          "addr(bytes32,uint256)",
+          [(0, import_normalise.namehash)(name), coinType]
+        )
+      };
+    }
+    const formatter = typeof coinType === "string" && Number.isNaN(parseInt(coinType)) ? import_address_encoder.formatsByName[coinType] : import_address_encoder.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)",
+        [(0, import_normalise.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)) ? import_address_encoder.formatsByName[coinType] : import_address_encoder.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 (import_ethers.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 };
+  }
+};
+const 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 async function getAddr(
-//   { contracts }: ENSArgs<'contracts'>,
-//   name: string,
-//   coinType?: string | number,
-// ) {
-//   if (!coinType) {
-//     coinType = 60
-//   }
-//   const universalResolver = await contracts?.getUniversalResolver()
-//   const publicResolver = await contracts?.getPublicResolver()
-//   const formatter =
-//     typeof coinType === 'string'
-//       ? formatsByName[coinType]
-//       : formatsByCoinType[coinType]
-//   if (!formatter) {
-//     throw new Error(`Coin type ${coinType} is not supported`)
-//   }
-//   const data = publicResolver?.interface.encodeFunctionData(
-//     'addr(bytes32,uint256)',
-//     [ethers.utils.namehash(name), formatter.coinType],
-//   )
-//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
-//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
-//     ['bytes'],
-//     result['0'],
-//   )
-//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
-//     return
-//   }
-//   const decodedAddr = formatter.encoder(
-//     Buffer.from(encodedAddr.slice(2), 'hex'),
-//   )
-//   if (!decodedAddr) {
-//     return
-//   }
-//   return decodedAddr
-// }
-// export const getContentHash = {
-//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const prData = publicResolver.interface.encodeFunctionData(
-//       'contenthash(bytes32)',
-//       [ethers.utils.namehash(name)],
-//     )
-//     const urData = universalResolver.interface.encodeFunctionData(
-//       'resolve(bytes,bytes)',
-//       [hexEncodeName(name), prData],
-//     )
-//     return {
-//       to: universalResolver.address,
-//       data: urData,
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-//     if (!response || !response[1]) {
-//       return
-//     }
-//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
-//       'contenthash(bytes32)',
-//       response[0],
-//     )
-//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
-//       return
-//     }
-//     return decodeContenthash(encodedContentHash)
-//   },
-// }
-// const getText = {
-//   raw: async (
-//     { contracts }: ENSArgs<'contracts'>,
-//     name: string,
-//     key: string,
-//   ) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const data = publicResolver.interface.encodeFunctionData(
-//       'text(bytes32,string)',
-//       [ethers.utils.namehash(name), key],
-//     )
-//     return {
-//       to: universalResolver.address,
-//       data: universalResolver.interface.encodeFunctionData(
-//         'resolve(bytes,bytes)',
-//         [hexEncodeName(name), data],
-//       ),
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-//     if (!response || !response[1]) {
-//       return
-//     }
-//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
-//       'text(bytes32,string)',
-//       response[0],
-//     )
-//     if (decodedText === '') {
-//       return
-//     }
-//     return decodedText
-//   },
-// }