@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

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

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+    resolverAddress?: string;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, ...params }: Params): Promise<{
+    customData: {
+        secret: string;
+        commitment: string;
+        wrapperExpiry: import("ethers").BigNumberish;
+    };
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+}>;
+export {};

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

@@ -1,19 +1,17 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapper';
 declare type BaseArgs = {
-    name: string;
     owner: string;
     resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
+    expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

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

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

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

@@ -4,4 +4,4 @@ export declare function encodeURLParams(p: {
 }): string;
 export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
 export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
-export default function (dnsName: string): Promise<any>;
+export default function (_: any, dnsName: string): Promise<any>;

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

@@ -0,0 +1,19 @@
+import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
+declare const _default: {
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
+        expiry: Date | null;
+        gracePeriod: number;
+    } | undefined>;
+};
+export default _default;

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

@@ -0,0 +1,28 @@
+import { ENSArgs } from '..';
+declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet';
+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<{
+    domain: {
+        type: DomainEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    registration: {
+        type: RegistrationEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    resolver: {
+        type: ResolverEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+} | undefined>;
+export {};

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

@@ -10,8 +10,8 @@ declare const _default: {
         reverseResolverAddress: any;
         resolverAddress: any;
     } | {
-        name: null;
-        match: boolean;
+        name: undefined;
+        match?: undefined;
         reverseResolverAddress?: undefined;
         resolverAddress?: undefined;
     } | undefined>;

package/dist/{esm → 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/{esm → types}/functions/getPrice.d.ts

@@ -1,11 +1,11 @@
 import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, nameOrNames: string | string[], duration: number, legacy?: boolean | undefined) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _name: string, _number: number, legacy?: boolean | undefined) => Promise<{
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
         base: BigNumber;
         premium: BigNumber;
     } | undefined>;

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';
@@ -26,5 +31,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,6 +3,7 @@ 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;

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

@@ -52,21 +52,21 @@ export declare const getText: {
     decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
 };
 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>;

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

@@ -16,8 +16,8 @@ declare type Params = {
     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/{cjs/functions/getFuses.d.ts → types/functions/getWrapperData.d.ts}

@@ -1,17 +1,15 @@
 import { BigNumber } from 'ethers';
-import { ENSArgs } from '..';
+import { ENSArgs } from '../index';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
-        fuseObj: {
-            [k: string]: any;
-        };
-        vulnerability: any;
-        vulnerableNode: null;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+        fuseObj: import("../utils/fuses").CurrentFuses;
+        expiryDate: Date;
         rawFuses: BigNumber;
+        owner: any;
     } | 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/types/functions/registerName.d.ts

@@ -0,0 +1,8 @@
+import { BigNumber } from 'ethers';
+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,13 @@
+import { BigNumber, BigNumberish } from 'ethers';
+import { ENSArgs } from '..';
+import { FuseProps } from '../utils/fuses';
+declare type BaseProps = {
+    duration: number;
+    value: BigNumber;
+};
+export declare function renewNameWithData({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, fuses, wrapperExpiry, }: BaseProps & {
+    fuses?: FuseProps;
+    wrapperExpiry?: BigNumberish;
+}): 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/setName.d.ts

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

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

@@ -0,0 +1,18 @@
+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';
+};
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

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

@@ -0,0 +1,6 @@
+import { ENSArgs } from '..';
+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").PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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