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

package/dist/cjs/contracts/multicall.js

@@ -1,22 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Multicall__factory_1 = require("../generated/factories/Multicall__factory");
-const ABI = [
-    'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
-    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-    'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-    'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-    'function getBasefee() view returns (uint256 basefee)',
-    'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
-    'function getBlockNumber() view returns (uint256 blockNumber)',
-    'function getChainId() view returns (uint256 chainid)',
-    'function getCurrentBlockCoinbase() view returns (address coinbase)',
-    'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
-    'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
-    'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
-    'function getEthBalance(address addr) view returns (uint256 balance)',
-    'function getLastBlockHash() view returns (bytes32 blockHash)',
-    'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-    'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-];
-exports.default = (provider, address) => Multicall__factory_1.Multicall__factory.connect(address, provider);
+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 multicall_exports = {};
+__export(multicall_exports, {
+  default: () => multicall_default
+});
+module.exports = __toCommonJS(multicall_exports);
+var import_Multicall_factory = require("../generated/factories/Multicall__factory");
+var multicall_default = (provider, address) => import_Multicall_factory.Multicall__factory.connect(address, provider);
+//# sourceMappingURL=multicall.js.map

package/dist/cjs/contracts/multicall.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/multicall.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { Multicall__factory } from '../generated/factories/Multicall__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  Multicall__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,+BAAmC;AAEnC,IAAO,oBAAQ,CAAC,UAA4C,YAC1D,4CAAmB,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/contracts/nameWrapper.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").NameWrapper;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/NameWrapper").NameWrapper;
 export default _default;

package/dist/cjs/contracts/nameWrapper.js

@@ -1,4 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const NameWrapper__factory_1 = require("../generated/factories/NameWrapper__factory");
-exports.default = (provider, address) => NameWrapper__factory_1.NameWrapper__factory.connect(address, provider);
+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 nameWrapper_exports = {};
+__export(nameWrapper_exports, {
+  default: () => nameWrapper_default
+});
+module.exports = __toCommonJS(nameWrapper_exports);
+var import_NameWrapper_factory = require("../generated/factories/NameWrapper__factory");
+var nameWrapper_default = (provider, address) => import_NameWrapper_factory.NameWrapper__factory.connect(address, provider);
+//# sourceMappingURL=nameWrapper.js.map

package/dist/cjs/contracts/nameWrapper.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/nameWrapper.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { NameWrapper__factory } from '../generated/factories/NameWrapper__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  NameWrapper__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,iCAAqC;AAErC,IAAO,sBAAQ,CAAC,UAA4C,YAC1D,gDAAqB,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/contracts/publicResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").PublicResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/PublicResolver").PublicResolver;
 export default _default;

package/dist/cjs/contracts/publicResolver.js

@@ -1,4 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const PublicResolver__factory_1 = require("../generated/factories/PublicResolver__factory");
-exports.default = (provider, address) => PublicResolver__factory_1.PublicResolver__factory.connect(address, provider);
+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 publicResolver_exports = {};
+__export(publicResolver_exports, {
+  default: () => publicResolver_default
+});
+module.exports = __toCommonJS(publicResolver_exports);
+var import_PublicResolver_factory = require("../generated/factories/PublicResolver__factory");
+var publicResolver_default = (provider, address) => import_PublicResolver_factory.PublicResolver__factory.connect(address, provider);
+//# sourceMappingURL=publicResolver.js.map

package/dist/cjs/contracts/publicResolver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/publicResolver.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { PublicResolver__factory } from '../generated/factories/PublicResolver__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  PublicResolver__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAwC;AAExC,IAAO,yBAAQ,CAAC,UAA4C,YAC1D,sDAAwB,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/contracts/registry.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ENSRegistry;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ENSRegistry").ENSRegistry;
 export default _default;

package/dist/cjs/contracts/registry.js

@@ -1,4 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ENSRegistry__factory_1 = require("../generated/factories/ENSRegistry__factory");
-exports.default = (provider, address) => ENSRegistry__factory_1.ENSRegistry__factory.connect(address, provider);
+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 registry_exports = {};
+__export(registry_exports, {
+  default: () => registry_default
+});
+module.exports = __toCommonJS(registry_exports);
+var import_ENSRegistry_factory = require("../generated/factories/ENSRegistry__factory");
+var registry_default = (provider, address) => import_ENSRegistry_factory.ENSRegistry__factory.connect(address, provider);
+//# sourceMappingURL=registry.js.map

package/dist/cjs/contracts/registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/registry.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  ENSRegistry__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,iCAAqC;AAErC,IAAO,mBAAQ,CAAC,UAA4C,YAC1D,gDAAqB,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/contracts/reverseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ReverseRegistrar;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ReverseRegistrar").ReverseRegistrar;
 export default _default;

package/dist/cjs/contracts/reverseRegistrar.js

@@ -1,4 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ReverseRegistrar__factory_1 = require("../generated/factories/ReverseRegistrar__factory");
-exports.default = (provider, address) => ReverseRegistrar__factory_1.ReverseRegistrar__factory.connect(address, provider);
+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 reverseRegistrar_exports = {};
+__export(reverseRegistrar_exports, {
+  default: () => reverseRegistrar_default
+});
+module.exports = __toCommonJS(reverseRegistrar_exports);
+var import_ReverseRegistrar_factory = require("../generated/factories/ReverseRegistrar__factory");
+var reverseRegistrar_default = (provider, address) => import_ReverseRegistrar_factory.ReverseRegistrar__factory.connect(address, provider);
+//# sourceMappingURL=reverseRegistrar.js.map

package/dist/cjs/contracts/reverseRegistrar.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/reverseRegistrar.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  ReverseRegistrar__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sCAA0C;AAE1C,IAAO,2BAAQ,CAAC,UAA4C,YAC1D,0DAA0B,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/contracts/types.js

@@ -1,2 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/cjs/contracts/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/types.ts"],
+  "sourcesContent": ["export type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337'\n\nexport type ContractName =\n  | 'BaseRegistrarImplementation'\n  | 'ETHRegistrarController'\n  | 'Multicall'\n  | 'NameWrapper'\n  | 'PublicResolver'\n  | 'ENSRegistryWithFallback'\n  | 'ReverseRegistrar'\n  | 'UniversalResolver'\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/contracts/universalResolver.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").UniversalResolver;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/UniversalResolver").UniversalResolver;
 export default _default;

package/dist/cjs/contracts/universalResolver.js

@@ -1,4 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const UniversalResolver__factory_1 = require("../generated/factories/UniversalResolver__factory");
-exports.default = (provider, address) => UniversalResolver__factory_1.UniversalResolver__factory.connect(address, provider);
+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 universalResolver_exports = {};
+__export(universalResolver_exports, {
+  default: () => universalResolver_default
+});
+module.exports = __toCommonJS(universalResolver_exports);
+var import_UniversalResolver_factory = require("../generated/factories/UniversalResolver__factory");
+var universalResolver_default = (provider, address) => import_UniversalResolver_factory.UniversalResolver__factory.connect(address, provider);
+//# sourceMappingURL=universalResolver.js.map

package/dist/cjs/contracts/universalResolver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contracts/universalResolver.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory'\n\nexport default (provider: ethers.providers.JsonRpcProvider, address: string) =>\n  UniversalResolver__factory.connect(address, provider)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,uCAA2C;AAE3C,IAAO,4BAAQ,CAAC,UAA4C,YAC1D,4DAA2B,QAAQ,SAAS,QAAQ;",
+  "names": []
+}

package/dist/cjs/functions/batch.js

@@ -1,21 +1,49 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+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 batch_exports = {};
+__export(batch_exports, {
+  default: () => batch_default
+});
+module.exports = __toCommonJS(batch_exports);
 const raw = async ({ multicallWrapper }, ...items) => {
-    const rawDataArr = await Promise.all(items.map(({ args, raw }, i) => {
-        if (!raw) {
-            throw new Error(`Function ${i} is not batchable`);
-        }
-        return raw(...args);
-    }));
-    return multicallWrapper.raw(rawDataArr);
+  const rawDataArr = await Promise.all(
+    items.map(({ args, raw: rawRef }, i) => {
+      if (!rawRef) {
+        throw new Error(`Function ${i} is not batchable`);
+      }
+      return rawRef(...args);
+    })
+  );
+  return multicallWrapper.raw(rawDataArr);
 };
 const decode = async ({ multicallWrapper }, data, ...items) => {
-    const response = await multicallWrapper.decode(data);
-    if (!response)
-        return;
-    return Promise.all(response.map((ret, i) => items[i].decode(ret.returnData, ...items[i].args)));
+  const response = await multicallWrapper.decode(data);
+  if (!response)
+    return;
+  return Promise.all(
+    response.map(
+      (ret, i) => items[i].decode(ret.returnData, ...items[i].args)
+    )
+  );
 };
-exports.default = {
-    raw,
-    decode,
+var batch_default = {
+  raw,
+  decode
 };
+//# sourceMappingURL=batch.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/batch.ts"],
+  "sourcesContent": ["import { BatchFunctionResult, ENSArgs, RawFunction } from '..'\n\nconst raw = async (\n  { multicallWrapper }: ENSArgs<'multicallWrapper'>,\n  ...items: BatchFunctionResult<RawFunction>[]\n) => {\n  const rawDataArr: { to: string; data: string }[] = await Promise.all(\n    items.map(({ args, raw: rawRef }, i: number) => {\n      if (!rawRef) {\n        throw new Error(`Function ${i} is not batchable`)\n      }\n      return rawRef(...args)\n    }),\n  )\n  return multicallWrapper.raw(rawDataArr)\n}\n\nconst decode = async (\n  { multicallWrapper }: ENSArgs<'multicallWrapper'>,\n  data: string,\n  ...items: BatchFunctionResult<RawFunction>[]\n): Promise<any[] | undefined> => {\n  const response = await multicallWrapper.decode(data)\n  if (!response) return\n\n  return Promise.all(\n    response.map((ret: any, i: number) =>\n      items[i].decode(ret.returnData, ...items[i].args),\n    ),\n  )\n}\n\nexport default {\n  raw,\n  decode,\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,MAAM,MAAM,OACV,EAAE,iBAAiB,MAChB,UACA;AACH,QAAM,aAA6C,MAAM,QAAQ;AAAA,IAC/D,MAAM,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,MAAc;AAC9C,UAAI,CAAC,QAAQ;AACX,cAAM,IAAI,MAAM,YAAY,oBAAoB;AAAA,MAClD;AACA,aAAO,OAAO,GAAG,IAAI;AAAA,IACvB,CAAC;AAAA,EACH;AACA,SAAO,iBAAiB,IAAI,UAAU;AACxC;AAEA,MAAM,SAAS,OACb,EAAE,iBAAiB,GACnB,SACG,UAC4B;AAC/B,QAAM,WAAW,MAAM,iBAAiB,OAAO,IAAI;AACnD,MAAI,CAAC;AAAU;AAEf,SAAO,QAAQ;AAAA,IACb,SAAS;AAAA,MAAI,CAAC,KAAU,MACtB,MAAM,GAAG,OAAO,IAAI,YAAY,GAAG,MAAM,GAAG,IAAI;AAAA,IAClD;AAAA,EACF;AACF;AAEA,IAAO,gBAAQ;AAAA,EACb;AAAA,EACA;AACF;",
+  "names": []
+}

package/dist/cjs/functions/batchWrappers.d.ts

@@ -21,9 +21,9 @@ export declare const resolverMulticallWrapper: {
     decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
 };
 export declare const multicallWrapper: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+    raw({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean): Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode({ contracts }: ENSArgs<'contracts'>, data: string): Promise<any>;
 };

package/dist/cjs/functions/batchWrappers.js

@@ -1,71 +1,102 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.multicallWrapper = exports.resolverMulticallWrapper = exports.universalWrapper = void 0;
-const hexEncodedName_1 = require("../utils/hexEncodedName");
-exports.universalWrapper = {
-    raw: async ({ contracts }, name, data) => {
-        const universalResolver = await contracts?.getUniversalResolver();
-        return {
-            to: universalResolver.address,
-            data: universalResolver.interface.encodeFunctionData('resolve', [
-                (0, hexEncodedName_1.hexEncodeName)(name),
-                data,
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const universalResolver = await contracts?.getUniversalResolver();
-        const response = universalResolver.interface.decodeFunctionResult('resolve', data);
-        if (!response || !response[0]) {
-            return;
-        }
-        return { data: response[0], resolver: response[1] };
-    },
+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.resolverMulticallWrapper = {
-    raw: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const formattedDataArr = data.map((item) => item.data);
-        return {
-            to: publicResolver.address,
-            data: publicResolver.interface.encodeFunctionData('multicall', [
-                formattedDataArr,
-            ]),
-        };
-    },
-    decode: async ({ contracts }, data) => {
-        const publicResolver = await contracts?.getPublicResolver();
-        const response = publicResolver.interface.decodeFunctionResult('multicall', data);
-        if (!response) {
-            return;
-        }
-        return response;
-    },
+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.multicallWrapper = {
-    raw: async function ({ contracts }, transactions, requireSuccess = false) {
-        const multicall = await contracts?.getMulticall();
-        return {
-            to: multicall.address,
-            data: multicall.interface.encodeFunctionData('tryAggregate', [
-                requireSuccess,
-                transactions.map((tx) => ({
-                    target: tx.to,
-                    callData: tx.data,
-                })),
-            ]),
-        };
-    },
-    decode: async function ({ contracts }, data) {
-        if (!data)
-            return;
-        const multicall = await contracts?.getMulticall();
-        try {
-            const [result] = multicall.interface.decodeFunctionResult('tryAggregate', data);
-            return result;
-        }
-        catch {
-            return;
-        }
-    },
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var batchWrappers_exports = {};
+__export(batchWrappers_exports, {
+  multicallWrapper: () => multicallWrapper,
+  resolverMulticallWrapper: () => resolverMulticallWrapper,
+  universalWrapper: () => universalWrapper
+});
+module.exports = __toCommonJS(batchWrappers_exports);
+var import_hexEncodedName = require("../utils/hexEncodedName");
+const universalWrapper = {
+  raw: async ({ contracts }, name, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    return {
+      to: universalResolver.address,
+      data: universalResolver.interface.encodeFunctionData("resolve", [
+        (0, import_hexEncodedName.hexEncodeName)(name),
+        data
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const response = universalResolver.interface.decodeFunctionResult(
+      "resolve",
+      data
+    );
+    if (!response || !response[0]) {
+      return;
+    }
+    return { data: response[0], resolver: response[1] };
+  }
 };
+const resolverMulticallWrapper = {
+  raw: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const formattedDataArr = data.map((item) => item.data);
+    return {
+      to: publicResolver.address,
+      data: publicResolver.interface.encodeFunctionData("multicall", [
+        formattedDataArr
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const response = publicResolver.interface.decodeFunctionResult(
+      "multicall",
+      data
+    );
+    if (!response) {
+      return;
+    }
+    return response;
+  }
+};
+const multicallWrapper = {
+  async raw({ contracts }, transactions, requireSuccess = false) {
+    const multicall = await contracts?.getMulticall();
+    return {
+      to: multicall.address,
+      data: multicall.interface.encodeFunctionData("tryAggregate", [
+        requireSuccess,
+        transactions.map((tx) => ({
+          target: tx.to,
+          callData: tx.data
+        }))
+      ])
+    };
+  },
+  async decode({ contracts }, data) {
+    if (!data)
+      return;
+    const multicall = await contracts?.getMulticall();
+    try {
+      const [result] = multicall.interface.decodeFunctionResult(
+        "tryAggregate",
+        data
+      );
+      return result;
+    } catch {
+      return;
+    }
+  }
+};
+//# sourceMappingURL=batchWrappers.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/batchWrappers.ts"],
+  "sourcesContent": ["import { ethers } from 'ethers'\nimport { ENSArgs } from '..'\nimport { hexEncodeName } from '../utils/hexEncodedName'\n\nexport const universalWrapper = {\n  raw: async (\n    { contracts }: ENSArgs<'contracts'>,\n    name: string,\n    data: string,\n  ) => {\n    const universalResolver = await contracts?.getUniversalResolver()!\n    return {\n      to: universalResolver.address,\n      data: universalResolver.interface.encodeFunctionData('resolve', [\n        hexEncodeName(name),\n        data,\n      ]),\n    }\n  },\n  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {\n    const universalResolver = await contracts?.getUniversalResolver()!\n    const response = universalResolver.interface.decodeFunctionResult(\n      'resolve',\n      data,\n    )\n    if (!response || !response[0]) {\n      return\n    }\n    return { data: response[0], resolver: response[1] }\n  },\n}\n\nexport const resolverMulticallWrapper = {\n  raw: async (\n    { contracts }: ENSArgs<'contracts'>,\n    data: { to: string; data: string }[],\n  ) => {\n    const publicResolver = await contracts?.getPublicResolver()!\n    const formattedDataArr = data.map((item) => (item as any).data)\n    return {\n      to: publicResolver.address,\n      data: publicResolver.interface.encodeFunctionData('multicall', [\n        formattedDataArr,\n      ]),\n    }\n  },\n  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {\n    const publicResolver = await contracts?.getPublicResolver()!\n    const response = publicResolver.interface.decodeFunctionResult(\n      'multicall',\n      data,\n    )\n    if (!response) {\n      return\n    }\n    return response\n  },\n}\n\nexport const multicallWrapper = {\n  async raw(\n    { contracts }: ENSArgs<'contracts'>,\n    transactions: ethers.providers.TransactionRequest[],\n    requireSuccess: boolean = false,\n  ) {\n    const multicall = await contracts?.getMulticall()!\n    return {\n      to: multicall.address,\n      data: multicall.interface.encodeFunctionData('tryAggregate', [\n        requireSuccess,\n        transactions.map((tx) => ({\n          target: tx.to!,\n          callData: tx.data!,\n        })),\n      ]),\n    }\n  },\n  async decode({ contracts }: ENSArgs<'contracts'>, data: string) {\n    if (!data) return\n    const multicall = await contracts?.getMulticall()!\n    try {\n      const [result] = multicall.interface.decodeFunctionResult(\n        'tryAggregate',\n        data,\n      )\n      return result\n    } catch {\n      return\n    }\n  },\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,4BAA8B;AAEvB,MAAM,mBAAmB;AAAA,EAC9B,KAAK,OACH,EAAE,UAAU,GACZ,MACA,SACG;AACH,UAAM,oBAAoB,MAAM,WAAW,qBAAqB;AAChE,WAAO;AAAA,MACL,IAAI,kBAAkB;AAAA,MACtB,MAAM,kBAAkB,UAAU,mBAAmB,WAAW;AAAA,YAC9D,qCAAc,IAAI;AAAA,QAClB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA,QAAQ,OAAO,EAAE,UAAU,GAAyB,SAAiB;AACnE,UAAM,oBAAoB,MAAM,WAAW,qBAAqB;AAChE,UAAM,WAAW,kBAAkB,UAAU;AAAA,MAC3C;AAAA,MACA;AAAA,IACF;AACA,QAAI,CAAC,YAAY,CAAC,SAAS,IAAI;AAC7B;AAAA,IACF;AACA,WAAO,EAAE,MAAM,SAAS,IAAI,UAAU,SAAS,GAAG;AAAA,EACpD;AACF;AAEO,MAAM,2BAA2B;AAAA,EACtC,KAAK,OACH,EAAE,UAAU,GACZ,SACG;AACH,UAAM,iBAAiB,MAAM,WAAW,kBAAkB;AAC1D,UAAM,mBAAmB,KAAK,IAAI,CAAC,SAAU,KAAa,IAAI;AAC9D,WAAO;AAAA,MACL,IAAI,eAAe;AAAA,MACnB,MAAM,eAAe,UAAU,mBAAmB,aAAa;AAAA,QAC7D;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA,QAAQ,OAAO,EAAE,UAAU,GAAyB,SAAiB;AACnE,UAAM,iBAAiB,MAAM,WAAW,kBAAkB;AAC1D,UAAM,WAAW,eAAe,UAAU;AAAA,MACxC;AAAA,MACA;AAAA,IACF;AACA,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAEO,MAAM,mBAAmB;AAAA,EAC9B,MAAM,IACJ,EAAE,UAAU,GACZ,cACA,iBAA0B,OAC1B;AACA,UAAM,YAAY,MAAM,WAAW,aAAa;AAChD,WAAO;AAAA,MACL,IAAI,UAAU;AAAA,MACd,MAAM,UAAU,UAAU,mBAAmB,gBAAgB;AAAA,QAC3D;AAAA,QACA,aAAa,IAAI,CAAC,QAAQ;AAAA,UACxB,QAAQ,GAAG;AAAA,UACX,UAAU,GAAG;AAAA,QACf,EAAE;AAAA,MACJ,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA,MAAM,OAAO,EAAE,UAAU,GAAyB,MAAc;AAC9D,QAAI,CAAC;AAAM;AACX,UAAM,YAAY,MAAM,WAAW,aAAa;AAChD,QAAI;AACF,YAAM,CAAC,MAAM,IAAI,UAAU,UAAU;AAAA,QACnC;AAAA,QACA;AAAA,MACF;AACA,aAAO;AAAA,IACT,QAAE;AACA;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/functions/burnFuses.d.ts

@@ -1,24 +1,5 @@
 import { ENSArgs } from '..';
-import { fuseEnum, unnamedFuses } from '../utils/fuses';
-declare type FuseObj = typeof fuseEnum;
-declare type UnnamedFuseType = typeof unnamedFuses;
-declare type Fuse = keyof FuseObj;
-declare type UnnamedFuseValues = UnnamedFuseType[number];
-export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
-/**
- * This type creates a type error if there are any duplicate fuses.
- * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
- *
- * @template A The array to check for duplicates.
- * @template B The union of all checked existing types.
- */
-declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
-] : [
-    Head,
-    ...FusesWithoutDuplicates<Tail, Head | B>
-] : A : [
-];
-export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+import { NamedFusesToBurn, UnnamedFuseValues } from '../utils/fuses';
 export declare type FusePropsNamedArray = {
     namedFusesToBurn: NamedFusesToBurn;
 };
@@ -30,4 +11,3 @@ export declare type FusePropsNumber = {
 };
 export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;
-export {};