Documentation

Providers

About providers.

TYPES

<src>DebugEventBrowserProvider⇒ { action: "sendEip1193Payload" , payload: { method: string , params: Array< any > } } | { action: "receiveEip1193Result" , result: any } | { action: "receiveEip1193Error" , error: Error }

<src>GasCostParameters⇒ { txAccessListAddress?: number , txAccessListStorageKey?: number , txBase?: number , txCreate?: number , txDataNonzero?: number , txDataZero?: number }

<src>OrphanFilter⇒ { hash: string , number: number , orphan: "drop-block" } | { orphan: "drop-transaction" , other?: { blockHash: string , blockNumber: number , hash: string } , tx: { blockHash: string , blockNumber: number , hash: string } } | { orphan: "reorder-transaction" , other?: { blockHash: string , blockNumber: number , hash: string } , tx: { blockHash: string , blockNumber: number , hash: string } } | { log: { address: string , blockHash: string , blockNumber: number , data: string , index: number , topics: ReadonlyArray< string > , transactionHash: string } , orphan: "drop-log" }

An Orphan Filter allows detecting when an orphan block has resulted in dropping a block or transaction or has resulted in transactions changing order.

Not currently fully supported.

<src>ProviderEvent⇒ string | Array< string | Array< string > > | EventFilter | OrphanFilter

<src>TopicFilter⇒ Array< null | string | Array< string > >

A TopicFilter provides a struture to define bloom-filter queries.

Each field that is null matches any value, a field that is a string must match exactly that value and and array is effectively an OR-ed set, where any one of those values must match.

<src>WebSocketCreator⇒ () => WebSocketLike

FUNCTIONS

<src>copyRequest(req: TransactionRequest)⇒ PreparedTransactionRequest

<src>getDefaultProvider(network: string | Networkish | WebSocketLike, options?: any)⇒ AbstractProvider

class Block

inherits from BlockParams

A Block represents the data associated with a full block on Ethereum.

PROPERTIES

<src>block.baseFeePerGas⇒ null | bigintread-only

The base fee per gas that all transactions in this block were charged.

This adjusts after each block, depending on how congested the network is.

<src>block.date⇒ null | Dateread-only

The Date this block was included at.

<src>block.difficulty⇒ bigintread-only

The difficulty target.

On legacy networks, this is the proof-of-work target required for a block to meet the protocol rules to be included.

On modern networks, this is a random number arrived at using randao. @TODO: Find links?

<src>block.extraData⇒ stringread-only

Any extra data the validator wished to include.

<src>block.gasLimit⇒ bigintread-only

The total gas limit for this block.

<src>block.gasUsed⇒ bigintread-only

The total gas used in this block.

<src>block.hash⇒ null | stringread-only

The block hash.

<src>block.length⇒ numberread-only

The number of transactions in this block.

<src>block.miner⇒ stringread-only

The miner coinbase address, wihch receives any subsidies for including this block.

<src>block.nonce⇒ stringread-only

The nonce.

On legacy networks, this is the random number inserted which permitted the difficulty target to be reached.

<src>block.number⇒ numberread-only

The block number, sometimes called the block height. This is a sequential number that is one higher than the parent block.

<src>block.parentHash⇒ stringread-only

The block hash of the parent block.

<src>block.prefetchedTransactions⇒ Array< TransactionResponse >read-only

Returns the complete transactions for blocks which prefetched them, by passing true to prefetchTxs into provider_getBlock.

<src>block.provider⇒ Providerread-only

The provider connected to the block used to fetch additional details if necessary.

<src>block.timestamp⇒ numberread-only

The timestamp for this block, which is the number of seconds since epoch that this block was included.

<src>block.transactions⇒ ReadonlyArray< string >read-only

Returns the list of transaction hashes.

CREATING INSTANCES

<src>new Block(block: BlockParams, provider: Provider)

Create a new Block object.

This should generally not be necessary as the unless implementing a low-level library.

METHODS

<src>block.getPrefetchedTransaction(indexOrHash: number | string)⇒ TransactionResponse

<src>block.getTransaction(indexOrHash: number | string)⇒ Promise< TransactionResponse >

Get the transaction at indexe within this block.

<src>block.isLondon()⇒ boolean

<src>block.isMined()⇒ boolean

Has this block been mined.

If true, the block has been typed-gaurded that all mined properties are non-null.

<src>block.orphanedEvent()⇒ OrphanFilter

<src>block.toJSON()⇒ any

Returns a JSON-friendly value.

class BrowserProvider

inherits from JsonRpcApiPollingProvider, JsonRpcApiProvider

CREATING INSTANCES

<src>new BrowserProvider(ethereum: Eip1193Provider, network?: Networkish)

METHODS

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

<src>browserProvider.getRpcError(payload: JsonRpcPayload, error: JsonRpcError)⇒ Error

<src>browserProvider.getSigner(address?: number | string)⇒ Promise< JsonRpcSigner >

<src>browserProvider.hasSigner(address: number | string)⇒ Promise< boolean >

<src>browserProvider.send(method: string, params: Array< any > | Record< string, any >)⇒ Promise< any >

interface ContractRunner

PROPERTIES

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

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

<src>contractRunner.provider⇒ null | Provider

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

<src>contractRunner.sendTransaction⇒ (tx: TransactionRequest) => Promise< TransactionResponse >

interface Eip1193Provider

METHODS

<src>eip1193Provider.request(request: { method: string , params?: Array< any > | Record< string, any > })⇒ Promise< any >

class EnsPlugin

inherits from NetworkPlugin

PROPERTIES

<src>ensPlugin.address⇒ stringread-only

<src>ensPlugin.targetNetwork⇒ numberread-only

CREATING INSTANCES

<src>new EnsPlugin(address?: null | string, targetNetwork?: null | number)

METHODS

<src>ensPlugin.clone()⇒ EnsPlugin

interface EventFilter

PROPERTIES

<src>eventFilter.address⇒ AddressLike | Array< AddressLike >

<src>eventFilter.topics⇒ TopicFilter

class FeeData

A FeeData wraps all the fee-related values associated with the network.

PROPERTIES

<src>feeData.gasPrice⇒ null | bigintread-only

The gas price for legacy networks.

<src>feeData.maxFeePerGas⇒ null | bigintread-only

The maximum fee to pay per gas.

The base fee per gas is defined by the network and based on congestion, increasing the cost during times of heavy load and lowering when less busy.

The actual fee per gas will be the base fee for the block and the priority fee, up to the max fee per gas.

This will be null on legacy networks (i.e. pre-EIP-1559)

<src>feeData.maxPriorityFeePerGas⇒ null | bigintread-only

The additional amout to pay per gas to encourage a validator to include the transaction.

The purpose of this is to compensate the validator for the adjusted risk for including a given transaction.

This will be null on legacy networks (i.e. pre-EIP-1559)

CREATING INSTANCES

<src>new FeeData(gasPrice?: null | bigint, maxFeePerGas?: null | bigint, maxPriorityFeePerGas?: null | bigint)

Creates a new FeeData for gasPrice, maxFeePerGas and maxPriorityFeePerGas.

METHODS

<src>feeData.toJSON()⇒ any

Returns a JSON-friendly value.

class FeeDataNetworkPlugin

inherits from NetworkPlugin

PROPERTIES

<src>feeDataNetworkPlugin.feeDataFunc⇒ (provider: Provider) => Promise< FeeData >read-only

CREATING INSTANCES

<src>new FeeDataNetworkPlugin(feeDataFunc: (provider: Provider) => Promise< FeeData >)

METHODS

<src>feeDataNetworkPlugin.clone()⇒ FeeDataNetworkPlugin

<src>feeDataNetworkPlugin.getFeeData(provider: Provider)⇒ Promise< FeeData >

interface Filter

inherits from EventFilter

PROPERTIES

<src>filter.fromBlock⇒ BlockTag

<src>filter.toBlock⇒ BlockTag

interface FilterByBlockHash

inherits from EventFilter

PROPERTIES

<src>filterByBlockHash.blockHash⇒ string

class GasCostPlugin

inherits from NetworkPlugin

PROPERTIES

<src>gasCostPlugin.effectiveBlock⇒ numberread-only

<src>gasCostPlugin.txAccessListAddress⇒ numberread-only

<src>gasCostPlugin.txAccessListStorageKey⇒ numberread-only

<src>gasCostPlugin.txBase⇒ numberread-only

<src>gasCostPlugin.txCreate⇒ numberread-only

<src>gasCostPlugin.txDataNonzero⇒ numberread-only

<src>gasCostPlugin.txDataZero⇒ numberread-only

CREATING INSTANCES

<src>new GasCostPlugin(effectiveBlock?: number, costs?: GasCostParameters)

METHODS

<src>gasCostPlugin.clone()⇒ GasCostPlugin

class IpcSocketProvider

inherits from SocketProvider, JsonRpcApiProvider

PROPERTIES

<src>ipcSocketProvider.socket⇒ Socketread-only

CREATING INSTANCES

<src>new IpcSocketProvider(path: string, network?: Networkish)

METHODS

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

<src>ipcSocketProvider.destroy()⇒ void

class Log

inherits from LogParams

PROPERTIES

<src>log.address⇒ stringread-only

<src>log.blockHash⇒ stringread-only

<src>log.blockNumber⇒ numberread-only

<src>log.data⇒ stringread-only

<src>log.index⇒ numberread-only

<src>log.provider⇒ Providerread-only

<src>log.removed⇒ booleanread-only

<src>log.topics⇒ ReadonlyArray< string >read-only

<src>log.transactionHash⇒ stringread-only

<src>log.transactionIndex⇒ numberread-only

CREATING INSTANCES

<src>new Log(log: LogParams, provider: Provider)

METHODS

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

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

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

<src>log.removedEvent()⇒ OrphanFilter

<src>log.toJSON()⇒ any

interface MinedBlock

inherits from Block, BlockParams

An Interface to indicate a Block has been included in the blockchain. This asserts a Type Guard that necessary properties are non-null.

Before a block is included, it is a pending block.

PROPERTIES

<src>minedBlock.date⇒ Dateread-only

<src>minedBlock.hash⇒ stringread-only

<src>minedBlock.miner⇒ stringread-only

<src>minedBlock.number⇒ numberread-only

<src>minedBlock.timestamp⇒ numberread-only

interface MinedTransactionResponse

inherits from TransactionResponse, TransactionResponseParams

PROPERTIES

<src>minedTransactionResponse.blockHash⇒ string

<src>minedTransactionResponse.blockNumber⇒ number

<src>minedTransactionResponse.date⇒ Date

class NetworkPlugin

PROPERTIES

<src>networkPlugin.name⇒ stringread-only

CREATING INSTANCES

<src>new NetworkPlugin(name: string)

METHODS

<src>networkPlugin.clone()⇒ NetworkPlugin

class NonceManager

inherits from AbstractSigner, Signer

PROPERTIES

<src>nonceManager.signer⇒ Signer

CREATING INSTANCES

<src>new NonceManager(signer: Signer)

METHODS

<src>nonceManager.connect(provider: null | Provider)⇒ NonceManager

<src>nonceManager.getAddress()⇒ Promise< string >

<src>nonceManager.getNonce(blockTag?: BlockTag)⇒ Promise< number >

<src>nonceManager.increment()⇒ void

<src>nonceManager.reset()⇒ void

<src>nonceManager.sendTransaction(tx: TransactionRequest)⇒ Promise< TransactionResponse >

<src>nonceManager.signMessage(message: string | Uint8Array)⇒ Promise< string >

<src>nonceManager.signTransaction(tx: TransactionRequest)⇒ Promise< string >

<src>nonceManager.signTypedData(domain: TypedDataDomain, types: Record< string, Array< TypedDataField > >, value: Record< string, any >)⇒ Promise< string >

interface PreparedTransactionRequest

PROPERTIES

<src>preparedTransactionRequest.accessList⇒ AccessList

<src>preparedTransactionRequest.blockTag⇒ BlockTag

<src>preparedTransactionRequest.chainId⇒ bigint

<src>preparedTransactionRequest.customData⇒ any

<src>preparedTransactionRequest.data⇒ string

<src>preparedTransactionRequest.enableCcipRead⇒ boolean

<src>preparedTransactionRequest.from⇒ AddressLike

<src>preparedTransactionRequest.gasLimit⇒ bigint

<src>preparedTransactionRequest.gasPrice⇒ bigint

<src>preparedTransactionRequest.maxFeePerGas⇒ bigint

<src>preparedTransactionRequest.maxPriorityFeePerGas⇒ bigint

<src>preparedTransactionRequest.nonce⇒ number

<src>preparedTransactionRequest.to⇒ AddressLike

<src>preparedTransactionRequest.type⇒ number

<src>preparedTransactionRequest.value⇒ bigint

interface Provider

inherits from ContractRunner, EventEmitterable, NameResolver

A Provider is the primary method to interact with the read-only content on Ethereum.

It allows access to details about accounts, blocks and transactions and the ability to query event logs and simulate contract execution.

Account data includes the balance, transaction count, code and state trie storage.

Simulating execution can be used to call, estimate gas and get transaction results.

The broadcastTransaction is the only method which allows updating the blockchain, but it is usually accessed by a Signer, since a private key must be used to sign the transaction before it can be broadcast.

PROPERTIES

<src>provider.provider⇒ this

The provider iteself.

This is part of the necessary API for executing a contract, as it provides a common property on any ContractRunner that can be used to access the read-only portion of the runner.

METHODS

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

Broadcasts the signedTx to the network, adding it to the memory pool of any node for which the transaction meets the rebroadcast requirements.

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

Simulate the execution of tx. If the call reverts, it will throw a CallExceptionError which includes the revert data.

<src>provider.destroy()⇒ void

Shutdown any resources this provider is using. No additional calls should be made to this provider after calling this.

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

Estimates the amount of gas required to executre tx.

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

Get the account balance (in wei) of address. If blockTag is specified and the node supports archive access for that blockTag, the balance is as of that BlockTag.

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

Resolves to the block for blockHashOrBlockTag.

If prefetchTxs, and the backend supports including transactions with block requests, all transactions will be included and the Block object will not need to make remote calls for getting transactions.

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

Get the current block number.

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

Get the bytecode for address.

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

Get the best guess at the recommended FeeData.

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

Resolves to the list of Logs that match filter

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

Get the connected Network.

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

Get the storage slot value for address at slot position.

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

Resolves to the transaction for hash.

If the transaction is unknown or on pruning nodes which discard old transactions this resolves to null.

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

Get the number of transactions ever sent for address, which is used as the nonce when sending a transaction. If blockTag is specified and the node supports archive access for that blockTag, the transaction count is as of that BlockTag.

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

Resolves to the transaction receipt for hash, if mined.

If the transaction has not been mined, is unknown or on pruning nodes which discard old transactions this resolves to null.

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

Resolves to the result returned by the executions of hash.

This is only supported on nodes with archive access and with the necessary debug APIs enabled.

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

Resolves to the ENS name associated for the address or null if the primary name is not configured.

Users must perform additional steps to configure a primary name, which is not currently common.

<src>provider.resolveName(ensName: string)⇒ Promise< null | string >

Resolves to the address configured for the ensName or null if unconfigured.

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

Resolves to the block at blockTag once it has been mined.

This can be useful for waiting some number of blocks by using the currentBlockNumber + N.

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

Waits until the transaction hash is mined and has confirms confirmations.

interface Signer

inherits from Addressable, ContractRunner, NameResolver

A Signer represents an account on the Ethereum Blockchain, and is most often backed by a private key represented by a mnemonic or residing on a Hardware Wallet.

The API remains abstract though, so that it can deal with more advanced exotic Signing entities, such as Smart Contract Wallets or Virtual Wallets (where the private key may not be known).

PROPERTIES

<src>signer.provider⇒ null | Provider

The Provider attached to this Signer (if any).

METHODS

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

Evaluates the tx by running it against the current Blockchain state. This cannot change state and has no cost in ether, as it is effectively simulating execution.

This can be used to have the Blockchain perform computations based on its state (e.g. running a Contract's getters) or to simulate the effect of a transaction before actually performing an operation.

<src>signer.connect(provider: null | Provider)⇒ Signer

Returns a new instance of this Signer connected to provider or detached from any Provider if null.

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

Estimates the required gas required to execute tx on the Blockchain. This will be the expected amount a transaction will require as its gasLimit to successfully run all the necessary computations and store the needed state that the transaction intends.

Keep in mind that this is best efforts, since the state of the Blockchain is in flux, which could affect transaction gas requirements.

<src>signer.getAddress()⇒ Promise< string >

Get the address of the Signer.

<src>signer.getNonce(blockTag?: BlockTag)⇒ Promise< number >

Gets the next nonce required for this Signer to send a transaction.

<src>signer.populateCall(tx: TransactionRequest)⇒ Promise< TransactionLike < string > >

Prepares a {@link TransactionRequest} for calling:

resolves to and from addresses
if from is specified , check that it matches this Signer

<src>signer.populateTransaction(tx: TransactionRequest)⇒ Promise< TransactionLike < string > >

Prepares a {@link TransactionRequest} for sending to the network by populating any missing properties:

resolves to and from addresses
if from is specified , check that it matches this Signer
populates nonce via signer.getNonce("pending")
populates gasLimit via signer.estimateGas(tx)
populates chainId via signer.provider.getNetwork()
populates type and relevant fee data for that type (gasPrice for legacy transactions, maxFeePerGas for EIP-1559, etc)

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

Resolves an ENS Name to an address.

<src>signer.sendTransaction(tx: TransactionRequest)⇒ Promise< TransactionResponse >

Sends tx to the Network. The signer.populateTransaction(tx) is called first to ensure all necessary properties for the transaction to be valid have been popualted first.

<src>signer.signMessage(message: string | Uint8Array)⇒ Promise< string >

Signers an EIP-191 prefixed personal message.

If the message is a string, it is signed as UTF-8 encoded bytes. It is not interpretted as a BytesLike; so the string "0x1234" is signed as six characters, not two bytes.

To sign that example as two bytes, the Uint8Array should be used (i.e. new Uint8Array([ 0x12, 0x34 ])).

<src>signer.signTransaction(tx: TransactionRequest)⇒ Promise< string >

Signs tx, returning the fully signed transaction. This does not populate any additional properties within the transaction.

<src>signer.signTypedData(domain: TypedDataDomain, types: Record< string, Array< TypedDataField > >, value: Record< string, any >)⇒ Promise< string >

Signs the EIP-712 typed data.

class TransactionReceipt

inherits from TransactionReceiptParams

PROPERTIES

<src>transactionReceipt.blockHash⇒ stringread-only

<src>transactionReceipt.blockNumber⇒ numberread-only

<src>transactionReceipt.contractAddress⇒ null | stringread-only

<src>transactionReceipt.cumulativeGasUsed⇒ bigintread-only

<src>transactionReceipt.fee⇒ bigintread-only

<src>transactionReceipt.from⇒ stringread-only

<src>transactionReceipt.gasPrice⇒ bigintread-only

<src>transactionReceipt.gasUsed⇒ bigintread-only

<src>transactionReceipt.hash⇒ stringread-only

<src>transactionReceipt.index⇒ numberread-only

<src>transactionReceipt.length⇒ numberread-only

<src>transactionReceipt.logs⇒ ReadonlyArray< Log >read-only

<src>transactionReceipt.logsBloom⇒ stringread-only

<src>transactionReceipt.provider⇒ Providerread-only

<src>transactionReceipt.root⇒ null | stringread-only

<src>transactionReceipt.status⇒ null | numberread-only

<src>transactionReceipt.to⇒ null | stringread-only

<src>transactionReceipt.type⇒ numberread-only

CREATING INSTANCES

<src>new TransactionReceipt(tx: TransactionReceiptParams, provider: Provider)

METHODS

<src>transactionReceipt.confirmations()⇒ Promise< number >

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

<src>transactionReceipt.getResult()⇒ Promise< string >

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

<src>transactionReceipt.removedEvent()⇒ OrphanFilter

<src>transactionReceipt.reorderedEvent(other?: TransactionResponse)⇒ OrphanFilter

<src>transactionReceipt.toJSON()⇒ any

interface TransactionRequest

PROPERTIES

<src>transactionRequest.accessList⇒ null | AccessListish

<src>transactionRequest.blockTag⇒ BlockTag

<src>transactionRequest.chainId⇒ null | BigNumberish

<src>transactionRequest.customData⇒ any

<src>transactionRequest.data⇒ null | string

<src>transactionRequest.enableCcipRead⇒ boolean

<src>transactionRequest.from⇒ null | AddressLike

<src>transactionRequest.gasLimit⇒ null | BigNumberish

<src>transactionRequest.gasPrice⇒ null | BigNumberish

<src>transactionRequest.maxFeePerGas⇒ null | BigNumberish

<src>transactionRequest.maxPriorityFeePerGas⇒ null | BigNumberish

<src>transactionRequest.nonce⇒ null | number

<src>transactionRequest.to⇒ null | AddressLike

<src>transactionRequest.type⇒ null | number

<src>transactionRequest.value⇒ null | BigNumberish

class TransactionResponse

inherits from TransactionResponseParams

PROPERTIES

<src>transactionResponse.accessList⇒ null | AccessListread-only

The EIP-2930 access list for transaction types that support it, otherwise null.

<src>transactionResponse.blockHash⇒ null | stringread-only

The blockHash of the block that this transaction was included in.

This is null for pending transactions.

<src>transactionResponse.blockNumber⇒ null | numberread-only

The block number of the block that this transaction was included in.

This is null for pending transactions.

<src>transactionResponse.chainId⇒ bigintread-only

The chain ID.

<src>transactionResponse.data⇒ stringread-only

The data.

<src>transactionResponse.from⇒ stringread-only

The sender of this transaction. It is implicitly computed from the transaction pre-image hash (as the digest) and the signature using ecrecover.

<src>transactionResponse.gasLimit⇒ bigintread-only

The maximum units of gas this transaction can consume. If execution exceeds this, the entries transaction is reverted and the sender is charged for the full amount, despite not state changes being made.

<src>transactionResponse.gasPrice⇒ bigintread-only

The gas price can have various values, depending on the network.

In modern networks, for transactions that are included this is the effective gas price (the fee per gas that was actually charged), while for transactions that have not been included yet is the maxFeePerGas.

For legacy transactions, or transactions on legacy networks, this is the fee that will be charged per unit of gas the transaction consumes.

<src>transactionResponse.hash⇒ stringread-only

The transaction hash.

<src>transactionResponse.index⇒ numberread-only

The index within the block that this transaction resides at.

<src>transactionResponse.maxFeePerGas⇒ null | bigintread-only

The maximum fee (per unit of gas) to allow this transaction to charge the sender.

<src>transactionResponse.maxPriorityFeePerGas⇒ null | bigintread-only

The maximum priority fee (per unit of gas) to allow a validator to charge the sender. This is inclusive of the maxFeeFeePerGas.

<src>transactionResponse.nonce⇒ numberread-only

The nonce, which is used to prevent replay attacks and offer a method to ensure transactions from a given sender are explicitly ordered.

When sending a transaction, this must be equal to the number of transactions ever sent by from.

<src>transactionResponse.provider⇒ Providerread-only

The provider this is connected to, which will influence how its methods will resolve its async inspection methods.

<src>transactionResponse.signature⇒ Signatureread-only

The signature.

<src>transactionResponse.to⇒ null | stringread-only

The receiver of this transaction.

If null, then the transaction is an initcode transaction. This means the result of executing the data will be deployed as a new contract on chain (assuming it does not revert) and the address may be computed using getCreateAddress.

<src>transactionResponse.type⇒ numberread-only

The EIP-2718 transaction envelope type. This is 0 for legacy transactions types.

<src>transactionResponse.value⇒ bigintread-only

The value, in wei. Use formatEther to format this value as ether.

CREATING INSTANCES

<src>new TransactionResponse(tx: TransactionResponseParams, provider: Provider)

Create a new TransactionResponse with tx parameters connected to provider.

METHODS

<src>transactionResponse.getBlock()⇒ Promise< null | Block >

Resolves to the Block that this transaction was included in.

This will return null if the transaction has not been included yet.

<src>transactionResponse.getTransaction()⇒ Promise< null | TransactionResponse >

Resolves to this transaction being re-requested from the provider. This can be used if you have an unmined transaction and wish to get an up-to-date populated instance.

<src>transactionResponse.isBerlin()⇒ boolean

Returns true if the transaction is a Berlin (i.e. type == 1) transaction. See EIP-2930.

This provides a Type Guard that this transaction will have the null-ness for hardfork-specific properties set correctly.

<src>transactionResponse.isLegacy()⇒ boolean

Returns true if the transaction is a legacy (i.e. type == 0) transaction.

This provides a Type Guard that this transaction will have the null-ness for hardfork-specific properties set correctly.

<src>transactionResponse.isLondon()⇒ boolean

Returns true if the transaction is a London (i.e. type == 2) transaction. See EIP-1559.

This provides a Type Guard that this transaction will have the null-ness for hardfork-specific properties set correctly.

<src>transactionResponse.isMined()⇒ boolean

Returns true if this transaction has been included.

This is effective only as of the time the TransactionResponse was instantiated. To get up-to-date information, use getTransaction.

This provides a Type Guard that this transaction will have non-null property values for properties that are null for unmined transactions.

<src>transactionResponse.removedEvent()⇒ OrphanFilter

Returns a filter which can be used to listen for orphan events that evict this transaction.

<src>transactionResponse.reorderedEvent(other?: TransactionResponse)⇒ OrphanFilter

Returns a filter which can be used to listen for orphan events that re-order this event against other.

<src>transactionResponse.replaceableTransaction(startBlock: number)⇒ TransactionResponse

Returns a new TransactionResponse instance which has the ability to detect (and throw an error) if the transaction is replaced, which will begin scanning at startBlock.

This should generally not be used by developers and is intended primarily for internal use. Setting an incorrect startBlock can have devastating performance consequences if used incorrectly.

<src>transactionResponse.toJSON()⇒ any

Returns a JSON representation of this transaction.

<src>transactionResponse.wait(confirms?: number, timeout?: number)⇒ Promise< null | TransactionReceipt >

Resolves once this transaction has been mined and has confirms blocks including it (default: 1) with an optional timeout.

This can resolve to null only if confirms is 0 and the transaction has not been mined, otherwise this will wait until enough confirmations have completed.

interface WebSocketLike

PROPERTIES

<src>webSocketLike.onerror⇒ null | PAREN<(args: Array< any >) => any>

<src>webSocketLike.onmessage⇒ null | PAREN<(args: Array< any >) => any>

<src>webSocketLike.onopen⇒ null | PAREN<(args: Array< any >) => any>

<src>webSocketLike.readyState⇒ number

METHODS

<src>webSocketLike.close(code?: number, reason?: string)⇒ void

<src>webSocketLike.send(payload: any)⇒ void

class WebSocketProvider

inherits from SocketProvider, JsonRpcApiProvider

PROPERTIES

<src>webSocketProvider.websocket⇒ WebSocketLikeread-only

CREATING INSTANCES

<src>new WebSocketProvider(url: string | WebSocketLike | WebSocketCreator, network?: Networkish)

METHODS

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

<src>webSocketProvider.destroy()⇒ Promise< void >

Networks

About networks

TYPES

<src>Networkish⇒ Network | number | bigint | string | { chainId?: number , ensAddress?: string , ensNetwork?: number , name?: string }

A Networkish can be used to allude to a Network, by specifing:

a Network object
a well-known (or registered) network name
a well-known (or registered) chain ID
an object with sufficient details to describe a network

class Network

PROPERTIES

<src>network.chainId⇒ bigint

<src>network.name⇒ string

<src>network.plugins⇒ Array< NetworkPlugin >read-only

CREATING INSTANCES

<src>new Network(name: string, chainId: BigNumberish)

<src>Network.from(network?: Networkish)⇒ Network

Returns a new Network for the network name or chainId.

METHODS

<src>network.attachPlugin(plugin: NetworkPlugin)⇒ this

<src>network.clone()⇒ Network

<src>network.computeIntrinsicGas(tx: TransactionLike)⇒ number

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

<src>network.getPlugins(basename: string)⇒ Array< T >

<src>network.toJSON()⇒ any

STATIC METHODS

<src>Network.register(nameOrChainId: string | number | bigint, networkFunc: () => Network)⇒ void