Documentation

Documentation »API »Providers »Subclassing Provider

Subclassing Provider

About Subclassing the Provider...

Types
Functions
AbstractProvider
AbstractProviderPlugin
FilterIdEventSubscriber
FilterIdPendingSubscriber
FilterIdSubscriber
OnBlockSubscriber
PerformActionTransaction
PollingBlockSubscriber
PollingEventSubscriber
PollingOrphanSubscriber
PollingTransactionSubscriber
Subscriber
UnmanagedSubscriber

<src>DebugEventAbstractProvider⇒ { action: "sendCcipReadFetchRequest" , index: number , request: FetchRequest , urls: Array< string > } | { action: "receiveCcipReadFetchResult" , request: FetchRequest , result: any } | { action: "receiveCcipReadFetchError" , request: FetchRequest , result: any } | { action: "sendCcipReadCall" , transaction: { data: string , to: string } } | { action: "receiveCcipReadCallResult" , result: string , transaction: { data: string , to: string } } | { action: "receiveCcipReadCallError" , error: Error , transaction: { data: string , to: string } }

<src>PerformActionFilter⇒ { address?: string | Array< string > , fromBlock?: BlockTag , toBlock?: BlockTag , topics?: Array< null | string | Array< string > > } | { address?: string | Array< string > , blockHash?: string , topics?: Array< null | string | Array< string > > }

<src>PerformActionRequest⇒ { method: "broadcastTransaction" , signedTransaction: string } | { blockTag: BlockTag , method: "call" , transaction: PerformActionTransaction } | { method: "chainId" } | { method: "estimateGas" , transaction: PerformActionTransaction } | { address: string , blockTag: BlockTag , method: "getBalance" } | { blockTag: BlockTag , includeTransactions: boolean , method: "getBlock" } | { blockHash: string , includeTransactions: boolean , method: "getBlock" } | { method: "getBlockNumber" } | { address: string , blockTag: BlockTag , method: "getCode" } | { method: "getGasPrice" } | { filter: PerformActionFilter , method: "getLogs" } | { address: string , blockTag: BlockTag , method: "getStorage" , position: bigint } | { hash: string , method: "getTransaction" } | { address: string , blockTag: BlockTag , method: "getTransactionCount" } | { hash: string , method: "getTransactionReceipt" } | { hash: string , method: "getTransactionResult" }

<src>Subscription⇒ { tag: string , type: "block" | "close" | "debug" | "network" | "pending" } | { hash: string , tag: string , type: "transaction" } | { filter: EventFilter , tag: string , type: "event" } | { filter: OrphanFilter , tag: string , type: "orphan" }

<src>getPollingSubscriber(provider: AbstractProvider, event: ProviderEvent)⇒ Subscriber

Generic long-lived socket provider.

Sub-classing notes

a sub-class MUST call the `_start()` method once connected
a sub-class MUST override the `_write(string)` method
a sub-class MUST call `_processMessage(string)` for each message

<src>class SocketBlockSubscriber

inherits fromSocketSubscriber, Subscriber

<src>new SocketBlockSubscriber(provider: SocketProvider)

<src>class SocketEventSubscriber

inherits fromSocketSubscriber, Subscriber

<src>socketEventSubscriber.logFilter⇒ EventFilterread-only

<src>new SocketEventSubscriber(provider: SocketProvider, filter: EventFilter)

<src>class SocketPendingSubscriber

inherits fromSocketSubscriber, Subscriber

<src>new SocketPendingSubscriber(provider: SocketProvider)

<src>class SocketProvider

inherits fromJsonRpcApiProvider, AbstractProvider, Provider, ContractRunner, EventEmitterable, NameResolver

SocketProvider...

<src>new SocketProvider(network?: Networkish)

<src>socketProvider._processMessage(message: string)⇒ Promise< void >

<src>socketProvider._register(filterId: number | string, subscriber: SocketSubscriber)⇒ void

<src>socketProvider._write(message: string)⇒ Promise< void >

<src>class SocketSubscriber

inherits fromSubscriber

<src>socketSubscriber.filter⇒ Array< any >read-only

<src>new SocketSubscriber(provider: SocketProvider, filter: Array< any >)

<src>socketSubscriber._emit(provider: SocketProvider, message: any)⇒ Promise< void >

<src>socketSubscriber._handleMessage(message: any)⇒ void

<src>class AbstractProvider

inherits fromProvider, ContractRunner, EventEmitterable, NameResolver

<src>abstractProvider.disableCcipRead⇒ boolean

<src>abstractProvider.paused⇒ boolean

<src>abstractProvider.plugins⇒ Array< AbstractProviderPlugin >read-only

<src>new AbstractProvider(network?: "any" | Networkish)

<src>abstractProvider._clearTimeout(timerId: number)⇒ void

<src>abstractProvider._detectNetwork()⇒ Promise< Network >

<src>abstractProvider._forEachSubscriber(func: (s: Subscriber) => void)⇒ void

<src>abstractProvider._getAddress(address: AddressLike)⇒ string | Promise< string >

<src>abstractProvider._getBlockTag(blockTag?: BlockTag)⇒ string | Promise< string >

<src>abstractProvider._getFilter(filter: Filter | FilterByBlockHash)⇒ PerformActionFilter | Promise< PerformActionFilter >

<src>abstractProvider._getProvider(chainId: number)⇒ AbstractProvider

<src>abstractProvider._getSubscriber(sub: Subscription)⇒ Subscriber

<src>abstractProvider._getTransactionRequest(request: TransactionRequest)⇒ PerformActionTransaction | Promise< PerformActionTransaction >

<src>abstractProvider._perform(req: PerformActionRequest)⇒ Promise< T >

<src>abstractProvider._recoverSubscriber(oldSub: Subscriber, newSub: Subscriber)⇒ void

<src>abstractProvider._setTimeout(func: () => void, timeout?: number)⇒ number

<src>abstractProvider._wrapBlock(value: BlockParams, network: Network)⇒ Block

<src>abstractProvider._wrapLog(value: LogParams, network: Network)⇒ Log

<src>abstractProvider._wrapTransactionReceipt(value: TransactionReceiptParams, network: Network)⇒ TransactionReceipt

<src>abstractProvider._wrapTransactionResponse(tx: TransactionResponseParams, network: Network)⇒ TransactionResponse

<src>abstractProvider.attachPlugin(plugin: AbstractProviderPlugin)⇒ this

<src>abstractProvider.ccipReadFetch(tx: PerformActionTransaction, calldata: string, urls: Array< string >)⇒ Promise< null | string >

<src>abstractProvider.getAvatar(name: string)⇒ Promise< null | string >

<src>abstractProvider.getPlugin(name: string)⇒ null | T

<src>abstractProvider.getResolver(name: string)⇒ Promise< null | EnsResolver >

<src>abstractProvider.pause(dropWhilePaused?: boolean)⇒ void

<src>abstractProvider.resume()⇒ void

<src>interface AbstractProviderPlugin

<src>abstractProviderPlugin.name⇒ stringread-only

<src>abstractProviderPlugin.connect(provider: AbstractProvider)⇒ AbstractProviderPlugin

<src>class FilterIdEventSubscriber

inherits fromFilterIdSubscriber, Subscriber

A FilterIdSubscriber for receiving contract events.

<src>new FilterIdEventSubscriber(provider: JsonRpcApiProvider, filter: EventFilter)

<src>class FilterIdPendingSubscriber

inherits fromFilterIdSubscriber, Subscriber

A FilterIdSubscriber for receiving pending transactions events.

<src>class FilterIdSubscriber

inherits fromSubscriber

Some backends support subscribing to events using a Filter ID.

When subscribing with this technique, the node issues a unique Filter ID. At this point the node dedicates resources to the filter, so that periodic calls to follow up on the Filter ID will receive any events since the last call.

<src>new FilterIdSubscriber(provider: JsonRpcApiProvider)

<src>filterIdSubscriber._emitResults(provider: AbstractProvider, result: Array< any >)⇒ Promise< void >

<src>filterIdSubscriber._recover(provider: AbstractProvider)⇒ Subscriber

<src>filterIdSubscriber._subscribe(provider: JsonRpcApiProvider)⇒ Promise< string >

<src>class OnBlockSubscriber

inherits fromSubscriber

<src>new OnBlockSubscriber(provider: AbstractProvider)

<src>onBlockSubscriber._poll(blockNumber: number, provider: AbstractProvider)⇒ Promise< void >

<src>interface PerformActionTransaction

inherits fromPreparedTransactionRequest

<src>class PollingBlockSubscriber

inherits fromSubscriber

<src>new PollingBlockSubscriber(provider: AbstractProvider)

<src>class PollingEventSubscriber

inherits fromSubscriber

<src>new PollingEventSubscriber(provider: AbstractProvider, filter: EventFilter)

<src>class PollingOrphanSubscriber

inherits fromOnBlockSubscriber, Subscriber

<src>new PollingOrphanSubscriber(provider: AbstractProvider, filter: OrphanFilter)

<src>class PollingTransactionSubscriber

inherits fromOnBlockSubscriber, Subscriber

<src>new PollingTransactionSubscriber(provider: AbstractProvider, hash: string)

<src>interface Subscriber

<src>subscriber.pollingInterval⇒ number

<src>subscriber.pause(dropWhilePaused?: boolean)⇒ void

<src>subscriber.resume()⇒ void

<src>subscriber.start()⇒ void

<src>subscriber.stop()⇒ void

<src>class UnmanagedSubscriber

inherits fromSubscriber

<src>unmanagedSubscriber.name⇒ string

<src>new UnmanagedSubscriber(name: string)