Documentation

Documentation »API »Contracts

Contracts

About contracts...

Types
BaseContract
BaseContractMethod
ConstantContractMethod
Contract
ContractDeployTransaction
ContractEvent
ContractEventPayload
ContractFactory
ContractInterface
ContractMethod
ContractTransaction
ContractTransactionReceipt
ContractTransactionResponse
ContractUnknownEventPayload
DeferredTopicFilter
EventLog
Overrides

<src>ContractEventArgs⇒ TODO(A4BRecord<@TODO-005: @TODO-006>)

<src>ContractEventName⇒ string | ContractEvent | TopicFilter | DeferredTopicFilter

<src>ContractMethodArgs⇒ PostfixOverrides < TODO(A4BRecord<@TODO-005: @TODO-006>) >

<src>PostfixOverrides⇒ A | tuple< TODO(A5BFOOBAR ...[object Object]), Overrides >

<src>class BaseContract

inherits fromAddressable

<src>baseContract.fallback⇒ null | WrappedFallbackread-only

<src>baseContract.filters⇒ Record< string, ContractEvent >read-only

<src>baseContract.interface⇒ Interfaceread-only

<src>baseContract.internal⇒ anyread-only

<src>baseContract.runner⇒ null | ContractRunnerread-only

<src>baseContract.target⇒ string | Addressableread-only

<src>new BaseContract(target: string | Addressable, abi: Interface | InterfaceAbi, runner?: null | ContractRunner, deployTx?: null | TransactionResponse)

<src>BaseContract.from(target: string, abi: InterfaceAbi, runner?: null | ContractRunner)⇒ BaseContract & Omit< T, keyof<BaseContract }> >

<src>baseContract.addListener(event: ContractEventName, listener: Listener)⇒ Promise< this >

<src>baseContract.connect(runner: null | ContractRunner)⇒ BaseContract

<src>baseContract.deploymentTransaction()⇒ null | ContractTransactionResponse

<src>baseContract.emit(event: ContractEventName, args: Array< any >)⇒ Promise< boolean >

<src>baseContract.getDeployedCode()⇒ Promise< null | string >

<src>baseContract.getEvent(key: string | EventFragment)⇒ ContractEvent

<src>baseContract.getFunction(key: string | FunctionFragment)⇒ T

<src>baseContract.listenerCount(event?: ContractEventName)⇒ Promise< number >

<src>baseContract.listeners(event?: ContractEventName)⇒ Promise< Array< Listener > >

<src>baseContract.off(event: ContractEventName, listener?: Listener)⇒ Promise< this >

<src>baseContract.on(event: ContractEventName, listener: Listener)⇒ Promise< this >

<src>baseContract.once(event: ContractEventName, listener: Listener)⇒ Promise< this >

<src>baseContract.queryFilter(event: ContractEventName, fromBlock?: BlockTag, toBlock?: BlockTag)⇒ Promise< Array< EventLog | Log > >

<src>baseContract.queryTransaction(hash: string)⇒ Promise< Array< EventLog > >

<src>baseContract.removeAllListeners(event?: ContractEventName)⇒ Promise< this >

<src>baseContract.removeListener(event: ContractEventName, listener: Listener)⇒ Promise< this >

<src>baseContract.waitForDeployment()⇒ Promise< this >

<src>BaseContract.buildClass(abi: InterfaceAbi)⇒ TODO(A2Bconstructor(@TODO-001))

<src>interface BaseContractMethod

<src>baseContractMethod.fragment⇒ FunctionFragment

<src>baseContractMethod.name⇒ string

<src>baseContractMethod.estimateGas(args: ContractMethodArgs < A >)⇒ Promise< bigint >

<src>baseContractMethod.getFragment(args: ContractMethodArgs < A >)⇒ FunctionFragment

<src>baseContractMethod.populateTransaction(args: ContractMethodArgs < A >)⇒ Promise< ContractTransaction >

<src>baseContractMethod.send(args: ContractMethodArgs < A >)⇒ Promise< ContractTransactionResponse >

<src>baseContractMethod.staticCall(args: ContractMethodArgs < A >)⇒ Promise< R >

<src>baseContractMethod.staticCallResult(args: ContractMethodArgs < A >)⇒ Promise< Result >

<src>interface ConstantContractMethod

inherits fromContractMethod, BaseContractMethod

<src>class Contract

<src>interface ContractDeployTransaction

<src>interface ContractEvent

<src>contractEvent.fragment⇒ EventFragment

<src>contractEvent.name⇒ string

<src>contractEvent.getFragment(args: ContractEventArgs < A >)⇒ EventFragment

<src>class ContractEventPayload

inherits fromContractUnknownEventPayload, EventPayload

<src>contractEventPayload.args⇒ Resultread-only

<src>contractEventPayload.eventName⇒ stringread-only

<src>contractEventPayload.eventSignature⇒ stringread-only

<src>contractEventPayload.fragment⇒ EventFragmentread-only

<src>new ContractEventPayload(contract: BaseContract, listener: null | Listener, filter: ContractEventName, fragment: EventFragment, log: Log)

<src>class ContractFactory

<src>contractFactory.bytecode⇒ stringread-only

<src>contractFactory.interface⇒ Interfaceread-only

<src>contractFactory.runner⇒ null | ContractRunnerread-only

<src>new ContractFactory(abi: Interface | InterfaceAbi, bytecode: BytesLike | { object: string }, runner?: null | ContractRunner)

<src>ContractFactory.fromSolidity(output: any, runner?: ContractRunner)⇒ ContractFactory < A, I >

<src>contractFactory.connect(runner: null | ContractRunner)⇒ ContractFactory < A, I >

<src>contractFactory.deploy(args: ContractMethodArgs < A >)⇒ Promise< BaseContract & { deploymentTransaction: ContractTransactionResponse } & Omit< I, keyof<BaseContract }> > >

<src>contractFactory.getDeployTransaction(args: ContractMethodArgs < A >)⇒ Promise< ContractDeployTransaction >

<src>interface ContractInterface

<src>interface ContractMethod

inherits fromBaseContractMethod

<src>interface ContractTransaction

inherits fromPreparedTransactionRequest

<src>class ContractTransactionReceipt

inherits fromTransactionReceipt, TransactionReceiptParams

<src>new ContractTransactionReceipt(iface: Interface, provider: Provider, tx: TransactionReceipt)

<src>class ContractTransactionResponse

inherits fromTransactionResponse, TransactionResponseParams

<src>new ContractTransactionResponse(iface: Interface, provider: Provider, tx: TransactionResponse)

<src>class ContractUnknownEventPayload

inherits fromEventPayload

<src>contractUnknownEventPayload.log⇒ Logread-only

<src>new ContractUnknownEventPayload(contract: BaseContract, listener: null | Listener, filter: ContractEventName, log: Log)

<src>contractUnknownEventPayload.getBlock()⇒ Promise< Block >

<src>contractUnknownEventPayload.getTransaction()⇒ Promise< TransactionResponse >

<src>contractUnknownEventPayload.getTransactionReceipt()⇒ Promise< TransactionReceipt >

<src>interface DeferredTopicFilter

<src>deferredTopicFilter.fragment⇒ EventFragment

<src>deferredTopicFilter.getTopicFilter()⇒ Promise< TopicFilter >

<src>class EventLog

inherits fromLog, LogParams

<src>eventLog.args⇒ Resultread-only

<src>eventLog.eventName⇒ stringread-only

<src>eventLog.eventSignature⇒ stringread-only

<src>eventLog.fragment⇒ EventFragmentread-only

<src>eventLog.interface⇒ Interfaceread-only

<src>new EventLog(log: Log, iface: Interface, fragment: EventFragment)

<src>interface Overrides