@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.50

package/dist/{esm → 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';
@@ -11,6 +16,7 @@ declare type ResolvedProfile = {
     createdAt: string | null;
     address?: string;
     name?: string | null;
+    decryptedName?: string | null;
     match?: boolean;
     message?: string;
     records?: {
@@ -19,6 +25,7 @@ declare type ResolvedProfile = {
         coinTypes?: DataItem[];
     };
     resolverAddress?: string;
+    isInvalidResolverAddress?: boolean;
     reverseResolverAddress?: string;
 };
 declare type ProfileOptions = {
@@ -26,5 +33,9 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+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/{cjs → types}/functions/getRecords.d.ts

@@ -3,30 +3,33 @@ declare type ProfileOptions = {
     contentHash?: boolean;
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
+    resolverAddress?: string;
 };
 export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
     isMigrated: boolean | null;
     createdAt: string | null;
     address?: string | undefined;
     name?: string | null | undefined;
+    decryptedName?: string | null | undefined;
     match?: boolean | undefined;
     message?: string | undefined;
     records?: {
         contentHash?: string | import("../utils/contentHash").DecodedContentHash | null | undefined;
         texts?: {
             key: string | number;
-            type: "addr" | "text" | "contentHash";
+            type: "text" | "addr" | "contentHash";
             coin?: string | undefined;
             value: string;
         }[] | undefined;
         coinTypes?: {
             key: string | number;
-            type: "addr" | "text" | "contentHash";
+            type: "text" | "addr" | "contentHash";
             coin?: string | undefined;
             value: string;
         }[] | undefined;
     } | undefined;
     resolverAddress?: string | undefined;
+    isInvalidResolverAddress?: boolean | undefined;
     reverseResolverAddress?: string | undefined;
 } | undefined>;
 export {};

package/dist/{esm → types}/functions/getSpecificRecord.d.ts

@@ -42,32 +42,54 @@ export declare const _getText: {
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<string | undefined>;
 };
 export declare const getText: {
     raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, key: string) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<string | undefined>;
 };
 export declare const _getAddr: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;
 };
 export declare const getAddr: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         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>;
+};

package/dist/{esm → types}/functions/getSubnames.d.ts

@@ -1,23 +1,35 @@
 import { ENSArgs } from '..';
-declare type Subname = {
+import { AllCurrentFuses } from '../utils/fuses';
+declare type BaseSubname = {
     id: string;
     labelName: string | null;
     truncatedName?: string;
     labelhash: string;
     isMigrated: boolean;
     name: string;
-    owner: {
-        id: string;
-    };
+    owner: string | undefined;
 };
+declare type UnwrappedSubname = BaseSubname & {
+    fuses?: never;
+    expiryDate?: never;
+    pccExpired?: never;
+    type: 'domain';
+};
+declare type WrappedSubname = BaseSubname & {
+    fuses: AllCurrentFuses;
+    expiryDate: Date;
+    pccExpired: boolean;
+    type: 'wrappedDomain';
+};
+declare type Subname = WrappedSubname | UnwrappedSubname;
 declare type Params = {
     name: string;
     page?: number;
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
     orderBy?: 'createdAt' | 'labelName';
-    lastSubnames: Array<any>;
-    isLargeQuery?: boolean;
+    lastSubnames?: Array<any>;
+    search?: string;
 };
 declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
     subnames: Subname[];

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

@@ -0,0 +1,54 @@
+import { ENSArgs } from '../index';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+        expiryDate: Date | undefined;
+        rawFuses: number;
+        owner: string;
+        parent: {
+            unnamed: {
+                524288: boolean;
+                1048576: boolean;
+                2097152: boolean;
+                4194304: boolean;
+                8388608: boolean;
+                16777216: boolean;
+                33554432: boolean;
+                67108864: boolean;
+                134217728: boolean;
+                268435456: boolean;
+                536870912: boolean;
+                1073741824: boolean;
+                2147483648: boolean;
+            };
+            IS_DOT_ETH: boolean;
+            PARENT_CANNOT_CONTROL: boolean;
+            CAN_EXTEND_EXPIRY: boolean;
+        };
+        child: {
+            CAN_DO_EVERYTHING: boolean;
+            unnamed: {
+                1024: boolean;
+                64: boolean;
+                128: boolean;
+                256: boolean;
+                512: boolean;
+                2048: boolean;
+                4096: boolean;
+                8192: boolean;
+                16384: boolean;
+                32768: boolean;
+            };
+            CANNOT_UNWRAP: boolean;
+            CANNOT_BURN_FUSES: boolean;
+            CANNOT_TRANSFER: boolean;
+            CANNOT_SET_RESOLVER: boolean;
+            CANNOT_SET_TTL: boolean;
+            CANNOT_CREATE_SUBDOMAIN: boolean;
+        };
+    } | undefined>;
+};
+export default _default;

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

@@ -0,0 +1,7 @@
+import type { ENSArgs } from '..';
+export declare const DNS_OVER_HTTP_ENDPOINT = "https://1.1.1.1/dns-query";
+export declare type ImportDNSSECNameProps = {
+    address: string;
+    proverResult: any;
+};
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("ethers").PopulatedTransaction | undefined>;

package/dist/{cjs → types}/functions/initialGetters.d.ts

@@ -9,3 +9,4 @@ export { default as getProfile } from './getProfile';
 export { default as getRecords } from './getRecords';
 export * from './getSpecificRecord';
 export { default as getSubnames } from './getSubnames';
+export { default as supportsTLD } from './supportsTLD';

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

@@ -0,0 +1,8 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ENSArgs } from '..';
+import { BaseRegistrationParams } from '../utils/registerHelpers';
+declare type Params = BaseRegistrationParams & {
+    value: BigNumber;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
+export {};

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

@@ -0,0 +1,12 @@
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { ENSArgs } from '..';
+declare type BaseProps = {
+    duration: number;
+    value: BigNumber;
+};
+declare type WrappedProps = {
+    duration: BigNumberish;
+};
+export declare function extendWrappedName({ contracts }: ENSArgs<'contracts'>, name: string, options?: WrappedProps): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("ethers").PopulatedTransaction>;
+export {};

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

@@ -0,0 +1,7 @@
+import { ENSArgs } from '../index';
+import { CombinedFuseInput } from '../utils/fuses';
+export declare function setChildFuses({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fuses, expiry, }: {
+    fuses: Partial<CombinedFuseInput> | number;
+    expiry?: number;
+}): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: CombinedFuseInput['child']): Promise<import("ethers").PopulatedTransaction>;

package/dist/{esm → types}/functions/setName.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
     address?: string;
     resolver?: string;
-}): Promise<import("ethers").ContractTransaction | undefined>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -0,0 +1,22 @@
+import { ENSArgs } from '..';
+import { RecordInput } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+declare type ABIInput = {
+    record: RecordInput<'abi'>;
+    type: 'abi';
+};
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/{cjs → types}/functions/setRecords.d.ts

@@ -3,4 +3,4 @@ import { RecordOptions } from '../utils/recordHelpers';
 export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
     records: RecordOptions;
     resolverAddress?: string;
-}): Promise<import("ethers").ContractTransaction | undefined>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/{esm → types}/functions/setResolver.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
     contract: 'registry' | 'nameWrapper';
     resolver?: string;
-}): Promise<import("ethers").ContractTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -0,0 +1,2 @@
+import { ENSArgs } from '..';
+export default function ({ getOwner, provider }: ENSArgs<'getOwner' | 'provider'>, name: string): Promise<boolean>;

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

@@ -0,0 +1,5 @@
+import { ENSArgs } from '..';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, isOwner, }: {
+    newOwner: string;
+    isOwner: boolean;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/{esm → types}/functions/transferName.d.ts

@@ -1,6 +1,6 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, reclaim, }: {
     newOwner: string;
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
-}): Promise<ethers.ContractTransaction>;
+    reclaim?: boolean;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/{esm/functions/createSubname.d.ts → types/functions/transferSubname.d.ts}

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

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

@@ -0,0 +1,83 @@
+import type batch from './batch';
+import type { multicallWrapper, resolverMulticallWrapper, universalWrapper } from './batchWrappers';
+import type commitName from './commitName';
+import type createSubname from './createSubname';
+import type deleteSubname from './deleteSubname';
+import type getAvailable from './getAvailable';
+import type getDecryptedName from './getDecryptedName';
+import type getDNSOwner from './getDNSOwner';
+import type getExpiry from './getExpiry';
+import type { getHistory } from './getHistory';
+import type getName from './getName';
+import type getNames from './getNames';
+import type getOwner from './getOwner';
+import type getPrice from './getPrice';
+import type getProfile from './getProfile';
+import type getRecords from './getRecords';
+import type getResolver from './getResolver';
+import type { getABI, getAddr, getContentHash, getText, _getABI, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
+import type getSubnames from './getSubnames';
+import type getWrapperData from './getWrapperData';
+import type importDNSSECName from './importDNSSECName';
+import type registerName from './registerName';
+import type { default as renewNames, extendWrappedName } from './renewNames';
+import type setFuses from './setFuses';
+import type { setChildFuses } from './setFuses';
+import type setName from './setName';
+import type setRecord from './setRecord';
+import type setRecords from './setRecords';
+import type setResolver from './setResolver';
+import type supportsTLD from './supportsTLD';
+import type transferController from './transferController';
+import type transferName from './transferName';
+import type transferSubname from './transferSubname';
+import type unwrapName from './unwrapName';
+import type wrapName from './wrapName';
+declare type Function = {
+    batch: typeof batch;
+    multicallWrapper: typeof multicallWrapper;
+    resolverMulticallWrapper: typeof resolverMulticallWrapper;
+    universalWrapper: typeof universalWrapper;
+    setFuses: typeof setFuses;
+    setChildFuses: typeof setChildFuses;
+    commitName: typeof commitName;
+    createSubname: typeof createSubname;
+    deleteSubname: typeof deleteSubname;
+    getAvailable: typeof getAvailable;
+    getDecryptedName: typeof getDecryptedName;
+    getDNSOwner: typeof getDNSOwner;
+    getExpiry: typeof getExpiry;
+    getHistory: typeof getHistory;
+    getName: typeof getName;
+    getNames: typeof getNames;
+    getOwner: typeof getOwner;
+    getPrice: typeof getPrice;
+    getProfile: typeof getProfile;
+    getRecords: typeof getRecords;
+    getResolver: typeof getResolver;
+    getAddr: typeof getAddr;
+    getContentHash: typeof getContentHash;
+    getText: typeof getText;
+    getABI: typeof getABI;
+    _getAddr: typeof _getAddr;
+    _getContentHash: typeof _getContentHash;
+    _getText: typeof _getText;
+    _getABI: typeof _getABI;
+    getSubnames: typeof getSubnames;
+    getWrapperData: typeof getWrapperData;
+    importDNSSECName: typeof importDNSSECName;
+    registerName: typeof registerName;
+    renewNames: typeof renewNames;
+    extendWrappedName: typeof extendWrappedName;
+    setName: typeof setName;
+    setRecord: typeof setRecord;
+    setRecords: typeof setRecords;
+    setResolver: typeof setResolver;
+    supportsTLD: typeof supportsTLD;
+    transferController: typeof transferController;
+    transferName: typeof transferName;
+    transferSubname: typeof transferSubname;
+    unwrapName: typeof unwrapName;
+    wrapName: typeof wrapName;
+};
+export default Function;

package/dist/{esm → types}/functions/unwrapName.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
     newController: string;
     newRegistrant?: string;
-}): Promise<import("ethers").ContractTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -0,0 +1,9 @@
+import { ENSArgs } from '..';
+import { CombinedFuseInput } from '../utils/fuses';
+import { Expiry } from '../utils/wrapper';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
+    wrappedOwner: string;
+    fuseOptions?: Partial<CombinedFuseInput> | number;
+    expiry?: Expiry;
+    resolverAddress?: string;
+}): Promise<import("ethers").PopulatedTransaction>;