@feelyourprotocol/block 8141.0.0

package/README.md

@@ -0,0 +1,466 @@
+# @ethereumjs/block `v10`
+
+[![NPM Package][block-npm-badge]][block-npm-link]
+[![GitHub Issues][block-issues-badge]][block-issues-link]
+[![Actions Status][block-actions-badge]][block-actions-link]
+[![Code Coverage][block-coverage-badge]][block-coverage-link]
+[![Discord][discord-badge]][discord-link]
+
+| Implements schema and functions related to Ethereum blocks. |
+| ----------------------------------------------------------- |
+
+- 🦄 All block features till **Osaka**
+- 🌴 Tree-shakeable API
+- 👷🏼 Controlled dependency set (4 external + `@noble` crypto)
+- 🔮 `EIP-4844` Shard Blob Txs
+- 🔮 `EIP-7594` PeerDAS Blob Transactions
+- 💸 `EIP-4895` Beacon Chain Withdrawals
+- 📨 `EIP-7685` Consensus Layer Requests
+- 🛵 324KB bundle size (81KB gzipped)
+- 🏄🏾‍♂️ WASM-free default + Fully browser ready
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Getting Started](#getting-started)
+- [EIP Integrations](#eip-integrations)
+- [Consensus Types](#consensus-types)
+- [Browser](#browser)
+- [API](#api)
+- [Testing](#testing)
+- [EthereumJS](#ethereumjs)
+- [License](#license)
+
+## Installation
+
+To obtain the latest version, simply install the project using `npm`:
+
+```shell
+npm install @ethereumjs/block
+```
+
+**Note:** If you want to work with `EIP-4844` related functionality, you will have additional initialization steps for the **KZG setup**, see related section below.
+
+## Getting Started
+
+### Instantiation
+
+There are several standalone functions to instantiate a `Block`:
+
+- `createBlock(blockData: BlockData = {}, opts?: BlockOptions)`
+- `createEmptyBlock(headerData: HeaderData, opts?: BlockOptions)`
+- `createBlockFromBytesArray(values: BlockBytes, opts?: BlockOptions)`
+- `createBlockFromRLP(serialized: Uint8Array, opts?: BlockOptions)`
+- `createBlockFromRPC(blockParams: JSONRPCBlock, uncles?: any[], opts?: BlockOptions)`
+- `createBlockFromJSONRPCProvider(provider: string | EthersProvider, blockTag: string | bigint, opts: BlockOptions)`
+- `createBlockFromExecutionPayload(payload: ExecutionPayload, opts?: BlockOptions)`
+- `createBlockFromBeaconPayloadJSON(payload: BeaconPayloadJSON, opts?: BlockOptions)`
+- `createSealedCliqueBlock(blockData: BlockData = {}, cliqueSigner: Uint8Array, opts?: BlockOptions)`
+
+For `BlockHeader` instantiation, there are similar standalone functions:
+
+- `createBlockHeader(headerData: HeaderData = {}, opts?: BlockOptions)`
+- `createBlockHeaderFromBytesArray(values: BlockHeaderBytes, opts?: BlockOptions)`
+- `createBlockHeaderFromRLP(serializedHeaderData: Uint8Array, opts?: BlockOptions)`
+- `createBlockHeaderFromRPC(blockParams: JSONRPCBlock, options?: BlockOptions)`
+- `createSealedCliqueBlockHeader(headerData: HeaderData = {}, cliqueSigner: Uint8Array, opts?: BlockOptions)`
+
+Instantiation Example:
+
+```ts
+// ./examples/simple.ts
+
+import { createBlockHeader } from '@ethereumjs/block'
+import { bytesToHex } from '@ethereumjs/util'
+
+import type { HeaderData } from '@ethereumjs/block'
+
+const headerData: HeaderData = {
+  number: 15,
+  parentHash: '0x6bfee7294bf44572b7266358e627f3c35105e1c3851f3de09e6d646f955725a7',
+  gasLimit: 8000000,
+  timestamp: 1562422144,
+}
+const header = createBlockHeader(headerData)
+console.log(`Created block header with hash=${bytesToHex(header.hash())}`)
+```
+
+Properties of a `Block` or `BlockHeader` object are frozen with `Object.freeze()` which gives you enhanced security and consistency properties when working with the instantiated object. This behavior can be modified using the `freeze` option in the constructor if needed.
+
+API Usage Example:
+
+```ts
+// ./examples/1559.ts#L46-L50
+
+try {
+  await blockWithMatchingBaseFee.validateData()
+} catch (err) {
+  console.log(err) // block validation fails
+}
+```
+
+### WASM Crypto Support
+
+This library by default uses JavaScript implementations for the basic standard crypto primitives like hashing or signature verification (for included txs). See `@ethereumjs/common` [README](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/common) for instructions on how to replace with e.g. a more performant WASM implementation by using a shared `common` instance.
+
+## EIP Integrations
+
+### Blocks with an EIP-1559 Fee Market
+
+By default (since `Hardfork.London`) blocks created with this library are [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) compatible.
+
+```ts
+// ./examples/1559.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Mainnet } from '@ethereumjs/common'
+import { createTx } from '@ethereumjs/tx'
+const common = new Common({ chain: Mainnet })
+
+const block = createBlock(
+  {
+    header: {
+      baseFeePerGas: BigInt(10),
+      gasLimit: BigInt(100),
+      gasUsed: BigInt(60),
+    },
+  },
+  { common },
+)
+
+// Base fee will increase for next block since the
+// gas used is greater than half the gas limit
+console.log(Number(block.header.calcNextBaseFee())) // 11
+
+// So for creating a block with a matching base fee in a certain
+// chain context you can do:
+const blockWithMatchingBaseFee = createBlock(
+  {
+    header: {
+      baseFeePerGas: block.header.calcNextBaseFee(),
+      gasLimit: BigInt(100),
+      gasUsed: BigInt(60),
+    },
+  },
+  { common },
+)
+
+console.log(Number(blockWithMatchingBaseFee.header.baseFeePerGas)) // 11
+
+// successful validation does not throw error
+await blockWithMatchingBaseFee.validateData()
+
+// failed validation throws error
+const tx = createTx(
+  { type: 2, maxFeePerGas: BigInt(20) },
+  { common: new Common({ chain: Mainnet }) },
+)
+blockWithMatchingBaseFee.transactions.push(tx)
+console.log(blockWithMatchingBaseFee.getTransactionsValidationErrors()) // invalid transaction added to block
+try {
+  await blockWithMatchingBaseFee.validateData()
+} catch (err) {
+  console.log(err) // block validation fails
+}
+
+```
+
+### Blocks with EIP-4895 Beacon Chain Withdrawals
+
+Starting with the `v4.1.0` release there is support for [EIP-4895](https://eips.ethereum.org/EIPS/eip-4895) beacon chain withdrawals (`Hardfork.Shanghai` or higher). To create a block containing system-level withdrawals, the `withdrawals` data option together with a matching `withdrawalsRoot` can be used:
+
+```ts
+// ./examples/withdrawals.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Mainnet } from '@ethereumjs/common'
+import { Address, hexToBytes } from '@ethereumjs/util'
+
+import type { WithdrawalData } from '@ethereumjs/util'
+
+const common = new Common({ chain: Mainnet })
+
+const withdrawal: WithdrawalData = {
+  index: BigInt(0),
+  validatorIndex: BigInt(0),
+  address: new Address(hexToBytes(`0x${'20'.repeat(20)}`)),
+  amount: BigInt(1000),
+}
+
+const block = createBlock(
+  {
+    header: {
+      withdrawalsRoot: hexToBytes(
+        '0x69f28913c562b0d38f8dc81e72eb0d99052444d301bf8158dc1f3f94a4526357',
+      ),
+    },
+    withdrawals: [withdrawal],
+  },
+  {
+    common,
+  },
+)
+
+console.log(`Block with ${block.withdrawals!.length} withdrawal(s) created`)
+
+```
+
+Validation of the withdrawals trie can be manually triggered with the newly introduced async `Block.withdrawalsTrieIsValid()` method.
+
+### Blocks with EIP-4844 Shard Blob Transactions
+
+This library supports the blob transaction type introduced with [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) (`Hardfork.Cancun` or higher), see the following example:
+
+```ts
+// ./examples/4844.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+import { createBlob4844Tx } from '@ethereumjs/tx'
+import { createAddressFromPrivateKey } from '@ethereumjs/util'
+import { randomBytes } from '@noble/hashes/utils.js'
+import { trustedSetup } from '@paulmillr/trusted-setups/fast-peerdas.js'
+import { KZG as microEthKZG } from 'micro-eth-signer/kzg.js'
+
+const main = async () => {
+  const kzg = new microEthKZG(trustedSetup)
+
+  const common = new Common({
+    chain: Mainnet,
+    customCrypto: {
+      kzg,
+    },
+    hardfork: Hardfork.Cancun,
+  })
+  const blobTx = createBlob4844Tx(
+    { blobsData: ['myFirstBlob'], to: createAddressFromPrivateKey(randomBytes(32)) },
+    { common },
+  )
+
+  const block = createBlock(
+    {
+      header: {
+        excessBlobGas: 0n,
+      },
+      transactions: [blobTx],
+    },
+    {
+      common,
+      skipConsensusFormatValidation: true,
+    },
+  )
+
+  console.log(
+    `4844 block header with excessBlobGas=${block.header.excessBlobGas} created and ${
+      block.transactions.filter((tx) => tx.type === 3).length
+    } blob transactions`,
+  )
+}
+
+void main()
+
+```
+
+**Note:** Working with blob transactions needs a manual KZG library installation and global initialization, see [KZG Setup](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/tx/README.md#kzg-setup) for instructions.
+
+### Blocks with EIP-7685 Consensus Layer Requests
+
+Starting with v10 this library supports requests to the consensus layer which have been introduced with [EIP-7685](https://eips.ethereum.org/EIPS/eip-7685) (`Hardfork.Prague` or higher). See the `@ethereumjs/util` [Request](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/util#module-request) README section for an overview of current request types.
+
+```ts
+// ./examples/clrequests.ts
+
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+import { CLRequestType, bytesToHex, createCLRequest, hexToBytes } from '@ethereumjs/util'
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { createBlock, genRequestsRoot } from '../src'
+
+// Enable EIP-7685 to support CLRequests
+const common = new Common({ chain: Mainnet, hardfork: Hardfork.Cancun, eips: [7685] })
+
+// Create examples of the three CLRequest types
+const createExampleRequests = () => {
+  // Create a deposit request (type 0)
+  const depositData = hexToBytes(
+    '0x00ac842878bb70009552a4cfcad801d6e659c50bd50d7d03306790cb455ce7363c5b6972f0159d170f625a99b2064dbefc010000000000000000000000818ccb1c4eda80270b04d6df822b1e72dd83c3030040597307000000a747f75c72d0cf0d2b52504c7385b516f0523e2f0842416399f42b4aee5c6384a5674f6426b1cc3d0827886fa9b909e616f5c9f61f986013ed2b9bf37071cbae951136265b549f44e3c8e26233c0433e9124b7fd0dc86e82f9fedfc0a179d7690000000000000000',
+  )
+  const depositRequest = createCLRequest(depositData)
+
+  // Create a withdrawal request (type 1)
+  const withdrawalData = hexToBytes(
+    '0x01000000000000000000000000000000000000000001000000000000000000000de0b6b3a7640000',
+  )
+  const withdrawalRequest = createCLRequest(withdrawalData)
+
+  // Create a consolidation request (type 2)
+  const consolidationData = hexToBytes('0x020000000100000000000000000000000000000000000001')
+  const consolidationRequest = createCLRequest(consolidationData)
+
+  // CLRequests must be sorted by type (Deposit=0, Withdrawal=1, Consolidation=2)
+  return [depositRequest, withdrawalRequest, consolidationRequest]
+}
+
+// Generate a block with CLRequests
+function createBlockWithCLRequests() {
+  const requests = createExampleRequests()
+  console.log(`Created ${requests.length} CLRequests:`)
+
+  for (const req of requests) {
+    console.log(
+      `- Type: ${req.type} (${Object.keys(CLRequestType).find(
+        (k) => CLRequestType[k as keyof typeof CLRequestType] === req.type,
+      )})`,
+    )
+  }
+
+  // Generate the requestsHash by hashing all the CLRequests
+  const requestsHash = genRequestsRoot(requests, sha256)
+  console.log(`Generated requestsHash: 0x${bytesToHex(requestsHash)}`)
+
+  // Create a block with the CLRequests hash
+  const block = createBlock({ header: { requestsHash } }, { common })
+  console.log(`Created block hash: 0x${bytesToHex(block.hash())}`)
+
+  return block
+}
+
+// Execute
+createBlockWithCLRequests()
+
+```
+
+### Consensus Types
+
+### Proof-of-Stake
+
+By default (`Hardfork.Paris` (aka: Merge) and higher) blocks are created as Proof-of-Stake blocks. These blocks come with their own set of header field simplifications and associated validation rules. The difficulty is set to `0` since not relevant anymore, just to name an example. For a full list of changes see [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675).
+
+You can instantiate a Merge/PoS block like this:
+
+```ts
+// ./examples/pos.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Mainnet } from '@ethereumjs/common'
+
+const common = new Common({ chain: Mainnet })
+
+const block = createBlock(
+  {
+    // Provide your block data here or use default values
+  },
+  { common },
+)
+
+console.log(`Proof-of-Stake (default) block created with hardfork=${block.common.hardfork()}`)
+```
+
+### Ethash/PoW
+
+Blocks before the Merge or blocks on dedicated PoW chains are created as Proof-of-work blocks. An Ethash/PoW block can be instantiated as follows:
+
+```ts
+// ./examples/pow.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+
+const common = new Common({ chain: Mainnet, hardfork: Hardfork.Chainstart })
+
+console.log(common.consensusType()) // 'pow'
+console.log(common.consensusAlgorithm()) // 'ethash'
+
+createBlock({}, { common })
+console.log(`Old Proof-of-Work block created`)
+```
+
+To calculate the difficulty when creating the block pass in the block option `calcDifficultyFromHeader` with the preceding (parent) `BlockHeader`.
+
+### Clique/PoA
+
+Clique is a standalone Proof-of-Authority protocol which had been in use for older Ethereum testnets (like e.g. the `Goerli` testnet). This library still supports Clique/PoA so that blocks from those testnets can still be read.
+
+A clique block can be instantiated as follows:
+
+```ts
+// ./examples/clique.ts
+
+import { createBlock } from '@ethereumjs/block'
+import { Common, Hardfork } from '@ethereumjs/common'
+import { goerliChainConfig } from '@ethereumjs/testdata'
+
+const common = new Common({ chain: goerliChainConfig, hardfork: Hardfork.Chainstart })
+
+console.log(common.consensusType()) // 'poa'
+console.log(common.consensusAlgorithm()) // 'clique'
+
+createBlock({ header: { extraData: new Uint8Array(97) } }, { common })
+console.log(`Old Clique Proof-of-Authority block created`)
+
+```
+
+For sealing a block on instantiation you can use the `cliqueSigner` constructor option:
+
+```ts
+const cliqueSigner = hexToBytes('PRIVATE_KEY_HEX_STRING')
+const block = createSealedCliqueBlock(blockData, cliqueSigner)
+```
+
+See the API docs for detailed documentation on Clique/PoA related utility methods. Note that these methods will throw if called in a non-Clique/PoA context.
+
+## Browser
+
+We provide hybrid ESM/CJS builds for all our libraries. With the v10 breaking release round from Spring 2025, all libraries are "pure-JS" by default and we have eliminated all hard-wired WASM code. Additionally we have substantially lowered the bundle sizes, reduced the number of dependencies, and cut out all usages of Node.js-specific primitives (like the Node.js event emitter).
+
+It is easily possible to run a browser build of one of the EthereumJS libraries within a modern browser using the provided ESM build. For a setup example see [./examples/browser.html](./examples/browser.html).
+
+## API
+
+### Docs
+
+Generated TypeDoc API [Documentation](./docs/README.md)
+
+### Hybrid CJS/ESM Builds
+
+With the breaking releases from Summer 2023 we have started to ship our libraries with both CommonJS (`cjs` folder) and ESM builds (`esm` folder), see `package.json` for the detailed setup.
+
+If you use an ES6-style `import` in your code, the ESM build will be used:
+
+```ts
+import { EthereumJSClass } from '@ethereumjs/[PACKAGE_NAME]'
+```
+
+If you use Node.js specific `require`, the CJS build will be used:
+
+```ts
+const { EthereumJSClass } = require('@ethereumjs/[PACKAGE_NAME]')
+```
+
+Using ESM will give you additional advantages over CJS beyond browser usage like static code analysis / Tree Shaking which CJS cannot provide.
+
+
+## Testing
+
+Tests in the `tests` directory are partly outdated and testing is primarily done by running the `BlockchainTests` from within the [@ethereumjs/vm](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/vm) package.
+
+To avoid bloating this repository with [ethereum/tests](https://github.com/ethereum/tests) JSON files, we usually copy specific JSON files and wrap them with some metadata (source, date, commit hash). There's a helper to aid in that process and can be found at [wrap-ethereum-test.sh](https://github.com/ethereumjs/ethereumjs-monorepo/blob/master/packages/block/scripts/wrap-ethereum-test.sh).
+
+## EthereumJS
+
+The `EthereumJS` GitHub organization and its repositories are managed by members of the former Ethereum Foundation JavaScript team and the broader Ethereum community. If you want to join for work or carry out improvements on the libraries see the [developer docs](../../DEVELOPER.md) for an overview of current standards and tools and review our [code of conduct](../../CODE_OF_CONDUCT.md).
+
+## License
+
+[MPL-2.0](<https://tldrlegal.com/license/mozilla-public-license-2.0-(mpl-2)>)
+
+[discord-badge]: https://img.shields.io/static/v1?logo=discord&label=discord&message=Join&color=blue
+[discord-link]: https://discord.gg/TNwARpR
+[block-npm-badge]: https://img.shields.io/npm/v/@ethereumjs/block.svg
+[block-npm-link]: https://www.npmjs.com/package/@ethereumjs/block
+[block-issues-badge]: https://img.shields.io/github/issues/ethereumjs/ethereumjs-monorepo/package:%20block?label=issues
+[block-issues-link]: https://github.com/ethereumjs/ethereumjs-monorepo/issues?q=is%3Aopen+is%3Aissue+label%3A"package%3A+block"
+[block-actions-badge]: https://github.com/ethereumjs/ethereumjs-monorepo/workflows/Block/badge.svg
+[block-actions-link]: https://github.com/ethereumjs/ethereumjs-monorepo/actions?query=workflow%3A%22Block%22
+[block-coverage-badge]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/branch/master/graph/badge.svg?flag=block
+[block-coverage-link]: https://codecov.io/gh/ethereumjs/ethereumjs-monorepo/tree/master/packages/block

package/dist/cjs/block/block.d.ts

@@ -0,0 +1,147 @@
+import type { Common } from '@feelyourprotocol/common';
+import type { TypedTransaction } from '@feelyourprotocol/tx';
+import type { Withdrawal } from '@feelyourprotocol/util';
+import { BlockHeader } from '../index.ts';
+import type { BlockBytes, BlockOptions, ExecutionPayload, JSONBlock } from '../types.ts';
+/**
+ * Class representing a block in the Ethereum network. The {@link BlockHeader} has its own
+ * class and can be used independently, for a block it is included in the form of the
+ * {@link Block.header} property.
+ *
+ * A block object can be created with one of the following constructor methods
+ * (separate from the Block class to allow for tree shaking):
+ *
+ * - {@link createBlock }
+ * - {@link createBlockFromBytesArray }
+ * - {@link createBlockFromRLP }
+ * - {@link createBlockFromRPC }
+ * - {@link createBlockFromJSONRPCProvider }
+ * - {@link createBlockFromExecutionPayload }
+ * - {@link createBlockFromBeaconPayloadJSON }
+ */
+export declare class Block {
+    readonly header: BlockHeader;
+    readonly transactions: TypedTransaction[];
+    readonly uncleHeaders: BlockHeader[];
+    readonly withdrawals?: Withdrawal[];
+    readonly common: Common;
+    protected keccakFunction: (msg: Uint8Array) => Uint8Array;
+    protected sha256Function: (msg: Uint8Array) => Uint8Array;
+    protected cache: {
+        txTrieRoot?: Uint8Array;
+        withdrawalsTrieRoot?: Uint8Array;
+    };
+    /**
+     * This constructor takes the values, validates them, assigns them and freezes the object.
+     *
+     * @deprecated Use the static factory methods (see {@link Block} for an overview) to assist in creating
+     * a Block object from varying data types and options.
+     */
+    constructor(header?: BlockHeader, transactions?: TypedTransaction[], uncleHeaders?: BlockHeader[], withdrawals?: Withdrawal[], opts?: BlockOptions);
+    /**
+     * Returns an array of the raw byte arrays for this block, in order.
+     */
+    raw(): BlockBytes;
+    /**
+     * Returns the hash of the block.
+     */
+    hash(): Uint8Array;
+    /**
+     * Determines if this block is the genesis block.
+     */
+    isGenesis(): boolean;
+    /**
+     * Returns the rlp encoding of the block.
+     */
+    serialize(): Uint8Array;
+    /**
+     * Generates transaction trie for validation.
+     */
+    genTxTrie(): Promise<Uint8Array>;
+    /**
+     * Validates the transaction trie by generating a trie
+     * and do a check on the root hash.
+     * @returns True if the transaction trie is valid, false otherwise
+     */
+    transactionsTrieIsValid(): Promise<boolean>;
+    /**
+     * Validates transaction signatures and minimum gas requirements.
+     * @returns {string[]} an array of error strings
+     */
+    getTransactionsValidationErrors(): string[];
+    /**
+     * Validates transaction signatures and minimum gas requirements.
+     * @returns True if all transactions are valid, false otherwise
+     */
+    transactionsAreValid(): boolean;
+    /**
+     * Validates the block data, throwing if invalid.
+     * This can be checked on the Block itself without needing access to any parent block
+     * It checks:
+     * - All transactions are valid
+     * - The transactions trie is valid
+     * - The uncle hash is valid
+     * - Block size limit (EIP-7934)
+     * @param onlyHeader if only passed the header, skip validating txTrie and unclesHash (default: false)
+     * @param verifyTxs if set to `false`, will not check for transaction validation errors (default: true)
+     * @param validateBlockSize if set to `true`, will check for block size limit (EIP-7934) (default: false)
+     */
+    validateData(onlyHeader?: boolean, verifyTxs?: boolean, validateBlockSize?: boolean): Promise<void>;
+    /**
+     * Validates that blob gas fee for each transaction is greater than or equal to the
+     * blobGasPrice for the block and that total blob gas in block is less than maximum
+     * blob gas per block
+     * @param parentHeader header of parent block
+     */
+    validateBlobTransactions(parentHeader: BlockHeader): void;
+    /**
+     * Validates the uncle's hash.
+     * @returns true if the uncle's hash is valid, false otherwise.
+     */
+    uncleHashIsValid(): boolean;
+    /**
+     * Validates the withdrawal root
+     * @returns true if the withdrawals trie root is valid, false otherwise
+     */
+    withdrawalsTrieIsValid(): Promise<boolean>;
+    /**
+     * Consistency checks for uncles included in the block, if any.
+     *
+     * Throws if invalid.
+     *
+     * The rules for uncles checked are the following:
+     * Header has at most 2 uncles.
+     * Header does not count an uncle twice.
+     */
+    validateUncles(): void;
+    /**
+     * Validates if the block gasLimit remains in the boundaries set by the protocol.
+     * Throws if invalid
+     *
+     * @param parentBlock - the parent of this `Block`
+     */
+    validateGasLimit(parentBlock: Block): void;
+    /**
+     * Returns the block in JSON format.
+     */
+    toJSON(): JSONBlock;
+    /**
+     * Maps the block properties to the execution payload structure from the beacon chain,
+     * see https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#ExecutionPayload
+     *
+     * @returns dict with the execution payload parameters with camel case naming
+     */
+    toExecutionPayload(): ExecutionPayload;
+    /**
+     * Return a compact error string representation of the object
+     */
+    errorStr(): string;
+    /**
+     * Internal helper function to create an annotated error message
+     *
+     * @param msg Base error message
+     * @hidden
+     */
+    protected _errorMsg(msg: string): string;
+}
+//# sourceMappingURL=block.d.ts.map

package/dist/cjs/block/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../src/block/block.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAA6B,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAOlD,OAAO,EACL,WAAW,EAUZ,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAExF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,KAAK;IAChB,SAAgB,MAAM,EAAE,WAAW,CAAA;IACnC,SAAgB,YAAY,EAAE,gBAAgB,EAAE,CAAK;IACrD,SAAgB,YAAY,EAAE,WAAW,EAAE,CAAK;IAChD,SAAgB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;IAC1C,SAAgB,MAAM,EAAE,MAAM,CAAA;IAC9B,SAAS,CAAC,cAAc,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,UAAU,CAAA;IACzD,SAAS,CAAC,cAAc,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,UAAU,CAAA;IAEzD,SAAS,CAAC,KAAK,EAAE;QACf,UAAU,CAAC,EAAE,UAAU,CAAA;QACvB,mBAAmB,CAAC,EAAE,UAAU,CAAA;KACjC,CAAK;IAEN;;;;;OAKG;gBAED,MAAM,CAAC,EAAE,WAAW,EACpB,YAAY,GAAE,gBAAgB,EAAO,EACrC,YAAY,GAAE,WAAW,EAAO,EAChC,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,IAAI,GAAE,YAAiB;IAqCzB;;OAEG;IACH,GAAG,IAAI,UAAU;IAgBjB;;OAEG;IACH,IAAI,IAAI,UAAU;IAIlB;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,SAAS,IAAI,UAAU;IAIvB;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC;IAOtC;;;;OAIG;IACG,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAcjD;;;OAGG;IACH,+BAA+B,IAAI,MAAM,EAAE;IA8C3C;;;OAGG;IACH,oBAAoB,IAAI,OAAO;IAM/B;;;;;;;;;;;OAWG;IACG,YAAY,CAChB,UAAU,GAAE,OAAe,EAC3B,SAAS,GAAE,OAAc,EACzB,iBAAiB,GAAE,OAAe,GACjC,OAAO,CAAC,IAAI,CAAC;IAoDhB;;;;;OAKG;IACH,wBAAwB,CAAC,YAAY,EAAE,WAAW;IA4ClD;;;OAGG;IACH,gBAAgB,IAAI,OAAO;IAS3B;;;OAGG;IACG,sBAAsB,IAAI,OAAO,CAAC,OAAO,CAAC;IAqBhD;;;;;;;;OAQG;IACH,cAAc;IAmBd;;;;;OAKG;IACH,gBAAgB,CAAC,WAAW,EAAE,KAAK;IAInC;;OAEG;IACH,MAAM,IAAI,SAAS;IAcnB;;;;;OAKG;IACH,kBAAkB,IAAI,gBAAgB;IA+BtC;;OAEG;IACI,QAAQ;IAmBf;;;;;OAKG;IACH,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM;CAGhC"}