Documentation

Documentation »API »Providers »Subclassing Provider

Subclassing Provider

About Subclassing the Provider...

TYPES

<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" }

FUNCTIONS

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

class AbstractProvider

inherits from Provider, ContractRunner, EventEmitterable, NameResolver

PROPERTIES

<src>abstractProvider.disableCcipRead⇒ boolean

<src>abstractProvider.paused⇒ boolean

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

<src>abstractProvider.provider⇒ thisread-only

CREATING INSTANCES

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

METHODS

<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.addListener(event: ProviderEvent, listener: Listener)⇒ Promise< this >

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

<src>abstractProvider.broadcastTransaction(signedTx: string)⇒ Promise< TransactionResponse >

<src>abstractProvider.call(tx: TransactionRequest)⇒ Promise< string >

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

<src>abstractProvider.destroy()⇒ void

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

<src>abstractProvider.estimateGas(tx: TransactionRequest)⇒ Promise< bigint >

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

<src>abstractProvider.getBalance(address: AddressLike, blockTag?: BlockTag)⇒ Promise< bigint >

<src>abstractProvider.getBlock(block: BlockTag | string, prefetchTxs?: boolean)⇒ Promise< null | Block >

<src>abstractProvider.getBlockNumber()⇒ Promise< number >

<src>abstractProvider.getCode(address: AddressLike, blockTag?: BlockTag)⇒ Promise< string >

<src>abstractProvider.getFeeData()⇒ Promise< FeeData >

<src>abstractProvider.getLogs(filter: Filter | FilterByBlockHash)⇒ Promise< Array< Log > >

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

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

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

<src>abstractProvider.getStorage(address: AddressLike, position: BigNumberish, blockTag?: BlockTag)⇒ Promise< string >

<src>abstractProvider.getTransaction(hash: string)⇒ Promise< null | TransactionResponse >

<src>abstractProvider.getTransactionCount(address: AddressLike, blockTag?: BlockTag)⇒ Promise< number >

<src>abstractProvider.getTransactionReceipt(hash: string)⇒ Promise< null | TransactionReceipt >

<src>abstractProvider.getTransactionResult(hash: string)⇒ Promise< null | string >

<src>abstractProvider.listenerCount(event?: ProviderEvent)⇒ Promise< number >

<src>abstractProvider.listeners(event?: ProviderEvent)⇒ Promise< Array< Listener > >

<src>abstractProvider.lookupAddress(address: string)⇒ Promise< null | string >

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

<src>abstractProvider.on(event: ProviderEvent, listener: Listener)⇒ Promise< this >

<src>abstractProvider.once(event: ProviderEvent, listener: Listener)⇒ Promise< this >

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

<src>abstractProvider.removeAllListeners(event?: ProviderEvent)⇒ Promise< this >

<src>abstractProvider.removeListener(event: ProviderEvent, listener: Listener)⇒ Promise< this >

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

<src>abstractProvider.resume()⇒ void

<src>abstractProvider.waitForBlock(blockTag?: BlockTag)⇒ Promise< Block >

<src>abstractProvider.waitForTransaction(hash: string, confirms?: null | number, timeout?: null | number)⇒ Promise< null | TransactionReceipt >

interface AbstractProviderPlugin

PROPERTIES

<src>abstractProviderPlugin.name⇒ stringread-only

METHODS

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

class FilterIdEventSubscriber

inherits from FilterIdSubscriber, Subscriber

A FilterIdSubscriber for receiving contract events.

CREATING INSTANCES

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

METHODS

<src>filterIdEventSubscriber._emitResults(provider: JsonRpcApiProvider, results: Array< any >)⇒ Promise< void >

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

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

class FilterIdPendingSubscriber

inherits from FilterIdSubscriber, Subscriber

A FilterIdSubscriber for receiving pending transactions events.

METHODS

<src>filterIdPendingSubscriber._emitResults(provider: JsonRpcApiProvider, results: Array< any >)⇒ Promise< void >

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

class FilterIdSubscriber

inherits from Subscriber

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.

CREATING INSTANCES

<src>new FilterIdSubscriber(provider: JsonRpcApiProvider)

METHODS

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

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

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

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

<src>filterIdSubscriber.resume()⇒ void

<src>filterIdSubscriber.start()⇒ void

<src>filterIdSubscriber.stop()⇒ void

class OnBlockSubscriber

inherits from Subscriber

CREATING INSTANCES

<src>new OnBlockSubscriber(provider: AbstractProvider)

METHODS

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

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

<src>onBlockSubscriber.resume()⇒ void

<src>onBlockSubscriber.start()⇒ void

<src>onBlockSubscriber.stop()⇒ void

interface PerformActionTransaction

inherits from PreparedTransactionRequest

PROPERTIES

<src>performActionTransaction.from⇒ string

<src>performActionTransaction.to⇒ string

class PollingBlockSubscriber

inherits from Subscriber

PROPERTIES

<src>pollingBlockSubscriber.pollingInterval⇒ number

CREATING INSTANCES

<src>new PollingBlockSubscriber(provider: AbstractProvider)

METHODS

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

<src>pollingBlockSubscriber.resume()⇒ void

<src>pollingBlockSubscriber.start()⇒ void

<src>pollingBlockSubscriber.stop()⇒ void

class PollingEventSubscriber

inherits from Subscriber

CREATING INSTANCES

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

METHODS

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

<src>pollingEventSubscriber.resume()⇒ void

<src>pollingEventSubscriber.start()⇒ void

<src>pollingEventSubscriber.stop()⇒ void

class PollingOrphanSubscriber

inherits from OnBlockSubscriber, Subscriber

CREATING INSTANCES

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

METHODS

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

class PollingTransactionSubscriber

inherits from OnBlockSubscriber, Subscriber

CREATING INSTANCES

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

METHODS

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

interface Subscriber

PROPERTIES

<src>subscriber.pollingInterval⇒ number

METHODS

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

<src>subscriber.resume()⇒ void

<src>subscriber.start()⇒ void

<src>subscriber.stop()⇒ void

class UnmanagedSubscriber

inherits from Subscriber

PROPERTIES

<src>unmanagedSubscriber.name⇒ string

CREATING INSTANCES

<src>new UnmanagedSubscriber(name: string)

METHODS

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

<src>unmanagedSubscriber.resume()⇒ void

<src>unmanagedSubscriber.start()⇒ void

<src>unmanagedSubscriber.stop()⇒ void

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

class SocketBlockSubscriber

inherits from SocketSubscriber, Subscriber

CREATING INSTANCES

<src>new SocketBlockSubscriber(provider: SocketProvider)

METHODS

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

class SocketEventSubscriber

inherits from SocketSubscriber, Subscriber

PROPERTIES

<src>socketEventSubscriber.logFilter⇒ EventFilterread-only

CREATING INSTANCES

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

METHODS

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

class SocketPendingSubscriber

inherits from SocketSubscriber, Subscriber

CREATING INSTANCES

<src>new SocketPendingSubscriber(provider: SocketProvider)

METHODS

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

class SocketProvider

inherits from JsonRpcApiProvider, AbstractProvider

SocketProvider...

CREATING INSTANCES

<src>new SocketProvider(network?: Networkish)

METHODS

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

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

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

<src>socketProvider._send(payload: JsonRpcPayload | Array< JsonRpcPayload >)⇒ Promise< Array< JsonRpcResult | JsonRpcError > >

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

class SocketSubscriber

inherits from Subscriber

PROPERTIES

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

CREATING INSTANCES

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

METHODS

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

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

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

<src>socketSubscriber.resume()⇒ void

<src>socketSubscriber.start()⇒ void

<src>socketSubscriber.stop()⇒ void