@ensdomains/ensjs 3.0.0-alpha.40 → 3.0.0-alpha.42

package/dist/esm/utils/fuses.mjs

@@ -1,23 +1,43 @@
 // src/utils/fuses.ts
-import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
 var CANNOT_UNWRAP = 1;
 var CANNOT_BURN_FUSES = 2;
 var CANNOT_TRANSFER = 4;
 var CANNOT_SET_RESOLVER = 8;
 var CANNOT_SET_TTL = 16;
 var CANNOT_CREATE_SUBDOMAIN = 32;
-var PARENT_CANNOT_CONTROL = 64;
+var PARENT_CANNOT_CONTROL = 65536;
+var IS_DOT_ETH = 131072;
+var CAN_EXTEND_EXPIRY = 262144;
+var CHILD_CONTROLLED_FUSES = 65535;
+var PARENT_CONTROLLED_FUSES = 4294901760;
+var USER_SETTABLE_FUSES = 4294836223;
 var CAN_DO_EVERYTHING = 0;
-var fuseEnum = {
+var childFuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
   CANNOT_SET_RESOLVER,
   CANNOT_SET_TTL,
-  CANNOT_CREATE_SUBDOMAIN,
-  PARENT_CANNOT_CONTROL
+  CANNOT_CREATE_SUBDOMAIN
 };
-var unnamedFuses = [
+var parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY
+};
+var fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH
+};
+var userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum
+};
+var fullFuseEnum = {
+  ...userSettableFuseEnum,
+  CAN_DO_EVERYTHING
+};
+var unnamedChildFuses = [
+  64,
   128,
   256,
   512,
@@ -26,10 +46,9 @@ var unnamedFuses = [
   4096,
   8192,
   16384,
-  32768,
-  65536,
-  131072,
-  262144,
+  32768
+];
+var unnamedParentFuses = [
   524288,
   1048576,
   2097152,
@@ -42,74 +61,220 @@ var unnamedFuses = [
   268435456,
   536870912,
   1073741824,
-  2147483648,
-  4294967296
+  2147483648
 ];
-var fullFuseEnum = {
-  ...fuseEnum,
-  CAN_DO_EVERYTHING
+var unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses
+];
+var childFuseKeys = Object.keys(
+  childFuseEnum
+);
+var parentFuseKeys = Object.keys(
+  parentFuseEnum
+);
+var fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum
+);
+var userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum
+);
+var checkNumber = (fuses) => {
+  if (fuses > 2 ** 32 || fuses < 1) {
+    throw new Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${fuses < 1 ? "low" : "high"}.`
+    );
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`);
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} was not.`
+    );
+  }
 };
-var validateFuses = (fuses) => {
-  const isNumber = "fuseNumberToBurn" in fuses;
-  const hasNamedArray = "namedFusesToBurn" in fuses;
-  const hasUnnamedArray = "unnamedFusesToBurn" in fuses;
+var testFuses = (fuses) => {
+  if ("named" in fuses && fuses.named.length > 0) {
+    return true;
+  }
+  if ("unnamed" in fuses && fuses.unnamed.length > 0) {
+    return true;
+  }
+  if ("number" in fuses && fuses.number !== 0) {
+    return true;
+  }
+  return false;
+};
+var hasFuses = (fuses) => {
+  if (typeof fuses === "number") {
+    return fuses !== 0;
+  }
+  if (typeof fuses === "object") {
+    if ("child" in fuses && testFuses(fuses.child)) {
+      return true;
+    }
+    if ("parent" in fuses && testFuses(fuses.parent)) {
+      return true;
+    }
+    if (testFuses(fuses)) {
+      return true;
+    }
+  }
+  return false;
+};
+function encodeFuses(fuses, restrictTo) {
   let encodedFuses = 0;
-  if (isNumber) {
-    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
-      throw new Error(
-        `Fuse number must be limited to uint32, ${fuses.fuseNumberToBurn} was too ${fuses.fuseNumberToBurn < 1 ? "low" : "high"}.`
-      );
-    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
-      throw new Error(
-        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`
-      );
+  if (typeof fuses === "number") {
+    if (restrictTo) {
+      throw new Error("Cannot specify an exact fuse value when restricted.");
     }
-    encodedFuses = fuses.fuseNumberToBurn;
+    checkNumber(fuses);
+    encodedFuses = fuses;
   } else {
-    if (!hasNamedArray && !hasUnnamedArray) {
-      throw new Error("Please provide fuses to burn");
+    let fusesRef = fuses;
+    let allowedNamed = [];
+    let allowedUnnamed = [];
+    let namedArray = [];
+    let unnamedArray = [];
+    if (restrictTo) {
+      if ("parent" in fuses || "child" in fuses) {
+        throw new Error("Can't specify fuse category when restricted.");
+      }
+      allowedNamed = restrictTo === "child" ? childFuseKeys : parentFuseKeys;
+      allowedUnnamed = restrictTo === "child" ? unnamedChildFuses : unnamedParentFuses;
+      fusesRef = { [restrictTo]: fuses };
+    } else {
+      allowedNamed = userSettableFuseKeys;
+      allowedUnnamed = unnamedUserSettableFuses;
+    }
+    if ("parent" in fusesRef) {
+      if ("named" in fusesRef.parent)
+        namedArray = fusesRef.parent.named;
+      if ("unnamed" in fusesRef.parent)
+        unnamedArray = fusesRef.parent.unnamed;
+      if ("number" in fusesRef.parent) {
+        if ("named" in fusesRef.parent || "unnamed" in fusesRef.parent) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.parent.number);
+        if ((fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !== fusesRef.parent.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the parent's control."
+          );
+        }
+        encodedFuses |= fusesRef.parent.number;
+      }
+    }
+    if ("child" in fusesRef) {
+      if ("named" in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named];
+      if ("unnamed" in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed];
+      if ("number" in fusesRef.child) {
+        if ("named" in fusesRef.child || "unnamed" in fusesRef.child) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.child.number);
+        if ((fusesRef.child.number & CHILD_CONTROLLED_FUSES) !== fusesRef.child.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the owner's control."
+          );
+        }
+        encodedFuses |= fusesRef.child.number;
+      }
     }
-    if (hasNamedArray) {
-      for (const fuse of fuses.namedFusesToBurn) {
-        if (!(fuse in fuseEnum)) {
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses) {
+      throw new Error("Must specify at least one fuse.");
+    }
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
           throw new Error(`${fuse} is not a valid named fuse.`);
         }
-        encodedFuses |= fuseEnum[fuse];
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
       }
+      encodedFuses |= userSettableFuseEnum[fuse];
     }
-    if (hasUnnamedArray) {
-      for (const fuse of fuses.unnamedFusesToBurn) {
-        if (!unnamedFuses.includes(fuse)) {
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse)) {
           throw new Error(
-            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`
           );
         }
-        encodedFuses |= fuse;
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
       }
+      encodedFuses |= fuse;
     }
   }
   return encodedFuses;
-};
-var decodeFuses = (fuses) => {
-  const bnFuses = BigNumber.from(fuses);
+}
+var decodeNamedFuses = (fuses, arr) => {
   const fuseObj = Object.fromEntries(
-    Object.keys(fuseEnum).map((fuse) => [
+    arr.map((fuse) => [
       fuse,
-      bnFuses.and(fuseEnum[fuse]).gt(0)
+      (fuses & userSettableFuseEnum[fuse]) > 0
     ])
   );
-  if (bnFuses.eq(0)) {
-    fuseObj.CAN_DO_EVERYTHING = true;
-  } else {
-    fuseObj.CAN_DO_EVERYTHING = false;
-  }
   return fuseObj;
 };
+var decodeUnnamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) > 0])
+  );
+  return fuseObj;
+};
+var decodeFuses = (fuses) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys
+  );
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses
+  );
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys
+  );
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses
+  );
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses
+    }
+  };
+};
 var fuses_default = fullFuseEnum;
 export {
+  CHILD_CONTROLLED_FUSES,
+  PARENT_CONTROLLED_FUSES,
+  USER_SETTABLE_FUSES,
+  childFuseEnum,
+  childFuseKeys,
   decodeFuses,
   fuses_default as default,
-  fuseEnum,
-  unnamedFuses,
-  validateFuses
+  encodeFuses,
+  fullFuseEnum,
+  fullParentFuseEnum,
+  fullParentFuseKeys,
+  hasFuses,
+  parentFuseEnum,
+  parentFuseKeys,
+  unnamedChildFuses,
+  unnamedParentFuses,
+  unnamedUserSettableFuses,
+  userSettableFuseEnum,
+  userSettableFuseKeys
 };

package/dist/esm/utils/normalise.mjs

@@ -1,7 +1,7 @@
 // src/utils/normalise.ts
 import { concat, hexlify } from "@ethersproject/bytes";
 import { keccak256 } from "@ethersproject/keccak256";
-import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.js";
+import { toUtf8Bytes } from "@ethersproject/strings";
 import uts46 from "idna-uts46-hx/uts46bundle.js";
 import { decodeLabelhash, isEncodedLabelhash } from "./labels.mjs";
 var zeros = new Uint8Array(32);

package/dist/esm/utils/recordHelpers.mjs

@@ -1,5 +1,7 @@
 // src/utils/recordHelpers.ts
 import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { isBytesLike } from "@ethersproject/bytes";
+import { toUtf8Bytes } from "@ethersproject/strings";
 import { encodeContenthash } from "./contentHash.mjs";
 var generateSetAddr = (namehash, coinType, address, resolver) => {
   let coinTypeInstance;
@@ -15,6 +17,34 @@ var generateSetAddr = (namehash, coinType, address, resolver) => {
     [namehash, inputCoinType, encodedAddress]
   );
 };
+var generateABIInput = async (encodeAs, data) => {
+  let contentType;
+  let encodedData;
+  switch (encodeAs) {
+    case "json":
+      contentType = 1;
+      encodedData = JSON.stringify(data);
+      break;
+    case "zlib": {
+      contentType = 2;
+      const { deflate } = await import("pako/dist/pako_deflate.min.js");
+      encodedData = deflate(JSON.stringify(data));
+      break;
+    }
+    case "cbor": {
+      contentType = 4;
+      const { encode } = await import("cbor");
+      encodedData = encode(data);
+      break;
+    }
+    default: {
+      contentType = 8;
+      encodedData = data;
+      break;
+    }
+  }
+  return { contentType, data: encodedData };
+};
 function generateSingleRecordCall(namehash, resolver, type) {
   if (type === "contentHash") {
     return (_r) => {
@@ -32,6 +62,24 @@ function generateSingleRecordCall(namehash, resolver, type) {
       ]);
     };
   }
+  if (type === "abi") {
+    return (_r) => {
+      const record = _r;
+      const { contentType = 1, data } = record;
+      let encodedData = data;
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === "object") {
+          encodedData = JSON.stringify(encodedData);
+        }
+        encodedData = toUtf8Bytes(encodedData);
+      }
+      return resolver.interface.encodeFunctionData("setABI", [
+        namehash,
+        contentType,
+        encodedData
+      ]);
+    };
+  }
   return (_r) => {
     const record = _r;
     if (type === "text") {
@@ -69,6 +117,7 @@ var generateRecordCallArray = (namehash, records, resolver) => {
   return calls;
 };
 export {
+  generateABIInput,
   generateRecordCallArray,
   generateSetAddr,
   generateSingleRecordCall

package/dist/esm/utils/registerHelpers.mjs

@@ -1,11 +1,10 @@
 // src/utils/registerHelpers.ts
 import { defaultAbiCoder } from "@ethersproject/abi/lib.esm/abi-coder.js";
 import { keccak256 } from "@ethersproject/keccak256";
-import generateFuseInput from "./generateFuseInput.mjs";
+import { encodeFuses, hasFuses } from "./fuses.mjs";
 import { labelhash } from "./labels.mjs";
 import { namehash } from "./normalise.mjs";
 import { generateRecordCallArray } from "./recordHelpers.mjs";
-var MAX_INT_64 = 2n ** 64n - 1n;
 var randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32);
   return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
@@ -18,13 +17,12 @@ var makeCommitmentData = ({
   records,
   reverseRecord,
   fuses,
-  wrapperExpiry,
   secret
 }) => {
-  const label = labelhash(name.split(".")[0]);
+  const labelHash = labelhash(name.split(".")[0]);
   const hash = namehash(name);
   const resolverAddress = resolver.address;
-  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses, "child") : 0;
   if (reverseRecord) {
     if (!records) {
       records = { coinTypes: [{ key: "ETH", value: owner }] };
@@ -36,23 +34,20 @@ var makeCommitmentData = ({
   }
   const data = records ? generateRecordCallArray(hash, records, resolver) : [];
   return [
-    label,
+    labelHash,
     owner,
     duration,
+    secret,
     resolverAddress,
     data,
-    secret,
     !!reverseRecord,
-    fuseData,
-    wrapperExpiry || MAX_INT_64
+    fuseData
   ];
 };
 var makeRegistrationData = (params) => {
   const commitmentData = makeCommitmentData(params);
   const label = params.name.split(".")[0];
   commitmentData[0] = label;
-  const secret = commitmentData.splice(5, 1)[0];
-  commitmentData.splice(3, 0, secret);
   return commitmentData;
 };
 var _makeCommitment = (params) => {
@@ -62,12 +57,11 @@ var _makeCommitment = (params) => {
         "bytes32",
         "address",
         "uint256",
+        "bytes32",
         "address",
         "bytes[]",
-        "bytes32",
         "bool",
-        "uint32",
-        "uint64"
+        "uint16"
       ],
       params
     )
@@ -84,12 +78,10 @@ var makeCommitment = ({
   const commitment = _makeCommitment(generatedParams);
   return {
     secret,
-    commitment,
-    wrapperExpiry: generatedParams[8]
+    commitment
   };
 };
 export {
-  MAX_INT_64,
   _makeCommitment,
   makeCommitment,
   makeCommitmentData,

package/dist/esm/utils/wrapper.mjs

@@ -1,6 +1,6 @@
 // src/utils/wrapper.ts
 import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
-import { toUtf8Bytes } from "@ethersproject/strings/lib.esm/utf8.js";
+import { toUtf8Bytes } from "@ethersproject/strings";
 var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
 var makeExpiry = async ({ getExpiry }, name, expiry) => {
   if (expiry) {

package/dist/types/functions/commitName.d.ts

@@ -7,20 +7,19 @@ export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { re
     customData: {
         secret: string;
         commitment: string;
-        wrapperExpiry: import("@ethersproject/bignumber").BigNumberish;
     };
     to?: string | undefined;
     from?: string | undefined;
     nonce?: number | undefined;
-    gasLimit?: import("@ethersproject/bignumber").BigNumber | undefined;
-    gasPrice?: import("@ethersproject/bignumber").BigNumber | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
     data?: string | undefined;
-    value?: import("@ethersproject/bignumber").BigNumber | undefined;
+    value?: import("ethers").BigNumber | undefined;
     chainId?: number | undefined;
     type?: number | undefined;
     accessList?: import("@ethersproject/transactions").AccessList | undefined;
-    maxFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
-    maxPriorityFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
     ccipReadEnabled?: boolean | undefined;
 }>;
 export {};

package/dist/types/functions/createSubname.d.ts

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../utils/fuses';
+import { CombinedFuseInput } from '../utils/fuses';
 import { Expiry } from '../utils/wrapper';
 declare type BaseArgs = {
     owner: string;
@@ -8,9 +8,9 @@ declare type BaseArgs = {
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
-    fuses?: FuseOptions;
+    fuses?: CombinedFuseInput;
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/functions/deleteSubname.d.ts

@@ -2,5 +2,5 @@ import { ENSArgs } from '..';
 declare type Args = {
     contract: 'registry' | 'nameWrapper';
 };
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/functions/getHistory.d.ts

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet';
+declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet' | 'ExpiryExtended';
 declare type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred';
 declare type ResolverEvent = 'AddrChanged' | 'MulticoinAddrChanged' | 'NameChanged' | 'AbiChanged' | 'PubkeyChanged' | 'TextChanged' | 'ContenthashChanged' | 'InterfaceChanged' | 'AuthorisationChanged' | 'VersionChanged';
 export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{

package/dist/types/functions/getNames.d.ts

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-import { CurrentFuses } from '../utils/fuses';
+import { AllCurrentFuses } from '../utils/fuses';
 export declare type Name = {
     id: string;
     labelName: string | null;
@@ -13,7 +13,7 @@ export declare type Name = {
     createdAt?: Date;
     registrationDate?: Date;
     expiryDate?: Date;
-    fuses?: CurrentFuses;
+    fuses?: AllCurrentFuses;
     registration?: {
         expiryDate: Date;
         registrationDate: Date;
@@ -37,7 +37,7 @@ declare type OwnerParams = {
 };
 declare type WrappedOwnerParams = {
     type: 'wrappedOwner';
-    orderBy?: 'expiryDate' | 'labelName';
+    orderBy?: 'expiryDate' | 'name';
 };
 declare type AllParams = {
     type: 'all';

package/dist/types/functions/getOwner.d.ts

@@ -3,6 +3,7 @@ declare type Owner = {
     registrant?: string;
     owner?: string;
     ownershipLevel: 'nameWrapper' | 'registry' | 'registrar';
+    expired?: boolean;
 };
 declare const _default: {
     raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{

package/dist/types/functions/getSpecificRecord.d.ts

@@ -71,3 +71,25 @@ export declare const getAddr: {
         addr: string;
     } | undefined>;
 };
+export declare const _getABI: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        contentType: number;
+        decoded: boolean;
+        abi: string | object;
+    } | undefined>;
+};
+export declare const getABI: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<{
+        contentType: number;
+        decoded: boolean;
+        abi: string | object;
+    } | undefined>;
+};