@ensdomains/ensjs 3.0.0-alpha.17 → 3.0.0-alpha.18

package/dist/cjs/functions/getSpecificRecord.js

@@ -1,275 +1,196 @@
 "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) => {
-        let response;
-        const publicResolver = await contracts?.getPublicResolver();
-        try {
-            ;
-            [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
-        }
-        catch {
-            return;
-        }
-        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);
+  }
 };
-// 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
-//   },
-// }
+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);
+  }
+};
+//# sourceMappingURL=getSpecificRecord.js.map

package/dist/cjs/functions/getSpecificRecord.js.map

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