@ethersproject/contracts

constructor(
    addressOrName: string,
    contractInterface: any,
    signerOrProvider?: any
);

readonly address: string;

readonly callStatic: { [name: string]: ContractFunction<any> };

readonly deployTransaction: TransactionResponse;

readonly estimateGas: { [name: string]: ContractFunction<BigNumber> };

readonly filters: { [name: string]: (...args: Array<any>) => EventFilter };

readonly functions: { [name: string]: ContractFunction<any> };

readonly interface: Interface;

readonly populateTransaction: {
    [name: string]: ContractFunction<PopulatedTransaction>;
};

readonly provider: Provider;

readonly resolvedAddress: Promise<string>;

readonly signer: Signer;

attach: (addressOrName: string) => Contract;

connect: (signerOrProvider: Signer | Provider | string) => Contract;

deployed: () => Promise<Contract>;

emit: (eventName: EventFilter | string, ...args: Array<any>) => boolean;

fallback: (overrides?: TransactionRequest) => Promise<TransactionResponse>;

static getContractAddress: (transaction: {
    from: string;
    nonce: BigNumberish;
}) => string;

static getInterface: (contractInterface: ContractInterface) => Interface;

static isIndexed: (value: any) => value is Indexed;

listenerCount: (eventName?: EventFilter | string) => number;

listeners: (eventName?: EventFilter | string) => Array<Listener>;

off: (eventName: EventFilter | string, listener: Listener) => this;

on: (event: EventFilter | string, listener: Listener) => this;

once: (event: EventFilter | string, listener: Listener) => this;

queryFilter: (
    event: EventFilter | string,
    fromBlockOrBlockhash?: BlockTag | string,
    toBlock?: BlockTag
) => Promise<Array<Event>>;

removeAllListeners: (eventName?: EventFilter | string) => this;

removeListener: (eventName: EventFilter | string, listener: Listener) => this;

constructor(contractInterface: any, bytecode: any, signer?: Signer);

readonly bytecode: string;

readonly interface: Interface;

readonly signer: Signer;

attach: (address: string) => Contract;

connect: (signer: Signer) => ContractFactory;

deploy: (...args: Array<any>) => Promise<Contract>;

static fromSolidity: (compilerOutput: any, signer?: Signer) => ContractFactory;

static getContract: (
    address: string,
    contractInterface: ContractInterface,
    signer?: Signer
) => Contract;

static getContractAddress: (tx: {
    from: string;
    nonce: BytesLike | BigNumber | number;
}) => string;

getDeployTransaction: (...args: Array<any>) => TransactionRequest;

static getInterface: (contractInterface: ContractInterface) => Interface;

blockTag?: BlockTag | Promise<BlockTag>;

from?: string | Promise<string>;

events?: Array<Event>;

wait: (confirmations?: number) => Promise<ContractReceipt>;

args?: Result;

decode?: (data: string, topics?: Array<string>) => any;

decodeError?: Error;

event?: string;

eventSignature?: string;

getBlock: () => Promise<Block>;

getTransaction: () => Promise<TransactionResponse>;

getTransactionReceipt: () => Promise<TransactionReceipt>;

removeListener: () => void;

accessList?: AccessListish;

ccipReadEnabled?: boolean;

customData?: Record<string, any>;

gasLimit?: BigNumberish | Promise<BigNumberish>;

gasPrice?: BigNumberish | Promise<BigNumberish>;

maxFeePerGas?: BigNumberish | Promise<BigNumberish>;

maxPriorityFeePerGas?: BigNumberish | Promise<BigNumberish>;

nonce?: BigNumberish | Promise<BigNumberish>;

type?: number;

value?: BigNumberish | Promise<BigNumberish>;

accessList?: AccessList;

ccipReadEnabled?: boolean;

chainId?: number;

customData?: Record<string, any>;

data?: string;

from?: string;

gasLimit?: BigNumber;

gasPrice?: BigNumber;

maxFeePerGas?: BigNumber;

maxPriorityFeePerGas?: BigNumber;

nonce?: number;

to?: string;

type?: number;

value?: BigNumber;