import * as _ethereumjs_common from '@ethereumjs/common';
import { Common as Common$1, CustomCrypto } from '@ethereumjs/common';
export { AccountFields, CliqueConfig, ConsensusAlgorithm, ConsensusType, CustomCrypto, StateManagerInterface as EvmStateManagerInterface, StorageDump, StorageRange } from '@ethereumjs/common';
import { Prettify, Chain } from 'viem/chains';
import { LogOptions } from '@tevm/logger';
import * as viem from 'viem';

/**
 * Common is the main representation of chain specific configuration for tevm clients.
 *
 * Tevm specific chain configuration wrapping viem chain and ethereumjs commmon
 * Common contains the common configuration set between all chains such as fee information, hardfork information, eip information, predeployed contracts, default block explorers and more.
 * extends ethereumjs Common class with the Viem Chain type
 * @example
 * ```typescript
 * import { optimism, Common } from 'tevm/common'
 * import { createMemoryClient } from 'tevm'}
 *
 * const createClient = (common: Common) => {
 *   const client = createMemoryClient({
 *     common,
 *   })
 *   return client
 * }
 *
 * const client = createClient(optimism)
 * ```
 * @see [createCommon](https://tevm.sh/reference/tevm/common/functions/createcommon/)
 * @see [Tevm client docs](https://tevm.sh/learn/clients/)
 */
type Common = Prettify<Chain & {
    ethjsCommon: Common$1;
    copy: () => Common;
}>;

/**
 * Ethereum hardfork options. Default option is currently prague.
 * If you use older hardforks you might run into issues with EIPs not being supported.
 * @example
 * ```typescript
 * import { createCommon, mainnet } from 'tevm/common'`
 *
 * const hardfork: Hardfork = 'shanghai'
 *
 * const common = createCommon({
 *   ...mainnet,
 *   hardfork,
 * })
 * ```
 * @see [createCommon](https://tevm.sh/reference/tevm/common/functions/createcommon/)
 */
type Hardfork = 'chainstart' | 'homestead' | 'dao' | 'tangerineWhistle' | 'spuriousDragon' | 'byzantium' | 'constantinople' | 'petersburg' | 'istanbul' | 'muirGlacier' | 'berlin' | 'london' | 'arrowGlacier' | 'grayGlacier' | 'mergeForkIdTransition' | 'paris' | 'shanghai' | 'cancun' | 'prague' | 'osaka';

/**
 * @property {Hardfork} [hardfork='prague'] - Hardfork to use
 * @property {ReadonlyArray<number>} [eips=[1559, 4895]] - EIPs to enable
 * @property {LogOptions['level']} loggingLevel - Tevm logger instance
 * @property {CustomCrypto} [customCrypto] - Custom crypto implementations
 * Options for creating a Tevm Common instance
 * @example
 * ```typescript
 * import { mainnet, createCommon, type CommonOptions } from 'tevm/common'
 *
 * const opts: CommonOptions = {
 *   ...mainnet,
 *   hardfork: 'london',
 * }
 *
 * const common = createCommon(opts)
 * ```
 *
 * You can also create a Common instance from viem chains:
 * @example
 * ```typescript
 * import { mainnet } from 'viem/chains'
 * import { createCommon } from 'tevm/common'
 *
 * const common = createCommon({
 *   ...mainnet,
 *   hardfork: 'prague',
 * })
 * ```
 *
 * @see [createCommon](https://tevm.sh/reference/tevm/common/functions/createcommon/)
 */
type CommonOptions = Chain & {
    /**
     * Hardfork to use. Defaults to `prague`
     * @default 'prague'
     */
    hardfork?: Hardfork | undefined;
    /**
     * Eips to enable. Defaults to `[1559, 4895]`
     * @default [1559, 4895]
     */
    eips?: ReadonlyArray<number> | undefined;
    /**
     * Logging level of the Tevm logger instance
     * @default 'warn'
     */
    loggingLevel?: LogOptions['level'] | undefined;
    /**
     * Custom crypto implementations
     * For EIP-4844 support kzg must be passed
     * @warning KZG can add a significant amount of bundle size to an app
     * In future a stub will be provided that that automatically returns valid without checking the kzg proof
     * @example
     * ```typescript
     * import  { createMemoryClient } from 'tevm'
     * import  { mainnet } from 'tevm/common'
     * import { createMockKzg } from 'tevm/crypto'
     *
     * const common = createCommon({
     *   ...mainnet,
     *   customCrypto: {
     *     kzg: createMockKzg(),
     *     ...customCrypto,
     *   },
     * })
     * ```
     */
    customCrypto?: CustomCrypto;
};

declare function createCommon({ customCrypto, loggingLevel, hardfork, eips, ...chain }: CommonOptions): Common;

/**
 * The interface of the custom crypto for kzg implemented by `createMockKzg``
 * The real kzg commitmenet is over 500kb added to bundle size
 * so this is useful alternative for smaller bundles and the default
 * @example
 * ```typescript
 * import { createCommon, createMockKzg, mainnet, type MockKzg } from 'tevm/common'
 *
 * const kzg: MockKzg = createMockKzg()
 *
 * const common = createCommon({
 *   ...mainnet,
 *   customCrypto: {
 *     kzg:,
 *   },
 * })
 * ```
 * @see [createMockKzg](https://tevm.sh/reference/tevm/common/functions/createmockkzg/)
 * @see [createCommon](https://tevm.sh/reference/tevm/common/functions/createcommon/)
 */
type MockKzg = {
    loadTrustedSetup: (trustedSetup?: any) => number;
    freeTrustedSetup: () => void;
    blobToKzgCommitment: (blob: string) => string;
    computeBlobKzgProof: (blob: string, commitment: string) => string;
    verifyBlobKzgProofBatch: (blobs: string[], commitments: string[], proofs: string[]) => boolean;
    verifyKzgProof: (commitment: string, z: string, y: string, proof: string) => boolean;
    verifyBlobKzgProof: (blob: string, commitment: string, proof: string) => boolean;
    computeBlobProof: (blob: string, commitment: string) => string;
    verifyProof: (commitment: string, z: string, y: string, proof: string) => boolean;
    verifyBlobProofBatch: (blobs: string[], commitments: string[], proofs: string[]) => boolean;
};

declare function createMockKzg(): MockKzg;

/**
 * Creates a common configuration for the abstractTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11124
 * Chain Name: Abstract Testnet
 * Default Block Explorer: https://explorer.testnet.abs.xyz
 * Default RPC URL: https://api.testnet.abs.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { abstractTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: abstractTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const abstractTestnet: Common;

/**
 * Creates a common configuration for the acala chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 787
 * Chain Name: Acala
 * Default Block Explorer: https://blockscout.acala.network
 * Default RPC URL: https://eth-rpc-acala.aca-api.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { acala } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: acala,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const acala: Common;

/**
 * Creates a common configuration for the ancient8 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 888888888
 * Chain Name: Ancient8
 * Default Block Explorer: https://scan.ancient8.gg
 * Default RPC URL: https://rpc.ancient8.gg
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ancient8 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ancient8,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ancient8: Common;

/**
 * Creates a common configuration for the ancient8Sepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 28122024
 * Chain Name: Ancient8 Testnet
 * Default Block Explorer: https://scanv2-testnet.ancient8.gg
 * Default RPC URL: https://rpcv2-testnet.ancient8.gg
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ancient8Sepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ancient8Sepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ancient8Sepolia: Common;

/**
 * Creates a common configuration for the anvil chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 31337
 * Chain Name: Anvil
 * Default Block Explorer: Not specified
 * Default RPC URL: http://127.0.0.1:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { anvil } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: anvil,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const anvil: Common;

/**
 * Creates a common configuration for the apexTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3993
 * Chain Name: APEX Testnet
 * Default Block Explorer: https://exp-testnet.apexlayer.xyz
 * Default RPC URL: https://rpc-testnet.apexlayer.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { apexTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: apexTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const apexTestnet: Common;

/**
 * Creates a common configuration for the arbitrum chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42161
 * Chain Name: Arbitrum One
 * Default Block Explorer: https://arbiscan.io
 * Default RPC URL: https://arb1.arbitrum.io/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { arbitrum } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: arbitrum,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const arbitrum: Common;

/**
 * Creates a common configuration for the arbitrumGoerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 421613
 * Chain Name: Arbitrum Goerli
 * Default Block Explorer: https://goerli.arbiscan.io
 * Default RPC URL: https://goerli-rollup.arbitrum.io/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { arbitrumGoerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: arbitrumGoerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const arbitrumGoerli: Common;

/**
 * Creates a common configuration for the arbitrumNova chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42170
 * Chain Name: Arbitrum Nova
 * Default Block Explorer: https://nova.arbiscan.io
 * Default RPC URL: https://nova.arbitrum.io/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { arbitrumNova } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: arbitrumNova,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const arbitrumNova: Common;

/**
 * Creates a common configuration for the arbitrumSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 421614
 * Chain Name: Arbitrum Sepolia
 * Default Block Explorer: https://sepolia.arbiscan.io
 * Default RPC URL: https://sepolia-rollup.arbitrum.io/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { arbitrumSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: arbitrumSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const arbitrumSepolia: Common;

/**
 * Creates a common configuration for the areonNetwork chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 463
 * Chain Name: Areon Network
 * Default Block Explorer: https://areonscan.com
 * Default RPC URL: https://mainnet-rpc.areon.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { areonNetwork } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: areonNetwork,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const areonNetwork: Common;

/**
 * Creates a common configuration for the areonNetworkTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 462
 * Chain Name: Areon Network Testnet
 * Default Block Explorer: https://areonscan.com
 * Default RPC URL: https://testnet-rpc.areon.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { areonNetworkTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: areonNetworkTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const areonNetworkTestnet: Common;

/**
 * Creates a common configuration for the artelaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11822
 * Chain Name: Artela Testnet
 * Default Block Explorer: https://betanet-scan.artela.network
 * Default RPC URL: https://betanet-rpc1.artela.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { artelaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: artelaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const artelaTestnet: Common;

/**
 * Creates a common configuration for the assetChainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42421
 * Chain Name: AssetChain Testnet
 * Default Block Explorer: https://scan-testnet.assetchain.org
 * Default RPC URL: https://enugu-rpc.assetchain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { assetChainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: assetChainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const assetChainTestnet: Common;

/**
 * Creates a common configuration for the astar chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 592
 * Chain Name: Astar
 * Default Block Explorer: https://astar.subscan.io
 * Default RPC URL: https://astar.api.onfinality.io/public
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { astar } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: astar,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const astar: Common;

/**
 * Creates a common configuration for the astarZkEVM chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3776
 * Chain Name: Astar zkEVM
 * Default Block Explorer: https://astar-zkevm.explorer.startale.com
 * Default RPC URL: https://rpc.startale.com/astar-zkevm
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { astarZkEVM } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: astarZkEVM,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const astarZkEVM: Common;

/**
 * Creates a common configuration for the astarZkyoto chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 6038361
 * Chain Name: Astar zkEVM Testnet zKyoto
 * Default Block Explorer: https://zkyoto.explorer.startale.com
 * Default RPC URL: https://rpc.startale.com/zkyoto
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { astarZkyoto } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: astarZkyoto,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const astarZkyoto: Common;

/**
 * Creates a common configuration for the atletaOlympia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2340
 * Chain Name: Atleta Olympia
 * Default Block Explorer: https://blockscout.atleta.network
 * Default RPC URL: https://testnet-rpc.atleta.network:9944
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { atletaOlympia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: atletaOlympia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const atletaOlympia: Common;

/**
 * Creates a common configuration for the aurora chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1313161554
 * Chain Name: Aurora
 * Default Block Explorer: https://aurorascan.dev
 * Default RPC URL: https://mainnet.aurora.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { aurora } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: aurora,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const aurora: Common;

/**
 * Creates a common configuration for the auroraTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1313161555
 * Chain Name: Aurora Testnet
 * Default Block Explorer: https://testnet.aurorascan.dev
 * Default RPC URL: https://testnet.aurora.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { auroraTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: auroraTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const auroraTestnet: Common;

/**
 * Creates a common configuration for the auroria chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 205205
 * Chain Name: Auroria Testnet
 * Default Block Explorer: https://auroria.explorer.stratisevm.com
 * Default RPC URL: https://auroria.rpc.stratisevm.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { auroria } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: auroria,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const auroria: Common;

/**
 * Creates a common configuration for the avalanche chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 43114
 * Chain Name: Avalanche
 * Default Block Explorer: https://snowtrace.io
 * Default RPC URL: https://api.avax.network/ext/bc/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { avalanche } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: avalanche,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const avalanche: Common;

/**
 * Creates a common configuration for the avalancheFuji chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 43113
 * Chain Name: Avalanche Fuji
 * Default Block Explorer: https://testnet.snowtrace.io
 * Default RPC URL: https://api.avax-test.network/ext/bc/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { avalancheFuji } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: avalancheFuji,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const avalancheFuji: Common;

/**
 * Creates a common configuration for the b3 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8333
 * Chain Name: B3
 * Default Block Explorer: https://explorer.b3.fun
 * Default RPC URL: https://mainnet-rpc.b3.fun/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { b3 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: b3,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const b3: Common;

/**
 * Creates a common configuration for the b3Sepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1993
 * Chain Name: B3 Sepolia
 * Default Block Explorer: https://sepolia.explorer.b3.fun
 * Default RPC URL: https://sepolia.b3.fun/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { b3Sepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: b3Sepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const b3Sepolia: Common;

/**
 * Creates a common configuration for the bahamut chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5165
 * Chain Name: Bahamut
 * Default Block Explorer: https://www.ftnscan.com
 * Default RPC URL: https://rpc1.bahamut.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bahamut } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bahamut,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bahamut: Common;

/**
 * Creates a common configuration for the base chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8453
 * Chain Name: Base
 * Default Block Explorer: https://basescan.org
 * Default RPC URL: https://mainnet.base.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { base } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: base,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const base: Common;

/**
 * Creates a common configuration for the baseGoerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 84531
 * Chain Name: Base Goerli
 * Default Block Explorer: https://goerli.basescan.org
 * Default RPC URL: https://goerli.base.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { baseGoerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: baseGoerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const baseGoerli: Common;

/**
 * Creates a common configuration for the baseSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 84532
 * Chain Name: Base Sepolia
 * Default Block Explorer: https://sepolia.basescan.org
 * Default RPC URL: https://sepolia.base.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { baseSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: baseSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const baseSepolia: Common;

/**
 * Creates a common configuration for the beam chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4337
 * Chain Name: Beam
 * Default Block Explorer: https://subnets.avax.network/beam
 * Default RPC URL: https://build.onbeam.com/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { beam } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: beam,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const beam: Common;

/**
 * Creates a common configuration for the beamTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 13337
 * Chain Name: Beam Testnet
 * Default Block Explorer: https://subnets-test.avax.network/beam
 * Default RPC URL: https://build.onbeam.com/rpc/testnet
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { beamTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: beamTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const beamTestnet: Common;

/**
 * Creates a common configuration for the bearNetworkChainMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 641230
 * Chain Name: Bear Network Chain Mainnet
 * Default Block Explorer: https://brnkscan.bearnetwork.net
 * Default RPC URL: https://brnkc-mainnet.bearnetwork.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bearNetworkChainMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bearNetworkChainMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bearNetworkChainMainnet: Common;

/**
 * Creates a common configuration for the bearNetworkChainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 751230
 * Chain Name: Bear Network Chain Testnet
 * Default Block Explorer: https://brnktest-scan.bearnetwork.net
 * Default RPC URL: https://brnkc-test.bearnetwork.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bearNetworkChainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bearNetworkChainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bearNetworkChainTestnet: Common;

/**
 * Creates a common configuration for the berachainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 80085
 * Chain Name: Berachain Artio
 * Default Block Explorer: https://artio.beratrail.io
 * Default RPC URL: https://artio.rpc.berachain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { berachainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: berachainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const berachainTestnet: Common;

/**
 * Creates a common configuration for the berachainTestnetbArtio chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 80084
 * Chain Name: Berachain bArtio
 * Default Block Explorer: https://bartio.beratrail.io
 * Default RPC URL: https://bartio.rpc.berachain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { berachainTestnetbArtio } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: berachainTestnetbArtio,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const berachainTestnetbArtio: Common;

/**
 * Creates a common configuration for the bevmMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11501
 * Chain Name: BEVM Mainnet
 * Default Block Explorer: https://scan-mainnet.bevm.io
 * Default RPC URL: https://rpc-mainnet-1.bevm.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bevmMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bevmMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bevmMainnet: Common;

/**
 * Creates a common configuration for the bitkub chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 96
 * Chain Name: Bitkub
 * Default Block Explorer: https://www.bkcscan.com
 * Default RPC URL: https://rpc.bitkubchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bitkub } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bitkub,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bitkub: Common;

/**
 * Creates a common configuration for the bitkubTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 25925
 * Chain Name: Bitkub Testnet
 * Default Block Explorer: https://testnet.bkcscan.com
 * Default RPC URL: https://rpc-testnet.bitkubchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bitkubTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bitkubTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bitkubTestnet: Common;

/**
 * Creates a common configuration for the bitTorrent chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 199
 * Chain Name: BitTorrent
 * Default Block Explorer: https://bttcscan.com
 * Default RPC URL: https://rpc.bittorrentchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bitTorrent } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bitTorrent,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bitTorrent: Common;

/**
 * Creates a common configuration for the bitTorrentTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1028
 * Chain Name: BitTorrent Chain Testnet
 * Default Block Explorer: https://testnet.bttcscan.com
 * Default RPC URL: https://testrpc.bittorrentchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bitTorrentTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bitTorrentTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bitTorrentTestnet: Common;

/**
 * Creates a common configuration for the blast chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 81457
 * Chain Name: Blast
 * Default Block Explorer: https://blastscan.io
 * Default RPC URL: https://rpc.blast.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { blast } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: blast,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const blast: Common;

/**
 * Creates a common configuration for the blastSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 168587773
 * Chain Name: Blast Sepolia
 * Default Block Explorer: https://sepolia.blastscan.io
 * Default RPC URL: https://sepolia.blast.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { blastSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: blastSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const blastSepolia: Common;

/**
 * Creates a common configuration for the bob chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 60808
 * Chain Name: BOB
 * Default Block Explorer: https://explorer.gobob.xyz
 * Default RPC URL: https://rpc.gobob.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bob } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bob,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bob: Common;

/**
 * Creates a common configuration for the boba chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 288
 * Chain Name: Boba Network
 * Default Block Explorer: https://bobascan.com
 * Default RPC URL: https://mainnet.boba.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { boba } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: boba,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const boba: Common;

/**
 * Creates a common configuration for the bobaSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 28882
 * Chain Name: Boba Sepolia
 * Default Block Explorer: https://testnet.bobascan.com
 * Default RPC URL: https://sepolia.boba.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bobaSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bobaSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bobaSepolia: Common;

/**
 * Creates a common configuration for the bobSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 808813
 * Chain Name: BOB Sepolia
 * Default Block Explorer: https://bob-sepolia.explorer.gobob.xyz
 * Default RPC URL: https://bob-sepolia.rpc.gobob.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bobSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bobSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bobSepolia: Common;

/**
 * Creates a common configuration for the botanixTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3636
 * Chain Name: Botanix Testnet
 * Default Block Explorer: https://blockscout.botanixlabs.dev
 * Default RPC URL: https://poa-node.botanixlabs.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { botanixTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: botanixTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const botanixTestnet: Common;

/**
 * Creates a common configuration for the bronos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1039
 * Chain Name: Bronos
 * Default Block Explorer: https://broscan.bronos.org
 * Default RPC URL: https://evm.bronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bronos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bronos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bronos: Common;

/**
 * Creates a common configuration for the bronosTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1038
 * Chain Name: Bronos Testnet
 * Default Block Explorer: https://tbroscan.bronos.org
 * Default RPC URL: https://evm-testnet.bronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bronosTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bronosTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bronosTestnet: Common;

/**
 * Creates a common configuration for the bsc chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 56
 * Chain Name: BNB Smart Chain
 * Default Block Explorer: https://bscscan.com
 * Default RPC URL: https://rpc.ankr.com/bsc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bsc } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bsc,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bsc: Common;

/**
 * Creates a common configuration for the bscGreenfield chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1017
 * Chain Name: BNB Greenfield Chain
 * Default Block Explorer: https://greenfieldscan.com
 * Default RPC URL: https://greenfield-chain.bnbchain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bscGreenfield } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bscGreenfield,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bscGreenfield: Common;

/**
 * Creates a common configuration for the bscTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 97
 * Chain Name: Binance Smart Chain Testnet
 * Default Block Explorer: https://testnet.bscscan.com
 * Default RPC URL: https://data-seed-prebsc-1-s1.bnbchain.org:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bscTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bscTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bscTestnet: Common;

/**
 * Creates a common configuration for the btr chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 200901
 * Chain Name: Bitlayer
 * Default Block Explorer: https://www.btrscan.com
 * Default RPC URL: https://rpc.bitlayer.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { btr } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: btr,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const btr: Common;

/**
 * Creates a common configuration for the btrTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 200810
 * Chain Name: Bitlayer Testnet
 * Default Block Explorer: https://testnet.btrscan.com
 * Default RPC URL: https://testnet-rpc.bitlayer.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { btrTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: btrTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const btrTestnet: Common;

/**
 * Creates a common configuration for the bxn chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4999
 * Chain Name: BlackFort Exchange Network
 * Default Block Explorer: https://explorer.blackfort.network
 * Default RPC URL: https://mainnet.blackfort.network/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bxn } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bxn,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bxn: Common;

/**
 * Creates a common configuration for the bxnTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4777
 * Chain Name: BlackFort Exchange Network Testnet
 * Default Block Explorer: https://testnet-explorer.blackfort.network
 * Default RPC URL: https://testnet.blackfort.network/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { bxnTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: bxnTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const bxnTestnet: Common;

/**
 * Creates a common configuration for the canto chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7700
 * Chain Name: Canto
 * Default Block Explorer: https://tuber.build
 * Default RPC URL: https://canto.gravitychain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { canto } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: canto,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const canto: Common;

/**
 * Creates a common configuration for the celo chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42220
 * Chain Name: Celo
 * Default Block Explorer: https://celoscan.io
 * Default RPC URL: https://forno.celo.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { celo } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: celo,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const celo: Common;

/**
 * Creates a common configuration for the celoAlfajores chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 44787
 * Chain Name: Alfajores
 * Default Block Explorer: https://explorer.celo.org/alfajores
 * Default RPC URL: https://alfajores-forno.celo-testnet.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { celoAlfajores } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: celoAlfajores,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const celoAlfajores: Common;

/**
 * Creates a common configuration for the chiliz chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 88888
 * Chain Name: Chiliz Chain
 * Default Block Explorer: https://scan.chiliz.com
 * Default RPC URL: https://rpc.ankr.com/chiliz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { chiliz } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: chiliz,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const chiliz: Common;

/**
 * Creates a common configuration for the chips chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2882
 * Chain Name: Chips Network
 * Default Block Explorer: Not specified
 * Default RPC URL: https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { chips } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: chips,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const chips: Common;

/**
 * Creates a common configuration for the classic chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 61
 * Chain Name: Ethereum Classic
 * Default Block Explorer: https://blockscout.com/etc/mainnet
 * Default RPC URL: https://etc.rivet.link
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { classic } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: classic,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const classic: Common;

/**
 * Creates a common configuration for the confluxESpace chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1030
 * Chain Name: Conflux eSpace
 * Default Block Explorer: https://evm.confluxscan.io
 * Default RPC URL: https://evm.confluxrpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { confluxESpace } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: confluxESpace,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const confluxESpace: Common;

/**
 * Creates a common configuration for the confluxESpaceTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 71
 * Chain Name: Conflux eSpace Testnet
 * Default Block Explorer: https://evmtestnet.confluxscan.io
 * Default RPC URL: https://evmtestnet.confluxrpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { confluxESpaceTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: confluxESpaceTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const confluxESpaceTestnet: Common;

/**
 * Creates a common configuration for the coreDao chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1116
 * Chain Name: Core Dao
 * Default Block Explorer: https://scan.coredao.org
 * Default RPC URL: https://rpc.coredao.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { coreDao } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: coreDao,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const coreDao: Common;

/**
 * Creates a common configuration for the crab chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 44
 * Chain Name: Crab Network
 * Default Block Explorer: https://crab-scan.darwinia.network
 * Default RPC URL: https://crab-rpc.darwinia.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { crab } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: crab,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const crab: Common;

/**
 * Creates a common configuration for the cronos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 25
 * Chain Name: Cronos Mainnet
 * Default Block Explorer: https://explorer.cronos.org
 * Default RPC URL: https://evm.cronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cronos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cronos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cronos: Common;

/**
 * Creates a common configuration for the cronosTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 338
 * Chain Name: Cronos Testnet
 * Default Block Explorer: https://cronos.org/explorer/testnet3
 * Default RPC URL: https://evm-t3.cronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cronosTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cronosTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cronosTestnet: Common;

/**
 * Creates a common configuration for the cronoszkEVM chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 388
 * Chain Name: Cronos zkEVM Mainnet
 * Default Block Explorer: https://explorer.zkevm.cronos.org
 * Default RPC URL: https://mainnet.zkevm.cronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cronoszkEVM } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cronoszkEVM,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cronoszkEVM: Common;

/**
 * Creates a common configuration for the cronoszkEVMTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 282
 * Chain Name: Cronos zkEVM Testnet
 * Default Block Explorer: https://explorer.zkevm.cronos.org/testnet
 * Default RPC URL: https://testnet.zkevm.cronos.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cronoszkEVMTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cronoszkEVMTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cronoszkEVMTestnet: Common;

/**
 * Creates a common configuration for the crossbell chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3737
 * Chain Name: Crossbell
 * Default Block Explorer: https://scan.crossbell.io
 * Default RPC URL: https://rpc.crossbell.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { crossbell } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: crossbell,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const crossbell: Common;

/**
 * Creates a common configuration for the curtis chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 33111
 * Chain Name: Curtis
 * Default Block Explorer: https://explorer.curtis.apechain.com
 * Default RPC URL: https://rpc.curtis.apechain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { curtis } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: curtis,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const curtis: Common;

/**
 * Creates a common configuration for the cyber chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7560
 * Chain Name: Cyber
 * Default Block Explorer: https://cyberscan.co
 * Default RPC URL: https://cyber.alt.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cyber } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cyber,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cyber: Common;

/**
 * Creates a common configuration for the cyberTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 111557560
 * Chain Name: Cyber Testnet
 * Default Block Explorer: https://testnet.cyberscan.co
 * Default RPC URL: https://cyber-testnet.alt.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { cyberTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: cyberTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const cyberTestnet: Common;

/**
 * Creates a common configuration for the darwinia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 46
 * Chain Name: Darwinia Network
 * Default Block Explorer: https://explorer.darwinia.network
 * Default RPC URL: https://rpc.darwinia.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { darwinia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: darwinia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const darwinia: Common;

/**
 * Creates a common configuration for the dchain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2716446429837000
 * Chain Name: Dchain
 * Default Block Explorer: https://dchain-2716446429837000-1.sagaexplorer.io
 * Default RPC URL: https://dchain-2716446429837000-1.jsonrpc.sagarpc.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dchain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dchain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dchain: Common;

/**
 * Creates a common configuration for the dchainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2713017997578000
 * Chain Name: Dchain Testnet
 * Default Block Explorer: https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io
 * Default RPC URL: https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dchainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dchainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dchainTestnet: Common;

/**
 * Creates a common configuration for the defichainEvm chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1130
 * Chain Name: DeFiChain EVM Mainnet
 * Default Block Explorer: https://meta.defiscan.live
 * Default RPC URL: https://eth.mainnet.ocean.jellyfishsdk.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { defichainEvm } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: defichainEvm,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const defichainEvm: Common;

/**
 * Creates a common configuration for the defichainEvmTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1131
 * Chain Name: DeFiChain EVM Testnet
 * Default Block Explorer: https://meta.defiscan.live/?network=TestNet
 * Default RPC URL: https://eth.testnet.ocean.jellyfishsdk.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { defichainEvmTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: defichainEvmTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const defichainEvmTestnet: Common;

/**
 * Creates a common configuration for the degen chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 666666666
 * Chain Name: Degen
 * Default Block Explorer: https://explorer.degen.tips
 * Default RPC URL: https://rpc.degen.tips
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { degen } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: degen,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const degen: Common;

/**
 * Creates a common configuration for the dfk chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 53935
 * Chain Name: DFK Chain
 * Default Block Explorer: https://subnets.avax.network/defi-kingdoms
 * Default RPC URL: https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dfk } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dfk,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dfk: Common;

/**
 * Creates a common configuration for the dodochainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 53457
 * Chain Name: DODOchain Testnet
 * Default Block Explorer: https://testnet-scan.dodochain.com
 * Default RPC URL: https://dodochain-testnet.alt.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dodochainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dodochainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dodochainTestnet: Common;

/**
 * Creates a common configuration for the dogechain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2000
 * Chain Name: Dogechain
 * Default Block Explorer: https://explorer.dogechain.dog
 * Default RPC URL: https://rpc.dogechain.dog
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dogechain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dogechain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dogechain: Common;

/**
 * Creates a common configuration for the dreyerxMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 23451
 * Chain Name: DreyerX Mainnet
 * Default Block Explorer: https://scan.dreyerx.com
 * Default RPC URL: https://rpc.dreyerx.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dreyerxMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dreyerxMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dreyerxMainnet: Common;

/**
 * Creates a common configuration for the dreyerxTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 23452
 * Chain Name: DreyerX Testnet
 * Default Block Explorer: https://testnet-scan.dreyerx.com
 * Default RPC URL: http://testnet-rpc.dreyerx.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { dreyerxTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: dreyerxTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const dreyerxTestnet: Common;

/**
 * Creates a common configuration for the edgeless chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2026
 * Chain Name: Edgeless Network
 * Default Block Explorer: https://explorer.edgeless.network
 * Default RPC URL: https://rpc.edgeless.network/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { edgeless } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: edgeless,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const edgeless: Common;

/**
 * Creates a common configuration for the edgelessTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 202
 * Chain Name: Edgeless Testnet
 * Default Block Explorer: https://testnet.explorer.edgeless.network
 * Default RPC URL: https://edgeless-testnet.rpc.caldera.xyz/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { edgelessTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: edgelessTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const edgelessTestnet: Common;

/**
 * Creates a common configuration for the edgeware chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2021
 * Chain Name: Edgeware EdgeEVM Mainnet
 * Default Block Explorer: https://edgscan.live
 * Default RPC URL: https://edgeware-evm.jelliedowl.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { edgeware } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: edgeware,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const edgeware: Common;

/**
 * Creates a common configuration for the edgewareTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2022
 * Chain Name: Beresheet BereEVM Testnet
 * Default Block Explorer: https://testnet.edgscan.live
 * Default RPC URL: https://beresheet-evm.jelliedowl.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { edgewareTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: edgewareTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const edgewareTestnet: Common;

/**
 * Creates a common configuration for the ekta chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1994
 * Chain Name: Ekta
 * Default Block Explorer: https://ektascan.io
 * Default RPC URL: https://main.ekta.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ekta } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ekta,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ekta: Common;

/**
 * Creates a common configuration for the ektaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1004
 * Chain Name: Ekta Testnet
 * Default Block Explorer: https://test.ektascan.io
 * Default RPC URL: https://test.ekta.io:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ektaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ektaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ektaTestnet: Common;

/**
 * Creates a common configuration for the eon chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7332
 * Chain Name: Horizen EON
 * Default Block Explorer: https://eon-explorer.horizenlabs.io
 * Default RPC URL: https://eon-rpc.horizenlabs.io/ethv1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { eon } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: eon,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const eon: Common;

/**
 * Creates a common configuration for the eos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 17777
 * Chain Name: EOS EVM
 * Default Block Explorer: https://explorer.evm.eosnetwork.com
 * Default RPC URL: https://api.evm.eosnetwork.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { eos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: eos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const eos: Common;

/**
 * Creates a common configuration for the eosTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 15557
 * Chain Name: EOS EVM Testnet
 * Default Block Explorer: https://explorer.testnet.evm.eosnetwork.com
 * Default RPC URL: https://api.testnet.evm.eosnetwork.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { eosTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: eosTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const eosTestnet: Common;

/**
 * Creates a common configuration for the etherlink chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42793
 * Chain Name: Etherlink
 * Default Block Explorer: https://explorer.etherlink.com
 * Default RPC URL: https://node.mainnet.etherlink.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { etherlink } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: etherlink,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const etherlink: Common;

/**
 * Creates a common configuration for the etherlinkTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 128123
 * Chain Name: Etherlink Testnet
 * Default Block Explorer: https://testnet-explorer.etherlink.com
 * Default RPC URL: https://node.ghostnet.etherlink.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { etherlinkTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: etherlinkTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const etherlinkTestnet: Common;

/**
 * Creates a common configuration for the evmos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 9001
 * Chain Name: Evmos
 * Default Block Explorer: https://escan.live
 * Default RPC URL: https://eth.bd.evmos.org:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { evmos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: evmos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const evmos: Common;

/**
 * Creates a common configuration for the evmosTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 9000
 * Chain Name: Evmos Testnet
 * Default Block Explorer: https://evm.evmos.dev/
 * Default RPC URL: https://eth.bd.evmos.dev:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { evmosTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: evmosTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const evmosTestnet: Common;

/**
 * Creates a common configuration for the fantom chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 250
 * Chain Name: Fantom
 * Default Block Explorer: https://ftmscan.com
 * Default RPC URL: https://rpc.ankr.com/fantom
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fantom } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fantom,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fantom: Common;

/**
 * Creates a common configuration for the fantomSonicTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 64240
 * Chain Name: Fantom Sonic Open Testnet
 * Default Block Explorer: https://public-sonic.fantom.network
 * Default RPC URL: https://rpcapi.sonic.fantom.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fantomSonicTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fantomSonicTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fantomSonicTestnet: Common;

/**
 * Creates a common configuration for the fantomTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4002
 * Chain Name: Fantom Testnet
 * Default Block Explorer: https://testnet.ftmscan.com
 * Default RPC URL: https://rpc.testnet.fantom.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fantomTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fantomTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fantomTestnet: Common;

/**
 * Creates a common configuration for the fibo chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 12306
 * Chain Name: Fibo Chain
 * Default Block Explorer: https://scan.fibochain.org
 * Default RPC URL: https://network.hzroc.art
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fibo } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fibo,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fibo: Common;

/**
 * Creates a common configuration for the filecoin chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 314
 * Chain Name: Filecoin Mainnet
 * Default Block Explorer: https://filfox.info/en
 * Default RPC URL: https://api.node.glif.io/rpc/v1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { filecoin } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: filecoin,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const filecoin: Common;

/**
 * Creates a common configuration for the filecoinCalibration chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 314159
 * Chain Name: Filecoin Calibration
 * Default Block Explorer: https://calibration.filscan.io
 * Default RPC URL: https://api.calibration.node.glif.io/rpc/v1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { filecoinCalibration } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: filecoinCalibration,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const filecoinCalibration: Common;

/**
 * Creates a common configuration for the filecoinHyperspace chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3141
 * Chain Name: Filecoin Hyperspace
 * Default Block Explorer: https://hyperspace.filfox.info/en
 * Default RPC URL: https://api.hyperspace.node.glif.io/rpc/v1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { filecoinHyperspace } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: filecoinHyperspace,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const filecoinHyperspace: Common;

/**
 * Creates a common configuration for the flare chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 14
 * Chain Name: Flare Mainnet
 * Default Block Explorer: https://flare-explorer.flare.network
 * Default RPC URL: https://flare-api.flare.network/ext/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { flare } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: flare,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const flare: Common;

/**
 * Creates a common configuration for the flareTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 114
 * Chain Name: Coston2
 * Default Block Explorer: https://coston2-explorer.flare.network
 * Default RPC URL: https://coston2-api.flare.network/ext/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { flareTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: flareTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const flareTestnet: Common;

/**
 * Creates a common configuration for the flowMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 747
 * Chain Name: FlowEVM Mainnet
 * Default Block Explorer: https://flowdiver.io
 * Default RPC URL: https://mainnet.evm.nodes.onflow.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { flowMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: flowMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const flowMainnet: Common;

/**
 * Creates a common configuration for the flowPreviewnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 646
 * Chain Name: FlowEVM Previewnet
 * Default Block Explorer: https://previewnet.flowdiver.io
 * Default RPC URL: https://previewnet.evm.nodes.onflow.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { flowPreviewnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: flowPreviewnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const flowPreviewnet: Common;

/**
 * Creates a common configuration for the flowTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 545
 * Chain Name: FlowEVM Testnet
 * Default Block Explorer: https://testnet.flowdiver.io
 * Default RPC URL: https://testnet.evm.nodes.onflow.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { flowTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: flowTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const flowTestnet: Common;

/**
 * Creates a common configuration for the fluence chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 9999999
 * Chain Name: Fluence
 * Default Block Explorer: https://blockscout.mainnet.fluence.dev
 * Default RPC URL: https://rpc.mainnet.fluence.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fluence } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fluence,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fluence: Common;

/**
 * Creates a common configuration for the fluenceStage chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 123420000220
 * Chain Name: Fluence Stage
 * Default Block Explorer: https://blockscout.stage.fluence.dev
 * Default RPC URL: https://rpc.stage.fluence.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fluenceStage } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fluenceStage,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fluenceStage: Common;

/**
 * Creates a common configuration for the fluenceTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 52164803
 * Chain Name: Fluence Testnet
 * Default Block Explorer: https://blockscout.testnet.fluence.dev
 * Default RPC URL: https://rpc.testnet.fluence.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fluenceTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fluenceTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fluenceTestnet: Common;

/**
 * Creates a common configuration for the forma chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 984122
 * Chain Name: Forma
 * Default Block Explorer: https://explorer.forma.art
 * Default RPC URL: https://rpc.forma.art
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { forma } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: forma,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const forma: Common;

/**
 * Creates a common configuration for the foundry chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 31337
 * Chain Name: Foundry
 * Default Block Explorer: Not specified
 * Default RPC URL: http://127.0.0.1:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { foundry } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: foundry,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const foundry: Common;

/**
 * Creates a common configuration for the fraxtal chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 252
 * Chain Name: Fraxtal
 * Default Block Explorer: https://fraxscan.com
 * Default RPC URL: https://rpc.frax.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fraxtal } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fraxtal,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fraxtal: Common;

/**
 * Creates a common configuration for the fraxtalTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2522
 * Chain Name: Fraxtal Testnet
 * Default Block Explorer: https://holesky.fraxscan.com
 * Default RPC URL: https://rpc.testnet.frax.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fraxtalTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fraxtalTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fraxtalTestnet: Common;

/**
 * Creates a common configuration for the funkiMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 33979
 * Chain Name: Funki
 * Default Block Explorer: https://funkiscan.io
 * Default RPC URL: https://rpc-mainnet.funkichain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { funkiMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: funkiMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const funkiMainnet: Common;

/**
 * Creates a common configuration for the funkiSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3397901
 * Chain Name: Funki Sepolia Sandbox
 * Default Block Explorer: https://sepolia-sandbox.funkichain.com/
 * Default RPC URL: https://funki-testnet.alt.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { funkiSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: funkiSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const funkiSepolia: Common;

/**
 * Creates a common configuration for the fuse chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 122
 * Chain Name: Fuse
 * Default Block Explorer: https://explorer.fuse.io
 * Default RPC URL: https://rpc.fuse.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fuse } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fuse,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fuse: Common;

/**
 * Creates a common configuration for the fuseSparknet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 123
 * Chain Name: Fuse Sparknet
 * Default Block Explorer: https://explorer.fusespark.io
 * Default RPC URL: https://rpc.fusespark.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { fuseSparknet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: fuseSparknet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const fuseSparknet: Common;

/**
 * Creates a common configuration for the gnosis chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 100
 * Chain Name: Gnosis
 * Default Block Explorer: https://gnosisscan.io
 * Default RPC URL: https://rpc.gnosischain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { gnosis } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: gnosis,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const gnosis: Common;

/**
 * Creates a common configuration for the gnosisChiado chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 10200
 * Chain Name: Gnosis Chiado
 * Default Block Explorer: https://blockscout.chiadochain.net
 * Default RPC URL: https://rpc.chiadochain.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { gnosisChiado } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: gnosisChiado,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const gnosisChiado: Common;

/**
 * Creates a common configuration for the gobi chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1663
 * Chain Name: Horizen Gobi Testnet
 * Default Block Explorer: https://gobi-explorer.horizen.io
 * Default RPC URL: https://gobi-testnet.horizenlabs.io/ethv1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { gobi } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: gobi,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const gobi: Common;

/**
 * Creates a common configuration for the goerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5
 * Chain Name: Goerli
 * Default Block Explorer: https://goerli.etherscan.io
 * Default RPC URL: https://rpc.ankr.com/eth_goerli
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { goerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: goerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const goerli: Common;

/**
 * Creates a common configuration for the gravity chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1625
 * Chain Name: Gravity Alpha Mainnet
 * Default Block Explorer: https://explorer.gravity.xyz
 * Default RPC URL: https://rpc.gravity.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { gravity } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: gravity,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const gravity: Common;

/**
 * Creates a common configuration for the ham chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5112
 * Chain Name: Ham
 * Default Block Explorer: https://explorer.ham.fun
 * Default RPC URL: https://rpc.ham.fun
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ham } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ham,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ham: Common;

/**
 * Creates a common configuration for the haqqMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11235
 * Chain Name: HAQQ Mainnet
 * Default Block Explorer: https://explorer.haqq.network
 * Default RPC URL: https://rpc.eth.haqq.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { haqqMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: haqqMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const haqqMainnet: Common;

/**
 * Creates a common configuration for the haqqTestedge2 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 54211
 * Chain Name: HAQQ Testedge 2
 * Default Block Explorer: https://explorer.testedge2.haqq.network
 * Default RPC URL: https://rpc.eth.testedge2.haqq.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { haqqTestedge2 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: haqqTestedge2,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const haqqTestedge2: Common;

/**
 * Creates a common configuration for the hardhat chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 31337
 * Chain Name: Hardhat
 * Default Block Explorer: Not specified
 * Default RPC URL: http://127.0.0.1:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { hardhat } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: hardhat,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const hardhat: Common;

/**
 * Creates a common configuration for the harmonyOne chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1666600000
 * Chain Name: Harmony One
 * Default Block Explorer: https://explorer.harmony.one
 * Default RPC URL: https://rpc.ankr.com/harmony
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { harmonyOne } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: harmonyOne,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const harmonyOne: Common;

/**
 * Creates a common configuration for the hashkeyTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 133
 * Chain Name: HashKey Chain Testnet
 * Default Block Explorer: https://hashkeychain-testnet-explorer.alt.technology
 * Default RPC URL: https://hashkeychain-testnet.alt.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { hashkeyTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: hashkeyTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const hashkeyTestnet: Common;

/**
 * Creates a common configuration for the hedera chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 295
 * Chain Name: Hedera Mainnet
 * Default Block Explorer: https://hashscan.io/mainnet
 * Default RPC URL: https://mainnet.hashio.io/api
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { hedera } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: hedera,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const hedera: Common;

/**
 * Creates a common configuration for the hederaPreviewnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 297
 * Chain Name: Hedera Previewnet
 * Default Block Explorer: https://hashscan.io/previewnet
 * Default RPC URL: https://previewnet.hashio.io/api
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { hederaPreviewnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: hederaPreviewnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const hederaPreviewnet: Common;

/**
 * Creates a common configuration for the hederaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 296
 * Chain Name: Hedera Testnet
 * Default Block Explorer: https://hashscan.io/testnet
 * Default RPC URL: https://testnet.hashio.io/api
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { hederaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: hederaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const hederaTestnet: Common;

/**
 * Creates a common configuration for the holesky chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 17000
 * Chain Name: Holesky
 * Default Block Explorer: https://holesky.etherscan.io
 * Default RPC URL: https://ethereum-holesky-rpc.publicnode.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { holesky } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: holesky,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const holesky: Common;

/**
 * Creates a common configuration for the immutableZkEvm chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 13371
 * Chain Name: Immutable zkEVM
 * Default Block Explorer: https://explorer.immutable.com
 * Default RPC URL: https://rpc.immutable.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { immutableZkEvm } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: immutableZkEvm,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const immutableZkEvm: Common;

/**
 * Creates a common configuration for the immutableZkEvmTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 13473
 * Chain Name: Immutable zkEVM Testnet
 * Default Block Explorer: https://explorer.testnet.immutable.com/
 * Default RPC URL: https://rpc.testnet.immutable.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { immutableZkEvmTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: immutableZkEvmTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const immutableZkEvmTestnet: Common;

/**
 * Creates a common configuration for the inEVM chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2525
 * Chain Name: inEVM Mainnet
 * Default Block Explorer: https://inevm.calderaexplorer.xyz
 * Default RPC URL: https://mainnet.rpc.inevm.com/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { inEVM } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: inEVM,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const inEVM: Common;

/**
 * Creates a common configuration for the iota chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8822
 * Chain Name: IOTA EVM
 * Default Block Explorer: https://explorer.evm.iota.org
 * Default RPC URL: https://json-rpc.evm.iotaledger.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { iota } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: iota,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const iota: Common;

/**
 * Creates a common configuration for the iotaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1075
 * Chain Name: IOTA EVM Testnet
 * Default Block Explorer: https://explorer.evm.testnet.iotaledger.net
 * Default RPC URL: https://json-rpc.evm.testnet.iotaledger.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { iotaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: iotaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const iotaTestnet: Common;

/**
 * Creates a common configuration for the iotex chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4689
 * Chain Name: IoTeX
 * Default Block Explorer: https://iotexscan.io
 * Default RPC URL: https://babel-api.mainnet.iotex.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { iotex } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: iotex,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const iotex: Common;

/**
 * Creates a common configuration for the iotexTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4690
 * Chain Name: IoTeX Testnet
 * Default Block Explorer: https://testnet.iotexscan.io
 * Default RPC URL: https://babel-api.testnet.iotex.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { iotexTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: iotexTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const iotexTestnet: Common;

/**
 * Creates a common configuration for the jbc chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8899
 * Chain Name: JIBCHAIN L1
 * Default Block Explorer: https://exp-l1.jibchain.net
 * Default RPC URL: https://rpc-l1.jibchain.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { jbc } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: jbc,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const jbc: Common;

/**
 * Creates a common configuration for the jbcTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 88991
 * Chain Name: Jibchain Testnet
 * Default Block Explorer: https://exp.testnet.jibchain.net
 * Default RPC URL: https://rpc.testnet.jibchain.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { jbcTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: jbcTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const jbcTestnet: Common;

/**
 * Creates a common configuration for the kaia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8217
 * Chain Name: Kaia
 * Default Block Explorer: https://kaiascope.com
 * Default RPC URL: https://public-en.node.kaia.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kaia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kaia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kaia: Common;

/**
 * Creates a common configuration for the kairos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1001
 * Chain Name: Kairos Testnet
 * Default Block Explorer: https://kairos.kaiascope.com
 * Default RPC URL: https://public-en-kairos.node.kaia.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kairos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kairos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kairos: Common;

/**
 * Creates a common configuration for the kakarotSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1802203764
 * Chain Name: Kakarot Sepolia
 * Default Block Explorer: https://sepolia.kakarotscan.org
 * Default RPC URL: https://sepolia-rpc.kakarot.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kakarotSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kakarotSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kakarotSepolia: Common;

/**
 * Creates a common configuration for the karura chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 686
 * Chain Name: Karura
 * Default Block Explorer: https://blockscout.karura.network
 * Default RPC URL: https://eth-rpc-karura.aca-api.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { karura } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: karura,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const karura: Common;

/**
 * Creates a common configuration for the kava chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2222
 * Chain Name: Kava EVM
 * Default Block Explorer: https://kavascan.com
 * Default RPC URL: https://evm.kava.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kava } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kava,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kava: Common;

/**
 * Creates a common configuration for the kavaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2221
 * Chain Name: Kava EVM Testnet
 * Default Block Explorer: https://testnet.kavascan.com/
 * Default RPC URL: https://evm.testnet.kava.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kavaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kavaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kavaTestnet: Common;

/**
 * Creates a common configuration for the kcc chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 321
 * Chain Name: KCC Mainnet
 * Default Block Explorer: https://explorer.kcc.io
 * Default RPC URL: https://kcc-rpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kcc } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kcc,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kcc: Common;

/**
 * Creates a common configuration for the klaytn chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8217
 * Chain Name: Klaytn
 * Default Block Explorer: https://scope.klaytn.com
 * Default RPC URL: https://public-en-cypress.klaytn.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { klaytn } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: klaytn,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const klaytn: Common;

/**
 * Creates a common configuration for the klaytnBaobab chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1001
 * Chain Name: Klaytn Baobab Testnet
 * Default Block Explorer: https://baobab.klaytnscope.com
 * Default RPC URL: https://public-en-baobab.klaytn.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { klaytnBaobab } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: klaytnBaobab,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const klaytnBaobab: Common;

/**
 * Creates a common configuration for the koi chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 701
 * Chain Name: Koi Network
 * Default Block Explorer: https://koi-scan.darwinia.network
 * Default RPC URL: https://koi-rpc.darwinia.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { koi } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: koi,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const koi: Common;

/**
 * Creates a common configuration for the kroma chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 255
 * Chain Name: Kroma
 * Default Block Explorer: https://blockscout.kroma.network
 * Default RPC URL: https://api.kroma.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kroma } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kroma,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kroma: Common;

/**
 * Creates a common configuration for the kromaSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2358
 * Chain Name: Kroma Sepolia
 * Default Block Explorer: https://blockscout.sepolia.kroma.network
 * Default RPC URL: https://api.sepolia.kroma.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { kromaSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: kromaSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const kromaSepolia: Common;

/**
 * Creates a common configuration for the l3x chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 12324
 * Chain Name: L3X Protocol
 * Default Block Explorer: https://explorer.l3x.com
 * Default RPC URL: https://rpc-mainnet.l3x.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { l3x } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: l3x,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const l3x: Common;

/**
 * Creates a common configuration for the l3xTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 12325
 * Chain Name: L3X Protocol Testnet
 * Default Block Explorer: https://explorer-testnet.l3x.com
 * Default RPC URL: https://rpc-testnet.l3x.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { l3xTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: l3xTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const l3xTestnet: Common;

/**
 * Creates a common configuration for the lightlinkPegasus chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1891
 * Chain Name: LightLink Pegasus Testnet
 * Default Block Explorer: https://pegasus.lightlink.io
 * Default RPC URL: https://replicator.pegasus.lightlink.io/rpc/v1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lightlinkPegasus } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lightlinkPegasus,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lightlinkPegasus: Common;

/**
 * Creates a common configuration for the lightlinkPhoenix chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1890
 * Chain Name: LightLink Phoenix Mainnet
 * Default Block Explorer: https://phoenix.lightlink.io
 * Default RPC URL: https://replicator.phoenix.lightlink.io/rpc/v1
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lightlinkPhoenix } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lightlinkPhoenix,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lightlinkPhoenix: Common;

/**
 * Creates a common configuration for the linea chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 59144
 * Chain Name: Linea Mainnet
 * Default Block Explorer: https://lineascan.build
 * Default RPC URL: https://rpc.linea.build
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { linea } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: linea,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const linea: Common;

/**
 * Creates a common configuration for the lineaGoerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 59140
 * Chain Name: Linea Goerli Testnet
 * Default Block Explorer: https://goerli.lineascan.build
 * Default RPC URL: https://rpc.goerli.linea.build
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lineaGoerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lineaGoerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lineaGoerli: Common;

/**
 * Creates a common configuration for the lineaSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 59141
 * Chain Name: Linea Sepolia Testnet
 * Default Block Explorer: https://sepolia.lineascan.build
 * Default RPC URL: https://rpc.sepolia.linea.build
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lineaSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lineaSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lineaSepolia: Common;

/**
 * Creates a common configuration for the lineaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 59140
 * Chain Name: Linea Goerli Testnet
 * Default Block Explorer: https://goerli.lineascan.build
 * Default RPC URL: https://rpc.goerli.linea.build
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lineaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lineaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lineaTestnet: Common;

/**
 * Creates a common configuration for the lisk chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1135
 * Chain Name: Lisk
 * Default Block Explorer: https://blockscout.lisk.com
 * Default RPC URL: https://rpc.api.lisk.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lisk } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lisk,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lisk: Common;

/**
 * Creates a common configuration for the liskSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4202
 * Chain Name: Lisk Sepolia
 * Default Block Explorer: https://sepolia-blockscout.lisk.com
 * Default RPC URL: https://rpc.sepolia-api.lisk.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { liskSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: liskSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const liskSepolia: Common;

/**
 * Creates a common configuration for the localhost chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1337
 * Chain Name: Localhost
 * Default Block Explorer: Not specified
 * Default RPC URL: http://127.0.0.1:8545
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { localhost } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: localhost,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const localhost: Common;

/**
 * Creates a common configuration for the lukso chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42
 * Chain Name: LUKSO
 * Default Block Explorer: https://explorer.execution.mainnet.lukso.network
 * Default RPC URL: https://rpc.mainnet.lukso.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lukso } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lukso,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lukso: Common;

/**
 * Creates a common configuration for the luksoTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4201
 * Chain Name: LUKSO Testnet
 * Default Block Explorer: https://explorer.execution.testnet.lukso.network
 * Default RPC URL: https://rpc.testnet.lukso.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { luksoTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: luksoTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const luksoTestnet: Common;

/**
 * Creates a common configuration for the lycan chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 721
 * Chain Name: Lycan
 * Default Block Explorer: https://explorer.lycanchain.com
 * Default RPC URL: https://rpc.lycanchain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lycan } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lycan,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lycan: Common;

/**
 * Creates a common configuration for the lyra chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 957
 * Chain Name: Lyra Chain
 * Default Block Explorer: https://explorer.lyra.finance
 * Default RPC URL: https://rpc.lyra.finance
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { lyra } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: lyra,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const lyra: Common;

/**
 * Creates a common configuration for the mainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1
 * Chain Name: Ethereum
 * Default Block Explorer: https://etherscan.io
 * Default RPC URL: https://cloudflare-eth.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mainnet: Common;

/**
 * Creates a common configuration for the mandala chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 595
 * Chain Name: Mandala TC9
 * Default Block Explorer: https://blockscout.mandala.aca-staging.network
 * Default RPC URL: https://eth-rpc-tc9.aca-staging.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mandala } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mandala,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mandala: Common;

/**
 * Creates a common configuration for the manta chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 169
 * Chain Name: Manta Pacific Mainnet
 * Default Block Explorer: https://pacific-explorer.manta.network
 * Default RPC URL: https://pacific-rpc.manta.network/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { manta } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: manta,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const manta: Common;

/**
 * Creates a common configuration for the mantaSepoliaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3441006
 * Chain Name: Manta Pacific Sepolia Testnet
 * Default Block Explorer: https://pacific-explorer.sepolia-testnet.manta.network
 * Default RPC URL: https://pacific-rpc.sepolia-testnet.manta.network/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mantaSepoliaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mantaSepoliaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mantaSepoliaTestnet: Common;

/**
 * Creates a common configuration for the mantaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3441005
 * Chain Name: Manta Pacific Testnet
 * Default Block Explorer: https://pacific-explorer.testnet.manta.network
 * Default RPC URL: https://manta-testnet.calderachain.xyz/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mantaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mantaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mantaTestnet: Common;

/**
 * Creates a common configuration for the mantle chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5000
 * Chain Name: Mantle
 * Default Block Explorer: https://mantlescan.xyz/
 * Default RPC URL: https://rpc.mantle.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mantle } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mantle,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mantle: Common;

/**
 * Creates a common configuration for the mantleSepoliaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5003
 * Chain Name: Mantle Sepolia Testnet
 * Default Block Explorer: https://explorer.sepolia.mantle.xyz/
 * Default RPC URL: https://rpc.sepolia.mantle.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mantleSepoliaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mantleSepoliaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mantleSepoliaTestnet: Common;

/**
 * Creates a common configuration for the mantleTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5001
 * Chain Name: Mantle Testnet
 * Default Block Explorer: https://explorer.testnet.mantle.xyz
 * Default RPC URL: https://rpc.testnet.mantle.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mantleTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mantleTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mantleTestnet: Common;

/**
 * Creates a common configuration for the merlin chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4200
 * Chain Name: Merlin
 * Default Block Explorer: https://scan.merlinchain.io
 * Default RPC URL: https://rpc.merlinchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { merlin } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: merlin,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const merlin: Common;

/**
 * Creates a common configuration for the metachain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 571
 * Chain Name: MetaChain Mainnet
 * Default Block Explorer: https://explorer.metatime.com
 * Default RPC URL: https://rpc.metatime.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { metachain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: metachain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const metachain: Common;

/**
 * Creates a common configuration for the metachainIstanbul chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1453
 * Chain Name: MetaChain Istanbul
 * Default Block Explorer: https://istanbul-explorer.metachain.dev
 * Default RPC URL: https://istanbul-rpc.metachain.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { metachainIstanbul } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: metachainIstanbul,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const metachainIstanbul: Common;

/**
 * Creates a common configuration for the metalL2 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1750
 * Chain Name: Metal L2
 * Default Block Explorer: https://explorer.metall2.com
 * Default RPC URL: https://rpc.metall2.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { metalL2 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: metalL2,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const metalL2: Common;

/**
 * Creates a common configuration for the meter chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 82
 * Chain Name: Meter
 * Default Block Explorer: https://scan.meter.io
 * Default RPC URL: https://rpc.meter.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { meter } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: meter,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const meter: Common;

/**
 * Creates a common configuration for the meterTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 83
 * Chain Name: Meter Testnet
 * Default Block Explorer: https://scan-warringstakes.meter.io
 * Default RPC URL: https://rpctest.meter.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { meterTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: meterTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const meterTestnet: Common;

/**
 * Creates a common configuration for the metis chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1088
 * Chain Name: Metis
 * Default Block Explorer: https://explorer.metis.io
 * Default RPC URL: https://andromeda.metis.io/?owner=1088
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { metis } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: metis,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const metis: Common;

/**
 * Creates a common configuration for the metisGoerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 599
 * Chain Name: Metis Goerli
 * Default Block Explorer: https://goerli.explorer.metisdevops.link
 * Default RPC URL: https://goerli.gateway.metisdevops.link
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { metisGoerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: metisGoerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const metisGoerli: Common;

/**
 * Creates a common configuration for the mev chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7518
 * Chain Name: MEVerse Chain Mainnet
 * Default Block Explorer: https://www.meversescan.io
 * Default RPC URL: https://rpc.meversemainnet.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mev } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mev,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mev: Common;

/**
 * Creates a common configuration for the mevTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4759
 * Chain Name: MEVerse Chain Testnet
 * Default Block Explorer: https://testnet.meversescan.io/
 * Default RPC URL: https://rpc.meversetestnet.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mevTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mevTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mevTestnet: Common;

/**
 * Creates a common configuration for the mintSepoliaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1686
 * Chain Name: Mint Sepolia Testnet
 * Default Block Explorer: https://testnet-explorer.mintchain.io
 * Default RPC URL: https://testnet-rpc.mintchain.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mintSepoliaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mintSepoliaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mintSepoliaTestnet: Common;

/**
 * Creates a common configuration for the mode chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 34443
 * Chain Name: Mode Mainnet
 * Default Block Explorer: https://modescan.io
 * Default RPC URL: https://mainnet.mode.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { mode } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: mode,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const mode: Common;

/**
 * Creates a common configuration for the modeTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 919
 * Chain Name: Mode Testnet
 * Default Block Explorer: https://sepolia.explorer.mode.network
 * Default RPC URL: https://sepolia.mode.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { modeTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: modeTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const modeTestnet: Common;

/**
 * Creates a common configuration for the moonbaseAlpha chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1287
 * Chain Name: Moonbase Alpha
 * Default Block Explorer: https://moonbase.moonscan.io
 * Default RPC URL: https://rpc.api.moonbase.moonbeam.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { moonbaseAlpha } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: moonbaseAlpha,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const moonbaseAlpha: Common;

/**
 * Creates a common configuration for the moonbeam chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1284
 * Chain Name: Moonbeam
 * Default Block Explorer: https://moonscan.io
 * Default RPC URL: https://moonbeam.public.blastapi.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { moonbeam } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: moonbeam,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const moonbeam: Common;

/**
 * Creates a common configuration for the moonbeamDev chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1281
 * Chain Name: Moonbeam Development Node
 * Default Block Explorer: Not specified
 * Default RPC URL: http://127.0.0.1:9944
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { moonbeamDev } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: moonbeamDev,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const moonbeamDev: Common;

/**
 * Creates a common configuration for the moonriver chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1285
 * Chain Name: Moonriver
 * Default Block Explorer: https://moonriver.moonscan.io
 * Default RPC URL: https://moonriver.public.blastapi.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { moonriver } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: moonriver,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const moonriver: Common;

/**
 * Creates a common configuration for the morphHolesky chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2810
 * Chain Name: Morph Holesky
 * Default Block Explorer: https://explorer-holesky.morphl2.io
 * Default RPC URL: https://rpc-quicknode-holesky.morphl2.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { morphHolesky } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: morphHolesky,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const morphHolesky: Common;

/**
 * Creates a common configuration for the morphSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2710
 * Chain Name: Morph Sepolia
 * Default Block Explorer: https://explorer-testnet.morphl2.io
 * Default RPC URL: https://rpc-testnet.morphl2.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { morphSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: morphSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const morphSepolia: Common;

/**
 * Creates a common configuration for the nautilus chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 22222
 * Chain Name: Nautilus Mainnet
 * Default Block Explorer: https://nautscan.com
 * Default RPC URL: https://api.nautilus.nautchain.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { nautilus } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: nautilus,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const nautilus: Common;

/**
 * Creates a common configuration for the neonDevnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 245022926
 * Chain Name: Neon EVM DevNet
 * Default Block Explorer: https://devnet.neonscan.org
 * Default RPC URL: https://devnet.neonevm.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { neonDevnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: neonDevnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const neonDevnet: Common;

/**
 * Creates a common configuration for the neonMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 245022934
 * Chain Name: Neon EVM MainNet
 * Default Block Explorer: https://neonscan.org
 * Default RPC URL: https://neon-proxy-mainnet.solana.p2p.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { neonMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: neonMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const neonMainnet: Common;

/**
 * Creates a common configuration for the nexi chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4242
 * Chain Name: Nexi
 * Default Block Explorer: https://www.nexiscan.com
 * Default RPC URL: https://rpc.chain.nexi.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { nexi } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: nexi,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const nexi: Common;

/**
 * Creates a common configuration for the nexilix chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 240
 * Chain Name: Nexilix Smart Chain
 * Default Block Explorer: https://scan.nexilix.com
 * Default RPC URL: https://rpcurl.pos.nexilix.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { nexilix } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: nexilix,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const nexilix: Common;

/**
 * Creates a common configuration for the oasisTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 4090
 * Chain Name: Oasis Testnet
 * Default Block Explorer: https://oasis.ftnscan.com
 * Default RPC URL: https://rpc1.oasis.bahamutchain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { oasisTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: oasisTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const oasisTestnet: Common;

/**
 * Creates a common configuration for the oasys chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 248
 * Chain Name: Oasys
 * Default Block Explorer: https://scan.oasys.games
 * Default RPC URL: https://rpc.mainnet.oasys.games
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { oasys } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: oasys,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const oasys: Common;

/**
 * Creates a common configuration for the okc chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 66
 * Chain Name: OKC
 * Default Block Explorer: https://www.oklink.com/okc
 * Default RPC URL: https://exchainrpc.okex.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { okc } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: okc,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const okc: Common;

/**
 * Creates a common configuration for the oortMainnetDev chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 9700
 * Chain Name: OORT MainnetDev
 * Default Block Explorer: https://dev-scan.oortech.com
 * Default RPC URL: https://dev-rpc.oortech.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { oortMainnetDev } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: oortMainnetDev,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const oortMainnetDev: Common;

/**
 * Creates a common configuration for the opBNB chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 204
 * Chain Name: opBNB
 * Default Block Explorer: https://mainnet.opbnbscan.com
 * Default RPC URL: https://opbnb-mainnet-rpc.bnbchain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { opBNB } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: opBNB,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const opBNB: Common;

/**
 * Creates a common configuration for the opBNBTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5611
 * Chain Name: opBNB Testnet
 * Default Block Explorer: https://testnet.opbnbscan.com
 * Default RPC URL: https://opbnb-testnet-rpc.bnbchain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { opBNBTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: opBNBTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const opBNBTestnet: Common;

/**
 * Creates a common configuration for the optimism chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 10
 * Chain Name: OP Mainnet
 * Default Block Explorer: https://optimistic.etherscan.io
 * Default RPC URL: https://mainnet.optimism.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { optimism } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: optimism,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const optimism: Common;

/**
 * Creates a common configuration for the optimismGoerli chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 420
 * Chain Name: Optimism Goerli
 * Default Block Explorer: https://goerli-optimism.etherscan.io
 * Default RPC URL: https://goerli.optimism.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { optimismGoerli } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: optimismGoerli,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const optimismGoerli: Common;

/**
 * Creates a common configuration for the optimismSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11155420
 * Chain Name: OP Sepolia
 * Default Block Explorer: https://optimism-sepolia.blockscout.com
 * Default RPC URL: https://sepolia.optimism.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { optimismSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: optimismSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const optimismSepolia: Common;

/**
 * Creates a common configuration for the otimDevnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 41144114
 * Chain Name: Otim Devnet
 * Default Block Explorer: Not specified
 * Default RPC URL: http://devnet.otim.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { otimDevnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: otimDevnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const otimDevnet: Common;

/**
 * Creates a common configuration for the palm chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11297108109
 * Chain Name: Palm
 * Default Block Explorer: https://palm.chainlens.com
 * Default RPC URL: https://palm-mainnet.public.blastapi.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { palm } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: palm,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const palm: Common;

/**
 * Creates a common configuration for the palmTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11297108099
 * Chain Name: Palm Testnet
 * Default Block Explorer: https://palm.chainlens.com
 * Default RPC URL: https://palm-mainnet.public.blastapi.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { palmTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: palmTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const palmTestnet: Common;

/**
 * Creates a common configuration for the pgn chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 424
 * Chain Name: PGN
 * Default Block Explorer: https://explorer.publicgoods.network
 * Default RPC URL: https://rpc.publicgoods.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { pgn } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: pgn,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const pgn: Common;

/**
 * Creates a common configuration for the pgnTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 58008
 * Chain Name: PGN
 * Default Block Explorer: https://explorer.sepolia.publicgoods.network
 * Default RPC URL: https://sepolia.publicgoods.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { pgnTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: pgnTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const pgnTestnet: Common;

/**
 * Creates a common configuration for the phoenix chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 13381
 * Chain Name: Phoenix Blockchain
 * Default Block Explorer: https://phoenixplorer.com
 * Default RPC URL: https://rpc.phoenixplorer.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { phoenix } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: phoenix,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const phoenix: Common;

/**
 * Creates a common configuration for the playfiAlbireo chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1612127
 * Chain Name: PlayFi Albireo Testnet
 * Default Block Explorer: https://albireo-explorer.playfi.ai
 * Default RPC URL: https://albireo-rpc.playfi.ai
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { playfiAlbireo } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: playfiAlbireo,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const playfiAlbireo: Common;

/**
 * Creates a common configuration for the plinga chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 242
 * Chain Name: Plinga
 * Default Block Explorer: https://www.plgscan.com
 * Default RPC URL: https://rpcurl.mainnet.plgchain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { plinga } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: plinga,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const plinga: Common;

/**
 * Creates a common configuration for the plumeTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 161221135
 * Chain Name: Plume Testnet
 * Default Block Explorer: https://testnet-explorer.plumenetwork.xyz
 * Default RPC URL: https://testnet-rpc.plumenetwork.xyz/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { plumeTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: plumeTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const plumeTestnet: Common;

/**
 * Creates a common configuration for the polygon chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 137
 * Chain Name: Polygon
 * Default Block Explorer: https://polygonscan.com
 * Default RPC URL: https://polygon-rpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygon } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygon,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygon: Common;

/**
 * Creates a common configuration for the polygonAmoy chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 80002
 * Chain Name: Polygon Amoy
 * Default Block Explorer: https://amoy.polygonscan.com
 * Default RPC URL: https://rpc-amoy.polygon.technology
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygonAmoy } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygonAmoy,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygonAmoy: Common;

/**
 * Creates a common configuration for the polygonMumbai chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 80001
 * Chain Name: Polygon Mumbai
 * Default Block Explorer: https://mumbai.polygonscan.com
 * Default RPC URL: https://rpc.ankr.com/polygon_mumbai
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygonMumbai } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygonMumbai,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygonMumbai: Common;

/**
 * Creates a common configuration for the polygonZkEvm chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1101
 * Chain Name: Polygon zkEVM
 * Default Block Explorer: https://zkevm.polygonscan.com
 * Default RPC URL: https://zkevm-rpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygonZkEvm } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygonZkEvm,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygonZkEvm: Common;

/**
 * Creates a common configuration for the polygonZkEvmCardona chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2442
 * Chain Name: Polygon zkEVM Cardona
 * Default Block Explorer: https://cardona-zkevm.polygonscan.com
 * Default RPC URL: https://rpc.cardona.zkevm-rpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygonZkEvmCardona } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygonZkEvmCardona,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygonZkEvmCardona: Common;

/**
 * Creates a common configuration for the polygonZkEvmTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1442
 * Chain Name: Polygon zkEVM Testnet
 * Default Block Explorer: https://testnet-zkevm.polygonscan.com
 * Default RPC URL: https://rpc.public.zkevm-test.net
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { polygonZkEvmTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: polygonZkEvmTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const polygonZkEvmTestnet: Common;

/**
 * Creates a common configuration for the pulsechain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 369
 * Chain Name: PulseChain
 * Default Block Explorer: https://scan.pulsechain.com
 * Default RPC URL: https://rpc.pulsechain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { pulsechain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: pulsechain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const pulsechain: Common;

/**
 * Creates a common configuration for the pulsechainV4 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 943
 * Chain Name: PulseChain V4
 * Default Block Explorer: https://scan.v4.testnet.pulsechain.com
 * Default RPC URL: https://rpc.v4.testnet.pulsechain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { pulsechainV4 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: pulsechainV4,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const pulsechainV4: Common;

/**
 * Creates a common configuration for the qMainnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 35441
 * Chain Name: Q Mainnet
 * Default Block Explorer: https://explorer.q.org
 * Default RPC URL: https://rpc.q.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { qMainnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: qMainnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const qMainnet: Common;

/**
 * Creates a common configuration for the qTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 35443
 * Chain Name: Q Testnet
 * Default Block Explorer: https://explorer.qtestnet.org
 * Default RPC URL: https://rpc.qtestnet.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { qTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: qTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const qTestnet: Common;

/**
 * Creates a common configuration for the real chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 111188
 * Chain Name: re.al
 * Default Block Explorer: https://explorer.re.al
 * Default RPC URL: https://real.drpc.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { real } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: real,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const real: Common;

/**
 * Creates a common configuration for the redbellyTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 153
 * Chain Name: Redbelly Network Testnet
 * Default Block Explorer: https://explorer.testnet.redbelly.network
 * Default RPC URL: https://governors.testnet.redbelly.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { redbellyTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: redbellyTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const redbellyTestnet: Common;

/**
 * Creates a common configuration for the redstone chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 690
 * Chain Name: Redstone
 * Default Block Explorer: 	https://explorer.redstone.xyz
 * Default RPC URL: https://rpc.redstonechain.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { redstone } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: redstone,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const redstone: Common;

/**
 * Creates a common configuration for the reyaNetwork chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1729
 * Chain Name: Reya Network
 * Default Block Explorer: https://explorer.reya.network
 * Default RPC URL: https://rpc.reya.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { reyaNetwork } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: reyaNetwork,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const reyaNetwork: Common;

/**
 * Creates a common configuration for the rollux chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 570
 * Chain Name: Rollux Mainnet
 * Default Block Explorer: https://explorer.rollux.com
 * Default RPC URL: https://rpc.rollux.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rollux } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rollux,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rollux: Common;

/**
 * Creates a common configuration for the rolluxTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 57000
 * Chain Name: Rollux Testnet
 * Default Block Explorer: https://rollux.tanenbaum.io
 * Default RPC URL: https://rpc-tanenbaum.rollux.com/
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rolluxTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rolluxTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rolluxTestnet: Common;

/**
 * Creates a common configuration for the ronin chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2020
 * Chain Name: Ronin
 * Default Block Explorer: https://app.roninchain.com
 * Default RPC URL: https://api.roninchain.com/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { ronin } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: ronin,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const ronin: Common;

/**
 * Creates a common configuration for the root chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7668
 * Chain Name: The Root Network
 * Default Block Explorer: https://rootscan.io
 * Default RPC URL: https://root.rootnet.live/archive
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { root } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: root,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const root: Common;

/**
 * Creates a common configuration for the rootPorcini chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7672
 * Chain Name: The Root Network - Porcini
 * Default Block Explorer: https://porcini.rootscan.io
 * Default RPC URL: https://porcini.rootnet.app/archive
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rootPorcini } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rootPorcini,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rootPorcini: Common;

/**
 * Creates a common configuration for the rootstock chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 30
 * Chain Name: Rootstock Mainnet
 * Default Block Explorer: https://explorer.rsk.co
 * Default RPC URL: https://public-node.rsk.co
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rootstock } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rootstock,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rootstock: Common;

/**
 * Creates a common configuration for the rootstockTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 31
 * Chain Name: Rootstock Testnet
 * Default Block Explorer: https://explorer.testnet.rootstock.io
 * Default RPC URL: https://public-node.testnet.rsk.co
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rootstockTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rootstockTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rootstockTestnet: Common;

/**
 * Creates a common configuration for the rss3 chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 12553
 * Chain Name: RSS3 VSL Mainnet
 * Default Block Explorer: https://scan.rss3.io
 * Default RPC URL: https://rpc.rss3.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rss3 } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rss3,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rss3: Common;

/**
 * Creates a common configuration for the rss3Sepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2331
 * Chain Name: RSS3 VSL Sepolia Testnet
 * Default Block Explorer: https://scan.testnet.rss3.io
 * Default RPC URL: https://rpc.testnet.rss3.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { rss3Sepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: rss3Sepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const rss3Sepolia: Common;

/**
 * Creates a common configuration for the saigon chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2021
 * Chain Name: Saigon Testnet
 * Default Block Explorer: https://saigon-app.roninchain.com
 * Default RPC URL: https://saigon-testnet.roninchain.com/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { saigon } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: saigon,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const saigon: Common;

/**
 * Creates a common configuration for the sapphire chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 23294
 * Chain Name: Oasis Sapphire
 * Default Block Explorer: https://explorer.oasis.io/mainnet/sapphire
 * Default RPC URL: https://sapphire.oasis.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sapphire } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sapphire,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sapphire: Common;

/**
 * Creates a common configuration for the sapphireTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 23295
 * Chain Name: Oasis Sapphire Testnet
 * Default Block Explorer: https://explorer.oasis.io/testnet/sapphire
 * Default RPC URL: https://testnet.sapphire.oasis.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sapphireTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sapphireTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sapphireTestnet: Common;

/**
 * Creates a common configuration for the satoshiVM chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3109
 * Chain Name: SatoshiVM Alpha Mainnet
 * Default Block Explorer: https://svmscan.io
 * Default RPC URL: https://alpha-rpc-node-http.svmscan.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { satoshiVM } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: satoshiVM,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const satoshiVM: Common;

/**
 * Creates a common configuration for the satoshiVMTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 3110
 * Chain Name: SatoshiVM Testnet
 * Default Block Explorer: https://testnet.svmscan.io
 * Default RPC URL: https://test-rpc-node-http.svmscan.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { satoshiVMTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: satoshiVMTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const satoshiVMTestnet: Common;

/**
 * Creates a common configuration for the scroll chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 534352
 * Chain Name: Scroll
 * Default Block Explorer: https://scrollscan.com
 * Default RPC URL: https://rpc.scroll.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { scroll } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: scroll,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const scroll: Common;

/**
 * Creates a common configuration for the scrollSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 534351
 * Chain Name: Scroll Sepolia
 * Default Block Explorer: https://sepolia.scrollscan.com
 * Default RPC URL: https://sepolia-rpc.scroll.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { scrollSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: scrollSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const scrollSepolia: Common;

/**
 * Creates a common configuration for the sei chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1329
 * Chain Name: Sei Network
 * Default Block Explorer: https://seitrace.com
 * Default RPC URL: https://evm-rpc.sei-apis.com/
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sei } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sei,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sei: Common;

/**
 * Creates a common configuration for the seiDevnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 713715
 * Chain Name: Sei Devnet
 * Default Block Explorer: https://seitrace.com
 * Default RPC URL: https://evm-rpc-arctic-1.sei-apis.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { seiDevnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: seiDevnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const seiDevnet: Common;

/**
 * Creates a common configuration for the seiTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1328
 * Chain Name: Sei Testnet
 * Default Block Explorer: https://seitrace.com
 * Default RPC URL: https://evm-rpc-testnet.sei-apis.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { seiTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: seiTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const seiTestnet: Common;

/**
 * Creates a common configuration for the sepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11155111
 * Chain Name: Sepolia
 * Default Block Explorer: https://sepolia.etherscan.io
 * Default RPC URL: https://rpc.sepolia.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sepolia: Common;

/**
 * Creates a common configuration for the shapeSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 11011
 * Chain Name: Shape Sepolia Testnet
 * Default Block Explorer: https://shape-sepolia-explorer.alchemy.com
 * Default RPC URL: https://sepolia.shape.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shapeSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shapeSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shapeSepolia: Common;

/**
 * Creates a common configuration for the shardeumSphinx chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 8082
 * Chain Name: Shardeum Sphinx
 * Default Block Explorer: https://explorer-sphinx.shardeum.org
 * Default RPC URL: https://sphinx.shardeum.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shardeumSphinx } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shardeumSphinx,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shardeumSphinx: Common;

/**
 * Creates a common configuration for the shibarium chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 109
 * Chain Name: Shibarium
 * Default Block Explorer: https://shibariumscan.io
 * Default RPC URL: https://rpc.shibrpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shibarium } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shibarium,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shibarium: Common;

/**
 * Creates a common configuration for the shibariumTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 157
 * Chain Name: Puppynet Shibarium
 * Default Block Explorer: https://puppyscan.shib.io
 * Default RPC URL: https://puppynet.shibrpc.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shibariumTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shibariumTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shibariumTestnet: Common;

/**
 * Creates a common configuration for the shimmer chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 148
 * Chain Name: Shimmer
 * Default Block Explorer: https://explorer.evm.shimmer.network
 * Default RPC URL: https://json-rpc.evm.shimmer.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shimmer } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shimmer,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shimmer: Common;

/**
 * Creates a common configuration for the shimmerTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1073
 * Chain Name: Shimmer Testnet
 * Default Block Explorer: https://explorer.evm.testnet.shimmer.network
 * Default RPC URL: https://json-rpc.evm.testnet.shimmer.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { shimmerTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: shimmerTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const shimmerTestnet: Common;

/**
 * Creates a common configuration for the skaleBlockBrawlers chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 391845894
 * Chain Name: SKALE | Block Brawlers
 * Default Block Explorer: https://frayed-decent-antares.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/frayed-decent-antares
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleBlockBrawlers } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleBlockBrawlers,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleBlockBrawlers: Common;

/**
 * Creates a common configuration for the skaleCalypso chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1564830818
 * Chain Name: SKALE | Calypso NFT Hub
 * Default Block Explorer: https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleCalypso } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleCalypso,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleCalypso: Common;

/**
 * Creates a common configuration for the skaleCalypsoTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 974399131
 * Chain Name: SKALE Calypso Testnet
 * Default Block Explorer: https://giant-half-dual-testnet.explorer.testnet.skalenodes.com
 * Default RPC URL: https://testnet.skalenodes.com/v1/giant-half-dual-testnet
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleCalypsoTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleCalypsoTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleCalypsoTestnet: Common;

/**
 * Creates a common configuration for the skaleCryptoBlades chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1026062157
 * Chain Name: SKALE | CryptoBlades
 * Default Block Explorer: https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleCryptoBlades } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleCryptoBlades,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleCryptoBlades: Common;

/**
 * Creates a common configuration for the skaleCryptoColosseum chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1032942172
 * Chain Name: SKALE | Crypto Colosseum
 * Default Block Explorer: https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/haunting-devoted-deneb
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleCryptoColosseum } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleCryptoColosseum,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleCryptoColosseum: Common;

/**
 * Creates a common configuration for the skaleEuropa chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2046399126
 * Chain Name: SKALE | Europa Liquidity Hub
 * Default Block Explorer: https://elated-tan-skat.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/elated-tan-skat
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleEuropa } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleEuropa,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleEuropa: Common;

/**
 * Creates a common configuration for the skaleEuropaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1444673419
 * Chain Name: SKALE Europa Testnet
 * Default Block Explorer: https://juicy-low-small-testnet.explorer.testnet.skalenodes.com
 * Default RPC URL: https://testnet.skalenodes.com/v1/juicy-low-small-testnet
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleEuropaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleEuropaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleEuropaTestnet: Common;

/**
 * Creates a common configuration for the skaleExorde chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2139927552
 * Chain Name: SKALE | Exorde
 * Default Block Explorer: https://light-vast-diphda.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/light-vast-diphda
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleExorde } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleExorde,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleExorde: Common;

/**
 * Creates a common configuration for the skaleHumanProtocol chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1273227453
 * Chain Name: SKALE | Human Protocol
 * Default Block Explorer: https://wan-red-ain.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/wan-red-ain
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleHumanProtocol } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleHumanProtocol,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleHumanProtocol: Common;

/**
 * Creates a common configuration for the skaleNebula chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1482601649
 * Chain Name: SKALE | Nebula Gaming Hub
 * Default Block Explorer: https://green-giddy-denebola.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/green-giddy-denebola
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleNebula } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleNebula,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleNebula: Common;

/**
 * Creates a common configuration for the skaleNebulaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 37084624
 * Chain Name: SKALE Nebula Testnet
 * Default Block Explorer: https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com
 * Default RPC URL: https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleNebulaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleNebulaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleNebulaTestnet: Common;

/**
 * Creates a common configuration for the skaleRazor chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 278611351
 * Chain Name: SKALE | Razor Network
 * Default Block Explorer: https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/turbulent-unique-scheat
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleRazor } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleRazor,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleRazor: Common;

/**
 * Creates a common configuration for the skaleTitan chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1350216234
 * Chain Name: SKALE | Titan Community Hub
 * Default Block Explorer: https://parallel-stormy-spica.explorer.mainnet.skalenodes.com
 * Default RPC URL: https://mainnet.skalenodes.com/v1/parallel-stormy-spica
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleTitan } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleTitan,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleTitan: Common;

/**
 * Creates a common configuration for the skaleTitanTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1020352220
 * Chain Name: SKALE Titan Hub
 * Default Block Explorer: https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com
 * Default RPC URL: https://testnet.skalenodes.com/v1/aware-fake-trim-testnet
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { skaleTitanTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: skaleTitanTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const skaleTitanTestnet: Common;

/**
 * Creates a common configuration for the sketchpad chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 984123
 * Chain Name: Forma Sketchpad
 * Default Block Explorer: https://explorer.sketchpad-1.forma.art
 * Default RPC URL: https://rpc.sketchpad-1.forma.art
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sketchpad } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sketchpad,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sketchpad: Common;

/**
 * Creates a common configuration for the soneiumMinato chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1946
 * Chain Name: Soneium Minato
 * Default Block Explorer: https://explorer-testnet.soneium.org
 * Default RPC URL: https://rpc.minato.soneium.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { soneiumMinato } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: soneiumMinato,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const soneiumMinato: Common;

/**
 * Creates a common configuration for the songbird chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 19
 * Chain Name: Songbird Mainnet
 * Default Block Explorer: https://songbird-explorer.flare.network
 * Default RPC URL: https://songbird-api.flare.network/ext/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { songbird } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: songbird,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const songbird: Common;

/**
 * Creates a common configuration for the songbirdTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 16
 * Chain Name: Coston
 * Default Block Explorer: https://coston-explorer.flare.network
 * Default RPC URL: https://coston-api.flare.network/ext/C/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { songbirdTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: songbirdTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const songbirdTestnet: Common;

/**
 * Creates a common configuration for the sophonTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 531050104
 * Chain Name: Sophon Testnet
 * Default Block Explorer: https://explorer.testnet.sophon.xyz
 * Default RPC URL: https://rpc.testnet.sophon.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { sophonTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: sophonTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const sophonTestnet: Common;

/**
 * Creates a common configuration for the spicy chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 88882
 * Chain Name: Chiliz Spicy Testnet
 * Default Block Explorer: http://spicy-explorer.chiliz.com
 * Default RPC URL: https://spicy-rpc.chiliz.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { spicy } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: spicy,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const spicy: Common;

/**
 * Creates a common configuration for the storyTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1513
 * Chain Name: Story Testnet
 * Default Block Explorer: https://testnet.storyscan.xyz
 * Default RPC URL: https://testnet.storyrpc.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { storyTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: storyTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const storyTestnet: Common;

/**
 * Creates a common configuration for the stratis chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 105105
 * Chain Name: Stratis Mainnet
 * Default Block Explorer: https://explorer.stratisevm.com
 * Default RPC URL: https://rpc.stratisevm.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { stratis } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: stratis,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const stratis: Common;

/**
 * Creates a common configuration for the syscoin chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 57
 * Chain Name: Syscoin Mainnet
 * Default Block Explorer: https://explorer.syscoin.org
 * Default RPC URL: https://rpc.syscoin.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { syscoin } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: syscoin,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const syscoin: Common;

/**
 * Creates a common configuration for the syscoinTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 5700
 * Chain Name: Syscoin Tanenbaum Testnet
 * Default Block Explorer: https://tanenbaum.io
 * Default RPC URL: https://rpc.tanenbaum.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { syscoinTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: syscoinTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const syscoinTestnet: Common;

/**
 * Creates a common configuration for the taiko chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 167000
 * Chain Name: Taiko Mainnet
 * Default Block Explorer: https://taikoscan.io
 * Default RPC URL: https://rpc.mainnet.taiko.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taiko } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taiko,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taiko: Common;

/**
 * Creates a common configuration for the taikoHekla chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 167009
 * Chain Name: Taiko Hekla L2
 * Default Block Explorer: https://hekla.taikoscan.network
 * Default RPC URL: https://rpc.hekla.taiko.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taikoHekla } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taikoHekla,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taikoHekla: Common;

/**
 * Creates a common configuration for the taikoJolnir chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 167007
 * Chain Name: Taiko Jolnir (Alpha-5 Testnet)
 * Default Block Explorer: https://explorer.jolnir.taiko.xyz
 * Default RPC URL: https://rpc.jolnir.taiko.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taikoJolnir } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taikoJolnir,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taikoJolnir: Common;

/**
 * Creates a common configuration for the taikoKatla chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 167008
 * Chain Name: Taiko Katla (Alpha-6 Testnet)
 * Default Block Explorer: https://explorer.katla.taiko.xyz
 * Default RPC URL: https://rpc.katla.taiko.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taikoKatla } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taikoKatla,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taikoKatla: Common;

/**
 * Creates a common configuration for the taikoTestnetSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 167005
 * Chain Name: Taiko (Alpha-3 Testnet)
 * Default Block Explorer: https://explorer.test.taiko.xyz
 * Default RPC URL: https://rpc.test.taiko.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taikoTestnetSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taikoTestnetSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taikoTestnetSepolia: Common;

/**
 * Creates a common configuration for the taraxa chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 841
 * Chain Name: Taraxa Mainnet
 * Default Block Explorer: https://explorer.mainnet.taraxa.io
 * Default RPC URL: https://rpc.mainnet.taraxa.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taraxa } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taraxa,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taraxa: Common;

/**
 * Creates a common configuration for the taraxaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 842
 * Chain Name: Taraxa Testnet
 * Default Block Explorer: https://explorer.testnet.taraxa.io
 * Default RPC URL: https://rpc.testnet.taraxa.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { taraxaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: taraxaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const taraxaTestnet: Common;

/**
 * Creates a common configuration for the telcoinTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2017
 * Chain Name: Telcoin Adiri Testnet
 * Default Block Explorer: https://telscan.io
 * Default RPC URL: https://rpc.telcoin.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { telcoinTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: telcoinTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const telcoinTestnet: Common;

/**
 * Creates a common configuration for the telos chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 40
 * Chain Name: Telos
 * Default Block Explorer: https://www.teloscan.io/
 * Default RPC URL: https://mainnet.telos.net/evm
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { telos } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: telos,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const telos: Common;

/**
 * Creates a common configuration for the telosTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 41
 * Chain Name: Telos
 * Default Block Explorer: https://testnet.teloscan.io/
 * Default RPC URL: https://testnet.telos.net/evm
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { telosTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: telosTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const telosTestnet: Common;

/**
 * Creates a common configuration for the tenet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1559
 * Chain Name: Tenet
 * Default Block Explorer: https://tenetscan.io
 * Default RPC URL: https://rpc.tenet.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { tenet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: tenet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const tenet: Common;

/**
 * The default chain if no fork url is passed
 */
declare const tevmDefault: {
    blockExplorers?: {
        [key: string]: {
            name: string;
            url: string;
            apiUrl?: string | undefined;
        };
        default: {
            name: string;
            url: string;
            apiUrl?: string | undefined;
        };
    } | undefined | undefined;
    blockTime?: number | undefined | undefined;
    contracts?: {
        [x: string]: viem.ChainContract | {
            [sourceId: number]: viem.ChainContract | undefined;
        } | undefined;
        ensRegistry?: viem.ChainContract | undefined;
        ensUniversalResolver?: viem.ChainContract | undefined;
        multicall3?: viem.ChainContract | undefined;
        erc6492Verifier?: viem.ChainContract | undefined;
    } | undefined;
    ensTlds?: readonly string[] | undefined;
    id: number;
    name: string;
    nativeCurrency: {
        name: string;
        symbol: string;
        decimals: number;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        [key: string]: {
            http: readonly string[];
            webSocket?: readonly string[] | undefined;
        };
        default: {
            http: readonly string[];
            webSocket?: readonly string[] | undefined;
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<viem.ChainFormatters | undefined> | undefined;
    formatters?: viem.ChainFormatters | undefined;
    serializers?: viem.ChainSerializers<viem.ChainFormatters | undefined, viem.TransactionSerializable> | undefined;
    ethjsCommon: _ethereumjs_common.Common;
    copy: () => Common;
};

/**
 * Creates a common configuration for the thaiChain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7
 * Chain Name: ThaiChain
 * Default Block Explorer: https://exp.thaichain.org
 * Default RPC URL: https://rpc.thaichain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { thaiChain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: thaiChain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const thaiChain: Common;

/**
 * Creates a common configuration for the thunderTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 997
 * Chain Name: 5ireChain Thunder Testnet
 * Default Block Explorer: https://explorer.5ire.network
 * Default RPC URL: https://rpc-testnet.5ire.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { thunderTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: thunderTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const thunderTestnet: Common;

/**
 * Creates a common configuration for the tron chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 728126428
 * Chain Name: Tron
 * Default Block Explorer: https://tronscan.org
 * Default RPC URL: https://api.trongrid.io/jsonrpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { tron } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: tron,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const tron: Common;

/**
 * Creates a common configuration for the unreal chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 18233
 * Chain Name: Unreal
 * Default Block Explorer: https://unreal.blockscout.com
 * Default RPC URL: https://rpc.unreal-orbit.gelato.digital
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { unreal } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: unreal,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const unreal: Common;

/**
 * Creates a common configuration for the vechain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 100009
 * Chain Name: Vechain
 * Default Block Explorer: https://explore.vechain.org
 * Default RPC URL: https://mainnet.vechain.org
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { vechain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: vechain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const vechain: Common;

/**
 * Creates a common configuration for the wanchain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 888
 * Chain Name: Wanchain
 * Default Block Explorer: https://wanscan.org
 * Default RPC URL: https://gwan-ssl.wandevs.org:56891
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { wanchain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: wanchain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const wanchain: Common;

/**
 * Creates a common configuration for the wanchainTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 999
 * Chain Name: Wanchain Testnet
 * Default Block Explorer: https://wanscan.org
 * Default RPC URL: https://gwan-ssl.wandevs.org:46891
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { wanchainTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: wanchainTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const wanchainTestnet: Common;

/**
 * Creates a common configuration for the wemix chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1111
 * Chain Name: WEMIX
 * Default Block Explorer: https://explorer.wemix.com
 * Default RPC URL: https://api.wemix.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { wemix } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: wemix,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const wemix: Common;

/**
 * Creates a common configuration for the wemixTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1112
 * Chain Name: WEMIX Testnet
 * Default Block Explorer: https://testnet.wemixscan.com
 * Default RPC URL: https://api.test.wemix.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { wemixTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: wemixTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const wemixTestnet: Common;

/**
 * Creates a common configuration for the x1Testnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 195
 * Chain Name: X1 Testnet
 * Default Block Explorer: https://www.oklink.com/xlayer-test
 * Default RPC URL: https://xlayertestrpc.okx.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { x1Testnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: x1Testnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const x1Testnet: Common;

/**
 * Creates a common configuration for the xai chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 660279
 * Chain Name: Xai Mainnet
 * Default Block Explorer: https://explorer.xai-chain.net
 * Default RPC URL: https://xai-chain.net/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xai } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xai,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xai: Common;

/**
 * Creates a common configuration for the xaiTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 37714555429
 * Chain Name: Xai Testnet
 * Default Block Explorer: https://testnet-explorer-v2.xai-chain.net
 * Default RPC URL: https://testnet-v2.xai-chain.net/rpc
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xaiTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xaiTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xaiTestnet: Common;

/**
 * Creates a common configuration for the xdc chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 50
 * Chain Name: XinFin Network
 * Default Block Explorer: https://xdc.blocksscan.io
 * Default RPC URL: https://rpc.xinfin.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xdc } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xdc,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xdc: Common;

/**
 * Creates a common configuration for the xdcTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 51
 * Chain Name: Apothem Network
 * Default Block Explorer: https://apothem.blocksscan.io
 * Default RPC URL: https://erpc.apothem.network
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xdcTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xdcTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xdcTestnet: Common;

/**
 * Creates a common configuration for the xLayer chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 196
 * Chain Name: X Layer Mainnet
 * Default Block Explorer: https://www.oklink.com/xlayer
 * Default RPC URL: https://rpc.xlayer.tech
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xLayer } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xLayer,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xLayer: Common;

/**
 * Creates a common configuration for the xLayerTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 195
 * Chain Name: X1 Testnet
 * Default Block Explorer: https://www.oklink.com/xlayer-test
 * Default RPC URL: https://xlayertestrpc.okx.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xLayerTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xLayerTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xLayerTestnet: Common;

/**
 * Creates a common configuration for the xrSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 2730
 * Chain Name: XR Sepolia
 * Default Block Explorer: https://xr-sepolia-testnet.explorer.caldera.xyz
 * Default RPC URL: https://xr-sepolia-testnet.rpc.caldera.xyz/http
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { xrSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: xrSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const xrSepolia: Common;

/**
 * Creates a common configuration for the yooldoVerse chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 50005
 * Chain Name: Yooldo Verse
 * Default Block Explorer: https://explorer.yooldo-verse.xyz
 * Default RPC URL: https://rpc.yooldo-verse.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { yooldoVerse } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: yooldoVerse,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const yooldoVerse: Common;

/**
 * Creates a common configuration for the yooldoVerseTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 50006
 * Chain Name: Yooldo Verse Testnet
 * Default Block Explorer: https://explorer.testnet.yooldo-verse.xyz
 * Default RPC URL: https://rpc.testnet.yooldo-verse.xyz
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { yooldoVerseTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: yooldoVerseTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const yooldoVerseTestnet: Common;

/**
 * Creates a common configuration for the zetachain chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7000
 * Chain Name: ZetaChain
 * Default Block Explorer: https://explorer.zetachain.com
 * Default RPC URL: https://zetachain-evm.blockpi.network/v1/rpc/public
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zetachain } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zetachain,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zetachain: Common;

/**
 * Creates a common configuration for the zetachainAthensTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7001
 * Chain Name: ZetaChain Athens Testnet
 * Default Block Explorer: https://athens.explorer.zetachain.com
 * Default RPC URL: https://zetachain-athens-evm.blockpi.network/v1/rpc/public
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zetachainAthensTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zetachainAthensTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zetachainAthensTestnet: Common;

/**
 * Creates a common configuration for the zhejiang chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 1337803
 * Chain Name: Zhejiang
 * Default Block Explorer: https://zhejiang.beaconcha.in
 * Default RPC URL: https://rpc.zhejiang.ethpandaops.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zhejiang } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zhejiang,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zhejiang: Common;

/**
 * Creates a common configuration for the zilliqa chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 32769
 * Chain Name: Zilliqa
 * Default Block Explorer: https://evmx.zilliqa.com
 * Default RPC URL: https://api.zilliqa.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zilliqa } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zilliqa,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zilliqa: Common;

/**
 * Creates a common configuration for the zilliqaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 33101
 * Chain Name: Zilliqa Testnet
 * Default Block Explorer: https://evmx.testnet.zilliqa.com
 * Default RPC URL: https://dev-api.zilliqa.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zilliqaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zilliqaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zilliqaTestnet: Common;

/**
 * Creates a common configuration for the zircuitTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 48899
 * Chain Name: Zircuit Testnet
 * Default Block Explorer: https://explorer.zircuit.com
 * Default RPC URL: https://zircuit1.p2pify.com
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zircuitTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zircuitTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zircuitTestnet: Common;

/**
 * Creates a common configuration for the zkFair chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 42766
 * Chain Name: ZKFair Mainnet
 * Default Block Explorer: https://scan.zkfair.io
 * Default RPC URL: https://rpc.zkfair.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zkFair } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zkFair,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zkFair: Common;

/**
 * Creates a common configuration for the zkFairTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 43851
 * Chain Name: ZKFair Testnet
 * Default Block Explorer: https://testnet-scan.zkfair.io
 * Default RPC URL: https://testnet-rpc.zkfair.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zkFairTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zkFairTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zkFairTestnet: Common;

/**
 * Creates a common configuration for the zkLinkNova chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 810180
 * Chain Name: zkLink Nova
 * Default Block Explorer: https://explorer.zklink.io
 * Default RPC URL: https://rpc.zklink.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zkLinkNova } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zkLinkNova,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zkLinkNova: Common;

/**
 * Creates a common configuration for the zkLinkNovaSepoliaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 810181
 * Chain Name: zkLink Nova Sepolia Testnet
 * Default Block Explorer: https://sepolia.explorer.zklink.io
 * Default RPC URL: https://sepolia.rpc.zklink.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zkLinkNovaSepoliaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zkLinkNovaSepoliaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zkLinkNovaSepoliaTestnet: Common;

/**
 * Creates a common configuration for the zksync chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 324
 * Chain Name: ZKsync Era
 * Default Block Explorer: https://era.zksync.network/
 * Default RPC URL: https://mainnet.era.zksync.io
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zksync } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zksync,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zksync: Common;

/**
 * Creates a common configuration for the zksyncInMemoryNode chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 260
 * Chain Name: ZKsync InMemory Node
 * Default Block Explorer: Not specified
 * Default RPC URL: http://localhost:8011
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zksyncInMemoryNode } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zksyncInMemoryNode,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zksyncInMemoryNode: Common;

/**
 * Creates a common configuration for the zksyncLocalNode chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 270
 * Chain Name: ZKsync CLI Local Node
 * Default Block Explorer: Not specified
 * Default RPC URL: http://localhost:3050
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zksyncLocalNode } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zksyncLocalNode,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zksyncLocalNode: Common;

/**
 * Creates a common configuration for the zksyncSepoliaTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 300
 * Chain Name: ZKsync Sepolia Testnet
 * Default Block Explorer: https://sepolia-era.zksync.network/
 * Default RPC URL: https://sepolia.era.zksync.dev
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zksyncSepoliaTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zksyncSepoliaTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zksyncSepoliaTestnet: Common;

/**
 * Creates a common configuration for the zora chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 7777777
 * Chain Name: Zora
 * Default Block Explorer: https://explorer.zora.energy
 * Default RPC URL: https://rpc.zora.energy
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zora } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zora,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zora: Common;

/**
 * Creates a common configuration for the zoraSepolia chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 999999999
 * Chain Name: Zora Sepolia
 * Default Block Explorer: https://sepolia.explorer.zora.energy/
 * Default RPC URL: https://sepolia.rpc.zora.energy
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zoraSepolia } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zoraSepolia,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zoraSepolia: Common;

/**
 * Creates a common configuration for the zoraTestnet chain.
 * @type {import('../Common.js').Common}
 * @description
 * Chain ID: 999
 * Chain Name: Zora Goerli Testnet
 * Default Block Explorer: https://testnet.explorer.zora.energy
 * Default RPC URL: https://testnet.rpc.zora.energy
 * @example
 * import { createMemoryClient } from 'tevm'
 * import { zoraTestnet } from 'tevm/common'
 * import { http } from 'tevm'
 *
 * const client = createMemoryClient({
 *   common: zoraTestnet,
 *   fork: {
 *     transport: http({ url: 'https://example.com' })({})
 *   },
 * })
 */
declare const zoraTestnet: Common;

export { type Common, type CommonOptions, type Hardfork, type MockKzg, abstractTestnet, acala, ancient8, ancient8Sepolia, anvil, apexTestnet, arbitrum, arbitrumGoerli, arbitrumNova, arbitrumSepolia, areonNetwork, areonNetworkTestnet, artelaTestnet, assetChainTestnet, astar, astarZkEVM, astarZkyoto, atletaOlympia, aurora, auroraTestnet, auroria, avalanche, avalancheFuji, b3, b3Sepolia, bahamut, base, baseGoerli, baseSepolia, beam, beamTestnet, bearNetworkChainMainnet, bearNetworkChainTestnet, berachainTestnet, berachainTestnetbArtio, bevmMainnet, bitTorrent, bitTorrentTestnet, bitkub, bitkubTestnet, blast, blastSepolia, bob, bobSepolia, boba, bobaSepolia, botanixTestnet, bronos, bronosTestnet, bsc, bscGreenfield, bscTestnet, btr, btrTestnet, bxn, bxnTestnet, canto, celo, celoAlfajores, chiliz, chips, classic, confluxESpace, confluxESpaceTestnet, coreDao, crab, createCommon, createMockKzg, cronos, cronosTestnet, cronoszkEVM, cronoszkEVMTestnet, crossbell, curtis, cyber, cyberTestnet, darwinia, dchain, dchainTestnet, defichainEvm, defichainEvmTestnet, degen, dfk, dodochainTestnet, dogechain, dreyerxMainnet, dreyerxTestnet, edgeless, edgelessTestnet, edgeware, edgewareTestnet, ekta, ektaTestnet, eon, eos, eosTestnet, etherlink, etherlinkTestnet, evmos, evmosTestnet, fantom, fantomSonicTestnet, fantomTestnet, fibo, filecoin, filecoinCalibration, filecoinHyperspace, flare, flareTestnet, flowMainnet, flowPreviewnet, flowTestnet, fluence, fluenceStage, fluenceTestnet, forma, foundry, fraxtal, fraxtalTestnet, funkiMainnet, funkiSepolia, fuse, fuseSparknet, gnosis, gnosisChiado, gobi, goerli, gravity, ham, haqqMainnet, haqqTestedge2, hardhat, harmonyOne, hashkeyTestnet, hedera, hederaPreviewnet, hederaTestnet, holesky, immutableZkEvm, immutableZkEvmTestnet, inEVM, iota, iotaTestnet, iotex, iotexTestnet, jbc, jbcTestnet, kaia, kairos, kakarotSepolia, karura, kava, kavaTestnet, kcc, klaytn, klaytnBaobab, koi, kroma, kromaSepolia, l3x, l3xTestnet, lightlinkPegasus, lightlinkPhoenix, linea, lineaGoerli, lineaSepolia, lineaTestnet, lisk, liskSepolia, localhost, lukso, luksoTestnet, lycan, lyra, mainnet, mandala, manta, mantaSepoliaTestnet, mantaTestnet, mantle, mantleSepoliaTestnet, mantleTestnet, merlin, metachain, metachainIstanbul, metalL2, meter, meterTestnet, metis, metisGoerli, mev, mevTestnet, mintSepoliaTestnet, mode, modeTestnet, moonbaseAlpha, moonbeam, moonbeamDev, moonriver, morphHolesky, morphSepolia, nautilus, neonDevnet, neonMainnet, nexi, nexilix, oasisTestnet, oasys, okc, oortMainnetDev, opBNB, opBNBTestnet, optimism, optimismGoerli, optimismSepolia, otimDevnet, palm, palmTestnet, pgn, pgnTestnet, phoenix, playfiAlbireo, plinga, plumeTestnet, polygon, polygonAmoy, polygonMumbai, polygonZkEvm, polygonZkEvmCardona, polygonZkEvmTestnet, pulsechain, pulsechainV4, qMainnet, qTestnet, real, redbellyTestnet, redstone, reyaNetwork, rollux, rolluxTestnet, ronin, root, rootPorcini, rootstock, rootstockTestnet, rss3, rss3Sepolia, saigon, sapphire, sapphireTestnet, satoshiVM, satoshiVMTestnet, scroll, scrollSepolia, sei, seiDevnet, seiTestnet, sepolia, shapeSepolia, shardeumSphinx, shibarium, shibariumTestnet, shimmer, shimmerTestnet, skaleBlockBrawlers, skaleCalypso, skaleCalypsoTestnet, skaleCryptoBlades, skaleCryptoColosseum, skaleEuropa, skaleEuropaTestnet, skaleExorde, skaleHumanProtocol, skaleNebula, skaleNebulaTestnet, skaleRazor, skaleTitan, skaleTitanTestnet, sketchpad, soneiumMinato, songbird, songbirdTestnet, sophonTestnet, spicy, storyTestnet, stratis, syscoin, syscoinTestnet, taiko, taikoHekla, taikoJolnir, taikoKatla, taikoTestnetSepolia, taraxa, taraxaTestnet, telcoinTestnet, telos, telosTestnet, tenet, tevmDefault, thaiChain, thunderTestnet, tron, unreal, vechain, wanchain, wanchainTestnet, wemix, wemixTestnet, x1Testnet, xLayer, xLayerTestnet, xai, xaiTestnet, xdc, xdcTestnet, xrSepolia, yooldoVerse, yooldoVerseTestnet, zetachain, zetachainAthensTestnet, zhejiang, zilliqa, zilliqaTestnet, zircuitTestnet, zkFair, zkFairTestnet, zkLinkNova, zkLinkNovaSepoliaTestnet, zksync, zksyncInMemoryNode, zksyncLocalNode, zksyncSepoliaTestnet, zora, zoraSepolia, zoraTestnet };