@ethereumjs/common
Version:
Resources common to all Ethereum implementations
318 lines • 11.6 kB
TypeScript
import { EventEmitter } from 'eventemitter3';
import { Hardfork } from './enums.ts';
import type { BigIntLike, PrefixedHexString } from '@ethereumjs/util';
import type { ConsensusAlgorithm, ConsensusType } from './enums.ts';
import type { BootstrapNodeConfig, BpoSchedule, CasperConfig, ChainConfig, CliqueConfig, CommonEvent, CommonOpts, CustomCrypto, EthashConfig, GenesisBlockConfig, HardforkByOpts, HardforkConfig, HardforkTransitionConfig, ParamsConfig, ParamsDict } from './types.ts';
/**
* Common class to access chain and hardfork parameters and to provide
* a unified and shared view on the network and hardfork state.
*
* Use the {@link createCustomCommon} constructor for creating simple
* custom chain {@link Common} objects (more complete custom chain setups
* can be created via the main constructor).
*
* Use the {@link createCommonFromGethGenesis} constructor for creating
* a Common object from a Geth genesis file.
*/
export declare class Common {
readonly DEFAULT_HARDFORK: string | Hardfork;
protected _chainParams: ChainConfig;
protected _hardfork: string | Hardfork;
protected _eips: number[];
protected _params: ParamsDict;
readonly customCrypto: CustomCrypto;
protected _paramsCache: ParamsConfig;
protected _activatedEIPsCache: number[];
protected HARDFORK_CHANGES: [string, HardforkConfig][];
events: EventEmitter<CommonEvent>;
constructor(opts: CommonOpts);
/**
* Update the internal Common EIP params set. Existing values
* will get preserved unless there is a new value for a parameter
* provided with params.
*
* Example Format:
*
* ```ts
* {
* 1559: {
* initialBaseFee: 1000000000,
* }
* }
* ```
*
* @param params
*/
updateParams(params: ParamsDict): void;
/**
* Fully resets the internal Common EIP params set with the values provided.
*
* Example Format:
*
* ```ts
* {
* 1559: {
* initialBaseFee: 1000000000,
* }
* }
* ```
*
* @param params
*/
resetParams(params: ParamsDict): void;
/**
* Sets the hardfork to get params for
* @param hardfork String identifier (e.g. 'byzantium') or {@link Hardfork} enum
*/
setHardfork(hardfork: string | Hardfork): void;
/**
* Returns the hardfork either based on block number (older HFs) or
* timestamp (Shanghai upwards).
*
* @param opts Block number or timestamp
* @returns The name of the HF
*/
getHardforkBy(opts: HardforkByOpts): string;
/**
* Sets a new hardfork either based on block number (older HFs) or
* timestamp (Shanghai upwards).
*
* @param opts Block number or timestamp
* @returns The name of the HF set
*/
setHardforkBy(opts: HardforkByOpts): string;
/**
* Internal helper function, returns the params for the given hardfork for the chain set
* @param hardfork Hardfork name
* @returns Dictionary with hardfork params or null if hardfork not on chain
*/
protected _getHardfork(hardfork: string | Hardfork): HardforkTransitionConfig | null;
/**
* Sets the active EIPs
* @param eips
*/
setEIPs(eips?: number[]): void;
/**
* Internal helper for _buildParamsCache()
*/
protected _mergeWithParamsCache(params: ParamsConfig): void;
/**
* Build up a cache for all parameter values for the current HF and all activated EIPs
*/
protected _buildParamsCache(): void;
/**
* Builds the cache of EIPs activated either via hardforks or constructor `eips`.
*/
protected _buildActivatedEIPsCache(): void;
/**
* Returns a parameter for the current chain setup
*
* If the parameter is present in an EIP, the EIP always takes precedence.
* Otherwise the parameter is taken from the latest applied HF with
* a change on the respective parameter.
*
* @param name Parameter name (e.g. 'minGasLimit')
* @returns The value requested (throws if not found)
*/
param(name: string): bigint;
/**
* Returns the parameter corresponding to a hardfork
* @param name Parameter name (e.g. 'minGasLimit')
* @param hardfork Hardfork name
* @returns The value requested (throws if not found)
*/
paramByHardfork(name: string, hardfork: string | Hardfork): bigint;
/**
* Returns a parameter corresponding to an EIP
* @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)
* @param eip Number of the EIP
* @returns The value requested (throws if not found)
*/
paramByEIP(name: string, eip: number): bigint | undefined;
/**
* Returns a parameter for the hardfork active on block number or
* optional provided total difficulty (Merge HF)
* @param name Parameter name
* @param blockNumber Block number
* @returns The value requested or `BigInt(0)` if not found
*/
paramByBlock(name: string, blockNumber: BigIntLike, timestamp?: BigIntLike): bigint;
/**
* Returns the blob gas schedule for the current hardfork
* @returns The blob gas schedule
*/
getBlobGasSchedule(): BpoSchedule;
/**
* Checks if an EIP is activated by either being included in the EIPs
* manually passed in with the {@link CommonOpts.eips} or in a
* hardfork currently being active
*
* Note: this method only works for EIPs being supported
* by the {@link CommonOpts.eips} constructor option
* @param eip
*/
isActivatedEIP(eip: number): boolean;
/**
* Checks if set or provided hardfork is active on block number
* @param hardfork Hardfork name or null (for HF set)
* @param blockNumber
* @returns True if HF is active on block number
*/
hardforkIsActiveOnBlock(hardfork: string | Hardfork | null, blockNumber: BigIntLike): boolean;
/**
* Alias to hardforkIsActiveOnBlock when hardfork is set
* @param blockNumber
* @returns True if HF is active on block number
*/
activeOnBlock(blockNumber: BigIntLike): boolean;
/**
* Sequence based check if given or set HF1 is greater than or equal HF2
* @param hardfork1 Hardfork name or null (if set)
* @param hardfork2 Hardfork name
* @returns True if HF1 gte HF2
*/
hardforkGteHardfork(hardfork1: string | Hardfork | null, hardfork2: string | Hardfork): boolean;
/**
* Alias to hardforkGteHardfork when hardfork is set
* @param hardfork Hardfork name
* @returns True if hardfork set is greater than hardfork provided
*/
gteHardfork(hardfork: string | Hardfork): boolean;
/**
* Returns the hardfork change block for hardfork provided or set
* @param hardfork Hardfork name, optional if HF set
* @returns Block number or null if unscheduled
*/
hardforkBlock(hardfork?: string | Hardfork): bigint | null;
/**
* Returns the timestamp at which a given hardfork is scheduled (if any).
* @param hardfork Hardfork name, optional if HF set
* @returns Timestamp or null if the hardfork is not timestamp-based
*/
hardforkTimestamp(hardfork?: string | Hardfork): bigint | null;
/**
* Returns the hardfork change block for eip
* @param eip EIP number
* @returns Block number or null if unscheduled
*/
eipBlock(eip: number): bigint | null;
/**
* Returns the scheduled timestamp of the EIP (if scheduled and scheduled by timestamp)
* @param eip EIP number
* @returns Scheduled timestamp. If this EIP is unscheduled, or the EIP is scheduled by block number, then it returns `null`.
*/
eipTimestamp(eip: number): bigint | null;
/**
* Returns the block number or timestamp at which the next hardfork will occur.
* For pre-merge hardforks, returns the block number.
* For post-merge hardforks, returns the timestamp.
* Returns null if there is no next hardfork.
* @param hardfork Hardfork name, optional if HF set
* @returns Block number or timestamp, or null if not available
*/
nextHardforkBlockOrTimestamp(hardfork?: string | Hardfork): bigint | null;
/**
* Internal helper function to calculate a fork hash
* @param hardfork Hardfork name
* @param genesisHash Genesis block hash of the chain
* @returns Fork hash as hex string
*/
protected _calcForkHash(hardfork: string | Hardfork, genesisHash: Uint8Array): PrefixedHexString;
/**
* Returns an eth/64 compliant fork hash (EIP-2124)
* @param hardfork Hardfork name, optional if HF set
* @param genesisHash Genesis block hash of the network, optional if already defined and not needed to be calculated
* @returns Fork hash as a hex string
*/
forkHash(hardfork?: string | Hardfork, genesisHash?: Uint8Array): PrefixedHexString;
/**
*
* @param forkHash Fork hash as a hex string
* @returns Array with hardfork data (name, block, forkHash)
*/
hardforkForForkHash(forkHash: string): HardforkTransitionConfig | null;
/**
* Sets any missing forkHashes on this {@link Common} instance.
* @param genesisHash The genesis block hash
*/
setForkHashes(genesisHash: Uint8Array): void;
/**
* Returns the Genesis parameters of the current chain
* @returns Genesis dictionary
*/
genesis(): GenesisBlockConfig;
/**
* Returns the hardfork definitions for the current chain.
* @returns Array of hardfork transition configs
*/
hardforks(): HardforkTransitionConfig[];
/**
* Returns bootstrap nodes for the current chain.
* @returns Array of bootstrap node configs
*/
bootstrapNodes(): BootstrapNodeConfig[];
/**
* Returns DNS networks for the current chain
* @returns {String[]} Array of DNS ENR urls
*/
dnsNetworks(): string[];
/**
* Returns the hardfork set
* @returns Hardfork name
*/
hardfork(): string | Hardfork;
/**
* Returns the Id of current chain
* @returns chain Id
*/
chainId(): bigint;
/**
* Returns the name of current chain
* @returns chain name (lower case)
*/
chainName(): string;
/**
* Returns the additionally activated EIPs
* (by using the `eips` constructor option)
* @returns List of EIPs
*/
eips(): number[];
/**
* Returns the consensus type of the network
* Possible values: "pow"|"poa"|"pos"
*
* Note: This value can update along a Hardfork.
*/
consensusType(): string | ConsensusType;
/**
* 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.
*/
consensusAlgorithm(): string | ConsensusAlgorithm;
/**
* 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.
*/
consensusConfig(): {
[key: string]: CliqueConfig | EthashConfig | CasperConfig;
};
/**
* Returns a deep copy of this {@link Common} instance.
*/
copy(): Common;
}
//# sourceMappingURL=common.d.ts.map