eth
Index
References
Namespaces
Classes
Interfaces
Type Aliases
Variables
Functions
- call
- createAccessList
- detectTransactionType
- estimateGas
- formatTransaction
- getBalance
- getBlock
- getBlockNumber
- getBlockTransactionCount
- getBlockUncleCount
- getChainId
- getCode
- getCoinbase
- getFeeHistory
- getGasPrice
- getHashRate
- getLogs
- getPendingTransactions
- getProof
- getProtocolVersion
- getStorageAt
- getTransaction
- getTransactionCount
- getTransactionFromBlock
- getTransactionReceipt
- getUncle
- isAccessList
- isAccessListEntry
- isBaseTransaction
- isMining
- isSyncing
- isTransaction1559Unsigned
- isTransaction2930Unsigned
- isTransactionCall
- isTransactionLegacyUnsigned
- isTransactionWithSender
- prepareTransactionForSigning
- sendSignedTransaction
- sendTransaction
- sign
- signTransaction
- transactionBuilder
- validateBaseChain
- validateChainInfo
- validateCustomChainInfo
- validateFeeMarketGas
- validateGas
- validateHardfork
- validateLegacyGas
- validateTransactionCall
- validateTransactionForSigning
- validateTransactionWithSender
References
Web3Eth
Namespaces
abi
decodeContractErrorData
Parameters
errorsAbi: AbiErrorFragment[]
error: Eip838ExecutionError
Returns void
decodeLog
Type parameters
- ReturnType_1: DecodedParams<ReturnType_1>
Parameters
inputs: AbiParameter[]
A AbiParameter input array. See the Solidity documentation for a list of types.
data: string
The ABI byte code in the
datafield of a log.topics: string | string[]
An array with the index parameter topics of the log, without the topic[0] if its a non-anonymous event, otherwise with topic[0]
Returns ReturnType_1
- The result object containing the decoded parameters.
decodeParameter
Decodes an ABI encoded parameter to its JavaScript type.
Parameters
abi: AbiInput
The type of the parameter. See the Solidity documentation for a list of types.
bytes: string
The ABI byte code to decode
Returns unknown
- The decoded parameter
decodeParameters
Decodes ABI encoded parameters to its JavaScript types.
Parameters
abi: AbiInput[]
An array of AbiInput. See the Solidity documentation for a list of types.
bytes: string
The ABI byte code to decode
Returns { __length__: number }
- The result object containing the decoded parameters.
[key string]: unknown
__length__: number
decodeParametersWith
Should be used to decode list of params
Parameters
abis: AbiInput[]
bytes: string
loose: boolean
Returns { __length__: number }
[key string]: unknown
__length__: number
encodeErrorSignature
Encodes the error name to its ABI signature, which are the sha3 hash of the error name including input types.
Parameters
functionName: string | AbiErrorFragment
Returns string
encodeEventSignature
Encodes the event name to its ABI signature, which are the sha3 hash of the event name including input types.
Parameters
functionName: string | AbiEventFragment
The event name to encode, or the AbiEventFragment object of the event. If string, it has to be in the form of
eventName(param1Type,param2Type,...). eg: myEvent(uint256,bytes32).
Returns string
- The ABI signature of the event.
encodeFunctionCall
Encodes a function call using its
JSON interfaceobject and given parameters.Parameters
jsonInterface: AbiFunctionFragment
The
JSON interfaceobject of the function.params: unknown[]
The parameters to encode
Returns string
- The ABI encoded function call, which, means the function signature and the parameters passed.
encodeFunctionSignature
Encodes the function name to its ABI representation, which are the first 4 bytes of the sha3 of the function name including types.
Parameters
functionName: string | AbiFunctionFragment
The function name to encode or the
JSON interfaceobject of the function. If the passed parameter is a string, it has to be in the form offunctionName(param1Type,param2Type,...). eg: myFunction(uint256,uint32[],bytes10,bytes)
Returns string
- The ABI signature of the function.
encodeParameter
Encodes a parameter based on its type to its ABI representation.
Parameters
abi: AbiInput
The type of the parameter. See the Solidity documentation for a list of types.
param: unknown
The actual parameter to encode.
Returns string
- The ABI encoded parameter
encodeParameters
Encodes a parameter based on its type to its ABI representation.
Parameters
abi: readonly AbiInput[]
An array of AbiInput. See Solidity’s documentation for more details.
params: unknown[]
The actual parameters to encode.
Returns string
- The ABI encoded parameters
flattenTypes
used to flatten json abi inputs/outputs into an array of type-representing-strings
Parameters
includeTuple: boolean
puts: readonly AbiParameter[]
Returns string[]
formatOddHexstrings
format odd-length bytes to even-length
Parameters
param: string
Returns string
formatParam
Handle some formatting of params for backwards compatibility with Ethers V4
Parameters
type: string
_param: unknown
Returns unknown
isAbiConstructorFragment
Parameters
item: unknown
Returns item is AbiConstructorFragment
isAbiErrorFragment
Parameters
item: unknown
Returns item is AbiEventFragment
isAbiEventFragment
Parameters
item: unknown
Returns item is AbiEventFragment
isAbiFragment
Parameters
item: unknown
Returns item is AbiFragment
isAbiFunctionFragment
Parameters
item: unknown
Returns item is AbiFunctionFragment
isOddHexstring
returns true if input is a hexstring and is odd-lengthed
Parameters
param: unknown
Returns boolean
isSimplifiedStructFormat
Check if type is simplified struct format
Parameters
type: Partial<AbiParameter> | Partial<AbiInput>
Returns type is Omit<AbiParameter, name | components>
jsonInterfaceMethodToString
Should be used to create full function/event name from json abi returns a string
Parameters
json: AbiFragment
Returns string
mapStructNameAndType
Maps the correct tuple type and name when the simplified format in encode/decodeParameter is used
Parameters
structName: string
Returns AbiStruct
mapStructToCoderFormat
Maps the simplified format in to the expected format of the ABICoder
Parameters
struct: AbiStruct
Returns AbiCoderStruct[]
mapTypes
Map types if simplified format is used
Parameters
types: AbiInput[]
Returns (string | Record<string, unknown> | AbiParameter)[]
modifyParams
Parameters
coder: Coder
param: unknown[]
Returns unknown
accounts
Capability
Can be used in conjunction with Transaction.supports to query on tx capabilities
EIP1559FeeMarket
Tx supports EIP-1559 gas fee market mechanism See: 1559 Fee Market EIP
EIP155ReplayProtection
Tx supports EIP-155 replay protection See: 155 Replay Attack Protection EIP
EIP2718TypedTransaction
Tx is a typed transaction as defined in EIP-2718 See: 2718 Transaction Type EIP
EIP2930AccessLists
Tx supports access list generation as defined in EIP-2930 See: 2930 Access Lists EIP
Chain
Goerli
Mainnet
Sepolia
ConsensusAlgorithm
Casper
Clique
Ethash
ConsensusType
ProofOfAuthority
ProofOfStake
ProofOfWork
CustomChain
ArbitrumOne
Arbitrum One - mainnet for Arbitrum roll-up
ArbitrumRinkebyTestnet
Arbitrum Rinkeby Testnet
OptimisticEthereum
Optimistic Ethereum - mainnet for Optimism roll-up
OptimisticKovan
Optimistic Kovan - testnet for Optimism roll-up
PolygonMainnet
Polygon (Matic) Mainnet
PolygonMumbai
Polygon (Matic) Mumbai Testnet
xDaiChain
xDai EVM sidechain with a native stable token
Hardfork
ArrowGlacier
Berlin
Byzantium
Chainstart
Constantinople
Dao
GrayGlacier
Homestead
Istanbul
London
Merge
MergeForkIdTransition
MuirGlacier
Petersburg
Shanghai
ShardingForkDev
SpuriousDragon
TangerineWhistle
TypeOutput
Type output options
BigInt
Buffer
Number
PrefixedHexString
AccessListEIP2930Transaction
Typed transaction with optional access lists
- TransactionType: 1
- EIP: EIP-2930
constructor
This constructor takes the values, validates them, assigns them and freezes the object.
It is not recommended to use this constructor directly. Instead use the static factory methods to assist in creating a Transaction object from varying data types.
Parameters
txData: AccessListEIP2930TxData
optionalopts: TxOptions
Returns AccessListEIP2930Transaction
readonlyAccessListJSON
readonlyaccessList
readonlychainId
readonlycommon
readonlydata
readonlygasLimit
readonlygasPrice
readonlynonce
optionalreadonlyr
optionalreadonlys
optionalreadonlyto
optionalreadonlyv
readonlyvalue
type
Returns the transaction type.
Note: legacy txs will return tx type
0.Returns number
_processSignature
Parameters
v: bigint
r: Buffer
s: Buffer
Returns AccessListEIP2930Transaction
errorStr
Return a compact error string representation of the object
Returns string
getBaseFee
The minimum amount of gas the tx must have (DataFee + TxFee + Creation Fee)
Returns bigint
getDataFee
The amount of gas paid for the data in this tx
Returns bigint
getMessageToSign
Returns the serialized unsigned tx (hashed or raw), which can be used to sign the transaction (e.g. for sending to a hardware wallet).
Note: in contrast to the legacy tx the raw message format is already serialized and doesn’t need to be RLP encoded any more.
const serializedMessage = tx.getMessageToSign(false) // use this for the HW wallet inputParameters
optionalhashMessage: boolean
Return hashed message if set to true (default: true)
Returns Buffer
getMessageToVerifySignature
Computes a sha3-256 hash which can be used to verify the signature
Returns Buffer
getSenderAddress
Returns the sender’s address
Returns Address
getSenderPublicKey
Returns the public key of the sender
Returns Buffer
getUpfrontCost
The up front amount that an account must have for this transaction to be valid
Returns bigint
hash
Computes a sha3-256 hash of the serialized tx.
This method can only be used for signed txs (it throws otherwise). Use AccessListEIP2930Transaction.getMessageToSign to get a tx hash for the purpose of signing.
Returns Buffer
isSigned
Returns boolean
raw
Returns a Buffer Array of the raw Buffers of the EIP-2930 transaction, in order.
Format:
[chainId, nonce, gasPrice, gasLimit, to, value, data, accessList,
signatureYParity (v), signatureR (r), signatureS (s)]Use AccessListEIP2930Transaction.serialize to add a transaction to a block with Block.fromValuesArray.
For an unsigned tx this method uses the empty Buffer values for the signature parameters
v,randsfor encoding. For an EIP-155 compliant representation for external signing use AccessListEIP2930Transaction.getMessageToSign.Returns AccessListEIP2930ValuesArray
serialize
Returns the serialized encoding of the EIP-2930 transaction.
Format:
0x01 || rlp([chainId, nonce, gasPrice, gasLimit, to, value, data, accessList,
signatureYParity (v), signatureR (r), signatureS (s)])Note that in contrast to the legacy tx serialization format this is not valid RLP any more due to the raw tx type preceding and concatenated to the RLP encoding of the values.
Returns Buffer
sign
Signs a transaction.
Note that the signed tx is returned as a new object, use as follows:
const signedTx = tx.sign(privateKey)Parameters
privateKey: Buffer
Returns AccessListEIP2930Transaction
supports
Checks if a tx type defining capability is active on a tx, for example the EIP-1559 fee market mechanism or the EIP-2930 access list feature.
Note that this is different from the tx type itself, so EIP-2930 access lists can very well be active on an EIP-1559 tx for example.
This method can be useful for feature checks if the tx type is unknown (e.g. when instantiated with the tx factory).
See
Capabilitesin thetypesmodule for a reference on all supported capabilities.Parameters
capability: Capability
Returns boolean
toCreationAddress
If the tx’s
tois to the creation addressReturns boolean
toJSON
Returns an object with the JSON representation of the transaction
Returns JsonTx
validate
Checks if the transaction has the minimum amount of gas required (DataFee + TxFee + Creation Fee).
Returns boolean
verifySignature
Determines if the signature is valid
Returns boolean
staticfromSerializedTx
Instantiate a transaction from the serialized tx.
Format:
0x01 || rlp([chainId, nonce, gasPrice, gasLimit, to, value, data, accessList,
signatureYParity (v), signatureR (r), signatureS (s)])Parameters
serialized: Buffer
optionalopts: TxOptions
Returns AccessListEIP2930Transaction
staticfromTxData
Instantiate a transaction from a data dictionary.
Format: { chainId, nonce, gasPrice, gasLimit, to, value, data, accessList, v, r, s }
Notes:
chainIdwill be set automatically if not provided- All parameters are optional and have some basic default values
Parameters
txData: AccessListEIP2930TxData
optionalopts: TxOptions
Returns AccessListEIP2930Transaction
staticfromValuesArray
Create a transaction from a values array.
Format:
[chainId, nonce, gasPrice, gasLimit, to, value, data, accessList,
signatureYParity (v), signatureR (r), signatureS (s)]Parameters
values: AccessListEIP2930ValuesArray
optionalopts: TxOptions
Returns AccessListEIP2930Transaction
Common
Common class to access chain and hardfork parameters and to provide a unified and shared view on the network and hardfork state.
Use the Common.custom static constructor for creating simple custom chain Common objects (more complete custom chain setups can be created via the main constructor and the CommonOpts.customChains parameter).
constructor
Parameters
opts: CommonOpts
Returns Common
readonlyDEFAULT_HARDFORK
_calcForkHash
Internal helper function to calculate a fork hash
Parameters
hardfork: string
Hardfork name
genesisHash: Buffer
Genesis block hash of the chain
Returns string
Fork hash as hex string
_getHardfork
Internal helper function, returns the params for the given hardfork for the chain set
Parameters
hardfork: string
Hardfork name
Returns null | HardforkConfig
Dictionary with hardfork params or null if hardfork not on chain
activeOnBlock
Alias to hardforkIsActiveOnBlock when hardfork is set
Parameters
blockNumber: Numbers
Returns boolean
True if HF is active on block number
bootstrapNodes
Returns bootstrap nodes for the current chain
Returns undefined | BootstrapNodeConfig[]
Dict with bootstrap nodes
chainId
Returns the Id of current chain
Returns bigint
chain Id
chainName
Returns the name of current chain
Returns string
chain name (lower case)
consensusAlgorithm
Returns the concrete consensus implementation algorithm or protocol for the network e.g. “ethash” for “pow” consensus type, “clique” for “poa” consensus type or “casper” for “pos” consensus type.
Note: This value can update along a Hardfork.
Returns string
consensusConfig
Returns a dictionary with consensus configuration parameters based on the consensus algorithm
Expected returns (parameters must be present in the respective chain json files):
ethash: empty object clique: period, epoch casper: empty object
Note: This value can update along a Hardfork.
Returns {}
[key string]: CliqueConfig | EthashConfig | CasperConfig
consensusType
Returns the consensus type of the network Possible values: “pow”|”poa”|”pos”
Note: This value can update along a Hardfork.
Returns string
copy
Returns a deep copy of this Common instance.
Returns Common
dnsNetworks
Returns DNS networks for the current chain
Returns string[]
Array of DNS ENR urls
eipBlock
Returns the hardfork change block for eip
Parameters
eip: number
EIP number
Returns null | bigint
Block number or null if unscheduled
eips
Returns the active EIPs
Returns number[]
List of EIPs
forkHash
Returns an eth/64 compliant fork hash (EIP-2124)
Parameters
optional_hardfork: string
optionalgenesisHash: Buffer
Genesis block hash of the chain, optional if already defined and not needed to be calculated
Returns string
genesis
Returns the Genesis parameters of the current chain
Returns GenesisBlockConfig
Genesis dictionary
getHardforkByBlockNumber
Returns the hardfork based on the block number or an optional total difficulty (Merge HF) provided.
An optional TD takes precedence in case the corresponding HF block is set to
nullor otherwise needs to match (if not an error will be thrown).Parameters
Returns string
The name of the HF
gteHardfork
Alias to hardforkGteHardfork when hardfork is set
Parameters
hardfork: string
Hardfork name
Returns boolean
True if hardfork set is greater than hardfork provided
hardfork
Returns the hardfork set
Returns string
Hardfork name
hardforkBlock
Returns the hardfork change block for hardfork provided or set
Parameters
optional_hardfork: string
Returns null | bigint
Block number or null if unscheduled
hardforkForForkHash
Parameters
forkHash: string
Fork hash as a hex string
Returns null | HardforkConfig
Array with hardfork data (name, block, forkHash)
hardforkGteHardfork
Sequence based check if given or set HF1 is greater than or equal HF2
Parameters
_hardfork1: null | string
hardfork2: string
Hardfork name
Returns boolean
True if HF1 gte HF2
hardforkIsActiveOnBlock
Checks if set or provided hardfork is active on block number
Parameters
_hardfork: null | string
_blockNumber: Numbers
Returns boolean
True if HF is active on block number
hardforkTTD
Returns the hardfork change total difficulty (Merge HF) for hardfork provided or set
Parameters
optional_hardfork: string
Returns null | bigint
Total difficulty or null if no set
hardforkTimestamp
Parameters
optional_hardfork: string
Returns null | bigint
hardforks
Returns the hardforks for current chain
Returns HardforkConfig[]
Array with arrays of hardforks
isActivatedEIP
Checks if an EIP is activated by either being included in the EIPs manually passed in with the CommonOpts.eips or in a hardfork currently being active
Note: this method only works for EIPs being supported by the CommonOpts.eips constructor option
Parameters
eip: number
Returns boolean
isHardforkBlock
True if block number provided is the hardfork (given or set) change block
Parameters
_blockNumber: Numbers
optional_hardfork: string
Returns boolean
True if blockNumber is HF block
isNextHardforkBlock
True if block number provided is the hardfork change block following the hardfork given or set
Parameters
_blockNumber: Numbers
optional_hardfork: string
Returns boolean
True if blockNumber is HF block
networkId
Returns the Id of current network
Returns bigint
network Id
nextHardforkBlock
Returns the change block for the next hardfork after the hardfork provided or set
Parameters
optional_hardfork: string
Returns null | bigint
Block number or null if not available
nextHardforkBlockOrTimestamp
Returns the change block for the next hardfork after the hardfork provided or set
Parameters
optional_hardfork: string
Returns null | bigint
Block timestamp, number or null if not available
param
Returns a parameter for the current chain setup
If the parameter is present in an EIP, the EIP always takes precedence. Otherwise the parameter if taken from the latest applied HF with a change on the respective parameter.
Parameters
topic: string
Parameter topic (‘gasConfig’, ‘gasPrices’, ‘vm’, ‘pow’)
name: string
Parameter name (e.g. ‘minGasLimit’ for ‘gasConfig’ topic)
Returns bigint
The value requested or
BigInt(0)if not found
paramByBlock
Returns a parameter for the hardfork active on block number or optional provided total difficulty (Merge HF)
Parameters
topic: string
Parameter topic
name: string
Parameter name
blockNumber: Numbers
Block number
optionaltd: Numbers
Total difficulty
- @returns The value requested or
BigInt(0)if not found
- @returns The value requested or
optionaltimestamp: Numbers
Returns bigint
paramByEIP
Returns a parameter corresponding to an EIP
Parameters
topic: string
Parameter topic (‘gasConfig’, ‘gasPrices’, ‘vm’, ‘pow’)
name: string
Parameter name (e.g. ‘minGasLimit’ for ‘gasConfig’ topic)
eip: number
Number of the EIP
Returns undefined | bigint
The value requested or
undefinedif not found
paramByHardfork
Returns the parameter corresponding to a hardfork
Parameters
topic: string
Parameter topic (‘gasConfig’, ‘gasPrices’, ‘vm’, ‘pow’)
name: string
Parameter name (e.g. ‘minGasLimit’ for ‘gasConfig’ topic)
hardfork: string
Hardfork name
Returns bigint
The value requested or
BigInt(0)if not found
setChain
Sets the chain
Parameters
chain: string | number | bigint | object
String (‘mainnet’) or Number (1) chain representation. Or, a Dictionary of chain parameters for a private network.
Returns ChainConfig
The dictionary with parameters set as chain
setEIPs
Sets the active EIPs
Parameters
optionaleips: number[]
Returns void
setForkHashes
Sets any missing forkHashes on the passed-in Common instance
Parameters
genesisHash: Buffer
The genesis block hash
Returns void
setHardfork
Sets the hardfork to get params for
Parameters
hardfork: string
String identifier (e.g. ‘byzantium’) or Hardfork enum
Returns void
setHardforkByBlockNumber
Sets a new hardfork based on the block number or an optional total difficulty (Merge HF) provided.
An optional TD takes precedence in case the corresponding HF block is set to
nullor otherwise needs to match (if not an error will be thrown).Parameters
Returns string
The name of the HF set
static_getInitializedChains
Parameters
optionalcustomChains: ChainConfig[]
Returns ChainsConfig
staticcustom
Creates a Common object for a custom chain, based on a standard one.
It uses all the Chain parameters from the baseChain option except the ones overridden in a provided chainParamsOrName dictionary. Some usage example:
Common.custom({chainId: 123})There are also selected supported custom chains which can be initialized by using one of the CustomChains for chainParamsOrName, e.g.:
Common.custom(CustomChains.MaticMumbai)Note that these supported custom chains only provide some base parameters (usually the chain and network ID and a name) and can only be used for selected use cases (e.g. sending a tx with the
web3-utils/txlibrary to a Layer-2 chain).Parameters
chainParamsOrName: Partial<ChainConfig> | CustomChain
Custom parameter dict (
namewill default tocustom-chain) or string with name of a supported custom chainoptionalopts: CustomCommonOpts
Custom chain options to set the CustomCommonOpts.baseChain, selected CustomCommonOpts.hardfork and others
Returns Common
staticfromGethGenesis
Static method to load and set common from a geth genesis json
Parameters
genesisJson: any
json of geth configuration
to: GethConfigOpts
further configure the common instance
Returns Common
Common
staticisSupportedChainId
Static method to determine if a chainId is supported as a standard chain
Parameters
chainId: bigint
bigint id (
1) of a standard chain
Returns boolean
boolean
FeeMarketEIP1559Transaction
Typed transaction with a new gas fee market mechanism
- TransactionType: 2
- EIP: EIP-1559
constructor
This constructor takes the values, validates them, assigns them and freezes the object.
It is not recommended to use this constructor directly. Instead use the static factory methods to assist in creating a Transaction object from varying data types.
Parameters
txData: FeeMarketEIP1559TxData
optionalopts: TxOptions
Returns FeeMarketEIP1559Transaction
readonlyAccessListJSON
readonlyaccessList
readonlychainId
readonlycommon
readonlydata
readonlygasLimit
readonlymaxFeePerGas
readonlymaxPriorityFeePerGas
readonlynonce
optionalreadonlyr
optionalreadonlys
optionalreadonlyto
optionalreadonlyv
readonlyvalue
type
Returns the transaction type.
Note: legacy txs will return tx type
0.Returns number
_processSignature
Parameters
v: bigint
r: Buffer
s: Buffer
Returns FeeMarketEIP1559Transaction
errorStr
Return a compact error string representation of the object
Returns string
getBaseFee
The minimum amount of gas the tx must have (DataFee + TxFee + Creation Fee)
Returns bigint
getDataFee
The amount of gas paid for the data in this tx
Returns bigint
getMessageToSign
Returns the serialized unsigned tx (hashed or raw), which can be used to sign the transaction (e.g. for sending to a hardware wallet).
Note: in contrast to the legacy tx the raw message format is already serialized and doesn’t need to be RLP encoded any more.
const serializedMessage = tx.getMessageToSign(false) // use this for the HW wallet inputParameters
optionalhashMessage: boolean
Return hashed message if set to true (default: true)
Returns Buffer
getMessageToVerifySignature
Computes a sha3-256 hash which can be used to verify the signature
Returns Buffer
getSenderAddress
Returns the sender’s address
Returns Address
getSenderPublicKey
Returns the public key of the sender
Returns Buffer
getUpfrontCost
The up front amount that an account must have for this transaction to be valid
Parameters
optionalbaseFee: bigint
The base fee of the block (will be set to 0 if not provided)
Returns bigint
hash
Computes a sha3-256 hash of the serialized tx.
This method can only be used for signed txs (it throws otherwise). Use FeeMarketEIP1559Transaction.getMessageToSign to get a tx hash for the purpose of signing.
Returns Buffer
isSigned
Returns boolean
raw
Returns a Buffer Array of the raw Buffers of the EIP-1559 transaction, in order.
Format:
[chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, to, value, data,
accessList, signatureYParity, signatureR, signatureS]Use FeeMarketEIP1559Transaction.serialize to add a transaction to a block with Block.fromValuesArray.
For an unsigned tx this method uses the empty Buffer values for the signature parameters
v,randsfor encoding. For an EIP-155 compliant representation for external signing use FeeMarketEIP1559Transaction.getMessageToSign.Returns FeeMarketEIP1559ValuesArray
serialize
Returns the serialized encoding of the EIP-1559 transaction.
Format:
0x02 || rlp([chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, to, value, data,
accessList, signatureYParity, signatureR, signatureS])Note that in contrast to the legacy tx serialization format this is not valid RLP any more due to the raw tx type preceding and concatenated to the RLP encoding of the values.
Returns Buffer
sign
Signs a transaction.
Note that the signed tx is returned as a new object, use as follows:
const signedTx = tx.sign(privateKey)Parameters
privateKey: Buffer
Returns FeeMarketEIP1559Transaction
supports
Checks if a tx type defining capability is active on a tx, for example the EIP-1559 fee market mechanism or the EIP-2930 access list feature.
Note that this is different from the tx type itself, so EIP-2930 access lists can very well be active on an EIP-1559 tx for example.
This method can be useful for feature checks if the tx type is unknown (e.g. when instantiated with the tx factory).
See
Capabilitesin thetypesmodule for a reference on all supported capabilities.Parameters
capability: Capability
Returns boolean
toCreationAddress
If the tx’s
tois to the creation addressReturns boolean
toJSON
Returns an object with the JSON representation of the transaction
Returns JsonTx
validate
Checks if the transaction has the minimum amount of gas required (DataFee + TxFee + Creation Fee).
Returns boolean
verifySignature
Determines if the signature is valid
Returns boolean
staticfromSerializedTx
Instantiate a transaction from the serialized tx.
Format:
0x02 || rlp([chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, to, value, data,
accessList, signatureYParity, signatureR, signatureS])Parameters
serialized: Buffer
optionalopts: TxOptions
Returns FeeMarketEIP1559Transaction
staticfromTxData
Instantiate a transaction from a data dictionary.
Format: { chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, to, value, data, accessList, v, r, s }
Notes:
chainIdwill be set automatically if not provided- All parameters are optional and have some basic default values
Parameters
txData: FeeMarketEIP1559TxData
optionalopts: TxOptions
Returns FeeMarketEIP1559Transaction
staticfromValuesArray
Create a transaction from a values array.
Format:
[chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, to, value, data,
accessList, signatureYParity, signatureR, signatureS]Parameters
values: FeeMarketEIP1559ValuesArray
optionalopts: TxOptions
Returns FeeMarketEIP1559Transaction
Transaction
An Ethereum non-typed (legacy) transaction
constructor
This constructor takes the values, validates them, assigns them and freezes the object.
It is not recommended to use this constructor directly. Instead use the static factory methods to assist in creating a Transaction object from varying data types.
Parameters
txData: TxData
optionalopts: TxOptions
Returns Transaction
readonlycommon
readonlydata
readonlygasLimit
readonlygasPrice
readonlynonce
optionalreadonlyr
optionalreadonlys
optionalreadonlyto
optionalreadonlyv
readonlyvalue
type
Returns the transaction type.
Note: legacy txs will return tx type
0.Returns number
errorStr
Return a compact error string representation of the object
Returns string
getBaseFee
The minimum amount of gas the tx must have (DataFee + TxFee + Creation Fee)
Returns bigint
getDataFee
The amount of gas paid for the data in this tx
Returns bigint
getMessageToSign
Returns the unsigned tx (hashed or raw), which can be used to sign the transaction (e.g. for sending to a hardware wallet).
Note: the raw message message format for the legacy tx is not RLP encoded and you might need to do yourself with:
import { bufArrToArr } from '../util'
import { RLP } from '../rlp'
const message = tx.getMessageToSign(false)
const serializedMessage = Buffer.from(RLP.encode(bufArrToArr(message))) // use this for the HW wallet inputParameters
hashMessage: false
Return hashed message if set to true (default: true)
Returns Buffer[]
getMessageToVerifySignature
Computes a sha3-256 hash which can be used to verify the signature
Returns Buffer
getSenderAddress
Returns the sender’s address
Returns Address
getSenderPublicKey
Returns the public key of the sender
Returns Buffer
getUpfrontCost
The up front amount that an account must have for this transaction to be valid
Returns bigint
hash
Computes a sha3-256 hash of the serialized tx.
This method can only be used for signed txs (it throws otherwise). Use Transaction.getMessageToSign to get a tx hash for the purpose of signing.
Returns Buffer
isSigned
Returns boolean
raw
Returns a Buffer Array of the raw Buffers of the legacy transaction, in order.
Format:
[nonce, gasPrice, gasLimit, to, value, data, v, r, s]For legacy txs this is also the correct format to add transactions to a block with Block.fromValuesArray (use the
serialize()method for typed txs).For an unsigned tx this method returns the empty Buffer values for the signature parameters
v,rands. For an EIP-155 compliant representation have a look at Transaction.getMessageToSign.Returns TxValuesArray
serialize
Returns the serialized encoding of the legacy transaction.
Format:
rlp([nonce, gasPrice, gasLimit, to, value, data, v, r, s])For an unsigned tx this method uses the empty Buffer values for the signature parameters
v,randsfor encoding. For an EIP-155 compliant representation for external signing use Transaction.getMessageToSign.Returns Buffer
sign
Signs a transaction.
Note that the signed tx is returned as a new object, use as follows:
const signedTx = tx.sign(privateKey)Parameters
privateKey: Buffer
Returns Transaction
supports
Checks if a tx type defining capability is active on a tx, for example the EIP-1559 fee market mechanism or the EIP-2930 access list feature.
Note that this is different from the tx type itself, so EIP-2930 access lists can very well be active on an EIP-1559 tx for example.
This method can be useful for feature checks if the tx type is unknown (e.g. when instantiated with the tx factory).
See
Capabilitesin thetypesmodule for a reference on all supported capabilities.Parameters
capability: Capability
Returns boolean
toCreationAddress
If the tx’s
tois to the creation addressReturns boolean
toJSON
Returns an object with the JSON representation of the transaction.
Returns JsonTx
validate
Checks if the transaction has the minimum amount of gas required (DataFee + TxFee + Creation Fee).
Returns boolean
verifySignature
Determines if the signature is valid
Returns boolean
staticfromSerializedTx
Instantiate a transaction from the serialized tx.
Format:
rlp([nonce, gasPrice, gasLimit, to, value, data, v, r, s])Parameters
serialized: Buffer
optionalopts: TxOptions
Returns Transaction
staticfromTxData
Instantiate a transaction from a data dictionary.
Format: { nonce, gasPrice, gasLimit, to, value, data, v, r, s }
Notes:
- All parameters are optional and have some basic default values
Parameters
txData: TxData
optionalopts: TxOptions
Returns Transaction
staticfromValuesArray
Create a transaction from a values array.
Format:
[nonce, gasPrice, gasLimit, to, value, data, v, r, s]Parameters
values: TxValuesArray
optionalopts: TxOptions
Returns Transaction
TransactionFactory
staticfromBlockBodyData
When decoding a BlockBody, in the transactions field, a field is either: A Buffer (a TypedTransaction - encoded as TransactionType || rlp(TransactionPayload)) A Buffer[] (Legacy Transaction) This method returns the right transaction.
Parameters
data: Buffer | Buffer[]
A Buffer or Buffer[]
optionaltxOptions: TxOptions
The transaction options
Returns TypedTransaction
staticfromSerializedData
This method tries to decode serialized data.
Parameters
data: Buffer
The data Buffer
optionaltxOptions: TxOptions
The transaction options
Returns TypedTransaction
staticfromTxData
Create a transaction from a
txDataobjectParameters
txData: TypedTransaction | TxData
The transaction data. The
typefield will determine which transaction type is returned (if undefined, creates a legacy transaction)optionaltxOptions: TxOptions
Options to pass on to the constructor of the transaction
Returns TypedTransaction
Wallet
Wallet is an in memory wallet that can hold multiple accounts.
These accounts can be used when using web3.eth.sendTransaction().
Parameters
Web3AccountProvider - AccountProvider for the wallet
import Web3 from 'web3';
const web3 = new Web3("https://localhost:8454")
web3.eth.accounts.wallet
> Wallet(0) [
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_addressMap: Map(0) {},
_defaultKeyName: 'web3js_wallet'
]
Type parameters
constructor
Type parameters
Parameters
accountProvider: Web3AccountProvider<T>
Returns Wallet<T>
add
Adds an account using a private key or account object to the wallet.
Parameters
account: string | T
A private key or account object
Returns Wallet<T>
The wallet
web3.eth.accounts.wallet.add('0xbce9b59981303e76c4878b1a6d7b088ec6b9dd5c966b7d5f54d7a749ff683387');
> Wallet(1) [
{
address: '0x85D70633b90e03e0276B98880286D0D055685ed7',
privateKey: '0xbce9b59981303e76c4878b1a6d7b088ec6b9dd5c966b7d5f54d7a749ff683387',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
},
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_addressMap: Map(1) { '0x85d70633b90e03e0276b98880286d0d055685ed7' => 0 },
_defaultKeyName: 'web3js_wallet'
]
clear
Securely empties the wallet and removes all its accounts. Use this with *caution as it will remove all accounts stored in local wallet.
Returns Wallet<T>
The wallet object
web3.eth.accounts.wallet.clear();
> Wallet(0) [
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_addressMap: Map(0) {},
_defaultKeyName: 'web3js_wallet'
]
create
Generates one or more accounts in the wallet. If wallets already exist they will not be overridden.
Parameters
numberOfAccounts: number
Number of accounts to create. Leave empty to create an empty wallet.
Returns Wallet<T>
The wallet
web3.eth.accounts.wallet.create(2)
> Wallet(2) [
{
address: '0xde38310a42B751AE57d30cFFF4a0A3c52A442fCE',
privateKey: '0x6422c9d28efdcbee93c1d32a5fc6fd6fa081b985487885296cf8c9bbb5872600',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
},
{
address: '0x766BF755246d924B1d017Fdb5390f38a60166691',
privateKey: '0x756530f13c0eb636ebdda655335f5dea9921e3362e2e588b0ad59e556f7751f0',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
},
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_addressMap: Map(2) {
'0xde38310a42b751ae57d30cfff4a0a3c52a442fce' => 0,
'0x766bf755246d924b1d017fdb5390f38a60166691' => 1
},
_defaultKeyName: 'web3js_wallet'
]
decrypt
Decrypts keystore v3 objects.
Parameters
encryptedWallets: KeyStore[]
An array of encrypted keystore v3 objects to decrypt
password: string
The password to encrypt with
optionaloptions: Record<string, unknown>
decrypt options for the wallets
Returns Promise<Wallet<T>>
The decrypted wallet object
web3.eth.accounts.wallet.decrypt([
{ version: 3,
id: '83191a81-aaca-451f-b63d-0c5f3b849289',
address: '06f702337909c06c82b09b7a22f0a2f0855d1f68',
crypto:
{ ciphertext: '7d34deae112841fba86e3e6cf08f5398dda323a8e4d29332621534e2c4069e8d',
cipherparams: { iv: '497f4d26997a84d570778eae874b2333' },
cipher: 'aes-128-ctr',
kdf: 'scrypt',
kdfparams:
{ dklen: 32,
salt: '208dd732a27aa4803bb760228dff18515d5313fd085bbce60594a3919ae2d88d',
n: 262144,
r: 8,
p: 1 },
mac: '0062a853de302513c57bfe3108ab493733034bf3cb313326f42cf26ea2619cf9' } },
{ version: 3,
id: '7d6b91fa-3611-407b-b16b-396efb28f97e',
address: 'b5d89661b59a9af0b34f58d19138baa2de48baaf',
crypto:
{ ciphertext: 'cb9712d1982ff89f571fa5dbef447f14b7e5f142232bd2a913aac833730eeb43',
cipherparams: { iv: '8cccb91cb84e435437f7282ec2ffd2db' },
cipher: 'aes-128-ctr',
kdf: 'scrypt',
kdfparams:
{ dklen: 32,
salt: '08ba6736363c5586434cd5b895e6fe41ea7db4785bd9b901dedce77a1514e8b8',
n: 262144,
r: 8,
p: 1 },
mac: 'd2eb068b37e2df55f56fa97a2bf4f55e072bef0dd703bfd917717d9dc54510f0' } }
], 'test').then(console.log)
> Wallet {
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_defaultKeyName: 'web3js_wallet',
_accounts: {
'0x85d70633b90e03e0276b98880286d0d055685ed7': {
address: '0x85D70633b90e03e0276B98880286D0D055685ed7',
privateKey: '0xbce9b59981303e76c4878b1a6d7b088ec6b9dd5c966b7d5f54d7a749ff683387',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
},
'0x06f702337909c06c82b09b7a22f0a2f0855d1f68': {
address: '0x06F702337909C06C82B09B7A22F0a2f0855d1F68',
privateKey: '87a51da18900da7398b3bab03996833138f269f8f66dd1237b98df6b9ce14573',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
},
'0xb5d89661b59a9af0b34f58d19138baa2de48baaf': {
address: '0xB5d89661B59a9aF0b34f58D19138bAa2de48BAaf',
privateKey: '7ee61c5282979aae9dd795bb6a54e8bdc2bfe009acb64eb9a67322eec3b3da6e',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [Function: encrypt]
}
}
}
encrypt
Encrypts all wallet accounts to an array of encrypted keystore v3 objects.
Parameters
password: string
The password which will be used for encryption
optionaloptions: Record<string, unknown>
encryption options
Returns Promise<KeyStore[]>
An array of the encrypted keystore v3.
web3.eth.accounts.wallet.create(1)
web3.eth.accounts.wallet.encrypt("abc").then(console.log);
> [
'{"version":3,"id":"fa46e213-a7c3-4844-b903-dd14d39cc7db",
"address":"fa3e41a401609103c241431cbdee8623ae2a321a","crypto":
{"ciphertext":"8d179a911d6146ad2924e86bf493ed89b8ff3596ffec0816e761c542016ab13c",
"cipherparams":{"iv":"acc888c6cf4a19b86846cef0185a7164"},"cipher":"aes-128-ctr",
"kdf":"scrypt","kdfparams":{"n":8192,"r":8,"p":1,"dklen":32,"salt":"6a743c9b367d15f4758e4f3f3378ff0fd443708d1c64854e07588ea5331823ae"},
"mac":"410544c8307e3691fda305eb3722d82c3431f212a87daa119a21587d96698b57"}}'
]
get
Get the account of the wallet with either the index or public address.
Parameters
addressOrIndex: string | number
A string of the address or number index within the wallet.
Returns undefined | T
The account object or undefined if the account doesn’t exist
load
Loads a wallet from local storage and decrypts it. NOTE: Browser only
Parameters
password: string
The password to decrypt the wallet.
optionalkeyName: string
(optional)The key used for local storage position, defaults to
web3js_wallet"
Returns Promise<Wallet<T>>
Returns the wallet object
web3.eth.accounts.wallet.save('test#!$');
> true
web3.eth.accounts.wallet.load('test#!$');
{ defaultKeyName: "web3js_wallet",
length: 0,
_accounts: Accounts {_requestManager: RequestManager, givenProvider: Proxy, providers: {…}, _provider: WebsocketProvider, …},
[[Prototype]]: Object
}
remove
Removes an account from the wallet.
Parameters
addressOrIndex: string | number
The account address, or index in the wallet.
Returns boolean
true if the wallet was removed. false if it couldn’t be found.
web3.eth.accounts.wallet.add('0xbce9b59981303e76c4878b1a6d7b088ec6b9dd5c966b7d5f54d7a749ff683387');
web3.eth.accounts.wallet.remove('0x85D70633b90e03e0276B98880286D0D055685ed7');
> true
web3.eth.accounts.wallet
> Wallet(0) [
_accountProvider: {
create: [Function: create],
privateKeyToAccount: [Function: privateKeyToAccount],
decrypt: [Function: decrypt]
},
_addressMap: Map(0) {},
_defaultKeyName: 'web3js_wallet'
]
save
Stores the wallet encrypted and as string in local storage. NOTE: Browser only
Parameters
password: string
The password to encrypt the wallet
optionalkeyName: string
(optional) The key used for the local storage position, defaults to
"web3js_wallet".
Returns Promise<boolean>
Will return boolean value true if saved properly
web3.eth.accounts.wallet.save('test#!$');
>true
staticgetStorage
Get the storage object of the browser
Returns undefined | WebStorage
the storage
AccessListEIP2930TxData
AccessListEIP2930Transaction data.
optionalaccessList
The access list which contains the addresses/storage slots which the transaction wishes to access
optionalchainId
The transaction’s chain ID
optionaldata
This will contain the data of the message or the init of a contract.
optionalgasLimit
The transaction’s gas limit.
optionalgasPrice
The transaction’s gas price.
optionalnonce
The transaction’s nonce.
optionalr
EC signature parameter.
optionals
EC signature parameter.
optionalto
The transaction’s the address is sent to.
optionaltype
The transaction type
optionalv
EC recovery ID.
optionalvalue
The amount of Ether sent.
BootstrapNodeConfig
optionalchainId
comment
id
ip
location
optionalnetwork
port
ChainConfig
optionalbootstrapNodes
chainId
optionalcomment
consensus
Type declaration
algorithm: string
optionalcasper?: CasperConfig
optionalclique?: CliqueConfig
optionalethash?: EthashConfig
type: string
optionaldefaultHardfork
optionaldnsNetworks
genesis
hardforks
name
networkId
optionalurl
ChainName
ChainsConfig
CommonOpts
Options for instantiating a Common instance.
chain
Chain name (‘mainnet’), id (1), or Chain enum, either from a chain directly supported or a custom chain passed in via CommonOpts.customChains.
optionalcustomChains
Initialize (in addition to the supported chains) with the selected custom chains. Custom genesis state should be passed to the Blockchain class if used.
Usage (directly with the respective chain initialization via the CommonOpts.chain option):
import myCustomChain1 from '[PATH_TO_MY_CHAINS]/myCustomChain1.json'
const common = new Common({ chain: 'myCustomChain1', customChains: [ myCustomChain1 ]})
optionaleips
Selected EIPs which can be activated, please use an array for instantiation
(e.g. eips: [ 2537, ])
Currently supported:
- EIP-2537 - BLS12-381 precompiles
optionalhardfork
String identifier (‘byzantium’) for hardfork or Hardfork enum.
Default: Hardfork.London
CustomCommonOpts
Options to be used with the Common.custom static constructor.
optionalbaseChain
The name (mainnet), id (1), or Chain enum of
a standard chain used to base the custom chain params on.
optionaleips
Selected EIPs which can be activated, please use an array for instantiation
(e.g. eips: [ 2537, ])
Currently supported:
- EIP-2537 - BLS12-381 precompiles
optionalhardfork
String identifier (‘byzantium’) for hardfork or Hardfork enum.
Default: Hardfork.London
ECDSASignature
r
s
v
FeeMarketEIP1559TxData
FeeMarketEIP1559Transaction data.
optionalaccessList
The access list which contains the addresses/storage slots which the transaction wishes to access
optionalchainId
The transaction’s chain ID
optionaldata
This will contain the data of the message or the init of a contract.
optionalgasLimit
The transaction’s gas limit.
optionalgasPrice
The transaction’s gas price, inherited from Transaction. This property is not used for EIP1559 transactions and should always be undefined for this specific transaction type.
optionalmaxFeePerGas
The maximum total fee
optionalmaxPriorityFeePerGas
The maximum inclusion fee per gas (this fee is given to the miner)
optionalnonce
The transaction’s nonce.
optionalr
EC signature parameter.
optionals
EC signature parameter.
optionalto
The transaction’s the address is sent to.
optionaltype
The transaction type
optionalv
EC recovery ID.
optionalvalue
The amount of Ether sent.
GenesisBlockConfig
optionalbaseFeePerGas
difficulty
extraData
gasLimit
nonce
optionaltimestamp
GethConfigOpts
optionalchain
optionaleips
Selected EIPs which can be activated, please use an array for instantiation
(e.g. eips: [ 2537, ])
Currently supported:
- EIP-2537 - BLS12-381 precompiles
optionalgenesisHash
optionalhardfork
String identifier (‘byzantium’) for hardfork or Hardfork enum.
Default: Hardfork.London
optionalmergeForkIdPostMerge
HardforkConfig
block
optionalforkHash
name
optionaltimestamp
optionalttd
JsonTx
Generic interface for all tx types with a JSON representation of a transaction.
Note that all values are marked as optional
and not all the values are present on all tx types
(an EIP1559 tx e.g. lacks a gasPrice).
optionalaccessList
optionalchainId
optionaldata
optionalgasLimit
optionalgasPrice
optionalmaxFeePerDataGas
optionalmaxFeePerGas
optionalmaxPriorityFeePerGas
optionalnonce
optionalr
optionals
optionalto
optionaltype
optionalv
optionalvalue
optionalversionedHashes
TransformableToArray
toArray
Returns Uint8Array
optionaltoBuffer
Returns Buffer
TransformableToBuffer
optionaltoArray
Returns Uint8Array
toBuffer
Returns Buffer
TxOptions
The options for initializing a Transaction.
optionalallowUnlimitedInitCodeSize
Allows unlimited contract code-size init while debugging. This (partially) disables EIP-3860. Gas cost for initcode size analysis will still be charged. Use with caution.
optionalcommon
A Common object defining the chain and hardfork for the transaction.
Object will be internally copied so that tx behavior don’t incidentally change on future HF changes.
Default: Common object set to mainnet and the default hardfork as defined in the Common class.
Current default hardfork: istanbul
optionalfreeze
A transaction object by default gets frozen along initialization. This gives you
strong additional security guarantees on the consistency of the tx parameters.
It also enables tx hash caching when the hash() method is called multiple times.
If you need to deactivate the tx freeze - e.g. because you want to subclass tx and add additional properties - it is strongly encouraged that you do the freeze yourself within your code instead.
Default: true
Web3Account
address
privateKey
readonlyencrypt
Parameters
password: string
optionaloptions: Record<string, unknown>
Returns Promise<KeyStore>
readonlysign
Parameters
data: string | Record<string, unknown>
Returns { message?: string; messageHash: string; r: string; s: string; signature: string; v: string }
optionalreadonlymessage?: string
readonlymessageHash: string
readonlyr: string
readonlys: string
readonlysignature: string
readonlyv: string
readonlysignTransaction
Parameters
tx: Transaction
Returns Promise<{ messageHash: string; r: string; rawTransaction: string; s: string; transactionHash: string; v: string }>
WebStorage
This Web Storage API interface provides access to a particular domain’s session or local storage. It allows, for example, the addition, modification, or deletion of stored data items.
readonlylength
Returns the number of key/value pairs.
clear
Removes all key/value pairs, if there are any.
Dispatches a storage event on Window objects holding an equivalent Storage object.
Returns void
getItem
Returns the current value associated with the given key, or null if the given key does not exist.
Parameters
key: string
Returns null | string
key
Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
Parameters
index: number
Returns null | string
removeItem
Removes the key/value pair with the given key, if a key/value pair with the given key exists.
Dispatches a storage event on Window objects holding an equivalent Storage object.
Parameters
key: string
Returns void
setItem
Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
Throws a “QuotaExceededError” DOMException exception if the new value couldn’t be set. (Setting could fail if, e.g., the user has disabled storage for the site, or if the quota has been exceeded.)
Dispatches a storage event on Window objects holding an equivalent Storage object.
Parameters
key: string
value: string
Returns void
AccessList
AccessListBuffer
AccessListBufferItem
AccessListEIP2930ValuesArray
Buffer values array for an AccessListEIP2930Transaction
AccessListItem
Type declaration
address: PrefixedHexString
storageKeys: PrefixedHexString[]
BigIntLike
BufferLike
CasperConfig
CliqueConfig
Type declaration
epoch: number
period: number
EthashConfig
FeeMarketEIP1559ValuesArray
Buffer values array for a FeeMarketEIP1559Transaction
NestedBufferArray
NestedUint8Array
PrefixedHexString
SignFunction
Type declaration
Parameters
data: string
privateKey: string
Returns SignResult
SignResult
SignTransactionFunction
Type declaration
Parameters
transaction: TxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData | Record<string, unknown>
Returns SignTransactionResult
SignTransactionResult
SignatureObject
Type declaration
messageHash: string
r: string
s: string
v: string
ToBufferInputTypes
TxData
Legacy Transaction Data
Type declaration
optionaldata?: BufferLike
This will contain the data of the message or the init of a contract.
optionalgasLimit?: Numbers | Buffer
The transaction’s gas limit.
optionalgasPrice?: Numbers | Buffer | null
The transaction’s gas price.
optionalnonce?: Numbers | Buffer
The transaction’s nonce.
optionalr?: Numbers | Buffer
EC signature parameter.
optionals?: Numbers | Buffer
EC signature parameter.
optionalto?: Address | Buffer | HexString
The transaction’s the address is sent to.
optionaltype?: Numbers
The transaction type
optionalv?: Numbers | Buffer
EC recovery ID.
optionalvalue?: Numbers | Buffer
The amount of Ether sent.
TxValuesArray
Buffer values array for a legacy Transaction
TypeOutputReturnType
Type declaration
0: number
1: bigint
2: Buffer
3: PrefixedHexString
TypedTransaction
constkeyStoreSchema
Type declaration
properties: { address: { type: string }; crypto: { properties: { cipher: { type: string }; cipherparams: { type: string }; ciphertext: { type: string }; kdf: { type: string }; kdfparams: { type: string }; mac: { type: string }; salt: { type: string } }; required: string[]; type: string }; id: { type: string }; version: { type: string } }
address: { type: string }
type: string
crypto: { properties: { cipher: { type: string }; cipherparams: { type: string }; ciphertext: { type: string }; kdf: { type: string }; kdfparams: { type: string }; mac: { type: string }; salt: { type: string } }; required: string[]; type: string }
properties: { cipher: { type: string }; cipherparams: { type: string }; ciphertext: { type: string }; kdf: { type: string }; kdfparams: { type: string }; mac: { type: string }; salt: { type: string } }
cipher: { type: string }
type: string
cipherparams: { type: string }
type: string
ciphertext: { type: string }
type: string
kdf: { type: string }
type: string
kdfparams: { type: string }
type: string
mac: { type: string }
type: string
salt: { type: string }
type: string
required: string[]
type: string
id: { type: string }
type: string
version: { type: string }
type: string
required: string[]
type: string
arrToBufArr
Converts a Uint8Array or NestedUint8Array to Buffer or NestedBufferArray
Parameters
arr: Uint8Array
Returns Buffer
assertIsBuffer
Throws if input is not a buffer
Parameters
input: Buffer
value to check
Returns void
bigIntToBuffer
Converts a bigint to a Buffer
Parameters
num: bigint
Returns Buffer
bigIntToHex
Converts a bigint to a
0xprefixed hex stringParameters
num: bigint
Returns string
bigIntToUnpaddedBuffer
Convert value from bigint to an unpadded Buffer (useful for RLP transport)
Parameters
value: bigint
value to convert
Returns Buffer
bufArrToArr
Converts a Buffer or NestedBufferArray to Uint8Array or NestedUint8Array
Parameters
arr: Buffer
Returns Uint8Array
bufferToBigInt
Converts a Buffer to a bigint
Parameters
buf: Buffer
Returns bigint
bufferToHex
Converts a
Bufferinto a0x-prefixed hexString.Parameters
_buf: Buffer
Returns string
create
Generates and returns a Web3Account object that includes the private and public key For creation of private key, it uses an audited package ethereum-cryptography/secp256k1 that is cryptographically secure random number with certain characteristics. Read more: https://www.npmjs.com/package/ethereum-cryptography#secp256k1-curve
Returns Web3Account
A Web3Account object
web3.eth.accounts.create();
{
address: '0xbD504f977021b5E5DdccD8741A368b147B3B38bB',
privateKey: '0x964ced1c69ad27a311c432fdc0d8211e987595f7eb34ab405a5f16bdc9563ec5',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [AsyncFunction: encrypt]
}
decrypt
Decrypts a v3 keystore JSON, and creates the account.
Parameters
keystore: string | KeyStore
the encrypted Keystore object or string to decrypt
password: string | Buffer
The password that was used for encryption
optionalnonStrict: boolean
if true and given a json string, the keystore will be parsed as lowercase.
Returns Promise<Web3Account>
Returns the decrypted Web3Account object Decrypting scrypt
decrypt({
version: 3,
id: 'c0cb0a94-4702-4492-b6e6-eb2ac404344a',
address: 'cda9a91875fc35c8ac1320e098e584495d66e47c',
crypto: {
ciphertext: 'cb3e13e3281ff3861a3f0257fad4c9a51b0eb046f9c7821825c46b210f040b8f',
cipherparams: { iv: 'bfb43120ae00e9de110f8325143a2709' },
cipher: 'aes-128-ctr',
kdf: 'scrypt',
kdfparams: {
n: 8192,
r: 8,
p: 1,
dklen: 32,
salt: '210d0ec956787d865358ac45716e6dd42e68d48e346d795746509523aeb477dd'
},
mac: 'efbf6d3409f37c0084a79d5fdf9a6f5d97d11447517ef1ea8374f51e581b7efd'
}
}, '123').then(console.log)
> {
address: '0xcdA9A91875fc35c8Ac1320E098e584495d66e47c',
privateKey: '67f476289210e3bef3c1c75e4de993ff0a00663df00def84e73aa7411eac18a6',
signTransaction: [Function: signTransaction],
sign: [Function: sign],
encrypt: [AsyncFunction: encrypt]
}
ecrecover
ECDSA public key recovery from signature. NOTE: Accepts
v === 0 | v === 1for EIP1559 transactionsParameters
msgHash: Buffer
v: bigint
r: Buffer
s: Buffer
optionalchainId: bigint
Returns Buffer
Recovered public key
encrypt
encrypt a private key with a password, returns a V3 JSON Keystore
Parameters
privateKey: Bytes
The private key to encrypt, 32 bytes.
password: string | Buffer
The password used for encryption.
optionaloptions: CipherOptions
Options to configure to encrypt the keystore either scrypt or pbkdf2
Returns Promise<KeyStore>
Returns a V3 JSON Keystore
Encrypt using scrypt options
encrypt('0x67f476289210e3bef3c1c75e4de993ff0a00663df00def84e73aa7411eac18a6',
'123',
{
n: 8192,
iv: Buffer.from('bfb43120ae00e9de110f8325143a2709', 'hex'),
salt: Buffer.from(
'210d0ec956787d865358ac45716e6dd42e68d48e346d795746509523aeb477dd',
'hex',
),
}).then(console.log)
> {
version: 3,
id: 'c0cb0a94-4702-4492-b6e6-eb2ac404344a',
address: 'cda9a91875fc35c8ac1320e098e584495d66e47c',
crypto: {
ciphertext: 'cb3e13e3281ff3861a3f0257fad4c9a51b0eb046f9c7821825c46b210f040b8f',
cipherparams: { iv: 'bfb43120ae00e9de110f8325143a2709' },
cipher: 'aes-128-ctr',
kdf: 'scrypt',
kdfparams: {
n: 8192,
r: 8,
p: 1,
dklen: 32,
salt: '210d0ec956787d865358ac45716e6dd42e68d48e346d795746509523aeb477dd'
},
mac: 'efbf6d3409f37c0084a79d5fdf9a6f5d97d11447517ef1ea8374f51e581b7efd'
}
}Encrypting using pbkdf2 options
encrypt('0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709',
'123',
{
iv: 'bfb43120ae00e9de110f8325143a2709',
salt: '210d0ec956787d865358ac45716e6dd42e68d48e346d795746509523aeb477dd',
c: 262144,
kdf: 'pbkdf2',
}).then(console.log)
>
{
version: 3,
id: '77381417-0973-4e4b-b590-8eb3ace0fe2d',
address: 'b8ce9ab6943e0eced004cde8e3bbed6568b2fa01',
crypto: {
ciphertext: '76512156a34105fa6473ad040c666ae7b917d14c06543accc0d2dc28e6073b12',
cipherparams: { iv: 'bfb43120ae00e9de110f8325143a2709' },
cipher: 'aes-128-ctr',
kdf: 'pbkdf2',
kdfparams: {
dklen: 32,
salt: '210d0ec956787d865358ac45716e6dd42e68d48e346d795746509523aeb477dd',
c: 262144,
prf: 'hmac-sha256'
},
mac: '46eb4884e82dc43b5aa415faba53cc653b7038e9d61cc32fd643cf8c396189b7'
}
}
hashMessage
Hashes the given message. The data will be UTF-8 HEX decoded and enveloped as follows: “\x19Ethereum Signed Message:\n” + message.length + message and hashed using keccak256.
Parameters
message: string
A message to hash, if its HEX it will be UTF8 decoded.
Returns string
The hashed message
hashMessage("Hello world")
> "0x8144a6fa26be252b86456491fbcd43c1de7e022241845ffea1c3df066f7cfede"
hashMessage(utf8ToHex("Hello world")) // Will be hex decoded in hashMessage
> "0x8144a6fa26be252b86456491fbcd43c1de7e022241845ffea1c3df066f7cfede"
intToBuffer
Converts an
Numberto aBufferParameters
i: number
Returns Buffer
isAccessList
Parameters
input: AccessListBuffer | AccessList
Returns input is AccessList
isAccessListBuffer
Parameters
input: AccessListBuffer | AccessList
Returns input is AccessListBuffer
padToEven
Pads a
Stringto have an even lengthParameters
value: string
Returns string
output
parseAndValidatePrivateKey
Get the private key buffer after the validation
Parameters
data: Bytes
optionalignoreLength: boolean
Returns Buffer
parseGethGenesis
Parses a genesis.json exported from Geth into parameters for Common instance
Parameters
json: any
representing the Geth genesis file
optionalname: string
optional chain name
optionalmergeForkIdPostMerge: boolean
Returns { bootstrapNodes: never[]; chainId: number; consensus: { algorithm: string; clique: { epoch: any; period: any }; ethash?: undefined; type: string } | { algorithm: string; clique?: undefined; ethash: {}; type: string }; genesis: { baseFeePerGas: string; coinbase: string; difficulty: number; extraData: string; gasLimit: number; mixHash: string; nonce: string; timestamp: string }; hardfork: string | undefined; hardforks: ConfigHardfork[]; name: string; networkId: number }
parsed params
bootstrapNodes: never[]
chainId: number
consensus: { algorithm: string; clique: { epoch: any; period: any }; ethash?: undefined; type: string } | { algorithm: string; clique?: undefined; ethash: {}; type: string }
genesis: { baseFeePerGas: string; coinbase: string; difficulty: number; extraData: string; gasLimit: number; mixHash: string; nonce: string; timestamp: string }
baseFeePerGas: string
coinbase: string
difficulty: number
extraData: string
gasLimit: number
mixHash: string
nonce: string
timestamp: string
hardfork: string | undefined
hardforks: ConfigHardfork[]
name: string
networkId: number
privateKeyToAccount
Get an Account object from the privateKey
Parameters
privateKey: Bytes
String or buffer of 32 bytes
optionalignoreLength: boolean
if true, will not error check length
Returns Web3Account
A Web3Account object
The
Web3Account.signTransactionis not stateful here. We need network access to get the accountnonceandchainIdto sign the transaction. Use Web3.eth.accounts.signTransaction instead.privateKeyToAccount("0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709");
> {
address: '0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01',
privateKey: '0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709',
sign,
signTransaction,
encrypt,
}
privateKeyToAddress
Get the ethereum Address from a private key
Parameters
privateKey: Bytes
String or buffer of 32 bytes
Returns string
The Ethereum address
recover
Recovers the Ethereum address which was used to sign the given data
Parameters
data: string | SignatureObject
Either a signed message, hash, or the signatureObject
optionalsignatureOrV: string
signatureOrV
optionalprefixedOrR: string | boolean
prefixedOrR
optionals: string
s
optionalprefixed: boolean
(default: false) If the last parameter is true, the given message will NOT automatically be prefixed with “\x19Ethereum Signed Message:\n” + message.length + message, and assumed to be already prefixed.
Returns string
The Ethereum address used to sign this data
sign('Some data', '0xbe6383dad004f233317e46ddb46ad31b16064d14447a95cc1d8c8d4bc61c3728');
> {
message: 'Some data',
messageHash: '0x1da44b586eb0729ff70a73c326926f6ed5a25f5b056e7f47fbc6e58d86871655',
v: '0x1b',
r: '0xa8037a6116c176a25e6fc224947fde9e79a2deaa0dd8b67b366fbdfdbffc01f9',
s: '0x53e41351267b20d4a89ebfe9c8f03c04de9b345add4a52f15bd026b63c8fb150',
signature: '0xa8037a6116c176a25e6fc224947fde9e79a2deaa0dd8b67b366fbdfdbffc01f953e41351267b20d4a89ebfe9c8f03c04de9b345add4a52f15bd026b63c8fb1501b'
}
recover('0xa8037a6116c176a25e6fc224947fde9e79a2deaa0dd8b67b366fbdfdbffc01f953e41351267b20d4a89ebfe9c8f03c04de9b345add4a52f15bd026b63c8fb1501b');
> '0xEB014f8c8B418Db6b45774c326A0E64C78914dC0'
recoverTransaction
Recovers the Ethereum address which was used to sign the given RLP encoded transaction.
Parameters
rawTransaction: string
The hex string having RLP encoded transaction
Returns string
The Ethereum address used to sign this transaction
recoverTransaction('0xf869808504e3b29200831e848094f0109fc8df283027b6285cc889f5aa624eac1f55843b9aca008025a0c9cf86333bcb065d140032ecaab5d9281bde80f21b9687b3e94161de42d51895a0727a108a0b8d101465414033c3f705a9c7b826e596766046ee1183dbc8aeaa68');
> "0x2c7536E3605D9C16a7a3D7b1898e529396a65c23"
setLengthLeft
Left Pads a
Bufferwith leading zeros till it haslengthbytes. Or it truncates the beginning if it exceeds.Parameters
msg: Buffer
the value to pad (Buffer)
length: number
the number of bytes the output should be
Returns Buffer
(Buffer)
sign
Signs arbitrary data with a given private key. NOTE: The value passed as the data parameter will be UTF-8 HEX decoded and wrapped as follows: “\x19Ethereum Signed Message:\n” + message.length + message
Parameters
data: string
The data to sign
privateKey: Bytes
The 32 byte private key to sign with
Returns SignResult
The signature Object containing the message, messageHash, signature r, s, v
web3.eth.accounts.sign('Some data', '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318')
> {
message: 'Some data',
messageHash: '0x1da44b586eb0729ff70a73c326926f6ed5a25f5b056e7f47fbc6e58d86871655',
v: '0x1c',
r: '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd',
s: '0x6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a029',
signature: '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a0291c'
}
signTransaction
Signs an Ethereum transaction with a given private key.
Parameters
transaction: TypedTransaction
The transaction, must be a legacy, EIP2930 or EIP 1559 transaction type
privateKey: string
The private key to import. This is 32 bytes of random data.
Returns Promise<SignTransactionResult>
A signTransactionResult object that contains message hash, r, s, v, transaction hash and raw transaction.
This function is not stateful here. We need network access to get the account
nonceandchainIdto sign the transaction. This function will rely on user to provide the full transaction to be signed. If you want to sign a partial transaction object Use Web3.eth.accounts.sign instead.Signing a legacy transaction
signTransaction({
to: '0x118C2E5F57FD62C2B5b46a5ae9216F4FF4011a07',
value: '0x186A0',
gasLimit: '0x520812',
gasPrice: '0x09184e72a000',
data: '',
chainId: 1,
nonce: 0,
}, '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318'))
}
> {
messageHash: '0x28b7b75f7ba48d588a902c1ff4d5d13cc0ca9ac0aaa39562368146923fb853bf',
v: '0x25',
r: '0x601b0017b0e20dd0eeda4b895fbc1a9e8968990953482214f880bae593e71b5',
s: '0x690d984493560552e3ebdcc19a65b9c301ea9ddc82d3ab8cfde60485fd5722ce',
rawTransaction: '0xf869808609184e72a0008352081294118c2e5f57fd62c2b5b46a5ae9216f4ff4011a07830186a08025a00601b0017b0e20dd0eeda4b895fbc1a9e8968990953482214f880bae593e71b5a0690d984493560552e3ebdcc19a65b9c301ea9ddc82d3ab8cfde60485fd5722ce',
transactionHash: '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'Signing an eip 1559 transaction
signTransaction({
to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
maxPriorityFeePerGas: '0x3B9ACA00',
maxFeePerGas: '0xB2D05E00',
gasLimit: '0x6A4012',
value: '0x186A0',
data: '',
chainId: 1,
nonce: 0,
},"0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318")
> {
messageHash: '0x5744f24d5f0aff6c70487c8e85adf07d8564e50b08558788f00479611d7bae5f',
v: '0x25',
r: '0x78a5a6b2876c3985f90f82073d18d57ac299b608cc76a4ba697b8bb085048347',
s: '0x9cfcb40cc7d505ed17ff2d3337b51b066648f10c6b7e746117de69b2eb6358d',
rawTransaction: '0xf8638080836a401294f0109fc8df283027b6285cc889f5aa624eac1f55830186a08025a078a5a6b2876c3985f90f82073d18d57ac299b608cc76a4ba697b8bb085048347a009cfcb40cc7d505ed17ff2d3337b51b066648f10c6b7e746117de69b2eb6358d',
transactionHash: '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
}Signing an eip 2930 transaction
signTransaction({
chainId: 1,
nonce: 0,
gasPrice: '0x09184e72a000',
gasLimit: '0x2710321',
to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
value: '0x186A0',
data: '',
accessList: [
{
address: '0x0000000000000000000000000000000000000101',
storageKeys: [
'0x0000000000000000000000000000000000000000000000000000000000000000',
'0x00000000000000000000000000000000000000000000000000000000000060a7',
],
},
],
},"0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318")
> {
messageHash: '0xc55ea24bdb4c379550a7c9a6818ac39ca33e75bc78ddb862bd82c31cc1c7a073',
v: '0x26',
r: '0x27344e77871c8b2068bc998bf28e0b5f9920867a69c455b2ed0c1c150fec098e',
s: '0x519f0130a1d662841d4a28082e9c9bb0a15e0e59bb46cfc39a52f0e285dec6b9',
rawTransaction: '0xf86a808609184e72a000840271032194f0109fc8df283027b6285cc889f5aa624eac1f55830186a08026a027344e77871c8b2068bc998bf28e0b5f9920867a69c455b2ed0c1c150fec098ea0519f0130a1d662841d4a28082e9c9bb0a15e0e59bb46cfc39a52f0e285dec6b9',
transactionHash: '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
}
stripHexPrefix
Removes ‘0x’ from a given
Stringif presentParameters
str: string
the string value
Returns string
the string without 0x prefix
toBuffer
Attempts to turn a value into a
Buffer. Inputs supported:Buffer,String(hex-prefixed),Number, null/undefined,BigIntand other objects with atoArray()ortoBuffer()method.Parameters
v: ToBufferInputTypes
the value
Returns Buffer
toType
Convert an input to a specified type. Input of null/undefined returns null/undefined regardless of the output type.
Type parameters
- T: TypeOutput
Parameters
input: null
value to convert
outputType: T
type to output
Returns null
unpadBuffer
Trims leading zeros from a
Buffer.Parameters
a: Buffer
(Buffer)
Returns Buffer
(Buffer)
zeros
Returns a buffer filled with 0s.
Parameters
bytes: number
the number of bytes the buffer should be
Returns Buffer
contract
The web3.eth.Contract object makes it easy to interact with smart contracts on the Ethereum blockchain.
When you create a new contract object you give it the JSON interface of the respective smart contract and
web3 will auto convert all calls into low level ABI calls over RPC for you.
This allows you to interact with smart contracts as if they were JavaScript objects.
To use it standalone:
const Contract = require('web3-eth-contract');
// set provider for all later instances to use
Contract.setProvider('ws://localhost:8546');
const contract = new Contract(jsonInterface, address);
contract.methods.somFunc().send({from: ....})
.on('receipt', function(){
...
});
Contract
default
LogsSubscription
LogSubscription to be used to subscribe to events logs.
Following events are supported and can be accessed with either LogsSubscription.once or $LogsSubscription.on methods.
- connected: Emitted when the subscription is connected.
- data: Fires on each incoming event with the event object as argument.
- changed: Fires on each event which was removed from the blockchain. The event will have the additional property
removed: true. - error: Fires on each error.
const subscription = await myContract.events.MyEvent({
filter: {myIndexedParam: [20,23], myOtherIndexedParam: '0x123456789...'}, // Using an array means OR: e.g. 20 or 23
fromBlock: 0
});
subscription.on("connected", function(subscriptionId){
console.log(subscriptionId);
});
subscription.on('data', function(event){
console.log(event); // same results as the optional callback above
});
subscription.on('changed', function(event){
// remove event from local database
})
subscription.on('error', function(error, receipt) { // If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.
...
});
// event output example
> {
returnValues: {
myIndexedParam: 20,
myOtherIndexedParam: '0x123456789...',
myNonIndexParam: 'My String'
},
raw: {
data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
},
event: 'MyEvent',
signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
logIndex: 0,
transactionIndex: 0,
transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
blockNumber: 1234,
address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
}
constructor
Parameters
args: { abi: AbiBaseFragment & { anonymous?: boolean; inputs?: readonly AbiParameter[]; name: string; type: string } & { signature: string }; address?: string; jsonInterface: ContractAbiWithSignature; topics?: (string | string[])[] }
options: { requestManager: Web3RequestManager<EthExecutionAPI>; returnFormat?: DataFormat }
Returns LogsSubscription
readonlyabi
The JSON Interface of the event.
optionalreadonlyaddress
Address of tye contract
readonlyargs
Type declaration
abi: AbiEventFragment
optionaladdress?: string
optionaltopics?: (string | string[])[]
readonlyjsonInterface
optionalreadonlytopics
The list of topics subscribed
id
Returns undefined | string
lastBlock
Returns undefined | BlockOutput
emit
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
params: { changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }[K]
Returns void
eventNames
Returns (string | symbol)[]
getMaxListeners
Returns number
listenerCount
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
fn: Web3EventCallback<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }[K]>
Returns void
on
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
fn: Web3EventCallback<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }[K]>
Returns void
once
Type parameters
- K: Web3EventKey<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }>
Parameters
eventName: K
fn: Web3EventCallback<{ changed: EventLog & { removed: true }; connected: number; data: EventLog; error: Error }[K]>
Returns void
removeAllListeners
Returns EventEmitter
resubscribe
Returns Promise<void>
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
subscribe
Returns Promise<void>
unsubscribe
Returns Promise<void>
ContractEventOptions
optionalfilter
Let you filter events by indexed parameters, e.g. {filter: {myNumber: [12,13]}} means all events where myNumber is 12 or 13.
optionalfromBlock
The block number (greater than or equal to) from which to get events on. Pre-defined block numbers as earliest, latest, pending, safe or finalized can also be used. For specific range use Contract.getPastEvents.
optionaltopics
This allows to manually set the topics for the event filter. If given the filter property and event signature, (topic[0]) will not be set automatically. Each topic can also be a nested array of topics that behaves as “or” operation between the given nested topics.
ContractOptions
optionaladdress
The address used for this contract instance. All transactions generated by web3.js from this contract will contain this address as the to.
The address will be stored in lowercase.
myContract.options.address;
> '0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae'
// set a new address
myContract.options.address = '0x1234FFDD...';
optionalreadonlyfrom
The address transactions should be made from.
optionalreadonlygas
The maximum gas provided for a transaction (gas limit).
optionalreadonlygasPrice
The gas price in wei to use for transactions.
optionalreadonlyinput
The byte code of the contract. Used when the contract gets deployed
jsonInterface
The json interface object derived from the ABI of this contract.
Re-setting this will regenerate the methods and events of the contract instance.
myContract.options.jsonInterface;
> [{
"type":"function",
"name":"foo",
"inputs": [{"name":"a","type":"uint256"}],
"outputs": [{"name":"b","type":"address"}],
"signature": "0x...",
},{
"type":"event",
"name":"Event",
"inputs": [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"bytes32","indexed":false}],
"signature": "0x...",
}]
// Set a new ABI interface
// Note: the "signature" of every function and event's ABI is not needed to be provided when assigning.
// It will be calculated and set automatically inside the setter.
myContract.options.jsonInterface = [...];Returns ContractAbiWithSignature
The json interface object derived from the ABI of this contract.
Re-setting this will regenerate the methods and events of the contract instance.
myContract.options.jsonInterface;
> [{
"type":"function",
"name":"foo",
"inputs": [{"name":"a","type":"uint256"}],
"outputs": [{"name":"b","type":"address"}],
"signature": "0x...",
},{
"type":"event",
"name":"Event",
"inputs": [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"bytes32","indexed":false}],
"signature": "0x...",
}]
// Set a new ABI interface
// Note: the "signature" of every function and event's ABI is not needed to be provided when assigning.
// It will be calculated and set automatically inside the setter.
myContract.options.jsonInterface = [...];Parameters
value: ContractAbi
Returns void
EventLog
readonlyaddress
optionalreadonlyblockHash
optionalreadonlyblockNumber
readonlydata
readonlyevent
optionalreadonlyid
optionalreadonlylogIndex
optionalreadonlyraw
Type declaration
data: string
topics: unknown[]
readonlyreturnValues
optionalreadonlysignature
readonlytopics
optionalreadonlytransactionHash
optionalreadonlytransactionIndex
NonPayableMethodObject
Type parameters
- Inputs = unknown[]
- Outputs = unknown[]
arguments
call
This will call a method and execute its smart contract method in the EVM without sending any transaction. Note calling cannot alter the smart contract state.
// using the promise
const result = await myContract.methods.myMethod(123).call({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
// MULTI-ARGUMENT RETURN:
// Solidity
contract MyContract {
function myFunction() returns(uint256 myNumber, string myString) {
return (23456, "Hello!%");
}
}
// web3.js
var MyContract = new web3.eth.Contract(abi, address);
const result = MyContract.methods.myFunction().call()
console.log(result)
> Result {
myNumber: '23456',
myString: 'Hello!%',
0: '23456', // these are here as fallbacks if the name is not know or given
1: 'Hello!%'
}
// SINGLE-ARGUMENT RETURN:
// Solidity
contract MyContract {
function myFunction() returns(string myString) {
return "Hello!%";
}
}
// web3.js
const MyContract = new web3.eth.Contract(abi, address);
const result = await MyContract.methods.myFunction().call();
console.log(result);
> "Hello!%"Type parameters
- SpecialOutput = Outputs
Parameters
optionaltx: NonPayableCallOptions
The options used for calling.
optionalblock: BlockNumberOrTag
If you pass this parameter it will not use the default block set with contract.defaultBlock. Pre-defined block numbers as
earliest,latest,pending,safeor `finalized can also be used. Useful for requesting data from or replaying transactions in past blocks.
Returns Promise<SpecialOutput>
- The return value(s) of the smart contract method. If it returns a single value, it’s returned as is. If it has multiple return values they are returned as an object with properties and indices.
createAccessList
This method generates an access list for a transaction. You must specify a
fromaddress andgasif it’s not specified in options.Parameters
optionaltx: NonPayableCallOptions
optionalblock: BlockNumberOrTag
If you pass this parameter it will not use the default block set with contract.defaultBlock. Pre-defined block numbers as
earliest,latest,pending,safeor `finalized can also be used. Useful for requesting data from or replaying transactions in past blocks.
Returns Promise<AccessListResult>
The returned data of the createAccessList, e.g. The generated access list for transaction.
const result = await MyContract.methods.myFunction().createAccessList();
console.log(result);
> {
"accessList": [
{
"address": "0x15859bdf5aff2080a9968f6a410361e9598df62f",
"storageKeys": [
"0x0000000000000000000000000000000000000000000000000000000000000000"
]
}
],
"gasUsed": "0x7671"
}
encodeABI
Encodes the ABI for this method. The resulting hex string is 32-bit function signature hash plus the passed parameters in Solidity tightly packed format. This can be used to send a transaction, call a method, or pass it into another smart contract’s method as arguments. Set the data field on
web3.eth.sendTransactionoptions as the encodeABI() result and it is the same as calling the contract method withcontract.myMethod.send().Some use cases for encodeABI() include: preparing a smart contract transaction for a multi signature wallet, working with offline wallets and cold storage and creating transaction payload for complex smart contract proxy calls.
Returns string
- The encoded ABI byte code to send via a transaction or call.
estimateGas
Returns the amount of gas consumed by executing the method locally without creating a new transaction on the blockchain. The returned amount can be used as a gas estimate for executing the transaction publicly. The actual gas used can be different when sending the transaction later, as the state of the smart contract can be different at that time.
const gasAmount = await myContract.methods.myMethod(123).estimateGas({gas: 5000000});
if(gasAmount == 5000000) {
console.log('Method ran out of gas');
}Type parameters
- ReturnFormat: DataFormat = { bytes: HEX; number: BIGINT }
Parameters
optionaloptions: NonPayableCallOptions
The options used for calling
optionalreturnFormat: ReturnFormat
The data format you want the output in.
Returns Promise<NumberTypes[ReturnFormat[number]]>
- The gas amount estimated.
send
This will send a transaction to the smart contract and execute its method. Note this can alter the smart contract state.
await myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
const receipt = await myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
// using the event emitter
const sendObj = myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
sendObj.on('transactionHash', function(hash){
...
});
sendObj.on('confirmation', function(confirmationNumber, receipt){
...
});
sendObj.on('receipt', function(receipt){
// receipt example
console.log(receipt);
> {
"transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
"transactionIndex": 0,
"blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
"blockNumber": 3,
"contractAddress": "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
"cumulativeGasUsed": 314159,
"gasUsed": 30234,
"events": {
"MyEvent": {
returnValues: {
myIndexedParam: 20,
myOtherIndexedParam: '0x123456789...',
myNonIndexParam: 'My String'
},
raw: {
data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
},
event: 'MyEvent',
signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
logIndex: 0,
transactionIndex: 0,
transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
blockNumber: 1234,
address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},
"MyOtherEvent": {
...
},
"MyMultipleEvent":[{...}, {...}] // If there are multiple of the same event, they will be in an array
}
}
});
sendObj.on('error', function(error, receipt) { // If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.
...
});Parameters
optionaltx: NonPayableCallOptions
The options used for sending.
Returns Web3PromiEvent<{ blockHash: string; blockNumber: bigint; contractAddress?: string; cumulativeGasUsed: bigint; effectiveGasPrice?: bigint; from: string; gasUsed: bigint; logs: { readonly id?: string | undefined; readonly removed?: boolean | undefined; readonly logIndex?: bigint | undefined; readonly transactionIndex?: bigint | undefined; readonly transactionHash?: string | undefined; ... 4 more ...; readonly topics?: string[] | undefined; }[]; logsBloom: string; root: string; status: bigint; to: string; transactionHash: string; transactionIndex: bigint; type?: bigint }, SendTransactionEvents<{ bytes: HEX; number: BIGINT }>>
- Returns a PromiEvent resolved with transaction receipt.
PayableMethodObject
Type parameters
- Inputs = unknown[]
- Outputs = unknown[]
arguments
call
Will call a method and execute its smart contract method in the EVM without sending any transaction. Note calling cannot alter the smart contract state.
// using the promise
const result = await myContract.methods.myMethod(123).call({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
// MULTI-ARGUMENT RETURN:
// Solidity
contract MyContract {
function myFunction() returns(uint256 myNumber, string myString) {
return (23456, "Hello!%");
}
}
// web3.js
var MyContract = new web3.eth.Contract(abi, address);
const result = MyContract.methods.myFunction().call()
console.log(result)
> Result {
myNumber: '23456',
myString: 'Hello!%',
0: '23456', // these are here as fallbacks if the name is not know or given
1: 'Hello!%'
}
// SINGLE-ARGUMENT RETURN:
// Solidity
contract MyContract {
function myFunction() returns(string myString) {
return "Hello!%";
}
}
// web3.js
const MyContract = new web3.eth.Contract(abi, address);
const result = await MyContract.methods.myFunction().call();
console.log(result);
> "Hello!%"Type parameters
- SpecialOutput = Outputs
Parameters
optionaltx: PayableCallOptions
The options used for calling.
optionalblock: BlockNumberOrTag
If you pass this parameter it will not use the default block set with contract.defaultBlock. Pre-defined block numbers as
earliest,latest,pending,safeor `finalized can also be used. Useful for requesting data from or replaying transactions in past blocks.
Returns Promise<SpecialOutput>
- The return value(s) of the smart contract method. If it returns a single value, it’s returned as is. If it has multiple return values they are returned as an object with properties and indices.
createAccessList
This method generates an access list for a transaction. You must specify a
fromaddress andgasif it’s not specified in options.Parameters
optionaltx: NonPayableCallOptions
optionalblock: BlockNumberOrTag
If you pass this parameter it will not use the default block set with contract.defaultBlock. Pre-defined block numbers as
earliest,latest,pending,safeor `finalized can also be used. Useful for requesting data from or replaying transactions in past blocks.
Returns Promise<AccessListResult>
The returned data of the createAccessList, e.g. The generated access list for transaction.
const result = await MyContract.methods.myFunction().createAccessList();
console.log(result);
> {
"accessList": [
{
"address": "0x15859bdf5aff2080a9968f6a410361e9598df62f",
"storageKeys": [
"0x0000000000000000000000000000000000000000000000000000000000000000"
]
}
],
"gasUsed": "0x7671"
}
encodeABI
Encodes the ABI for this method. The resulting hex string is 32-bit function signature hash plus the passed parameters in Solidity tightly packed format. This can be used to send a transaction, call a method, or pass it into another smart contract’s method as arguments. Set the data field on
web3.eth.sendTransactionoptions as the encodeABI() result and it is the same as calling the contract method withcontract.myMethod.send().Some use cases for encodeABI() include: preparing a smart contract transaction for a multi signature wallet, working with offline wallets and cold storage and creating transaction payload for complex smart contract proxy calls.
Returns string
- The encoded ABI byte code to send via a transaction or call.
estimateGas
Returns the amount of gas consumed by executing the method locally without creating a new transaction on the blockchain. The returned amount can be used as a gas estimate for executing the transaction publicly. The actual gas used can be different when sending the transaction later, as the state of the smart contract can be different at that time.
const gasAmount = await myContract.methods.myMethod(123).estimateGas({gas: 5000000});
if(gasAmount == 5000000) {
console.log('Method ran out of gas');
}Type parameters
- ReturnFormat: DataFormat = { bytes: HEX; number: BIGINT }
Parameters
optionaloptions: PayableCallOptions
The options used for calling
optionalreturnFormat: ReturnFormat
The data format you want the output in.
Returns Promise<NumberTypes[ReturnFormat[number]]>
- The gas amount estimated.
send
Will send a transaction to the smart contract and execute its method. Note this can alter the smart contract state.
await myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
const receipt = await myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'});
// using the event emitter
const sendObj = myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
sendObj.on('transactionHash', function(hash){
...
});
sendObj.on('confirmation', function(confirmationNumber, receipt){
...
});
sendObj.on('receipt', function(receipt){
// receipt example
console.log(receipt);
> {
"transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
"transactionIndex": 0,
"blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
"blockNumber": 3,
"contractAddress": "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
"cumulativeGasUsed": 314159,
"gasUsed": 30234,
"events": {
"MyEvent": {
returnValues: {
myIndexedParam: 20,
myOtherIndexedParam: '0x123456789...',
myNonIndexParam: 'My String'
},
raw: {
data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
},
event: 'MyEvent',
signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
logIndex: 0,
transactionIndex: 0,
transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
blockNumber: 1234,
address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},
"MyOtherEvent": {
...
},
"MyMultipleEvent":[{...}, {...}] // If there are multiple of the same event, they will be in an array
}
}
});
sendObj.on('error', function(error, receipt) { // If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.
...
});Parameters
optionaltx: PayableCallOptions
The options used for sending.
Returns Web3PromiEvent<{ blockHash: string; blockNumber: bigint; contractAddress?: string; cumulativeGasUsed: bigint; effectiveGasPrice?: bigint; from: string; gasUsed: bigint; logs: { readonly id?: string | undefined; readonly removed?: boolean | undefined; readonly logIndex?: bigint | undefined; readonly transactionIndex?: bigint | undefined; readonly transactionHash?: string | undefined; ... 4 more ...; readonly topics?: string[] | undefined; }[]; logsBloom: string; root: string; status: bigint; to: string; transactionHash: string; transactionIndex: bigint; type?: bigint }, SendTransactionEvents<{ bytes: HEX; number: BIGINT }>>
- Returns a PromiEvent object resolved with transaction receipt.
ContractAbiWithSignature
ContractBoundEvent
Type declaration
The event object can be accessed from
myContract.events.myEvent.> Remember: To subscribe to an event, your provider must have support for subscriptions.
const subscription = await myContract.events.MyEvent([options])Parameters
optionaloptions: ContractEventOptions
The options used to subscribe for the event
Returns LogsSubscription
- A Promise resolved with LogsSubscription object
ContractEventEmitterInterface
Type parameters
- Abi: ContractAbi
ContractEventsInterface
Type parameters
- Abi: ContractAbi
- Events: ContractEvents<Abi> = ContractEvents<Abi>
ContractMethodsInterface
Type parameters
- Abi: ContractAbi
ContractOverloadedMethodInputs
Type parameters
- AbiArr: ReadonlyArray<unknown>
ContractOverloadedMethodOutputs
Type parameters
- AbiArr: ReadonlyArray<unknown>
NonPayableTxOptions
PayableTxOptions
Web3ContractContext
decodeEventABI
Parameters
event: AbiBaseFragment & { anonymous?: boolean; inputs?: readonly AbiParameter[]; name: string; type: string } & { signature: string }
data: LogsInput
jsonInterface: ContractAbiWithSignature
optionalreturnFormat: DataFormat
Returns EventLog
decodeMethodReturn
Parameters
abi: AbiFunctionFragment
optionalreturnValues: string
Returns unknown
encodeEventABI
Parameters
__namedParameters: ContractOptions
event: AbiBaseFragment & { anonymous?: boolean; inputs?: readonly AbiParameter[]; name: string; type: string } & { signature: string }
optionaloptions: { filter?: Filter; fromBlock?: BlockNumberOrTag; toBlock?: BlockNumberOrTag; topics?: (null | string | string[])[] }
Returns { address?: string; filter: Filter; fromBlock?: Numbers; toBlock?: Numbers; topics?: (string | string[])[] }
encodeMethodABI
Parameters
abi: AbiFunctionFragment | AbiConstructorFragment
args: unknown[]
optionaldeployData: string
Returns string
ens
The web3.eth.ens functions let you interact with ENS. We recommend reading the ENS documentation to get deeper insights about the internals of the name service.
Breaking Changes
- All the API level interfaces returning or accepting
nullin 1.x, useundefinedin 4.x. - Functions don’t accept a callback anymore.
- Functions that accepted an optional
TransactionConfigas the last argument, now accept an optionalNonPayableCallOptions. Seeweb3-eth-contractpackage for more details.
ENS
This class is designed to interact with the ENS system on the Ethereum blockchain.
constructor
Use to create an instance of ENS
Parameters
optionalregistryAddr: string
(Optional) The address of the ENS registry (default: mainnet registry address)
optionalprovider: string | SupportedProviders<EthExecutionAPI & Web3NetAPI> | Web3ContextObject<EthExecutionAPI & Web3NetAPI, any>
(Optional) The provider to use for the ENS instance
Returns ENS
config
readonlyproviders
Type declaration
HttpProvider: Web3BaseProviderConstructor
WebsocketProvider: Web3BaseProviderConstructor
registryAddress
The registryAddress property can be used to define a custom registry address when you are connected to an unknown chain. It defaults to the main registry address.
staticoptionalgivenProvider
staticreadonlyproviders
Type declaration
HttpProvider: Web3BaseProviderConstructor
WebsocketProvider: Web3BaseProviderConstructor
BatchRequest
Will return the Web3BatchRequest constructor.
Returns new () => Web3BatchRequest
Returns Web3BatchRequest
accountProvider
Returns undefined | Web3AccountProvider<Web3BaseWalletAccount>
blockHeaderTimeout
The blockHeaderTimeout is used over socket-based connections. This option defines the amount seconds it should wait for “newBlockHeaders” event before falling back to polling to fetch transaction receipt. Default is
10seconds.Returns number
Will set the blockHeaderTimeout
Parameters
val: number
Returns void
currentProvider
Will return the current provider. (The same as
provider)Returns undefined | Web3BaseProvider<API>
Returns the current provider
Will set the current provider. (The same as
provider)Parameters
provider: undefined | string | SupportedProviders<API>
SupportedProviders The provider to set
Returns void
Returns the current provider
defaultAccount
This default address is used as the default
fromproperty, if nofromproperty is specified in for the following methods:- web3.eth.sendTransaction()
- web3.eth.call()
- myContract.methods.myMethod().call()
- myContract.methods.myMethod().send()
Returns undefined | string
Will set the default account.
Parameters
val: undefined | string
Returns void
defaultBlock
The default block is used for certain methods. You can override it by passing in the defaultBlock as last parameter. The default value is
"latest".- web3.eth.getBalance()
- web3.eth.getCode()
- web3.eth.getTransactionCount()
- web3.eth.getStorageAt()
- web3.eth.call()
- myContract.methods.myMethod().call()
Returns BlockNumberOrTag
Will set the default block.
- A block number
"earliest"- String: The genesis block"latest"- String: The latest block (current head of the blockchain)"pending"- String: The currently mined block (including pending transactions)"finalized"- String: (For POS networks) The finalized block is one which has been accepted as canonical by greater than 2/3 of validators"safe"- String: (For POS networks) The safe head block is one which under normal network conditions, is expected to be included in the canonical chain. Under normal network conditions the safe head and the actual tip of the chain will be equivalent (with safe head trailing only by a few seconds). Safe heads will be less likely to be reorged than the proof of work network`s latest blocks.
Parameters
val: BlockNumberOrTag
Returns void
defaultChain
Returns string
Parameters
val: string
Returns void
defaultCommon
Will get the default common property The default common property does contain the following Common object:
customChain-Object: The custom chain propertiesname-string: (optional) The name of the chainnetworkId-number: Network ID of the custom chainchainId-number: Chain ID of the custom chain
baseChain-string: (optional) mainnet, goerli, kovan, rinkeby, or ropstenhardfork-string: (optional) chainstart, homestead, dao, tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, istanbul, berlin, or london Default isundefined.
Returns undefined | Common
Will set the default common property
Parameters
val: undefined | Common
Returns void
defaultHardfork
Will return the default hardfork. Default is
londonThe default hardfork property can be one of the following:chainstarthomesteaddaotangerineWhistlespuriousDragonbyzantiumconstantinoplepetersburgistanbulberlinlondon- ‘arrowGlacier’,
- ‘tangerineWhistle’,
- ‘muirGlacier’
Returns string
Will set the default hardfork.
Parameters
val: string
Returns void
defaultMaxPriorityFeePerGas
defaultNetworkId
defaultTransactionType
enableExperimentalFeatures
The enableExperimentalFeatures is used to enable trying new experimental features that are still not fully implemented or not fully tested or still have some related issues. Default is
falsefor every feature.Returns { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }
useRpcCallSpecification: boolean
useSubscriptionWhenCheckingBlockTimeout: boolean
Will set the enableExperimentalFeatures
Parameters
val: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }
Returns void
events
Returns ContractEventsInterface<readonly [{ inputs: readonly []; stateMutability: nonpayable; type: constructor }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: address; name: owner; type: address }, { indexed: true; internalType: address; name: operator; type: address }, { indexed: false; internalType: bool; name: approved; type: bool }]; name: ApprovalForAll; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: true; internalType: bytes32; name: label; type: bytes32 }, { indexed: false; internalType: address; name: owner; type: address }]; name: NewOwner; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: address; name: resolver; type: address }]; name: NewResolver; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: uint64; name: ttl; type: uint64 }]; name: NewTTL; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: address; name: owner; type: address }]; name: Transfer; type: event }, { inputs: readonly [{ internalType: address; name: owner; type: address }, { internalType: address; name: operator; type: address }]; name: isApprovedForAll; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: owner; outputs: readonly [{ internalType: address; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: recordExists; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: resolver; outputs: readonly [{ internalType: address; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: address; name: operator; type: address }, { internalType: bool; name: approved; type: bool }]; name: setApprovalForAll; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: owner; type: address }]; name: setOwner; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: owner; type: address }, { internalType: address; name: resolver; type: address }, { internalType: uint64; name: ttl; type: uint64 }]; name: setRecord; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: resolver; type: address }]; name: setResolver; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: label; type: bytes32 }, { internalType: address; name: owner; type: address }]; name: setSubnodeOwner; outputs: readonly [{ internalType: bytes32; name: ; type: bytes32 }]; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: label; type: bytes32 }, { internalType: address; name: owner; type: address }, { internalType: address; name: resolver; type: address }, { internalType: uint64; name: ttl; type: uint64 }]; name: setSubnodeRecord; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint64; name: ttl; type: uint64 }]; name: setTTL; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: ttl; outputs: readonly [{ internalType: uint64; name: ; type: uint64 }]; stateMutability: view; type: function }], ContractEvents<readonly [{ inputs: readonly []; stateMutability: nonpayable; type: constructor }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: address; name: owner; type: address }, { indexed: true; internalType: address; name: operator; type: address }, { indexed: false; internalType: bool; name: approved; type: bool }]; name: ApprovalForAll; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: true; internalType: bytes32; name: label; type: bytes32 }, { indexed: false; internalType: address; name: owner; type: address }]; name: NewOwner; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: address; name: resolver; type: address }]; name: NewResolver; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: uint64; name: ttl; type: uint64 }]; name: NewTTL; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: address; name: owner; type: address }]; name: Transfer; type: event }, { inputs: readonly [{ internalType: address; name: owner; type: address }, { internalType: address; name: operator; type: address }]; name: isApprovedForAll; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: owner; outputs: readonly [{ internalType: address; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: recordExists; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: resolver; outputs: readonly [{ internalType: address; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: address; name: operator; type: address }, { internalType: bool; name: approved; type: bool }]; name: setApprovalForAll; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: owner; type: address }]; name: setOwner; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: owner; type: address }, { internalType: address; name: resolver; type: address }, { internalType: uint64; name: ttl; type: uint64 }]; name: setRecord; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: resolver; type: address }]; name: setResolver; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: label; type: bytes32 }, { internalType: address; name: owner; type: address }]; name: setSubnodeOwner; outputs: readonly [{ internalType: bytes32; name: ; type: bytes32 }]; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: label; type: bytes32 }, { internalType: address; name: owner; type: address }, { internalType: address; name: resolver; type: address }, { internalType: uint64; name: ttl; type: uint64 }]; name: setSubnodeRecord; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint64; name: ttl; type: uint64 }]; name: setTTL; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: ttl; outputs: readonly [{ internalType: uint64; name: ; type: uint64 }]; stateMutability: view; type: function }]>>
- Returns all events that can be emitted by the ENS registry.
givenProvider
Will return the givenProvider if available.
When using web3.js in an Ethereum compatible browser, it will set with the current native provider by that browser. Will return the given provider by the (browser) environment, otherwise
undefined.Returns undefined | SupportedProviders<never>
handleRevert
The
handleRevertoptions property returns the revert reason string if enabled for the following methods:- web3.eth.sendTransaction()
- web3.eth.call()
- myContract.methods.myMethod().call()
- myContract.methods.myMethod().send()
Default is
false.
Note: At the momenthandleRevertis only supported forsendTransactionand not forsendSignedTransactionReturns boolean
Will set the handleRevert
Note: At the momenthandleRevertis only supported forsendTransactionand not forsendSignedTransactionParameters
val: boolean
Returns void
maxListenersWarningThreshold
Returns number
Parameters
val: number
Returns void
provider
Will return the current provider.
Returns undefined | Web3BaseProvider<API>
Returns the current provider
Will set the current provider.
Parameters
provider: undefined | string | SupportedProviders<API>
The provider to set
Accepted providers are of type SupportedProviders
Returns void
Returns the current provider
requestManager
Returns Web3RequestManager<API>
subscriptionManager
Will return the current subscriptionManager (Web3SubscriptionManager)
Returns undefined | Web3SubscriptionManager<API, RegisteredSubs>
transactionBlockTimeout
The
transactionBlockTimeoutis used over socket-based connections. This option defines the amount of new blocks it should wait until the first confirmation happens, otherwise the PromiEvent rejects with a timeout error. Default is50.Returns number
Will set the transactionBlockTimeout.
Parameters
val: number
Returns void
transactionBuilder
Returns undefined | TransactionBuilder<unknown>
Parameters
val: undefined | TransactionBuilder<unknown>
Returns void
transactionConfirmationBlocks
This defines the number of blocks it requires until a transaction is considered confirmed. Default is
24.Returns number
Will set the transactionConfirmationBlocks.
Parameters
val: number
Returns void
transactionConfirmationPollingInterval
Returns undefined | number
Parameters
val: undefined | number
Returns void
transactionPollingInterval
Used over HTTP connections. This option defines the number of seconds between Web3 calls for a receipt which confirms that a transaction was mined by the network. Default is
1000ms.Returns number
Will set the transactionPollingInterval.
Parameters
val: number
Returns void
transactionPollingTimeout
Used over HTTP connections. This option defines the number of seconds Web3 will wait for a receipt which confirms that a transaction was mined by the network. Note: If this method times out, the transaction may still be pending. Default is
750seconds (12.5 minutes).Returns number
Will set the transactionPollingTimeout.
Parameters
val: number
Returns void
transactionReceiptPollingInterval
The
transactionPollingIntervalis used over HTTP connections. This option defines the number of seconds between Web3 calls for a receipt which confirms that a transaction was mined by the network. Default isundefinedReturns undefined | number
Will set the transactionReceiptPollingInterval
Parameters
val: undefined | number
Returns void
transactionSendTimeout
The time used to wait for Ethereum Node to return the sent transaction result. Note: If the RPC call stuck at the Node and therefor timed-out, the transaction may still be pending or even mined by the Network. We recommend checking the pending transactions in such a case. Default is
750seconds (12.5 minutes).Returns number
Will set the transactionSendTimeout.
Parameters
val: number
Returns void
transactionTypeParser
Returns undefined | TransactionTypeParser
Parameters
val: undefined | TransactionTypeParser
Returns void
wallet
Returns undefined | Web3BaseWallet<Web3BaseWalletAccount>
checkNetwork
Checks if the current used network is synced and looks for ENS support there. Throws an error if not.
Returns Promise<string>
- The address of the ENS registry if the network has been detected successfully
emit
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
params: { CONFIG_CHANGE: { name: handleRevert; newValue: boolean; oldValue: boolean } | { name: defaultAccount; newValue: undefined | string; oldValue: undefined | string } | { name: defaultBlock; newValue: BlockNumberOrTag; oldValue: BlockNumberOrTag } | { name: transactionSendTimeout; newValue: number; oldValue: number } | { name: transactionBlockTimeout; newValue: number; oldValue: number } | { name: transactionConfirmationBlocks; newValue: number; oldValue: number } | { name: transactionPollingInterval; newValue: number; oldValue: number } | { name: transactionPollingTimeout; newValue: number; oldValue: number } | { name: transactionReceiptPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: transactionConfirmationPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: blockHeaderTimeout; newValue: number; oldValue: number } | { name: maxListenersWarningThreshold; newValue: number; oldValue: number } | { name: defaultNetworkId; newValue: undefined | Numbers; oldValue: undefined | Numbers } | { name: defaultChain; newValue: string; oldValue: string } | { name: defaultHardfork; newValue: string; oldValue: string } | { name: defaultCommon; newValue: undefined | Common; oldValue: undefined | Common } | { name: defaultTransactionType; newValue: Numbers; oldValue: Numbers } | { name: defaultMaxPriorityFeePerGas; newValue: Numbers; oldValue: Numbers } | { name: enableExperimentalFeatures; newValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }; oldValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean } } | { name: transactionBuilder; newValue: undefined | TransactionBuilder<unknown>; oldValue: undefined | TransactionBuilder<unknown> } | { name: transactionTypeParser; newValue: undefined | TransactionTypeParser; oldValue: undefined | TransactionTypeParser } }[K]
Returns void
eventNames
Returns (string | symbol)[]
getAddress
Resolves an ENS name to an Ethereum address.
Parameters
ENSName: string
The ENS name to resolve
optionalcoinType: number
(Optional) The coin type, defaults to 60 (ETH)
Returns Promise<MatchPrimitiveType<bytes, unknown>>
- The Ethereum address of the given name
const address = await web3.eth.ens.getAddress('ethereum.eth');
console.log(address);
> '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
getContenthash
Returns the content hash object associated with an ENS node.
Parameters
ENSName: string
The ENS name
Returns Promise<MatchPrimitiveType<bytes, unknown>>
- The content hash object associated with an ENS node
getContextObject
Returns Web3ContextObject<EthExecutionAPI & Web3NetAPI, any>
getMaxListeners
Returns number
getOwner
Returns the owner by the given name and current configured or detected Registry
Parameters
name: string
The ENS name
Returns Promise<unknown>
- Returns the address of the owner of the name.
getPubkey
Returns the X and Y coordinates of the curve point for the public key.
Parameters
ENSName: string
The ENS name
Returns Promise<unknown[] & Record<1, MatchPrimitiveType<bytes32, unknown>> & Record<0, MatchPrimitiveType<bytes32, unknown>> & [] & Record<x, MatchPrimitiveType<bytes32, unknown>> & Record<y, MatchPrimitiveType<bytes32, unknown>>>
- The X and Y coordinates of the curve point for the public key
getResolver
Returns the Resolver by the given address
Parameters
name: string
The name of the ENS domain
Returns Promise<Contract<readonly [{ inputs: readonly [{ internalType: contract ENS; name: _ens; type: address }, { internalType: contract INameWrapper; name: wrapperAddress; type: address }, { internalType: address; name: _trustedETHController; type: address }, { internalType: address; name: _trustedReverseRegistrar; type: address }]; stateMutability: nonpayable; type: constructor }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: true; internalType: uint256; name: contentType; type: uint256 }]; name: ABIChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: address; name: a; type: address }]; name: AddrChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: uint256; name: coinType; type: uint256 }, { indexed: false; internalType: bytes; name: newAddress; type: bytes }]; name: AddressChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: address; name: owner; type: address }, { indexed: true; internalType: address; name: operator; type: address }, { indexed: false; internalType: bool; name: approved; type: bool }]; name: ApprovalForAll; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: bytes; name: hash; type: bytes }]; name: ContenthashChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: bytes; name: name; type: bytes }, { indexed: false; internalType: uint16; name: resource; type: uint16 }, { indexed: false; internalType: bytes; name: record; type: bytes }]; name: DNSRecordChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: bytes; name: name; type: bytes }, { indexed: false; internalType: uint16; name: resource; type: uint16 }]; name: DNSRecordDeleted; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }]; name: DNSZoneCleared; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: bytes; name: lastzonehash; type: bytes }, { indexed: false; internalType: bytes; name: zonehash; type: bytes }]; name: DNSZonehashChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: true; internalType: bytes4; name: interfaceID; type: bytes4 }, { indexed: false; internalType: address; name: implementer; type: address }]; name: InterfaceChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: string; name: name; type: string }]; name: NameChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: false; internalType: bytes32; name: x; type: bytes32 }, { indexed: false; internalType: bytes32; name: y; type: bytes32 }]; name: PubkeyChanged; type: event }, { anonymous: false; inputs: readonly [{ indexed: true; internalType: bytes32; name: node; type: bytes32 }, { indexed: true; internalType: string; name: indexedKey; type: string }, { indexed: false; internalType: string; name: key; type: string }]; name: TextChanged; type: event }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint256; name: contentTypes; type: uint256 }]; name: ABI; outputs: readonly [{ internalType: uint256; name: ; type: uint256 }, { internalType: bytes; name: ; type: bytes }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: addr; outputs: readonly [{ internalType: address payable; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint256; name: coinType; type: uint256 }]; name: addr; outputs: readonly [{ internalType: bytes; name: ; type: bytes }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: clearDNSZone; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: contenthash; outputs: readonly [{ internalType: bytes; name: ; type: bytes }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: name; type: bytes32 }, { internalType: uint16; name: resource; type: uint16 }]; name: dnsRecord; outputs: readonly [{ internalType: bytes; name: ; type: bytes }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: name; type: bytes32 }]; name: hasDNSRecords; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes4; name: interfaceID; type: bytes4 }]; name: interfaceImplementer; outputs: readonly [{ internalType: address; name: ; type: address }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: address; name: account; type: address }, { internalType: address; name: operator; type: address }]; name: isApprovedForAll; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes[]; name: data; type: bytes[] }]; name: multicall; outputs: readonly [{ internalType: bytes[]; name: results; type: bytes[] }]; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: name; outputs: readonly [{ internalType: string; name: ; type: string }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: pubkey; outputs: readonly [{ internalType: bytes32; name: x; type: bytes32 }, { internalType: bytes32; name: y; type: bytes32 }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint256; name: contentType; type: uint256 }, { internalType: bytes; name: data; type: bytes }]; name: setABI; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: uint256; name: coinType; type: uint256 }, { internalType: bytes; name: a; type: bytes }]; name: setAddr; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: address; name: a; type: address }]; name: setAddr; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: address; name: operator; type: address }, { internalType: bool; name: approved; type: bool }]; name: setApprovalForAll; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes; name: hash; type: bytes }]; name: setContenthash; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes; name: data; type: bytes }]; name: setDNSRecords; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes4; name: interfaceID; type: bytes4 }, { internalType: address; name: implementer; type: address }]; name: setInterface; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: string; name: newName; type: string }]; name: setName; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes32; name: x; type: bytes32 }, { internalType: bytes32; name: y; type: bytes32 }]; name: setPubkey; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: string; name: key; type: string }, { internalType: string; name: value; type: string }]; name: setText; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: bytes; name: hash; type: bytes }]; name: setZonehash; outputs: readonly []; stateMutability: nonpayable; type: function }, { inputs: readonly [{ internalType: bytes4; name: interfaceID; type: bytes4 }]; name: supportsInterface; outputs: readonly [{ internalType: bool; name: ; type: bool }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }, { internalType: string; name: key; type: string }]; name: text; outputs: readonly [{ internalType: string; name: ; type: string }]; stateMutability: view; type: function }, { inputs: readonly [{ internalType: bytes32; name: node; type: bytes32 }]; name: zonehash; outputs: readonly [{ internalType: bytes; name: ; type: bytes }]; stateMutability: view; type: function }]>>
- An contract instance of the resolver
getTTL
Returns the address of the owner of an ENS name.
Parameters
name: string
The ENS name
Returns Promise<unknown>
- Returns the caching TTL (time-to-live) of a name.
isApprovedForAll
Returns true if the operator is approved to make ENS registry operations on behalf of the owner.
Parameters
owner: string
The owner address
operator: string
The operator address
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<unknown>
trueif the operator is approved,falseotherwise
link
Link current context to another context.
Type parameters
- T: Web3Context<unknown, any, T>
Parameters
parentContext: T
Returns void
listenerCount
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
fn: Web3EventCallback<{ CONFIG_CHANGE: { name: handleRevert; newValue: boolean; oldValue: boolean } | { name: defaultAccount; newValue: undefined | string; oldValue: undefined | string } | { name: defaultBlock; newValue: BlockNumberOrTag; oldValue: BlockNumberOrTag } | { name: transactionSendTimeout; newValue: number; oldValue: number } | { name: transactionBlockTimeout; newValue: number; oldValue: number } | { name: transactionConfirmationBlocks; newValue: number; oldValue: number } | { name: transactionPollingInterval; newValue: number; oldValue: number } | { name: transactionPollingTimeout; newValue: number; oldValue: number } | { name: transactionReceiptPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: transactionConfirmationPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: blockHeaderTimeout; newValue: number; oldValue: number } | { name: maxListenersWarningThreshold; newValue: number; oldValue: number } | { name: defaultNetworkId; newValue: undefined | Numbers; oldValue: undefined | Numbers } | { name: defaultChain; newValue: string; oldValue: string } | { name: defaultHardfork; newValue: string; oldValue: string } | { name: defaultCommon; newValue: undefined | Common; oldValue: undefined | Common } | { name: defaultTransactionType; newValue: Numbers; oldValue: Numbers } | { name: defaultMaxPriorityFeePerGas; newValue: Numbers; oldValue: Numbers } | { name: enableExperimentalFeatures; newValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }; oldValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean } } | { name: transactionBuilder; newValue: undefined | TransactionBuilder<unknown>; oldValue: undefined | TransactionBuilder<unknown> } | { name: transactionTypeParser; newValue: undefined | TransactionTypeParser; oldValue: undefined | TransactionTypeParser } }[K]>
Returns void
on
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
fn: Web3EventCallback<{ CONFIG_CHANGE: { name: handleRevert; newValue: boolean; oldValue: boolean } | { name: defaultAccount; newValue: undefined | string; oldValue: undefined | string } | { name: defaultBlock; newValue: BlockNumberOrTag; oldValue: BlockNumberOrTag } | { name: transactionSendTimeout; newValue: number; oldValue: number } | { name: transactionBlockTimeout; newValue: number; oldValue: number } | { name: transactionConfirmationBlocks; newValue: number; oldValue: number } | { name: transactionPollingInterval; newValue: number; oldValue: number } | { name: transactionPollingTimeout; newValue: number; oldValue: number } | { name: transactionReceiptPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: transactionConfirmationPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: blockHeaderTimeout; newValue: number; oldValue: number } | { name: maxListenersWarningThreshold; newValue: number; oldValue: number } | { name: defaultNetworkId; newValue: undefined | Numbers; oldValue: undefined | Numbers } | { name: defaultChain; newValue: string; oldValue: string } | { name: defaultHardfork; newValue: string; oldValue: string } | { name: defaultCommon; newValue: undefined | Common; oldValue: undefined | Common } | { name: defaultTransactionType; newValue: Numbers; oldValue: Numbers } | { name: defaultMaxPriorityFeePerGas; newValue: Numbers; oldValue: Numbers } | { name: enableExperimentalFeatures; newValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }; oldValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean } } | { name: transactionBuilder; newValue: undefined | TransactionBuilder<unknown>; oldValue: undefined | TransactionBuilder<unknown> } | { name: transactionTypeParser; newValue: undefined | TransactionTypeParser; oldValue: undefined | TransactionTypeParser } }[K]>
Returns void
once
Type parameters
- K: CONFIG_CHANGE
Parameters
eventName: K
fn: Web3EventCallback<{ CONFIG_CHANGE: { name: handleRevert; newValue: boolean; oldValue: boolean } | { name: defaultAccount; newValue: undefined | string; oldValue: undefined | string } | { name: defaultBlock; newValue: BlockNumberOrTag; oldValue: BlockNumberOrTag } | { name: transactionSendTimeout; newValue: number; oldValue: number } | { name: transactionBlockTimeout; newValue: number; oldValue: number } | { name: transactionConfirmationBlocks; newValue: number; oldValue: number } | { name: transactionPollingInterval; newValue: number; oldValue: number } | { name: transactionPollingTimeout; newValue: number; oldValue: number } | { name: transactionReceiptPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: transactionConfirmationPollingInterval; newValue: undefined | number; oldValue: undefined | number } | { name: blockHeaderTimeout; newValue: number; oldValue: number } | { name: maxListenersWarningThreshold; newValue: number; oldValue: number } | { name: defaultNetworkId; newValue: undefined | Numbers; oldValue: undefined | Numbers } | { name: defaultChain; newValue: string; oldValue: string } | { name: defaultHardfork; newValue: string; oldValue: string } | { name: defaultCommon; newValue: undefined | Common; oldValue: undefined | Common } | { name: defaultTransactionType; newValue: Numbers; oldValue: Numbers } | { name: defaultMaxPriorityFeePerGas; newValue: Numbers; oldValue: Numbers } | { name: enableExperimentalFeatures; newValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean }; oldValue: { useRpcCallSpecification: boolean; useSubscriptionWhenCheckingBlockTimeout: boolean } } | { name: transactionBuilder; newValue: undefined | TransactionBuilder<unknown>; oldValue: undefined | TransactionBuilder<unknown> } | { name: transactionTypeParser; newValue: undefined | TransactionTypeParser; oldValue: undefined | TransactionTypeParser } }[K]>
Returns void
recordExists
Returns true if the record exists
Parameters
name: string
The ENS name
Returns Promise<unknown>
- Returns
trueif node exists in this ENS registry. This will returnfalsefor records that are in the legacy ENS registry but have not yet been migrated to the new one.
registerPlugin
Parameters
plugin: Web3PluginBase<unknown>
Returns void
removeAllListeners
Returns EventEmitter
setAddress
Sets the address of an ENS name in his resolver.
Parameters
name: string
The ENS name
address: string
The address to set
txConfig: NonPayableCallOptions
(Optional) The transaction config
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
const receipt = await ens.setAddress('web3js.eth','0xe2597eb05cf9a87eb1309e86750c903ec38e527e');
setApprovalForAll
Sets or clears an approval by the given operator.
Parameters
operator: string
The operator address
approved: boolean
trueto set the approval,falseto clear ittxConfig: NonPayableCallOptions
(Optional) The transaction config
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setConfig
Parameters
options: Partial<Web3ConfigOptions>
Returns void
setContenthash
Sets the content hash associated with an ENS node. Emits a
ContenthashChangedevent.Parameters
name: string
The ENS name
hash: string
The content hash to set
txConfig: NonPayableCallOptions
(Optional) The transaction config
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
setOwner
Sets the address of the owner of an ENS name.
Parameters
name: string
The ENS name
address: string
The address of the new owner
txConfig: NonPayableCallOptions
(Optional) The transaction config
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setProvider
Will set the provider.
Parameters
optionalprovider: string | SupportedProviders<EthExecutionAPI & Web3NetAPI>
SupportedProviders The provider to set
Returns boolean
Returns true if the provider was set
setPubkey
Sets the SECP256k1 public key associated with an ENS node. (Emits a
PublicKeyChangedevent)Parameters
name: string
The ENS name
x: string
The X coordinate of the public key
y: string
The Y coordinate of the public key
txConfig: NonPayableCallOptions
(Optional) The transaction config
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
const receipt = await web3.eth.ens.setPubkey(
'ethereum.eth',
'0x0000000000000000000000000000000000000000000000000000000000000000',
'0x0000000000000000000000000000000000000000000000000000000000000000',
{ from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c' });
setRecord
Returns the address of the owner of an ENS name.
Parameters
name: string
The ENS name
owner: string
The owner of the name record.
resolver: string
The resolver of the name record.
ttl: number
Time to live value
txConfig: NonPayableCallOptions
(Optional) The transaction config
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setResolver
set the resolver of the given name
Parameters
name: string
The name of the ENS domain
address: string
The address of the resolver
txConfig: NonPayableCallOptions
The transaction config
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<{ blockHash: string; blockNumber: bigint; contractAddress?: string; cumulativeGasUsed: bigint; effectiveGasPrice?: bigint; from: string; gasUsed: bigint; logs: { readonly id?: string | undefined; readonly removed?: boolean | undefined; readonly logIndex?: bigint | undefined; readonly transactionIndex?: bigint | undefined; readonly transactionHash?: string | undefined; ... 4 more ...; readonly topics?: string[] | undefined; }[]; logsBloom: string; root: string; status: bigint; to: string; transactionHash: string; transactionIndex: bigint; type?: bigint } | { code: bigint; innerError: undefined | { name: string; message: string; stack?: string | undefined; } | { name: string; message: string; stack?: string | undefined; }[]; name: string; reason: string; signature: string; stack: undefined | string; toJSON: any }>
The transaction receipt
setSubnodeOwner
Creates a new subdomain of the given node, assigning ownership of it to the specified owner.
Parameters
node: string
The ENS name
label: string
The name of the sub-domain or the sha3 hash of it
address: string
The registrar of this sub-domain
txConfig: NonPayableCallOptions
(Optional) The transaction config
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setSubnodeRecord
Sets the owner, resolver and TTL for a subdomain, creating it if necessary.
Parameters
name: string
The ENS name
label: string
The name of the sub-domain or sha3 hash of it
owner: string
The owner of the name record
resolver: string
The resolver address of the name record
ttl: number
Time to live value
txConfig: NonPayableCallOptions
(Optional) The transaction config
optionalreturnFormat: DataFormat
(Optional) The return format, defaults to DEFAULT_RETURN_FORMAT
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
setTTL
Sets the TTL of a name. Emits a NewTTL event.
Parameters
name: string
THe ENS name
ttl: number
The TTL value
txConfig: NonPayableCallOptions
(Optional) The transaction config
Returns Promise<TransactionReceipt | RevertInstructionError>
- The transaction receipt
supportsInterface
Returns true if the related Resolver does support the given signature or interfaceId.
Parameters
ENSName: string
The ENS name
interfaceId: string
The signature of the function or the interfaceId as described in the ENS documentation
Returns Promise<MatchPrimitiveType<bool, unknown>>
trueif the related Resolver does support the given signature or interfaceId.
use
Use to create new object of any type extended by
Web3Contextand link it to current context. This can be used to initiate a global context object and then use it to create new objects of any type extended byWeb3Context.Type parameters
- T: Web3Context<unknown, any, T>
- T2: unknown[]
Parameters
ContextRef: Web3ContextConstructor<T, T2>
rest...args: [...T2[]]
Returns T
staticfromContextObject
Type parameters
- T: Web3Context<unknown, any, T>
- T3: unknown[]
Parameters
this: Web3ContextConstructor<T, T3>
rest...args: [Web3ContextObject<unknown, any>, ...T3[]]
Returns T
constregistryAddresses
An object holding the addressed of the ENS registries on the different networks (mainnet, goerli).
Type declaration
[T string]: string
iban
Iban
default
IbanOptions
An object that could hold the components for an Indirect IBAN (BBAN)
Type declaration
identifier: string
institution: string
personal
The web3-eth-personal package allows you to interact with the Ethereum node’s accounts.
NOTE: Many of these functions send sensitive information like passwords. Never call these functions over a unsecured Websocket or HTTP provider, as your password will be sent in plain text!
import Personal from ‘web3-eth-personal’;
const personal = new Personal(‘http://localhost:8545');
or using the web3 umbrella package
import Personal from ‘web3-eth-personal’; const web3 = new Web3(‘http://localhost:8545'); // web3.eth.personal
Personal
default
Classes
LogsSubscription
subscribe(“logs”)
Subscribes to incoming logs, filtered by the given options. If a valid numerical fromBlock options property is set, web3.js will retrieve logs beginning from this point, backfilling the response as necessary.
You can subscribe to logs matching a given filter object, which can take the following parameters:
fromBlock: (optional, default: “latest”) Integer block number, or “latest” for the last mined block or “pending”, “earliest” for not yet mined transactions.address: (optional) Contract address or a list of addresses from which logs should originate.topics: (optional) Array of 32 Bytes DATA topics. Topics are order-dependent. Each topic can also be an array of DATA with “or” options.
constructor
Parameters
args: { address?: string | string[]; fromBlock?: BlockNumberOrTag; topics?: string[] }
options: { requestManager: Web3RequestManager<EthExecutionAPI>; returnFormat?: DataFormat }
Returns LogsSubscription
readonlyargs
Type declaration
optionalreadonlyaddress?: string | string[]
optionalreadonlyfromBlock?: BlockNumberOrTag
optionalreadonlytopics?: string[]
id
Returns undefined | string
lastBlock
Returns undefined | BlockOutput
_processSubscriptionError
Parameters
error: Error
Returns void
_processSubscriptionResult
Parameters
data: LogsOutput
Returns void
emit
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
params: CommonSubscriptionEvents & { data: LogsOutput }[K]
Returns void
eventNames
Returns (string | symbol)[]
getMaxListeners
Returns number
listenerCount
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: LogsOutput }[K]>
Returns void
on
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: LogsOutput }[K]>
Returns void
once
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: LogsOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: LogsOutput }[K]>
Returns void
removeAllListeners
Returns EventEmitter
resubscribe
Returns Promise<void>
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
subscribe
Returns Promise<void>
unsubscribe
Returns Promise<void>
NewHeadsSubscription
subscribe(“newHeads”) ( same as subscribe(“newBlockHeaders”))
Subscribes to incoming block headers. This can be used as timer to check for changes on the blockchain.
The structure of a returned block header is BlockHeaderOutput:
constructor
Parameters
args: any
options: { requestManager: Web3RequestManager<EthExecutionAPI>; returnFormat?: DataFormat }
Returns NewHeadsSubscription
readonlyargs
id
Returns undefined | string
lastBlock
Returns undefined | BlockOutput
emit
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
params: CommonSubscriptionEvents & { data: BlockHeaderOutput }[K]
Returns void
eventNames
Returns (string | symbol)[]
getMaxListeners
Returns number
listenerCount
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: BlockHeaderOutput }[K]>
Returns void
on
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: BlockHeaderOutput }[K]>
Returns void
once
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: BlockHeaderOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: BlockHeaderOutput }[K]>
Returns void
removeAllListeners
Returns EventEmitter
resubscribe
Returns Promise<void>
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
subscribe
Returns Promise<void>
unsubscribe
Returns Promise<void>
NewPendingTransactionsSubscription
subscribe(“pendingTransactions”)
Subscribes to incoming pending transactions.
You can subscribe to pending transactions by calling web3.eth.subscribe(“pendingTransactions”).
constructor
Parameters
args: any
options: { requestManager: Web3RequestManager<EthExecutionAPI>; returnFormat?: DataFormat }
Returns NewPendingTransactionsSubscription
readonlyargs
id
Returns undefined | string
lastBlock
Returns undefined | BlockOutput
emit
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
params: CommonSubscriptionEvents & { data: string }[K]
Returns void
eventNames
Returns (string | symbol)[]
getMaxListeners
Returns number
listenerCount
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: string }[K]>
Returns void
on
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: string }[K]>
Returns void
once
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { data: string }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { data: string }[K]>
Returns void
removeAllListeners
Returns EventEmitter
resubscribe
Returns Promise<void>
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
subscribe
Returns Promise<void>
unsubscribe
Returns Promise<void>
SyncingSubscription
subscribe(“syncing”)
Subscribe to syncing events. This will return true when the node is syncing and when it’s finished syncing will return false, for the changed event.
constructor
Parameters
args: any
options: { requestManager: Web3RequestManager<EthExecutionAPI>; returnFormat?: DataFormat }
Returns SyncingSubscription
readonlyargs
id
Returns undefined | string
lastBlock
Returns undefined | BlockOutput
emit
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
params: CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }[K]
Returns void
eventNames
Returns (string | symbol)[]
getMaxListeners
Returns number
listenerCount
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
Returns number
listeners
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
Returns Function[]
off
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }[K]>
Returns void
on
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }[K]>
Returns void
once
Type parameters
- K: Web3EventKey<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }>
Parameters
eventName: K
fn: Web3EventCallback<CommonSubscriptionEvents & { changed: boolean; data: SyncOutput }[K]>
Returns void
removeAllListeners
Returns EventEmitter
resubscribe
Returns Promise<void>
setMaxListenerWarningThreshold
Parameters
maxListenersWarningThreshold: number
Returns void
subscribe
Returns Promise<void>
unsubscribe
Returns Promise<void>
Interfaces
RevertReason
optionaldata
reason
optionalsignature
RevertReasonWithCustomError
customErrorArguments
customErrorDecodedSignature
customErrorName
optionaldata
reason
optionalsignature
SendSignedTransactionOptions
Type parameters
- ResolveType = TransactionReceipt
optionalcheckRevertBeforeSending
optionalcontractAbi
optionaltransactionResolver
Parameters
receipt: TransactionReceipt
Returns ResolveType
SendTransactionOptions
Type parameters
- ResolveType = TransactionReceipt
optionalcheckRevertBeforeSending
optionalcontractAbi
optionalignoreGasPricing
optionaltransactionResolver
Parameters
receipt: TransactionReceipt
Returns ResolveType
Type Aliases
InternalTransaction
SendSignedTransactionEvents
Type parameters
- ReturnFormat: DataFormat
Type declaration
confirmation: { confirmations: FormatType<Numbers, ReturnFormat>; latestBlockHash: FormatType<Bytes, ReturnFormat>; receipt: FormatType<TransactionReceipt, ReturnFormat> }
confirmations: FormatType<Numbers, ReturnFormat>
latestBlockHash: FormatType<Bytes, ReturnFormat>
receipt: FormatType<TransactionReceipt, ReturnFormat>
error: TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>> | InvalidResponseError | ContractExecutionError
receipt: FormatType<TransactionReceipt, ReturnFormat>
sending: FormatType<Bytes, typeof ETH_DATA_FORMAT>
sent: FormatType<Bytes, typeof ETH_DATA_FORMAT>
transactionHash: FormatType<Bytes, ReturnFormat>
SendTransactionEvents
Type parameters
- ReturnFormat: DataFormat
Type declaration
confirmation: { confirmations: FormatType<Numbers, ReturnFormat>; latestBlockHash: FormatType<Bytes, ReturnFormat>; receipt: FormatType<TransactionReceipt, ReturnFormat> }
confirmations: FormatType<Numbers, ReturnFormat>
latestBlockHash: FormatType<Bytes, ReturnFormat>
receipt: FormatType<TransactionReceipt, ReturnFormat>
error: TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>> | TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>> | InvalidResponseError | ContractExecutionError
receipt: FormatType<TransactionReceipt, ReturnFormat>
sending: FormatType<Transaction, typeof ETH_DATA_FORMAT>
sent: FormatType<Transaction, typeof ETH_DATA_FORMAT>
transactionHash: FormatType<Bytes, ReturnFormat>
Variables
constaccessListItemSchema
Type declaration
properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }
address: { eth: string }
eth: string
storageKeys: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
constaccessListResultSchema
Type declaration
properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; gasUsed: { type: string } }
accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }
items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }
properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }
address: { eth: string }
eth: string
storageKeys: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
type: string
gasUsed: { type: string }
type: string
type: string
constaccessListSchema
Type declaration
items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }
properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }
address: { eth: string }
eth: string
storageKeys: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
type: string
constaccountSchema
Type declaration
properties: { accountProof: { items: { eth: string }; type: string }; balance: { eth: string }; codeHash: { eth: string }; nonce: { eth: string }; storageHash: { eth: string }; storageProof: { items: { properties: { key: { eth: string }; proof: { items: { eth: string }; type: string }; value: { eth: string } }; type: string }; type: string } }
accountProof: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
balance: { eth: string }
eth: string
codeHash: { eth: string }
eth: string
nonce: { eth: string }
eth: string
storageHash: { eth: string }
eth: string
storageProof: { items: { properties: { key: { eth: string }; proof: { items: { eth: string }; type: string }; value: { eth: string } }; type: string }; type: string }
items: { properties: { key: { eth: string }; proof: { items: { eth: string }; type: string }; value: { eth: string } }; type: string }
properties: { key: { eth: string }; proof: { items: { eth: string }; type: string }; value: { eth: string } }
key: { eth: string }
eth: string
proof: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
value: { eth: string }
eth: string
type: string
type: string
type: string
constblockHeaderSchema
Type declaration
properties: { difficulty: { eth: string }; extraData: { eth: string }; gasLimit: { eth: string }; gasUsed: { eth: string }; logsBloom: { eth: string }; miner: { eth: string }; nonce: { eth: string }; number: { eth: string }; parentHash: { eth: string }; receiptRoot: { eth: string }; sha3Uncles: { eth: string }; stateRoot: { eth: string }; timestamp: { eth: string }; transactionsRoot: { eth: string } }
difficulty: { eth: string }
eth: string
extraData: { eth: string }
eth: string
gasLimit: { eth: string }
eth: string
gasUsed: { eth: string }
eth: string
logsBloom: { eth: string }
eth: string
miner: { eth: string }
eth: string
nonce: { eth: string }
eth: string
number: { eth: string }
eth: string
parentHash: { eth: string }
eth: string
receiptRoot: { eth: string }
eth: string
sha3Uncles: { eth: string }
eth: string
stateRoot: { eth: string }
eth: string
timestamp: { eth: string }
eth: string
transactionsRoot: { eth: string }
eth: string
type: string
constblockSchema
Type declaration
properties: { baseFeePerGas: { eth: string }; difficulty: { eth: string }; extraData: { eth: string }; gasLimit: { eth: string }; gasUsed: { eth: string }; hash: { eth: string }; logsBloom: { eth: string }; miner: { eth: string }; mixHash: { eth: string }; nonce: { eth: string }; number: { eth: string }; parentHash: { eth: string }; receiptsRoot: { eth: string }; sha3Uncles: { eth: string }; size: { eth: string }; stateRoot: { eth: string }; timestamp: { eth: string }; totalDifficulty: { eth: string }; transactions: { oneOf: ({ items: { eth?: undefined; properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; blockHash: { eth: string }; blockNumber: { eth: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; hash: { eth: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; transactionIndex: { eth: string }; type: { eth: string }; v: { eth: string }; value: { eth: string } }; type: string }; type: string } | { items: { eth: string }; type: string })[] }; transactionsRoot: { eth: string }; uncles: { items: { eth: string }; type: string } }
baseFeePerGas: { eth: string }
eth: string
difficulty: { eth: string }
eth: string
extraData: { eth: string }
eth: string
gasLimit: { eth: string }
eth: string
gasUsed: { eth: string }
eth: string
hash: { eth: string }
eth: string
logsBloom: { eth: string }
eth: string
miner: { eth: string }
eth: string
mixHash: { eth: string }
eth: string
nonce: { eth: string }
eth: string
number: { eth: string }
eth: string
parentHash: { eth: string }
eth: string
receiptsRoot: { eth: string }
eth: string
sha3Uncles: { eth: string }
eth: string
size: { eth: string }
eth: string
stateRoot: { eth: string }
eth: string
timestamp: { eth: string }
eth: string
totalDifficulty: { eth: string }
eth: string
transactions: { oneOf: ({ items: { eth?: undefined; properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; blockHash: { eth: string }; blockNumber: { eth: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; hash: { eth: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; transactionIndex: { eth: string }; type: { eth: string }; v: { eth: string }; value: { eth: string } }; type: string }; type: string } | { items: { eth: string }; type: string })[] }
oneOf: ({ items: { eth?: undefined; properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; blockHash: { eth: string }; blockNumber: { eth: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; hash: { eth: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; transactionIndex: { eth: string }; type: { eth: string }; v: { eth: string }; value: { eth: string } }; type: string }; type: string } | { items: { eth: string }; type: string })[]
transactionsRoot: { eth: string }
eth: string
uncles: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
constchainSchema
Type declaration
enum: string[]
type: string
constcustomChainSchema
Type declaration
properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }
chainId: { eth: string }
eth: string
name: { eth: string }
eth: string
networkId: { eth: string }
eth: string
type: string
constfeeHistorySchema
Type declaration
properties: { baseFeePerGas: { items: { eth: string }; type: string }; gasUsedRatio: { items: { type: string }; type: string }; oldestBlock: { eth: string }; reward: { items: { items: { eth: string }; type: string }; type: string } }
baseFeePerGas: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
gasUsedRatio: { items: { type: string }; type: string }
items: { type: string }
type: string
type: string
oldestBlock: { eth: string }
eth: string
reward: { items: { items: { eth: string }; type: string }; type: string }
items: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
type: string
consthardforkSchema
Type declaration
enum: string[]
type: string
constlogSchema
Type declaration
properties: { address: { eth: string }; blockHash: { eth: string }; blockNumber: { eth: string }; data: { eth: string }; logIndex: { eth: string }; removed: { eth: string }; topics: { items: { eth: string }; type: string }; transactionHash: { eth: string }; transactionIndex: { eth: string } }
address: { eth: string }
eth: string
blockHash: { eth: string }
eth: string
blockNumber: { eth: string }
eth: string
data: { eth: string }
eth: string
logIndex: { eth: string }
eth: string
removed: { eth: string }
eth: string
topics: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
transactionHash: { eth: string }
eth: string
transactionIndex: { eth: string }
eth: string
type: string
constregisteredSubscriptions
Type declaration
logs: typeof LogsSubscription
newBlockHeaders: typeof NewHeadsSubscription
newHeads: typeof NewHeadsSubscription
newPendingTransactions: typeof NewPendingTransactionsSubscription
pendingTransactions: typeof NewPendingTransactionsSubscription
syncing: typeof SyncingSubscription
conststorageProofSchema
Type declaration
properties: { key: { eth: string }; proof: { items: { eth: string }; type: string }; value: { eth: string } }
key: { eth: string }
eth: string
proof: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
value: { eth: string }
eth: string
type: string
constsyncSchema
Type declaration
properties: { currentBlock: { eth: string }; highestBlock: { eth: string }; knownStates: { eth: string }; pulledStates: { eth: string }; startingBlock: { eth: string } }
currentBlock: { eth: string }
eth: string
highestBlock: { eth: string }
eth: string
knownStates: { eth: string }
eth: string
pulledStates: { eth: string }
eth: string
startingBlock: { eth: string }
eth: string
type: string
consttransactionInfoSchema
Type declaration
properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; blockHash: { eth: string }; blockNumber: { eth: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; hash: { eth: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; transactionIndex: { eth: string }; type: { eth: string }; v: { eth: string }; value: { eth: string } }
accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }
items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }
properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }
address: { eth: string }
eth: string
storageKeys: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
type: string
blockHash: { eth: string }
eth: string
blockNumber: { eth: string }
eth: string
chain: { enum: string[]; type: string }
enum: string[]
type: string
chainId: { eth: string }
eth: string
common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }
properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }
baseChain: { enum: string[]; type: string }
enum: string[]
type: string
customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }
properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }
chainId: { eth: string }
eth: string
name: { eth: string }
eth: string
networkId: { eth: string }
eth: string
type: string
hardfork: { enum: string[]; type: string }
enum: string[]
type: string
type: string
data: { eth: string }
eth: string
effectiveGasPrice: { eth: string }
eth: string
from: { eth: string }
eth: string
gas: { eth: string }
eth: string
gasLimit: { eth: string }
eth: string
gasPrice: { eth: string }
eth: string
hardfork: { enum: string[]; type: string }
enum: string[]
type: string
hash: { eth: string }
eth: string
input: { eth: string }
eth: string
maxFeePerGas: { eth: string }
eth: string
maxPriorityFeePerGas: { eth: string }
eth: string
networkId: { eth: string }
eth: string
nonce: { eth: string }
eth: string
r: { eth: string }
eth: string
s: { eth: string }
eth: string
to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }
oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[]
transactionIndex: { eth: string }
eth: string
type: { eth: string }
eth: string
v: { eth: string }
eth: string
value: { eth: string }
eth: string
type: string
consttransactionReceiptSchema
Type declaration
properties: { blockHash: { eth: string }; blockNumber: { eth: string }; contractAddress: { eth: string }; cumulativeGasUsed: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gasUsed: { eth: string }; logs: { items: { properties: { address: { eth: string }; blockHash: { eth: string }; blockNumber: { eth: string }; data: { eth: string }; logIndex: { eth: string }; removed: { eth: string }; topics: { items: { eth: string }; type: string }; transactionHash: { eth: string }; transactionIndex: { eth: string } }; type: string }; type: string }; logsBloom: { eth: string }; root: { eth: string }; status: { eth: string }; to: { eth: string }; transactionHash: { eth: string }; transactionIndex: { eth: string }; type: { eth: string } }
blockHash: { eth: string }
eth: string
blockNumber: { eth: string }
eth: string
contractAddress: { eth: string }
eth: string
cumulativeGasUsed: { eth: string }
eth: string
effectiveGasPrice: { eth: string }
eth: string
from: { eth: string }
eth: string
gasUsed: { eth: string }
eth: string
logs: { items: { properties: { address: { eth: string }; blockHash: { eth: string }; blockNumber: { eth: string }; data: { eth: string }; logIndex: { eth: string }; removed: { eth: string }; topics: { items: { eth: string }; type: string }; transactionHash: { eth: string }; transactionIndex: { eth: string } }; type: string }; type: string }
items: { properties: { address: { eth: string }; blockHash: { eth: string }; blockNumber: { eth: string }; data: { eth: string }; logIndex: { eth: string }; removed: { eth: string }; topics: { items: { eth: string }; type: string }; transactionHash: { eth: string }; transactionIndex: { eth: string } }; type: string }
properties: { address: { eth: string }; blockHash: { eth: string }; blockNumber: { eth: string }; data: { eth: string }; logIndex: { eth: string }; removed: { eth: string }; topics: { items: { eth: string }; type: string }; transactionHash: { eth: string }; transactionIndex: { eth: string } }
address: { eth: string }
eth: string
blockHash: { eth: string }
eth: string
blockNumber: { eth: string }
eth: string
data: { eth: string }
eth: string
logIndex: { eth: string }
eth: string
removed: { eth: string }
eth: string
topics: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
transactionHash: { eth: string }
eth: string
transactionIndex: { eth: string }
eth: string
type: string
type: string
logsBloom: { eth: string }
eth: string
root: { eth: string }
eth: string
status: { eth: string }
eth: string
to: { eth: string }
eth: string
transactionHash: { eth: string }
eth: string
transactionIndex: { eth: string }
eth: string
type: { eth: string }
eth: string
type: string
consttransactionSchema
Type declaration
properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; type: { eth: string }; v: { eth: string }; value: { eth: string } }
accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }
items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }
properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }
address: { eth: string }
eth: string
storageKeys: { items: { eth: string }; type: string }
items: { eth: string }
eth: string
type: string
type: string
type: string
chain: { enum: string[]; type: string }
enum: string[]
type: string
chainId: { eth: string }
eth: string
common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }
properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }
baseChain: { enum: string[]; type: string }
enum: string[]
type: string
customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }
properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }
chainId: { eth: string }
eth: string
name: { eth: string }
eth: string
networkId: { eth: string }
eth: string
type: string
hardfork: { enum: string[]; type: string }
enum: string[]
type: string
type: string
data: { eth: string }
eth: string
effectiveGasPrice: { eth: string }
eth: string
from: { eth: string }
eth: string
gas: { eth: string }
eth: string
gasLimit: { eth: string }
eth: string
gasPrice: { eth: string }
eth: string
hardfork: { enum: string[]; type: string }
enum: string[]
type: string
input: { eth: string }
eth: string
maxFeePerGas: { eth: string }
eth: string
maxPriorityFeePerGas: { eth: string }
eth: string
networkId: { eth: string }
eth: string
nonce: { eth: string }
eth: string
r: { eth: string }
eth: string
s: { eth: string }
eth: string
to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }
oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[]
type: { eth: string }
eth: string
v: { eth: string }
eth: string
value: { eth: string }
eth: string
type: string
Functions
call
Executes a message call within the EVM without creating a transaction. It does not publish anything to the blockchain and does not consume any gas.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transaction: TransactionCall
A transaction object where all properties are optional except
to, however it’s recommended to include thefromproperty or it may default to0x0000000000000000000000000000000000000000depending on your node or provider.blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) - Specifies what block to use as the current state of the blockchain while processing the transaction.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<string>
The returned data of the call, e.g. a smart contract function’s return value.
createAccessList
This function generates access list for a transaction.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transaction: TransactionForAccessList
A transaction object where all properties are optional except
from, however it’s also recommended to include thetoproperty.blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) - Specifies what block to use as the current state of the blockchain while sending this request.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data should be formatted.
Returns Promise<{ accessList?: { address?: string; storageKeys?: string[] }[]; gasUsed?: NumberTypes[ReturnFormat[number]] }>
The returned data of the createAccessList, e.g. The generated access list for transaction.
detectTransactionType
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
optionalweb3Context: Web3Context<EthExecutionAPI, any>
Returns undefined | string
estimateGas
Simulates the transaction within the EVM to estimate the amount of gas to be used by the transaction. The transaction will not be added to the blockchain, and actual gas usage can vary when interacting with a contract as a result of updating the contract’s state.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transaction: Transaction
The Transaction object to estimate the gas for.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) - Specifies what block to use as the current state of the blockchain while processing the gas estimation.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The used gas for the simulated transaction execution.
const transaction = {
from: '0xe899f0130FD099c0b896B2cE4E5E15A25b23139a',
to: '0xe899f0130FD099c0b896B2cE4E5E15A25b23139a',
value: '0x1',
nonce: '0x1',
type: '0x0'
}
web3.eth.estimateGas(transaction).then(console.log);
> 21000n
web3.eth.estimateGas(transaction, { number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }).then(console.log);
> 21000
formatTransaction
Type parameters
- ReturnFormat: DataFormat = { bytes: HEX; number: BIGINT }
- TransactionType: Transaction = Transaction
Parameters
transaction: TransactionType
optionalreturnFormat: ReturnFormat
optionaloptions: { transactionSchema: { properties: { accessList: { items: { properties: { address: { eth: string }; storageKeys: { items: { eth: string }; type: string } }; type: string }; type: string }; chain: { enum: string[]; type: string }; chainId: { eth: string }; common: { properties: { baseChain: { enum: string[]; type: string }; customChain: { properties: { chainId: { eth: string }; name: { eth: string }; networkId: { eth: string } }; type: string }; hardfork: { enum: string[]; type: string } }; type: string }; data: { eth: string }; effectiveGasPrice: { eth: string }; from: { eth: string }; gas: { eth: string }; gasLimit: { eth: string }; gasPrice: { eth: string }; hardfork: { enum: string[]; type: string }; input: { eth: string }; maxFeePerGas: { eth: string }; maxPriorityFeePerGas: { eth: string }; networkId: { eth: string }; nonce: { eth: string }; r: { eth: string }; s: { eth: string }; to: { oneOf: ({ eth: string; type?: undefined } | { eth?: undefined; type: string })[] }; type: { eth: string }; v: { eth: string }; value: { eth: string } }; type: string } | ValidationSchemaInput }
Returns FormatType<TransactionType, ReturnFormat>
getBalance
Get the balance of an address at a given block.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
address: string
The address to get the balance of.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) Specifies what block to use as the current state for the balance query.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The current balance for the given address in
wei.web3.eth.getBalance("0x407d73d8a49eeb85d32cf465507dd71d507100c1").then(console.log);
> 1000000000000n
web3.eth.getBalance("0x407d73d8a49eeb85d32cf465507dd71d507100c1", { number: FMT_NUMBER.HEX , bytes: FMT_BYTES.HEX }).then(console.log);
> "0xe8d4a51000"
getBlock
Retrieves a Block matching the provided block number, block hash or block tag.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
block: undefined | string | number | bigint | Buffer | ArrayBuffer | Uint8Array
The BlockNumberOrTag (defaults to Web3Eth.defaultBlock) or block hash of the desired block.
hydrated: undefined | boolean
If specified
true, the returned block will contain all transactions as objects. Iffalseit will only contain transaction hashes.returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted (does not format transaction objects or hashes).
Returns Promise<{ baseFeePerGas?: NumberTypes[ReturnFormat[number]]; difficulty?: NumberTypes[ReturnFormat[number]]; extraData: ByteTypes[ReturnFormat[bytes]]; gasLimit: NumberTypes[ReturnFormat[number]]; gasUsed: NumberTypes[ReturnFormat[number]]; hash?: ByteTypes[ReturnFormat[bytes]]; logsBloom?: ByteTypes[ReturnFormat[bytes]]; miner: ByteTypes[ReturnFormat[bytes]]; mixHash: ByteTypes[ReturnFormat[bytes]]; nonce: NumberTypes[ReturnFormat[number]]; number: NumberTypes[ReturnFormat[number]]; parentHash: ByteTypes[ReturnFormat[bytes]]; receiptsRoot: ByteTypes[ReturnFormat[bytes]]; sha3Uncles: ByteTypes[ReturnFormat[bytes]]; size: NumberTypes[ReturnFormat[number]]; stateRoot: ByteTypes[ReturnFormat[bytes]]; timestamp: NumberTypes[ReturnFormat[number]]; totalDifficulty: NumberTypes[ReturnFormat[number]]; transactions: string[] | { accessList?: { address?: string; storageKeys?: string[] }[]; blockHash?: ByteTypes[ReturnFormat[bytes]]; blockNumber?: NumberTypes[ReturnFormat[number]]; chain?: ValidChains; chainId?: NumberTypes[ReturnFormat[number]]; common?: { baseChain?: ValidChains; customChain: { chainId: NumberTypes[ReturnFormat[number]]; name?: string; networkId: NumberTypes[ReturnFormat[number]] }; hardfork?: Hardfork }; data?: ByteTypes[ReturnFormat[bytes]]; from: string; gas?: NumberTypes[ReturnFormat[number]]; gasLimit?: NumberTypes[ReturnFormat[number]]; gasPrice?: NumberTypes[ReturnFormat[number]]; hardfork?: Hardfork; hash: ByteTypes[ReturnFormat[bytes]]; input?: ByteTypes[ReturnFormat[bytes]]; maxFeePerGas?: NumberTypes[ReturnFormat[number]]; maxPriorityFeePerGas?: NumberTypes[ReturnFormat[number]]; networkId?: NumberTypes[ReturnFormat[number]]; nonce?: NumberTypes[ReturnFormat[number]]; r?: ByteTypes[ReturnFormat[bytes]]; s?: ByteTypes[ReturnFormat[bytes]]; to?: string | null; transactionIndex?: NumberTypes[ReturnFormat[number]]; type?: NumberTypes[ReturnFormat[number]]; v?: NumberTypes[ReturnFormat[number]]; value?: NumberTypes[ReturnFormat[number]]; yParity?: string }[]; transactionsRoot: ByteTypes[ReturnFormat[bytes]]; uncles: string[] }>
A Block object matching the provided block number or block hash.
web3.eth.getBlock(0).then(console.log);
> {
hash: '0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d',
parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
sha3Uncles: '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
miner: '0x0000000000000000000000000000000000000000',
stateRoot: '0x5ed9882897d363c4632a6e67fba6203df61bd994813dcf048da59be442a9c6c4',
transactionsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
receiptsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
difficulty: 1n,
number: 0n,
gasLimit: 30000000n,
gasUsed: 0n,
timestamp: 1658281638n,
extraData: '0x',
mixHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
nonce: 0n,
totalDifficulty: 1n,
baseFeePerGas: 1000000000n,
size: 514n,
transactions: [],
uncles: []
}
web3.eth.getBlock(
"0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d",
false,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> {
hash: '0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d',
parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
sha3Uncles: '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
miner: '0x0000000000000000000000000000000000000000',
stateRoot: '0x5ed9882897d363c4632a6e67fba6203df61bd994813dcf048da59be442a9c6c4',
transactionsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
receiptsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
difficulty: 1,
number: 0,
gasLimit: 30000000,
gasUsed: 0,
timestamp: 1658281638,
extraData: '0x',
mixHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
nonce: 0,
totalDifficulty: 1,
baseFeePerGas: 1000000000,
size: 514,
transactions: [],
uncles: []
}
getBlockNumber
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The current block number.
web3.eth.getBlockNumber().then(console.log);
> 2744n
web3.eth.getBlockNumber({ number: FMT_NUMBER.HEX , bytes: FMT_BYTES.HEX }).then(console.log);
> "0xab8"
getBlockTransactionCount
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
block: undefined | string | number | bigint | Buffer | ArrayBuffer | Uint8Array
The BlockNumberOrTag (defaults to Web3Eth.defaultBlock) or block hash of the desired block.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The number of transactions in the provided block.
web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1").then(console.log);
> 1n
web3.eth.getBlockTransactionCount(
"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> 1
getBlockUncleCount
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
block: undefined | string | number | bigint | Buffer | ArrayBuffer | Uint8Array
The BlockNumberOrTag (defaults to Web3Eth.defaultBlock) or block hash of the desired block.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The number of uncles in the provided block.
web3.eth.getBlockUncleCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1").then(console.log);
> 1n
web3.eth.getBlockUncleCount(
"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> 1
getChainId
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The chain ID of the current connected node as described in the EIP-695.
web3.eth.getChainId().then(console.log);
> 61n
web3.eth.getChainId({ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }).then(console.log);
> 61
getCode
Get the code at a specific address.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
address: string
The address to get the code from.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) Specifies what block to use as the current state for the code query.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<string>
The data at the provided
address.web3.eth.getCode("0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234").then(console.log);
> "0x600160008035811a818181146012578301005b601b6001356025565b8060005260206000f25b600060078202905091905056"
web3.eth.getCode(
"0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234",
undefined,
{ number: FMT_NUMBER.HEX , bytes: FMT_BYTES.BUFFER }
).then(console.log);
> <Buffer 30 78 36 30 30 31 36 30 30 30 38 30 33 35 38 31 31 61 38 31 38 31 38 31 31 34 36 30 31 32 35 37 38 33 30 31 30 30 35 62 36 30 31 62 36 30 30 31 33 35 ... >
getCoinbase
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
Returns Promise<string>
Returns the coinbase address to which mining rewards will go.
web3.eth.getCoinbase().then(console.log);
> "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe"
getFeeHistory
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
blockCount: Numbers
Number of blocks in the requested range. Between
1and1024blocks can be requested in a single query. Less than requested may be returned if not all blocks are available.newestBlock: undefined | BlockNumberOrTag
Highest number block of the requested range.
rewardPercentiles: Numbers[]
A monotonically increasing list of percentile values to sample from each block’s effective priority fees per gas in ascending order, weighted by gas used. Example:
[“0”, “25”, “50”, “75”, “100”]or[“0”, “0.5”, “1”, “1.5”, “3”, “80”]returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<{ baseFeePerGas: NumberTypes[ReturnFormat[number]]; gasUsedRatio: NumberTypes[ReturnFormat[number]][]; oldestBlock: NumberTypes[ReturnFormat[number]]; reward: NumberTypes[ReturnFormat[number]][][] }>
baseFeePerGasand transaction effectivepriorityFeePerGashistory for the requested block range if available. The range betweenheadBlock - 4andheadBlockis guaranteed to be available while retrieving data from thependingblock and older history are optional to support. For pre-EIP-1559 blocks thegasPrices are returned asrewardsand zeroes are returned for thebaseFeePerGas.web3.eth.getFeeHistory(4, 'pending', [0, 25, 75, 100]).then(console.log);
> {
baseFeePerGas: [
22983878621n,
21417903463n,
19989260230n,
17770954829n,
18850641304n
],
gasUsedRatio: [
0.22746546666666667,
0.2331871,
0.05610054885262125,
0.7430227268212117
],
oldestBlock: 15216343n,
reward: [
[ '0x3b9aca00', '0x53724e00', '0x77359400', '0x1d92c03423' ],
[ '0x3b9aca00', '0x3b9aca00', '0x3b9aca00', '0xee6b2800' ],
[ '0x3b9aca00', '0x4f86a721', '0x77d9743a', '0x9502f900' ],
[ '0xcc8ff9e', '0x53724e00', '0x77359400', '0x1ec9771bb3' ]
]
}
web3.eth.getFeeHistory(4, BlockTags.LATEST, [0, 25, 75, 100], { number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }).then(console.log);
> {
baseFeePerGas: [
22983878621,
21417903463,
19989260230,
17770954829,
18850641304
],
gasUsedRatio: [
0.22746546666666667,
0.2331871,
0.05610054885262125,
0.7430227268212117
],
oldestBlock: 15216343,
reward: [
[ '0x3b9aca00', '0x53724e00', '0x77359400', '0x1d92c03423' ],
[ '0x3b9aca00', '0x3b9aca00', '0x3b9aca00', '0xee6b2800' ],
[ '0x3b9aca00', '0x4f86a721', '0x77d9743a', '0x9502f900' ],
[ '0xcc8ff9e', '0x53724e00', '0x77359400', '0x1ec9771bb3' ]
]
}
getGasPrice
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The gas price determined by the last few blocks median gas price.
web3.eth.getGasPrice().then(console.log);
> 20000000000n
web3.eth.getGasPrice({ number: FMT_NUMBER.HEX , bytes: FMT_BYTES.HEX }).then(console.log);
> "0x4a817c800"
getHashRate
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The number of hashes per second that the node is mining with.
web3.eth.getHashRate().then(console.log);
> 493736n
web3.eth.getHashRate({ number: FMT_NUMBER.HEX , bytes: FMT_BYTES.HEX }).then(console.log);
> "0x788a8"
getLogs
Gets past logs, matching the provided
filter.Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<Web3EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
filter: Filter
A Filter object containing the properties for the desired logs.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<(string | { address?: string; blockHash?: ByteTypes[ReturnFormat[bytes]]; blockNumber?: NumberTypes[ReturnFormat[number]]; data?: ByteTypes[ReturnFormat[bytes]]; id?: string; logIndex?: NumberTypes[ReturnFormat[number]]; removed?: boolean; topics?: ByteTypes[ReturnFormat[bytes]][]; transactionHash?: ByteTypes[ReturnFormat[bytes]]; transactionIndex?: NumberTypes[ReturnFormat[number]] })[]>
FilterResultsAPI, an array of Log objects.
web3.eth.getPastLogs({
address: "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
topics: ["0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"]
}).then(console.log);
> [{
data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
logIndex: 0n,
transactionIndex: 0n,
transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
blockNumber: 1234n,
address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},
{...}]
web3.eth.getPastLogs(
{
address: "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
topics: ["0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"]
},
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> [{
data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
logIndex: 0,
transactionIndex: 0,
transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
blockNumber: 1234,
address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},
{...}]
getPendingTransactions
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<{ accessList?: { address?: string; storageKeys?: string[] }[]; chain?: ValidChains; chainId?: NumberTypes[ReturnFormat[number]]; common?: { baseChain?: ValidChains; customChain: { chainId: NumberTypes[ReturnFormat[number]]; name?: string; networkId: NumberTypes[ReturnFormat[number]] }; hardfork?: Hardfork }; data?: ByteTypes[ReturnFormat[bytes]]; from?: string; gas?: NumberTypes[ReturnFormat[number]]; gasLimit?: NumberTypes[ReturnFormat[number]]; gasPrice?: NumberTypes[ReturnFormat[number]]; hardfork?: Hardfork; input?: ByteTypes[ReturnFormat[bytes]]; maxFeePerGas?: NumberTypes[ReturnFormat[number]]; maxPriorityFeePerGas?: NumberTypes[ReturnFormat[number]]; networkId?: NumberTypes[ReturnFormat[number]]; nonce?: NumberTypes[ReturnFormat[number]]; r?: ByteTypes[ReturnFormat[bytes]]; s?: ByteTypes[ReturnFormat[bytes]]; to?: string | null; type?: NumberTypes[ReturnFormat[number]]; v?: NumberTypes[ReturnFormat[number]]; value?: NumberTypes[ReturnFormat[number]]; yParity?: string }[]>
A list of pending transactions.
web3.eth.getPendingTransactions().then(console.log);
> [
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0n,
nonce: 0n,
blockHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
blockNumber: null,
transactionIndex: 0n,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1n,
gas: 90000n,
gasPrice: 2000000000n,
input: '0x',
v: 2709n,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
},
{
hash: '0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f',
type: 0n,
nonce: 1n,
blockHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
blockNumber: null,
transactionIndex: 0n,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1n,
gas: 90000n,
gasPrice: 2000000000n,
input: '0x',
v: 2710n,
r: '0x55ac19fade21db035a1b7ea0a8d49e265e05dbb926e75f273f836ad67ce5c96a',
s: '0x6550036a7c3fd426d5c3d35d96a7075cd673957620b7889846a980d2d017ec08'
}
]
* web3.eth.getPendingTransactions({ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }).then(console.log);
> [
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0,
nonce: 0,
blockHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
blockNumber: null,
transactionIndex: 0,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1,
gas: 90000,
gasPrice: 2000000000,
input: '0x',
v: 2709,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
},
{
hash: '0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f',
type: 0,
nonce: 1,
blockHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
blockNumber: null,
transactionIndex: 0,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1,
gas: 90000,
gasPrice: 2000000000,
input: '0x',
v: 2710,
r: '0x55ac19fade21db035a1b7ea0a8d49e265e05dbb926e75f273f836ad67ce5c96a',
s: '0x6550036a7c3fd426d5c3d35d96a7075cd673957620b7889846a980d2d017ec08'
}
]
getProof
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<Web3EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
address: string
The Address of the account or contract.
storageKeys: Bytes[]
Array of storage-keys which should be proofed and included. See web3.getStorageAt.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) - Specifies what block to use as the current state of the blockchain while processing the gas estimation.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) - Specifies how the return data from the call should be formatted.
Returns Promise<{ accountProof: ByteTypes[ReturnFormat[bytes]][]; balance: NumberTypes[ReturnFormat[number]]; codeHash: ByteTypes[ReturnFormat[bytes]]; nonce: NumberTypes[ReturnFormat[number]]; storageHash: ByteTypes[ReturnFormat[bytes]]; storageProof: { key: ByteTypes[ReturnFormat[bytes]]; proof: ByteTypes[ReturnFormat[bytes]][]; value: NumberTypes[ReturnFormat[number]] }[] }>
The account and storage-values of the specified account including the Merkle-proof as described in EIP-1186.
web3.eth.getProof(
"0x1234567890123456789012345678901234567890",
["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000001"],
"latest"
).then(console.log);
> {
"address": "0x1234567890123456789012345678901234567890",
"accountProof": [
"0xf90211a090dcaf88c40c7bbc95a912cbdde67c175767b31173df9ee4b0d733bfdd511c43a0babe369f6b12092f49181ae04ca173fb68d1a5456f18d20fa32cba73954052bda0473ecf8a7e36a829e75039a3b055e51b8332cbf03324ab4af2066bbd6fbf0021a0bbda34753d7aa6c38e603f360244e8f59611921d9e1f128372fec0d586d4f9e0a04e44caecff45c9891f74f6a2156735886eedf6f1a733628ebc802ec79d844648a0a5f3f2f7542148c973977c8a1e154c4300fec92f755f7846f1b734d3ab1d90e7a0e823850f50bf72baae9d1733a36a444ab65d0a6faaba404f0583ce0ca4dad92da0f7a00cbe7d4b30b11faea3ae61b7f1f2b315b61d9f6bd68bfe587ad0eeceb721a07117ef9fc932f1a88e908eaead8565c19b5645dc9e5b1b6e841c5edbdfd71681a069eb2de283f32c11f859d7bcf93da23990d3e662935ed4d6b39ce3673ec84472a0203d26456312bbc4da5cd293b75b840fc5045e493d6f904d180823ec22bfed8ea09287b5c21f2254af4e64fca76acc5cd87399c7f1ede818db4326c98ce2dc2208a06fc2d754e304c48ce6a517753c62b1a9c1d5925b89707486d7fc08919e0a94eca07b1c54f15e299bd58bdfef9741538c7828b5d7d11a489f9c20d052b3471df475a051f9dd3739a927c89e357580a4c97b40234aa01ed3d5e0390dc982a7975880a0a089d613f26159af43616fd9455bb461f4869bfede26f2130835ed067a8b967bfb80",
"0xf90211a0395d87a95873cd98c21cf1df9421af03f7247880a2554e20738eec2c7507a494a0bcf6546339a1e7e14eb8fb572a968d217d2a0d1f3bc4257b22ef5333e9e4433ca012ae12498af8b2752c99efce07f3feef8ec910493be749acd63822c3558e6671a0dbf51303afdc36fc0c2d68a9bb05dab4f4917e7531e4a37ab0a153472d1b86e2a0ae90b50f067d9a2244e3d975233c0a0558c39ee152969f6678790abf773a9621a01d65cd682cc1be7c5e38d8da5c942e0a73eeaef10f387340a40a106699d494c3a06163b53d956c55544390c13634ea9aa75309f4fd866f312586942daf0f60fb37a058a52c1e858b1382a8893eb9c1f111f266eb9e21e6137aff0dddea243a567000a037b4b100761e02de63ea5f1fcfcf43e81a372dafb4419d126342136d329b7a7ba032472415864b08f808ba4374092003c8d7c40a9f7f9fe9cc8291f62538e1cc14a074e238ff5ec96b810364515551344100138916594d6af966170ff326a092fab0a0d31ac4eef14a79845200a496662e92186ca8b55e29ed0f9f59dbc6b521b116fea090607784fe738458b63c1942bba7c0321ae77e18df4961b2bc66727ea996464ea078f757653c1b63f72aff3dcc3f2a2e4c8cb4a9d36d1117c742833c84e20de994a0f78407de07f4b4cb4f899dfb95eedeb4049aeb5fc1635d65cf2f2f4dfd25d1d7a0862037513ba9d45354dd3e36264aceb2b862ac79d2050f14c95657e43a51b85c80",
"0xf90171a04ad705ea7bf04339fa36b124fa221379bd5a38ffe9a6112cb2d94be3a437b879a08e45b5f72e8149c01efcb71429841d6a8879d4bbe27335604a5bff8dfdf85dcea00313d9b2f7c03733d6549ea3b810e5262ed844ea12f70993d87d3e0f04e3979ea0b59e3cdd6750fa8b15164612a5cb6567cdfb386d4e0137fccee5f35ab55d0efda0fe6db56e42f2057a071c980a778d9a0b61038f269dd74a0e90155b3f40f14364a08538587f2378a0849f9608942cf481da4120c360f8391bbcc225d811823c6432a026eac94e755534e16f9552e73025d6d9c30d1d7682a4cb5bd7741ddabfd48c50a041557da9a74ca68da793e743e81e2029b2835e1cc16e9e25bd0c1e89d4ccad6980a041dda0a40a21ade3a20fcd1a4abb2a42b74e9a32b02424ff8db4ea708a5e0fb9a09aaf8326a51f613607a8685f57458329b41e938bb761131a5747e066b81a0a16808080a022e6cef138e16d2272ef58434ddf49260dc1de1f8ad6dfca3da5d2a92aaaadc58080",
"0xf851808080a009833150c367df138f1538689984b8a84fc55692d3d41fe4d1e5720ff5483a6980808080808080808080a0a319c1c415b271afc0adcb664e67738d103ac168e0bc0b7bd2da7966165cb9518080"
],
"balance": 0n,
"codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
"nonce": 0n,
"storageHash": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"storageProof": [
{
"key": "0x0000000000000000000000000000000000000000000000000000000000000000",
"value": 0n,
"proof": []
},
{
"key": "0x0000000000000000000000000000000000000000000000000000000000000001",
"value": 0n,
"proof": []
}
]
}
web3.eth.getProof(
"0x1234567890123456789012345678901234567890",
["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000001"],
undefined,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> {
"address": "0x1234567890123456789012345678901234567890",
"accountProof": [
"0xf90211a090dcaf88c40c7bbc95a912cbdde67c175767b31173df9ee4b0d733bfdd511c43a0babe369f6b12092f49181ae04ca173fb68d1a5456f18d20fa32cba73954052bda0473ecf8a7e36a829e75039a3b055e51b8332cbf03324ab4af2066bbd6fbf0021a0bbda34753d7aa6c38e603f360244e8f59611921d9e1f128372fec0d586d4f9e0a04e44caecff45c9891f74f6a2156735886eedf6f1a733628ebc802ec79d844648a0a5f3f2f7542148c973977c8a1e154c4300fec92f755f7846f1b734d3ab1d90e7a0e823850f50bf72baae9d1733a36a444ab65d0a6faaba404f0583ce0ca4dad92da0f7a00cbe7d4b30b11faea3ae61b7f1f2b315b61d9f6bd68bfe587ad0eeceb721a07117ef9fc932f1a88e908eaead8565c19b5645dc9e5b1b6e841c5edbdfd71681a069eb2de283f32c11f859d7bcf93da23990d3e662935ed4d6b39ce3673ec84472a0203d26456312bbc4da5cd293b75b840fc5045e493d6f904d180823ec22bfed8ea09287b5c21f2254af4e64fca76acc5cd87399c7f1ede818db4326c98ce2dc2208a06fc2d754e304c48ce6a517753c62b1a9c1d5925b89707486d7fc08919e0a94eca07b1c54f15e299bd58bdfef9741538c7828b5d7d11a489f9c20d052b3471df475a051f9dd3739a927c89e357580a4c97b40234aa01ed3d5e0390dc982a7975880a0a089d613f26159af43616fd9455bb461f4869bfede26f2130835ed067a8b967bfb80",
"0xf90211a0395d87a95873cd98c21cf1df9421af03f7247880a2554e20738eec2c7507a494a0bcf6546339a1e7e14eb8fb572a968d217d2a0d1f3bc4257b22ef5333e9e4433ca012ae12498af8b2752c99efce07f3feef8ec910493be749acd63822c3558e6671a0dbf51303afdc36fc0c2d68a9bb05dab4f4917e7531e4a37ab0a153472d1b86e2a0ae90b50f067d9a2244e3d975233c0a0558c39ee152969f6678790abf773a9621a01d65cd682cc1be7c5e38d8da5c942e0a73eeaef10f387340a40a106699d494c3a06163b53d956c55544390c13634ea9aa75309f4fd866f312586942daf0f60fb37a058a52c1e858b1382a8893eb9c1f111f266eb9e21e6137aff0dddea243a567000a037b4b100761e02de63ea5f1fcfcf43e81a372dafb4419d126342136d329b7a7ba032472415864b08f808ba4374092003c8d7c40a9f7f9fe9cc8291f62538e1cc14a074e238ff5ec96b810364515551344100138916594d6af966170ff326a092fab0a0d31ac4eef14a79845200a496662e92186ca8b55e29ed0f9f59dbc6b521b116fea090607784fe738458b63c1942bba7c0321ae77e18df4961b2bc66727ea996464ea078f757653c1b63f72aff3dcc3f2a2e4c8cb4a9d36d1117c742833c84e20de994a0f78407de07f4b4cb4f899dfb95eedeb4049aeb5fc1635d65cf2f2f4dfd25d1d7a0862037513ba9d45354dd3e36264aceb2b862ac79d2050f14c95657e43a51b85c80",
"0xf90171a04ad705ea7bf04339fa36b124fa221379bd5a38ffe9a6112cb2d94be3a437b879a08e45b5f72e8149c01efcb71429841d6a8879d4bbe27335604a5bff8dfdf85dcea00313d9b2f7c03733d6549ea3b810e5262ed844ea12f70993d87d3e0f04e3979ea0b59e3cdd6750fa8b15164612a5cb6567cdfb386d4e0137fccee5f35ab55d0efda0fe6db56e42f2057a071c980a778d9a0b61038f269dd74a0e90155b3f40f14364a08538587f2378a0849f9608942cf481da4120c360f8391bbcc225d811823c6432a026eac94e755534e16f9552e73025d6d9c30d1d7682a4cb5bd7741ddabfd48c50a041557da9a74ca68da793e743e81e2029b2835e1cc16e9e25bd0c1e89d4ccad6980a041dda0a40a21ade3a20fcd1a4abb2a42b74e9a32b02424ff8db4ea708a5e0fb9a09aaf8326a51f613607a8685f57458329b41e938bb761131a5747e066b81a0a16808080a022e6cef138e16d2272ef58434ddf49260dc1de1f8ad6dfca3da5d2a92aaaadc58080",
"0xf851808080a009833150c367df138f1538689984b8a84fc55692d3d41fe4d1e5720ff5483a6980808080808080808080a0a319c1c415b271afc0adcb664e67738d103ac168e0bc0b7bd2da7966165cb9518080"
],
"balance": 0,
"codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
"nonce": 0,
"storageHash": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"storageProof": [
{
"key": "0x0000000000000000000000000000000000000000000000000000000000000000",
"value": 0,
"proof": []
},
{
"key": "0x0000000000000000000000000000000000000000000000000000000000000001",
"value": 0,
"proof": []
}
]
}
getProtocolVersion
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
Returns Promise<string>
Returns the ethereum protocol version of the node.
web3.eth.getProtocolVersion().then(console.log);
> "63"
getStorageAt
Get the storage at a specific position of an address.
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
address: string
The address to get the storage from.
storageSlot: Numbers
The index position of the storage.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) Specifies what block to use as the current state for the storage query.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<string>
The value in storage at the given position.
web3.eth.getStorageAt("0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234", 0).then(console.log);
> "0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"
web3.eth.getStorageAt(
"0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234",
0,
undefined,
{ number: FMT_NUMBER.HEX , bytes: FMT_BYTES.BUFFER }
).then(console.log);
> <Buffer 03 34 56 73 21 23 ff ff 23 42 34 2d d1 23 42 43 43 24 23 42 34 fd 23 4f d2 3f d4 f2 3d 42 34>
getTransaction
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transactionHash: Bytes
The hash of the desired transaction.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<{ accessList: { address?: string; storageKeys?: string[] }[]; blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; hash: string; input: string; maxFeePerGas: string; maxPriorityFeePerGas: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; value: string; yParity: string } | { accessList: { address?: string; storageKeys?: string[] }[]; blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; gasPrice: string; hash: string; input: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; value: string; yParity: string } | { blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; gasPrice: string; hash: string; input: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; v: string; value: string } | undefined>
The desired transaction object.
web3.eth.getTransaction('0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc').then(console.log);
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0n,
nonce: 0n,
blockHash: '0x43202bd16b6bd54bea1b310736bd78bdbe93a64ad940f7586739d9eb25ad8d00',
blockNumber: 1n,
transactionIndex: 0n,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1n,
gas: 90000n,
gasPrice: 2000000000n,
input: '0x',
v: 2709n,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
}
web3.eth.getTransaction(
<Buffer 30 78 37 33 61 65 61 37 30 65 39 36 39 39 34 31 66 32 33 66 39 64 32 34 31 30 33 65 39 31 61 61 31 66 35 35 63 37 39 36 34 65 62 31 33 64 61 66 31 63 ... >,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0,
nonce: 0,
blockHash: '0x43202bd16b6bd54bea1b310736bd78bdbe93a64ad940f7586739d9eb25ad8d00',
blockNumber: 1,
transactionIndex: 0,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1,
gas: 90000,
gasPrice: 2000000000,
input: '0x',
v: 2709,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
}
getTransactionCount
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
address: string
The address to get the number of transactions for.
blockNumber: undefined | BlockNumberOrTag
(BlockNumberOrTag defaults to Web3Eth.defaultBlock) Specifies what block to use as the current state for the query.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<NumberTypes[ReturnFormat[number]]>
The number of transactions sent from the provided address.
web3.eth.getTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1").then(console.log);
> 1n
web3.eth.getTransactionCount(
"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
undefined,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> 1
getTransactionFromBlock
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
block: undefined | string | number | bigint | Buffer | ArrayBuffer | Uint8Array
The BlockNumberOrTag (defaults to Web3Eth.defaultBlock) or block hash of the desired block.
transactionIndex: Numbers
The index position of the transaction.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<{ accessList: { address?: string; storageKeys?: string[] }[]; blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; hash: string; input: string; maxFeePerGas: string; maxPriorityFeePerGas: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; value: string; yParity: string } | { accessList: { address?: string; storageKeys?: string[] }[]; blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; gasPrice: string; hash: string; input: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; value: string; yParity: string } | { blockHash?: string; blockNumber?: string; chainId?: string; data?: string; from: string; gas: string; gasPrice: string; hash: string; input: string; nonce: string; r: string; s: string; to?: string | null; transactionIndex?: string; type: string; v: string; value: string } | undefined>
The desired transaction object.
web3.eth.getTransactionFromBlock('0x43202bd16b6bd54bea1b310736bd78bdbe93a64ad940f7586739d9eb25ad8d00', 0).then(console.log);
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0n,
nonce: 0n,
blockHash: '0x43202bd16b6bd54bea1b310736bd78bdbe93a64ad940f7586739d9eb25ad8d00',
blockNumber: 1n,
transactionIndex: 0n,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1n,
gas: 90000n,
gasPrice: 2000000000n,
input: '0x',
v: 2709n,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
}
web3.eth.getTransactionFromBlock(
<Buffer 30 78 34 33 32 30 32 62 64 31 36 62 36 62 64 35 34 62 65 61 31 62 33 31 30 37 33 36 62 64 37 38 62 64 62 65 39 33 61 36 34 61 64 39 34 30 66 37 35 38 ... >,
0,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
{
hash: '0x73aea70e969941f23f9d24103e91aa1f55c7964eb13daf1c9360c308a72686dc',
type: 0,
nonce: 0,
blockHash: '0x43202bd16b6bd54bea1b310736bd78bdbe93a64ad940f7586739d9eb25ad8d00',
blockNumber: 1,
transactionIndex: 0,
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
value: 1,
gas: 90000,
gasPrice: 2000000000,
input: '0x',
v: 2709,
r: '0x8b336c290f6d7b2af3ccb2c02203a8356cc7d5b150ab19cce549d55636a3a78c',
s: '0x5a83c6f816befc5cd4b0c997a347224a8aa002e5799c4b082a3ec726d0e9531d'
}
getTransactionReceipt
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transactionHash: Bytes
Hash of the transaction to retrieve the receipt for.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<TransactionReceipt | undefined>
The desired TransactionReceipt object.
web3.eth.getTransactionReceipt("0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f").then(console.log);
> {
transactionHash: '0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f',
transactionIndex: 0n,
blockNumber: 2n,
blockHash: '0xeb1565a08b23429552dafa92e32409f42eb43944f7611963c63ce40e7243941a',
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
cumulativeGasUsed: 21000n,
gasUsed: 21000n,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1n,
effectiveGasPrice: 2000000000n,
type: 0n
}
web3.eth.getTransactionReceipt(
"0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f",
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> {
transactionHash: '0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f',
transactionIndex: 0,
blockNumber: 2,
blockHash: '0xeb1565a08b23429552dafa92e32409f42eb43944f7611963c63ce40e7243941a',
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
cumulativeGasUsed: 21000,
gasUsed: 21000,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1,
effectiveGasPrice: 2000000000,
type: 0n
}
getUncle
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
block: undefined | string | number | bigint | Buffer | ArrayBuffer | Uint8Array
The BlockNumberOrTag (defaults to Web3Eth.defaultBlock) or block hash of the desired block.
uncleIndex: Numbers
The index position of the uncle.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<{ baseFeePerGas?: NumberTypes[ReturnFormat[number]]; difficulty?: NumberTypes[ReturnFormat[number]]; extraData: ByteTypes[ReturnFormat[bytes]]; gasLimit: NumberTypes[ReturnFormat[number]]; gasUsed: NumberTypes[ReturnFormat[number]]; hash?: ByteTypes[ReturnFormat[bytes]]; logsBloom?: ByteTypes[ReturnFormat[bytes]]; miner: ByteTypes[ReturnFormat[bytes]]; mixHash: ByteTypes[ReturnFormat[bytes]]; nonce: NumberTypes[ReturnFormat[number]]; number: NumberTypes[ReturnFormat[number]]; parentHash: ByteTypes[ReturnFormat[bytes]]; receiptsRoot: ByteTypes[ReturnFormat[bytes]]; sha3Uncles: ByteTypes[ReturnFormat[bytes]]; size: NumberTypes[ReturnFormat[number]]; stateRoot: ByteTypes[ReturnFormat[bytes]]; timestamp: NumberTypes[ReturnFormat[number]]; totalDifficulty: NumberTypes[ReturnFormat[number]]; transactions: string[] | { accessList?: { address?: string; storageKeys?: string[] }[]; blockHash?: ByteTypes[ReturnFormat[bytes]]; blockNumber?: NumberTypes[ReturnFormat[number]]; chain?: ValidChains; chainId?: NumberTypes[ReturnFormat[number]]; common?: { baseChain?: ValidChains; customChain: { chainId: NumberTypes[ReturnFormat[number]]; name?: string; networkId: NumberTypes[ReturnFormat[number]] }; hardfork?: Hardfork }; data?: ByteTypes[ReturnFormat[bytes]]; from: string; gas?: NumberTypes[ReturnFormat[number]]; gasLimit?: NumberTypes[ReturnFormat[number]]; gasPrice?: NumberTypes[ReturnFormat[number]]; hardfork?: Hardfork; hash: ByteTypes[ReturnFormat[bytes]]; input?: ByteTypes[ReturnFormat[bytes]]; maxFeePerGas?: NumberTypes[ReturnFormat[number]]; maxPriorityFeePerGas?: NumberTypes[ReturnFormat[number]]; networkId?: NumberTypes[ReturnFormat[number]]; nonce?: NumberTypes[ReturnFormat[number]]; r?: ByteTypes[ReturnFormat[bytes]]; s?: ByteTypes[ReturnFormat[bytes]]; to?: string | null; transactionIndex?: NumberTypes[ReturnFormat[number]]; type?: NumberTypes[ReturnFormat[number]]; v?: NumberTypes[ReturnFormat[number]]; value?: NumberTypes[ReturnFormat[number]]; yParity?: string }[]; transactionsRoot: ByteTypes[ReturnFormat[bytes]]; uncles: string[] }>
A blocks uncle by a given uncle index position.
web3.eth.getUncle(0, 1).then(console.log);
> {
hash: '0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d',
parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
sha3Uncles: '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
miner: '0x0000000000000000000000000000000000000000',
stateRoot: '0x5ed9882897d363c4632a6e67fba6203df61bd994813dcf048da59be442a9c6c4',
transactionsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
receiptsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
difficulty: 1n,
number: 0n,
gasLimit: 30000000n,
gasUsed: 0n,
timestamp: 1658281638n,
extraData: '0x',
mixHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
nonce: 0n,
totalDifficulty: 1n,
baseFeePerGas: 1000000000n,
size: 514n,
transactions: [],
uncles: []
}
web3.eth.getUncle(
"0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d",
1,
{ number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }
).then(console.log);
> {
hash: '0x7dbfdc6a7a67a670cb9b0c3f81ca60c007762f1e4e598cb027a470678ff26d0d',
parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
sha3Uncles: '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
miner: '0x0000000000000000000000000000000000000000',
stateRoot: '0x5ed9882897d363c4632a6e67fba6203df61bd994813dcf048da59be442a9c6c4',
transactionsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
receiptsRoot: '0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421',
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
difficulty: 1,
number: 0,
gasLimit: 30000000,
gasUsed: 0,
timestamp: 1658281638,
extraData: '0x',
mixHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
nonce: 0,
totalDifficulty: 1,
baseFeePerGas: 1000000000,
size: 514,
transactions: [],
uncles: []
}
isAccessList
Parameters
value: AccessList
Returns boolean
isAccessListEntry
Parameters
value: AccessListEntry
Returns boolean
isBaseTransaction
Parameters
value: BaseTransactionAPI
Returns boolean
isMining
Checks whether the node is mining or not.
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
Returns Promise<boolean>
trueif the node is mining, otherwisefalse.web3.eth.isMining().then(console.log);
> true
isSyncing
Checks if the node is currently syncing.
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
Returns Promise<SyncingStatusAPI>
Either a SyncingStatusAPI, or
false.web3.eth.isSyncing().then(console.log);
> {
startingBlock: 100,
currentBlock: 312,
highestBlock: 512,
knownStates: 234566,
pulledStates: 123455
}
isTransaction1559Unsigned
Parameters
value: Transaction1559UnsignedAPI
Returns boolean
isTransaction2930Unsigned
Parameters
value: Transaction2930UnsignedAPI
Returns boolean
isTransactionCall
Parameters
value: TransactionCall
Returns boolean
isTransactionLegacyUnsigned
Parameters
value: TransactionLegacyUnsignedAPI
Returns boolean
isTransactionWithSender
Parameters
value: TransactionWithSenderAPI
Returns boolean
prepareTransactionForSigning
Parameters
transaction: Transaction
web3Context: Web3Context<EthExecutionAPI, any>
optionalprivateKey: string | Buffer
Returns Promise<TypedTransaction>
sendSignedTransaction
Type parameters
- ReturnFormat: DataFormat
- ResolveType = { blockHash: ByteTypes[ReturnFormat[bytes]]; blockNumber: NumberTypes[ReturnFormat[number]]; contractAddress?: string; cumulativeGasUsed: NumberTypes[ReturnFormat[number]]; effectiveGasPrice?: NumberTypes[ReturnFormat[number]]; from: string; gasUsed: NumberTypes[ReturnFormat[number]]; logs: { readonly id?: string | undefined; readonly removed?: boolean | undefined; readonly logIndex?: NumberTypes[ReturnFormat["number"]] | undefined; ... 6 more ...; readonly topics?: ByteTypes[ReturnFormat["bytes"]][] | undefined; }[]; logsBloom: ByteTypes[ReturnFormat[bytes]]; root: ByteTypes[ReturnFormat[bytes]]; status: NumberTypes[ReturnFormat[number]]; to: string; transactionHash: ByteTypes[ReturnFormat[bytes]]; transactionIndex: NumberTypes[ReturnFormat[number]]; type?: NumberTypes[ReturnFormat[number]] }
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
signedTransaction: Bytes
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
optionaloptions: SendSignedTransactionOptions<ResolveType>
Returns Web3PromiEvent<ResolveType, SendSignedTransactionEvents<ReturnFormat>>
If
awaited or.thend (i.e. the promise resolves), the transaction hash is returned.const signedTransaction = "0xf86580843b9aca0182520894e899f0130fd099c0b896b2ce4e5e15a25b23139a0180820a95a03a42d53ca5b71f845e1cd4c65359b05446a85d16881372d3bfaab8980935cb04a0711497bc8dd3b541152e2fed14fe650a647f1f0edab0d386ad9506f0e642410f"
const transactionHash = await web3.eth.sendSignedTransaction(signedTransaction);
console.log(transactionHash);
> 0xed8c241ea44d57f4605dc22c63500de46254d6c7844fd65fa438b128c80cf700
web3.eth.sendSignedTransaction(signedTransaction).then(console.log);
> 0xed8c241ea44d57f4605dc22c63500de46254d6c7844fd65fa438b128c80cf700
web3.eth.sendSignedTransaction(signedTransaction).catch(console.log);
> <Some TransactionError>Otherwise, a Web3PromiEvent is returned which has several events than can be listened to using the
.onsyntax, such as:sendingweb3.eth.sendSignedTransaction(signedTransaction).on('sending', transactionToBeSent => console.log(transactionToBeSent));
> "0xf86580843b9aca0182520894e899f0130fd099c0b896b2ce4e5e15a25b23139a0180820a95a03a42d53ca5b71f845e1cd4c65359b05446a85d16881372d3bfaab8980935cb04a0711497bc8dd3b541152e2fed14fe650a647f1f0edab0d386ad9506f0e642410f"sentweb3.eth.sendSignedTransaction(signedTransaction).on('sent', sentTransaction => console.log(sentTransaction));
> "0xf86580843b9aca0182520894e899f0130fd099c0b896b2ce4e5e15a25b23139a0180820a95a03a42d53ca5b71f845e1cd4c65359b05446a85d16881372d3bfaab8980935cb04a0711497bc8dd3b541152e2fed14fe650a647f1f0edab0d386ad9506f0e642410f"transactionHashweb3.eth.sendSignedTransaction(signedTransaction).on('transactionHash', transactionHash => console.log(transactionHash));
> 0xed8c241ea44d57f4605dc22c63500de46254d6c7844fd65fa438b128c80cf700receiptweb3.eth.sendSignedTransaction(signedTransaction).on('receipt', receipt => console.log(receipt));
> {
blockHash: '0xff2b1687995d81066361bc6affe4455746120a7d4bb75fc938211a2692a50081',
blockNumber: 1n,
cumulativeGasUsed: 21000n,
effectiveGasPrice: 1000000001n,
from: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
gasUsed: 21000n,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1n,
to: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
transactionHash: '0xed8c241ea44d57f4605dc22c63500de46254d6c7844fd65fa438b128c80cf700',
transactionIndex: 0n,
type: 0n
}confirmationweb3.eth.sendSignedTransaction(signedTransaction).on('confirmation', confirmation => console.log(confirmation));
> {
confirmations: 1n,
receipt: {
blockHash: '0xff2b1687995d81066361bc6affe4455746120a7d4bb75fc938211a2692a50081',
blockNumber: 1n,
cumulativeGasUsed: 21000n,
effectiveGasPrice: 1000000001n,
from: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
gasUsed: 21000n,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1n,
to: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
transactionHash: '0xed8c241ea44d57f4605dc22c63500de46254d6c7844fd65fa438b128c80cf700',
transactionIndex: 0n,
type: 0n
},
latestBlockHash: '0xff2b1687995d81066361bc6affe4455746120a7d4bb75fc938211a2692a50081'
}errorweb3.eth.sendSignedTransaction(signedTransaction).on('error', error => console.log(error));
> <Some TransactionError>
sendTransaction
Type parameters
- ReturnFormat: DataFormat
- ResolveType = { blockHash: ByteTypes[ReturnFormat[bytes]]; blockNumber: NumberTypes[ReturnFormat[number]]; contractAddress?: string; cumulativeGasUsed: NumberTypes[ReturnFormat[number]]; effectiveGasPrice?: NumberTypes[ReturnFormat[number]]; from: string; gasUsed: NumberTypes[ReturnFormat[number]]; logs: { readonly id?: string | undefined; readonly removed?: boolean | undefined; readonly logIndex?: NumberTypes[ReturnFormat["number"]] | undefined; ... 6 more ...; readonly topics?: ByteTypes[ReturnFormat["bytes"]][] | undefined; }[]; logsBloom: ByteTypes[ReturnFormat[bytes]]; root: ByteTypes[ReturnFormat[bytes]]; status: NumberTypes[ReturnFormat[number]]; to: string; transactionHash: ByteTypes[ReturnFormat[bytes]]; transactionIndex: NumberTypes[ReturnFormat[number]]; type?: NumberTypes[ReturnFormat[number]] }
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transaction: Transaction | TransactionWithFromLocalWalletIndex | TransactionWithToLocalWalletIndex | TransactionWithFromAndToLocalWalletIndex
The Transaction, TransactionWithFromLocalWalletIndex, TransactionWithToLocalWalletIndex, or TransactionWithFromAndToLocalWalletIndex to send.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
optionaloptions: SendTransactionOptions<ResolveType>
A configuration object used to change the behavior of the
sendTransactionmethod.
Returns Web3PromiEvent<ResolveType, SendTransactionEvents<ReturnFormat>>
If
awaited or.thend (i.e. the promise resolves), the transaction hash is returned.const transaction = {
from: '0x6E599DA0bfF7A6598AC1224E4985430Bf16458a4',
to: '0x6f1DF96865D09d21e8f3f9a7fbA3b17A11c7C53C',
value: '0x1'
}
const transactionHash = await web3.eth.sendTransaction(transaction);
console.log(transactionHash);
> 0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f
web3.eth.sendTransaction(transaction).then(console.log);
> 0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f
web3.eth.sendTransaction(transaction).catch(console.log);
> <Some TransactionError>
// Example using options.ignoreGasPricing = true
web3.eth.sendTransaction(transaction, undefined, { ignoreGasPricing: true }).then(console.log);
> 0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3fOtherwise, a Web3PromiEvent is returned which has several events than can be listened to using the
.onsyntax, such as:sendingweb3.eth.sendTransaction(transaction).on('sending', transactionToBeSent => console.log(transactionToBeSent));
> {
from: '0x6E599DA0bfF7A6598AC1224E4985430Bf16458a4',
to: '0x6f1DF96865D09d21e8f3f9a7fbA3b17A11c7C53C',
value: '0x1',
gasPrice: '0x77359400',
maxPriorityFeePerGas: undefined,
maxFeePerGas: undefined
}sentweb3.eth.sendTransaction(transaction).on('sent', sentTransaction => console.log(sentTransaction));
> {
from: '0x6E599DA0bfF7A6598AC1224E4985430Bf16458a4',
to: '0x6f1DF96865D09d21e8f3f9a7fbA3b17A11c7C53C',
value: '0x1',
gasPrice: '0x77359400',
maxPriorityFeePerGas: undefined,
maxFeePerGas: undefined
}transactionHashweb3.eth.sendTransaction(transaction).on('transactionHash', transactionHash => console.log(transactionHash));
> 0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3freceiptweb3.eth.sendTransaction(transaction).on('receipt', receipt => console.log(receipt));
> {
transactionHash: '0xdf7756865c2056ce34c4eabe4eff42ad251a9f920a1c620c00b4ea0988731d3f',
transactionIndex: 0n,
blockNumber: 2n,
blockHash: '0xeb1565a08b23429552dafa92e32409f42eb43944f7611963c63ce40e7243941a',
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
cumulativeGasUsed: 21000n,
gasUsed: 21000n,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1n,
effectiveGasPrice: 2000000000n,
type: 0n
}confirmationweb3.eth.sendTransaction(transaction).on('confirmation', confirmation => console.log(confirmation));
> {
confirmations: 1n,
receipt: {
transactionHash: '0xb4a3a35ae0f3e77ef0ff7be42010d948d011b21a4e341072ee18717b67e99ab8',
transactionIndex: 0n,
blockNumber: 5n,
blockHash: '0xb57fbe6f145cefd86a305a9a024a4351d15d4d39607d7af53d69a319bc3b5548',
from: '0x6e599da0bff7a6598ac1224e4985430bf16458a4',
to: '0x6f1df96865d09d21e8f3f9a7fba3b17a11c7c53c',
cumulativeGasUsed: 21000n,
gasUsed: 21000n,
logs: [],
logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
status: 1n,
effectiveGasPrice: 2000000000n,
type: 0n
},
latestBlockHash: '0xb57fbe6f145cefd86a305a9a024a4351d15d4d39607d7af53d69a319bc3b5548'
}errorweb3.eth.sendTransaction(transaction).on('error', error => console.log);
> <Some TransactionError>
sign
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
message: Bytes
Data to sign in one of the valid Bytes format.
addressOrIndex: string | number
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<string | { message?: string; messageHash: string; r: string; s: string; signature: string; v: string }>
The signed
message.// Using an unlocked account managed by connected RPC client
web3.eth.sign("0x48656c6c6f20776f726c64", "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe").then(console.log);
> "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"
// Using an unlocked account managed by connected RPC client
web3.eth.sign("0x48656c6c6f20776f726c64", "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", { number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.BUFFER }).then(console.log);
> <Buffer 30 78 33 30 37 35 35 65 64 36 35 33 39 36 66 61 63 66 38 36 63 35 33 65 36 32 31 37 63 35 32 62 34 64 61 65 62 65 37 32 61 61 34 39 34 31 64 38 39 36 ... >// Using an indexed account managed by local Web3 wallet web3.eth.sign(“0x48656c6c6f20776f726c64”, 0).then(console.log);
“0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400”
signTransaction
Type parameters
- ReturnFormat: DataFormat
Parameters
web3Context: Web3Context<EthExecutionAPI, any>
(Web3Context) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
transaction: Transaction
The transaction object to sign.
returnFormat: ReturnFormat
(DataFormat defaults to DEFAULT_RETURN_FORMAT) Specifies how the return data should be formatted.
Returns Promise<SignedTransactionInfoAPI>
SignedTransactionInfoAPI, an object containing the RLP encoded signed transaction (accessed via the
rawproperty) and the signed transaction object (accessed via thetxproperty).const transaction = {
from: '0xe899f0130FD099c0b896B2cE4E5E15A25b23139a',
to: '0xe899f0130FD099c0b896B2cE4E5E15A25b23139a',
value: '0x1',
gas: '21000',
gasPrice: await web3Eth.getGasPrice(),
nonce: '0x1',
type: '0x0'
}
web3.eth.signTransaction(transaction).then(console.log);
> {
raw: '0xf86501843b9aca0182520894e899f0130fd099c0b896b2ce4e5e15a25b23139a0180820a96a0adb3468dbb4dce89fe1785ea9182e85fb56b399b378f82b93af7a8a12a4f9679a027d37d736e9bcf00121f78b2d10e4404fa5c45856d62b746574345f5cd278097',
tx: {
type: 0n,
nonce: 1n,
gasPrice: 1000000001n,
gas: 21000n,
value: 1n,
v: 2710n,
r: '0xadb3468dbb4dce89fe1785ea9182e85fb56b399b378f82b93af7a8a12a4f9679',
s: '0x27d37d736e9bcf00121f78b2d10e4404fa5c45856d62b746574345f5cd278097',
to: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
data: '0x'
}
}
web3.eth.signTransaction(transaction, { number: FMT_NUMBER.NUMBER , bytes: FMT_BYTES.HEX }).then(console.log);
> {
raw: '0xf86501843b9aca0182520894e899f0130fd099c0b896b2ce4e5e15a25b23139a0180820a96a0adb3468dbb4dce89fe1785ea9182e85fb56b399b378f82b93af7a8a12a4f9679a027d37d736e9bcf00121f78b2d10e4404fa5c45856d62b746574345f5cd278097',
tx: {
type: 0,
nonce: 1,
gasPrice: 1000000001,
gas: 21000,
value: 1,
v: 2710,
r: '0xadb3468dbb4dce89fe1785ea9182e85fb56b399b378f82b93af7a8a12a4f9679',
s: '0x27d37d736e9bcf00121f78b2d10e4404fa5c45856d62b746574345f5cd278097',
to: '0xe899f0130fd099c0b896b2ce4e5e15a25b23139a',
data: '0x'
}
}
transactionBuilder
Type parameters
- ReturnType_1 = Transaction
Parameters
options: { privateKey?: string | Buffer; transaction: Transaction; web3Context: Web3Context<EthExecutionAPI, any> }
Returns Promise<ReturnType_1>
validateBaseChain
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateChainInfo
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateCustomChainInfo
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateFeeMarketGas
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateGas
This method checks if all required gas properties are present for either legacy gas (type 0x0 and 0x1) OR fee market transactions (0x2)
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateHardfork
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateLegacyGas
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
Returns void
validateTransactionCall
Parameters
value: TransactionCall
Returns void
validateTransactionForSigning
Parameters
transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }
optionaloverrideMethod: (transaction: { accessList?: { readonly address?: string | undefined; readonly storageKeys?: string[] | undefined; }[]; chain?: ValidChains; chainId?: string; common?: { customChain: { name?: string | undefined; networkId: string; chainId: string; }; baseChain?: ValidChains | undefined; hardfork?: Hardfork | undefined; }; data?: string; from?: string; gas?: string; gasLimit?: string; gasPrice?: string; hardfork?: Hardfork; input?: string; maxFeePerGas?: string; maxPriorityFeePerGas?: string; networkId?: string; nonce?: string; r?: string; s?: string; to?: null | string; type?: string; v?: string; value?: string; yParity?: string }) => void
Returns void
validateTransactionWithSender
Parameters
value: TransactionWithSenderAPI
Returns void
Decodes ABI-encoded log data and indexed topic data.