@ensdomains/ensjs 3.0.0-alpha.26 → 3.0.0-alpha.28

package/dist/esm/generated/factories/UniversalResolver__factory.mjs

@@ -14,6 +14,11 @@ var _abi = [
         internalType: "address",
         name: "_registry",
         type: "address"
+      },
+      {
+        internalType: "string[]",
+        name: "_urls",
+        type: "string[]"
       }
     ],
     stateMutability: "nonpayable",
@@ -50,6 +55,69 @@ var _abi = [
     name: "OffchainLookup",
     type: "error"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      },
+      {
+        internalType: "bytes4",
+        name: "callbackFunction",
+        type: "bytes4"
+      },
+      {
+        internalType: "bytes",
+        name: "metaData",
+        type: "bytes"
+      }
+    ],
+    name: "_resolveSingle",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "batchGatewayURLs",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -87,6 +155,103 @@ var _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "data",
+        type: "bytes[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "data",
+        type: "bytes[]"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -130,11 +295,84 @@ var _abi = [
       }
     ],
     name: "resolveCallback",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "response",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "extraData",
+        type: "bytes"
+      }
+    ],
+    name: "resolveSingleCallback",
     outputs: [
       {
         internalType: "bytes",
         name: "",
         type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "reverseName",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "reverse",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
       }
     ],
     stateMutability: "view",
@@ -174,6 +412,45 @@ var _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "response",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "extraData",
+        type: "bytes"
+      }
+    ],
+    name: "reverseCallback",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {

package/dist/esm/utils/ccip.mjs

@@ -0,0 +1,114 @@
+// src/utils/ccip.ts
+import { BigNumber } from "ethers";
+import {
+  arrayify,
+  hexConcat,
+  hexDataSlice,
+  toUtf8String
+} from "ethers/lib/utils.js";
+function bytesPad(value) {
+  if (value.length % 32 === 0) {
+    return value;
+  }
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
+  result.set(value);
+  return result;
+}
+function numPad(value) {
+  const result = arrayify(value);
+  if (result.length > 32) {
+    throw new Error("internal; should not happen");
+  }
+  const padded = new Uint8Array(32);
+  padded.set(result, 32 - result.length);
+  return padded;
+}
+function encodeBytes(datas) {
+  const result = [];
+  let byteCount = 0;
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0));
+    byteCount += 32;
+  }
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = arrayify(datas[i]);
+    result[i] = numPad(byteCount);
+    result.push(numPad(data.length));
+    result.push(bytesPad(data));
+    byteCount += 32 + Math.ceil(data.length / 32) * 32;
+  }
+  return hexConcat(result);
+}
+function _parseBytes(result, start) {
+  if (result === "0x") {
+    return null;
+  }
+  const offset = BigNumber.from(
+    hexDataSlice(result, start, start + 32)
+  ).toNumber();
+  const length = BigNumber.from(
+    hexDataSlice(result, offset, offset + 32)
+  ).toNumber();
+  return hexDataSlice(result, offset + 32, offset + 32 + length);
+}
+function _parseString(result, start) {
+  try {
+    const bytes = _parseBytes(result, start);
+    if (bytes == null)
+      return null;
+    return toUtf8String(bytes);
+  } catch (error) {
+  }
+  return null;
+}
+var ccipLookup = async (provider, transaction, result) => {
+  const txSender = transaction.to;
+  try {
+    const data = hexDataSlice(result, 4);
+    const sender = hexDataSlice(data, 0, 32);
+    if (!BigNumber.from(sender).eq(txSender)) {
+      throw new Error("CCIP Read sender did not match");
+    }
+    const urls = [];
+    const urlsOffset = BigNumber.from(hexDataSlice(data, 32, 64)).toNumber();
+    const urlsLength = BigNumber.from(
+      hexDataSlice(data, urlsOffset, urlsOffset + 32)
+    ).toNumber();
+    const urlsData = hexDataSlice(data, urlsOffset + 32);
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32);
+      if (url == null) {
+        throw new Error("CCIP Read contained corrupt URL string");
+      }
+      urls.push(url);
+    }
+    const calldata = _parseBytes(data, 64);
+    if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {
+      throw new Error("CCIP Read callback selected included junk");
+    }
+    const callbackSelector = hexDataSlice(data, 96, 100);
+    const extraData = _parseBytes(data, 128);
+    const ccipResult = await provider.ccipReadFetch(
+      transaction,
+      calldata,
+      urls
+    );
+    if (ccipResult == null) {
+      throw new Error("CCIP Read disabled or provided no URLs");
+    }
+    const tx = {
+      to: sender,
+      data: hexConcat([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData])
+      ])
+    };
+    return await provider._call(tx, "latest", 1);
+  } catch (error) {
+    console.error(error);
+  }
+};
+var ccip_default = ccipLookup;
+export {
+  ccip_default as default
+};

package/dist/esm/utils/fuses.mjs

@@ -1,4 +1,5 @@
 // src/utils/fuses.ts
+import { BigNumber } from "ethers";
 var CANNOT_UNWRAP = 1;
 var CANNOT_BURN_FUSES = 2;
 var CANNOT_TRANSFER = 4;
@@ -89,8 +90,24 @@ var validateFuses = (fuses) => {
   }
   return encodedFuses;
 };
+var decodeFuses = (fuses) => {
+  const bnFuses = BigNumber.from(fuses);
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse]).gt(0)
+    ])
+  );
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true;
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false;
+  }
+  return fuseObj;
+};
 var fuses_default = fullFuseEnum;
 export {
+  decodeFuses,
   fuses_default as default,
   fuseEnum,
   unnamedFuses,

package/dist/esm/utils/singleCall.mjs

@@ -1,5 +1,5 @@
 // src/utils/singleCall.ts
-var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call(rawData)).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
 export {
   singleCall_default as default
 };

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

@@ -25,5 +25,62 @@ export declare const multicallWrapper: {
         to: string;
         data: string;
     }>;
-    decode({ contracts }: ENSArgs<'contracts'>, data: string): Promise<any>;
+    decode({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, data: string, transactions: ethers.providers.TransactionRequest[]): Promise<{
+        success: boolean;
+        returnData: string;
+        0: boolean;
+        1: string;
+        length: 2;
+        toString(): string;
+        toLocaleString(): string;
+        pop(): string | boolean | undefined;
+        push(...items: (string | boolean)[]): number;
+        concat(...items: ConcatArray<string | boolean>[]): (string | boolean)[];
+        concat(...items: (string | boolean | ConcatArray<string | boolean>)[]): (string | boolean)[];
+        join(separator?: string | undefined): string;
+        reverse(): (string | boolean)[];
+        shift(): string | boolean | undefined;
+        slice(start?: number | undefined, end?: number | undefined): (string | boolean)[];
+        sort(compareFn?: ((a: string | boolean, b: string | boolean) => number) | undefined): [boolean, string];
+        splice(start: number, deleteCount?: number | undefined): (string | boolean)[];
+        splice(start: number, deleteCount: number, ...items: (string | boolean)[]): (string | boolean)[];
+        unshift(...items: (string | boolean)[]): number;
+        indexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+        lastIndexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+        every<S extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => U, thisArg?: any): U[];
+        filter<S_1 extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S_1, thisArg?: any): S_1[];
+        filter(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): (string | boolean)[];
+        reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+        reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+        reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_1, initialValue: U_1): U_1;
+        reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+        reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+        reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_2, initialValue: U_2): U_2;
+        find<S_2 extends string | boolean>(predicate: (this: void, value: string | boolean, index: number, obj: (string | boolean)[]) => value is S_2, thisArg?: any): S_2 | undefined;
+        find(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): string | boolean | undefined;
+        findIndex(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): number;
+        fill(value: string | boolean, start?: number | undefined, end?: number | undefined): [boolean, string];
+        copyWithin(target: number, start: number, end?: number | undefined): [boolean, string];
+        entries(): IterableIterator<[number, string | boolean]>;
+        keys(): IterableIterator<number>;
+        values(): IterableIterator<string | boolean>;
+        includes(searchElement: string | boolean, fromIndex?: number | undefined): boolean;
+        flatMap<U_3, This = undefined>(callback: (this: This, value: string | boolean, index: number, array: (string | boolean)[]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        [Symbol.iterator](): IterableIterator<string | boolean>;
+        [Symbol.unscopables](): {
+            copyWithin: boolean;
+            entries: boolean;
+            fill: boolean;
+            find: boolean;
+            findIndex: boolean;
+            keys: boolean;
+            values: boolean;
+        };
+        at(index: number): string | boolean | undefined;
+    }[] | undefined>;
 };

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

@@ -1,4 +1,5 @@
 import { ENSArgs } from '..';
+import { CurrentFuses } from '../utils/fuses';
 export declare type Name = {
     id: string;
     labelName: string | null;
@@ -12,11 +13,12 @@ export declare type Name = {
     createdAt?: Date;
     registrationDate?: Date;
     expiryDate?: Date;
-    type: 'domain' | 'registration';
+    fuses?: CurrentFuses;
+    type: 'domain' | 'registration' | 'wrappedDomain';
 };
 declare type BaseParams = {
     address: string;
-    type: 'registrant' | 'owner' | 'all';
+    type: 'registrant' | 'owner' | 'wrappedOwner' | 'all';
     page?: number;
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
@@ -29,12 +31,16 @@ declare type OwnerParams = {
     type: 'owner';
     orderBy?: 'createdAt' | 'labelName';
 };
+declare type WrappedOwnerParams = {
+    type: 'wrappedOwner';
+    orderBy?: 'expiryDate' | 'labelName';
+};
 declare type AllParams = {
     type: 'all';
     orderBy?: 'labelName' | 'creationDate';
     page?: never;
     pageSize?: never;
 };
-declare type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams);
+declare type Params = BaseParams & (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams);
 declare const getNames: ({ gqlInstance }: ENSArgs<'gqlInstance'>, { address: _address, type, page, pageSize, orderDirection, orderBy, }: Params) => Promise<Name[]>;
 export default getNames;

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

@@ -1,5 +1,10 @@
 import { ENSArgs } from '..';
 import { DecodedContentHash } from '../utils/contentHash';
+declare type FallbackRecords = {
+    contentHash?: boolean;
+    texts?: string[];
+    coinTypes?: string[];
+};
 declare type DataItem = {
     key: string | number;
     type: 'addr' | 'text' | 'contentHash';
@@ -28,6 +33,7 @@ declare type ProfileOptions = {
 };
 declare type InputProfileOptions = ProfileOptions & {
     resolverAddress?: string;
+    fallback?: FallbackRecords;
 };
 export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

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

@@ -1,13 +1,12 @@
 import { BigNumber } from 'ethers';
 import { ENSArgs } from '../index';
-import { CurrentFuses } from '../utils/fuses';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
         to: string;
         data: string;
     }>;
     decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-        fuseObj: CurrentFuses;
+        fuseObj: import("../utils/fuses").CurrentFuses;
         expiryDate: Date;
         rawFuses: BigNumber;
         owner: any;

package/dist/types/generated/NameWrapper.d.ts

@@ -15,6 +15,7 @@ export interface NameWrapperInterface extends utils.Interface {
         "isTokenOwnerOrApproved(bytes32,address)": FunctionFragment;
         "isWrapped(bytes32)": FunctionFragment;
         "metadataService()": FunctionFragment;
+        "name()": FunctionFragment;
         "names(bytes32)": FunctionFragment;
         "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
         "owner()": FunctionFragment;
@@ -48,7 +49,7 @@ export interface NameWrapperInterface extends utils.Interface {
         "wrap(bytes,address,address)": FunctionFragment;
         "wrapETH2LD(string,address,uint32,uint64,address)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "_tokens" | "allFusesBurned" | "balanceOf" | "balanceOfBatch" | "controllers" | "ens" | "getData" | "isApprovedForAll" | "isTokenOwnerOrApproved" | "isWrapped" | "metadataService" | "names" | "onERC721Received" | "owner" | "ownerOf" | "recoverFunds" | "registerAndWrapETH2LD" | "registrar" | "renew" | "renounceOwnership" | "safeBatchTransferFrom" | "safeTransferFrom" | "setApprovalForAll" | "setChildFuses" | "setController" | "setFuses" | "setMetadataService" | "setRecord" | "setResolver" | "setSubnodeOwner" | "setSubnodeRecord" | "setTTL" | "setUpgradeContract" | "supportsInterface" | "transferOwnership" | "unwrap" | "unwrapETH2LD" | "upgrade" | "upgradeContract" | "upgradeETH2LD" | "uri" | "wrap" | "wrapETH2LD"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "_tokens" | "allFusesBurned" | "balanceOf" | "balanceOfBatch" | "controllers" | "ens" | "getData" | "isApprovedForAll" | "isTokenOwnerOrApproved" | "isWrapped" | "metadataService" | "name" | "names" | "onERC721Received" | "owner" | "ownerOf" | "recoverFunds" | "registerAndWrapETH2LD" | "registrar" | "renew" | "renounceOwnership" | "safeBatchTransferFrom" | "safeTransferFrom" | "setApprovalForAll" | "setChildFuses" | "setController" | "setFuses" | "setMetadataService" | "setRecord" | "setResolver" | "setSubnodeOwner" | "setSubnodeRecord" | "setTTL" | "setUpgradeContract" | "supportsInterface" | "transferOwnership" | "unwrap" | "unwrapETH2LD" | "upgrade" | "upgradeContract" | "upgradeETH2LD" | "uri" | "wrap" | "wrapETH2LD"): FunctionFragment;
     encodeFunctionData(functionFragment: "_tokens", values: [PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: "allFusesBurned", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
@@ -60,6 +61,7 @@ export interface NameWrapperInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "isTokenOwnerOrApproved", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: "isWrapped", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "metadataService", values?: undefined): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
     encodeFunctionData(functionFragment: "names", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "onERC721Received", values: [
         PromiseOrValue<string>,
@@ -187,6 +189,7 @@ export interface NameWrapperInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "isTokenOwnerOrApproved", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "isWrapped", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "metadataService", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "names", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "onERC721Received", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
@@ -366,6 +369,7 @@ export interface NameWrapper extends BaseContract {
         isTokenOwnerOrApproved(node: PromiseOrValue<BytesLike>, addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
         isWrapped(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
         metadataService(overrides?: CallOverrides): Promise<[string]>;
+        name(overrides?: CallOverrides): Promise<[string]>;
         names(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
         onERC721Received(to: PromiseOrValue<string>, arg1: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -462,6 +466,7 @@ export interface NameWrapper extends BaseContract {
     isTokenOwnerOrApproved(node: PromiseOrValue<BytesLike>, addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
     isWrapped(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
     metadataService(overrides?: CallOverrides): Promise<string>;
+    name(overrides?: CallOverrides): Promise<string>;
     names(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
     onERC721Received(to: PromiseOrValue<string>, arg1: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
@@ -556,6 +561,7 @@ export interface NameWrapper extends BaseContract {
         isTokenOwnerOrApproved(node: PromiseOrValue<BytesLike>, addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
         isWrapped(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
         metadataService(overrides?: CallOverrides): Promise<string>;
+        name(overrides?: CallOverrides): Promise<string>;
         names(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         onERC721Received(to: PromiseOrValue<string>, arg1: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         owner(overrides?: CallOverrides): Promise<string>;
@@ -621,6 +627,7 @@ export interface NameWrapper extends BaseContract {
         isTokenOwnerOrApproved(node: PromiseOrValue<BytesLike>, addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
         isWrapped(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         metadataService(overrides?: CallOverrides): Promise<BigNumber>;
+        name(overrides?: CallOverrides): Promise<BigNumber>;
         names(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         onERC721Received(to: PromiseOrValue<string>, arg1: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -716,6 +723,7 @@ export interface NameWrapper extends BaseContract {
         isTokenOwnerOrApproved(node: PromiseOrValue<BytesLike>, addr: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         isWrapped(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         metadataService(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         names(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         onERC721Received(to: PromiseOrValue<string>, arg1: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;